Mesures

• Objectif :Création d'une géolocalisation Centimétrique à faible coût

Le fonctionnement

Le matériel

Chapitre	Sous-Chapitre	Image	Désignation	Fournisseur	Prix	Stock
Modules	Capteur de position		NEO-8M Module GPS GPS8MV2, NEO8M avec EEPROM APM2.5	aliexpress	8,3€	2
Modules	Capteur de position		Hoxiao-Antenne GPS de voiture, connecteur SMA, câble de 1.6m	aliexpress	2,245€	2
Microcontrolleurs	Micro contrôleur 32 bits		RP2040-Zero, une carte MCU basée sur le microcontrôleur Raspberry Pi RP2040 Puce de microcontrôleur RP2040 conçue par Raspberry Pi au royaume-uni Régulateur de tension intégré maxi : 800mA Processeur Arm Cortex M0 + Dual-core, horloge flexible fonctionnant jusqu'à 133 MHz 264 ko de SRAM et 2 mo de mémoire Flash intégrée Connecteur USB-C - USB 1.1 avec dispositif et support hôte Programmation glisser-déposer en utilisant le stockage de masse via USB 29 × broches GPIO multifonctions (20 × via le brochage des bords, d'autres via des points de soudure) 2 × SPI, 2 × I2C, 2 × UART, 4 × 12-bit ADC, 16 × canaux PWM contrôlables Bibliothèques à virgule flottante accélérée sur puce 8 × machines d'état d'i/O (PIO) programmables pour le support de périphérique personnalisé	aliexpress	5,47€	2

Les configurations

Dans le menu receiver, connection.

Mettre à jour le firmware

Configurer la base

1. Définissez la position en demandant à la station de base d'effectuer l'une des opérations suivantes :
   • recherche des coordonnées
   • être configuré avec des coordonnées pré-définies
2. Configurez le port pour la configuration de la transmission de données
3. Sélectionnez les messages RTCM à transmettre

Commencer une auto-enquète (Survey-in) Utilisez, par exemple, comme cibles, 5 minutes (300s) et 2 mètres . Avec une bonne antenne 1 mètre avec 10-15 min (600 à 900s). Ou, fournissez une position fixe approximative

Les coordonnées de la station de base

• Objectif :Déscription des capteurs

Les différents type de capteurs

infrarouge à led

Capteur infrarouge à fourche

Capteur de champ magnétique

Capteur effet Hall Y3144 4.5-24V, Détecteur magnétique. Peut-être remplacé par US1881 3.5V à 24V 5mA

Capteur de lumière

Câblage toujours avec une résistance de tirage.

Bouton poussoir

Avec un seul poussoir, l'entrée est tirée à la masse via une résistance de 10kΩ. L'appui sur le poussoir amène cette entrée à 5V. Ceci permet d'avoir un signal propre, en effet, si nous laissons un bouton poussoir, sans connection le signal peut-être influencé par un champ extérieur.

• Objectif :Mesurer la fréquence
• Moyen:
  • Processeur Attiny85 - 20Mhz
  • Batterie 852540 3.7V
  • Afficheur Oled 128x64 1.3" ou 0.96"
  • 1 LED Infrarouge IR 940nm Émetteur Ø5mm
  • 2 LED Infrarouge IR 940nm Récepteur Ø3mm
  • 2 résistances 1/4W 1kΩ
  • 1 résistances 1/4W 120Ω
  • 2 SS1200G3 Bouton Interrupteur 0.5A 50 V DC
  • 1 Bouton-poussoir/interrupteur 6x6x7mm 4 Pin DIP Contact

Méthode

1. Le microcontroleur attend une interuption sur la broche PB2.
2. Commence le comptage sur 32 bits des impulsions sur PB2 et demarre le chrono
3. Au bout d'une seconde, STOP le chrono et le comptage
4. Convertion pour l'affichage Hexadécimal -> DCB ascii
5. Affichage sur Oled la valeur de comptage
6. multiplie la valeur par 60
7. Affichage sur Oled de la valeur en tr/min

Programme

;             ATtiny45 - 20MHz interne
;              +-\/-+
;         PB5 1|-  -|8  Vcc
;  RESET  PB3 2|-  -|7  PB2 T0/Int0 entrée signal
;  SENS   PB4 3|-  -|6  PB1 SDA OLED 128x32
;         GND 4|-  -|5  PB0 SCL OLED    
;              +----+

main.asm

    ;
; Frequencemetre.asm
;
; Created: 28/07/2020 12:52:11
; Author : samuel.dupre
;
;        ATtiny45 - 8MHz interne
;             +-\/-+
; 	     PB5 1|-  -|8  Vcc
;		 PB3 2|-  -|7  PB2 T0/Int0 entrée signal
;   	 PB4 3|-  -|6  PB1 SDA OLED 128x32
;		 GND 4|-  -|5  PB0 SCL OLED
;             +----+

/*
.device atmega328p
.nolist
.include  "m328pdef.inc"			; definitions for the Atmega 328
*/
.device attiny85
.nolist
.include  "tn85def.inc"			; definitions for the Atmega 328
.list
;.def regC	= R25		; GENERAL PURPOSE ACCUMULATOR
;.equ	PN532_I2C	= 0x24	;Adresse I2C
;.equ	PN532_HOSTTOPN532 = 0xD4
#define F_CPU  16000000 // Clock Speed
;#define freq_timer1 1		;Hz
;#define timer1_counter 65536-(F_CPU/256/freq_timer1)
#define	nbrint	61		;nombre d'interruptions pour un comptage  Ti= (1024*256)/16 =16384?s x61= 999424?s soit environs 1s
;#define DEBUG		;si test via uart
;#define fontcp437	;si omis font5x8
;count  r5:r4:r3:r2
.def	DATA	=r20
.def	regA	=r16
.def	regB	=r17
.def	regC	=r18
.def    tmp		=r19
.def	zero	=r10
.def	countLL =r11
.def	countLH =r12
.def	countHL =r13
.def	countHH =r14

;ZH:ZL  r31:r30
;YH:YL  r29:r28
;XH:XL	r27:r26
;Pour temps
.def	VH		=r25	;nombre d'interruption
.def	VL		=r24	
.def	WH		=r23	;min
.def	WL		=r22	;sec



.def	State=r21

;Pour affichage et son
.equ	buzz	=PB1
.equ  	SENSELED=PB5   ;  SENSELED pin (Output on AVR)

.macro   ldz
	ldi 	zl, LOW(@0<<1)
	ldi		zh, HIGH(@0<<1)
.endm
.macro   ldy
	ldi 	yl, LOW(@0)
	ldi		yh, HIGH(@0)
.endm
.dseg
.org	0x60
count:		.byte 4		;32 bits

in_buf:
lne:		.byte 30	;50 si usart, 30 si pas usart
fin_ram:
buffermax:	.byte 8*5	;4 pour l'affichage 1 pour le scroll
Buffer:		.byte 100	;Pour buffer bluetooth
.cseg
.org 0000
;************************************************
;* Interrupt Vectors				      *
;************************************************
	rjmp		main	; Reset Handler
	reti		; External Interrupt 0
	reti		; Pin change Interrupt Request 0
	reti		; Timer/Counter1 Compare Match 1A
	rjmp		TIMER1_OVF		; Timer/Counter1 Overflow
	rjmp		TIMER0_OVF		; Timer/Counter0 Overflow
	reti		; EEPROM Ready
	reti		; Analog comparator
	reti		; ADC Conversion ready
	reti		; Timer/Counter1 Compare Match B
	reti;rjmp		TIMER0_COMPA		; Timer/Counter0 Compare Match A
	reti		; Timer/Counter0 Compare Match B
	reti		; Watchdog Time-out
	reti		; USI START
	reti		; USI Overflow

main:
	ldi		regA,high(RAMEND)	; set up stack pointer
	out		SPH,regA
	ldi		regA,low(RAMEND)
	out		SPL,regA
	ldi		regA,(1<<CLKPCE)	; enable the clock prescaler
	sts		CLKPR,regA		; for 4 cycles
	clr		regA
	sts		CLKPR,regA		; and div factor to 1
	clr		zero
	rcall	SSD1306_INIT
loop:
	;rcall	start_count

	;------------------------------ test
	ldi		regA,BYTE4(12321)
	mov		r5,regA
	ldi		regA,BYTE3(12321)
	mov		r4,regA
	ldi		regA,BYTE2(12321)
	mov		r3,regA
	ldi		regA,BYTE1(12321)
	mov		r2,regA
	rcall	BIN2DCB32
;------------------------------ fin test
	clr		posX
	clr		posY
	rcall	ssd1306_setpos
	ldi		zh,high(lne)		; formatted line image
	ldi		zl,low(lne)
	rcall	ssd1306_write_string

	
	ldi		regA,1
	rcall	waitseconds
	rjmp	loop
	;freq = count*16000000/(nbrint*1024*256);
	;freq= count* 15625/(nbrint*256); si nbrint=61 interruption pour une seconde
	;freq= count
	rcall	BIN2DCB32
	clr		posX
	clr		posY
	rcall	ssd1306_setpos
	ldi		zh,high(lne)		; formatted line image
	ldi		zl,low(lne)
	rcall	ssd1306_write_string
	rjmp	loop


start_count:
;count = 0	;la variable count représente le nombre d’impulsion qui généra par  le timer 1
	clr		countHH	;high H
	clr		countHL	;high L
	clr		countLH	;low H
	clr		countLL	;low L
	clr		r2
	clr		r3
	clr		r4
	clr		r5
	cbi		DDRB,2
; Clear registers
;Timer/Counter 0 initialization comptage sur T0	
;TCCR0A=0;  (0<<COM0A1) | (0<<COM0A0) | (0<<COM0B1) | (0<<COM0B0) | (1<<WGM01) | (0<<WGM00)
	;ldi		regA,(0<<COM0A1) | (0<<COM0A0) | (0<<COM0B1) | (0<<COM0B0) | (1<<WGM01) | (0<<WGM00)
	;out		TCCR0A,regA
	out		TCCR0A,zero
	out		TCNT0,zero
	;ser		regA
	;out		OCR0A ,regA	;tous les 255 T0
	
	
;Timer/Counter 0 Interrupt(s) initialization compteur
	ldi		regA,(0<<OCIE1A) |(0<<OCIE1B) |(0<<OCIE0A) | (0<<OCIE0B) | (1<<TOIE1) | (1<<TOIE0) ; TOIE0: Timer/Counter0 Overflow Interrupt Enable
	out		TIMSK,regA

; Timer/Counter 1 initialization
;TCCR1A=(0<<COM1A1) | (0<<COM1A0) | (0<<COM1B1) | (0<<COM1B0) | (1<<WGM11) | (0<<WGM10)
;CTC	top:OCR1	Clear Timer on Compare Match  prescaler = 1024
	ldi		regA,(0<<CTC1) | (0<<PWM1A) | (0<<COM1A1) | (0<<COM1A0) | (1<<CS13) | (0<<CS12) | (1<<CS11)  | (1<<CS10)
	out		TCCR1,regA
;TCNT1=0x00
	out		TCNT1,zero
;OCR1A=0xFF
	ser		regA
	out		OCR1A,regA
;ni = 0 compteur d'interruptions
	clr		VL
	clr		VH
	sei		;activation des interruptions
	ldi		regA,(1 << CS02) | (1 << CS01) | (1 << CS00)	;External clock source on T0 pin. Clock on rising edge
	out		TCCR0B,regA
	ret
 
TIMER0_OVF:
;add count+1
	push	regA
	in      regA,SREG
	push    regA
	ldi		regA,1
	add		countLH,regA			;(count+1) high
	adc		countHL,zero			;(count+2)
	adc		countHH,zero			;(count+3)
	pop		regA
	out		SREG,regA
	pop		regA
	reti
;Timer1 overflow interrupt service routine
;Toutes les 16384us
TIMER1_OVF:
	push	regA
	in      regA,SREG
	push    regA
	;ni++
	adiw	VL,1	
	cpi		VL,low(nbrint)
	ldi		regA,high(nbrint)
	cpc		VH,regA  ;nombre d'interruptions pour un comptage 
	brne	no_ni_egal
	in		countLL,TCNT0	;count Low L
	mov		r2,countLL
	mov		r3,countLH
	mov		r4,countHL
	mov		r5,countHH
	out		TCNT0,zero
no_ni_egal:
	pop		regA
	out		SREG,regA
	pop		regA
	reti

.include "wait.inc"
.include "oled.inc"     

BIN2DCB32.inc

    ;32-bit unsigned binary integer to 8-bit BCD in AVR ASM for ATtiny
;Entrée : r5:r4:r3:r2
;Sortie : r9:r8:r7:r6
; .def	regA  =	  r16
; .def 	r10=r8
; .def	regC=r17
BIN2DCB32:
	push	zh
	push	zl
	push	regA
	push	regB
	push	regC
	push	r2
	push	r3
	push	r4
	push	r5
	push	r6
	push	r7
	push	r8
	push	r9
	push	r10
		ldi		zh,high(lne)		; formatted line image
		ldi		zl,low(lne)
		clr		r6
		clr		r7
		clr		r8
		clr		r9
		
		LDI		regC,32	;Compteur de bit 32 shift
BCD8:	;8 octals
		lsl		r2			;peu importe le carry
		ROL		r3
		ROL		r4
		ROL		r5
		ROL		r6
		ROL		r7
		ROL		r8
		ROL		r9
		dec		regC
		brne	tst8o		;si <>32 test sinon ret

		mov		regA,r9
		rcall	DCB4
		mov		regA,r8
		rcall	DCB4
		mov		regA,r7
		rcall	DCB4
		mov		regA,r6
		rcall	DCB4
		pop		r10
		pop		r9
		pop		r8
		pop		r7
		pop		r6
		pop		r5
		pop		r4
		pop		r3
		pop		r2
		ldi		zh,high(lne)		; formatted line image
		ldi		zl,low(lne)
		;supprime Zero départ
	sup0:
		ld		regA,Z
		cpi		regA,0
		breq finsupp
		cpi		regA,'0'
		brne	finsupp
		ldi		regA,' '
		st		Z,regA
		adiw	ZL,1
		rjmp	sup0
	finsupp:
		;rcall	lne_usart	
		pop		regC
		pop		regB
		pop		regA
		pop		zl
		pop		zh
		ret

DCB4:
		swap	regA
		mov		regB,regA
		andi	regB,0x0F
		ori		regB,0x30
		st		Z+,regB
		swap	regA
		mov		regB,regA
		andi	regB,0x0F
		ori		regB,0x30
		st		Z+,regB
		st		Z,zero
		ret

		
		
tst8o:	mov		r10,r6
		rcall	tst2o		;rcall test 2 octals
		mov		r6,r10
		
		mov		r10,r7
		rcall	tst2o		;rcall test 2 octals
		mov		r7,r10
		
		mov		r10,r8
		rcall	tst2o		;rcall test 2 octals
		mov		r8,r10
		
		mov		r10,r9
		rcall	tst2o		;rcall test 2 octals
		mov		r9,r10
		rjmp 	BCD8
		
tst2o:	ldi		regA,0x0F
		and		regA,r10
		cpi		regA,5
		brlo	tst1o		;regA<5 test 1 octal bas
		ldi		regA,0x03		;si>=5 enlève 0x03
		add		r10,regA
tst1o:	ldi		regA,0xF0
		and		regA,r10
		swap	regA
		cpi		regA,5
		brlo	endtst2o	;regA<5 test 1 octal haut
		ldi		regA,0x30
		add		r10,regA	;si>=5 enlève 0x30
endtst2o:
		ret
		     

i2c.inc

    
; IO Port Bits
.equ	bSDA		= PB4	;* SCL Port B, PB1 Pin 6
.equ	bSCL		= PB3	;* SDA Port B, PB0 Pin 5
.equ	mSDA		= (1<<bSDA) ;Calculate binary value corresponding to I/O port bit for masking
.equ	mSCL		= (1<<bSCL) ;Calculate binary value corresponding to I/O port bit for masking

;Port C
.equ	I2CPORT 	= PORTB	;*Set to correspond to I/O Port used for I2C
.equ	I2CDDR  	= DDRB	;*Set to correspond to I/O Port used for I2C
.equ	I2CPIN  	= PINB	;*Set to correspond to I/O Port used for I2C

; delay half period
; For I2C in normal mode (100kHz), use T/2 > 5us
; For I2C in fast mode (400kHz),   use T/2 > 1.25us
#define	I2C_speed   int(F_CPU*1.5/4000000)	;1.5us
;Pour l'I²C
.ifndef DCounter
	.def DCounter=r8;
	.message "DCounter vient d'etre defini!"
.else
	.message "AM3220:DCounter est deja defini!"
.endif
.ifndef DATA
	.def DATA=r18;Read/Write data 
	.message "DATA vient d'etre defini!"
.else
	.message "AM3220:DATA est deja defini!"
.endif


;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
;		START I2C ROUTINES
;xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
;-----------------------------------------------------------------

;*************************************************************************
; delay half period
; For I2C in normal mode (100kHz), use T/2 > 5us
; For I2C in fast mode (400kHz),   use T/2 > 1.25us
;*************************************************************************
I2CDelay:
	ldi		XH,HIGH(I2C_speed) ;5us
	ldi		XL,LOW(I2C_speed)
	rcall	Wait4xCycles
	ret								 ; 4 cycle = total 60 cycles = 5.0 microsec with 8 Mhz crystal
	
;-----------------------------------------------------------------		
I2CInit:
	; Set up port assignments
	sbi		I2CDDR,bSCL		; SCL only output by default 
	sbi		I2CPORT,bSCL	; SCL outputs high, input pullups disabled
	cbi		I2CPORT,bSDA	; Data line always drives low if driven
	cbi		I2CDDR,bSDA		; SDA as input to start with - floats high
	cbi		I2CPORT,bSCL	; Set SCL low to try and avoid...	
	sbi		I2CDDR,bSCL		; ...false start transitions
	rcall	I2CDelay
	rjmp	I2CStop			; Stop any erroneous transfer
	

;-----------------------------------------------------------------
; I2CStart
; Send I2C start condition
; Assumes SCL and SDA are high to start with.
; Leaves SCL and SDA low
I2CStart:
	rcall	I2CDelay	
	sbi		I2CDDR,bSDA		; Drive data line low (start bit)
	rcall	I2CDelay
	cbi		I2CPORT,bSCL	; Clock line low (ready to start)
	ret	
;-----------------------------------------------------------------
; I2CStop
; Send I2C stop condition
; Assumes SCL is low to start with, SDA may be in either state
; Leaves SCL and SDA high
I2CStop:
	sbi		I2CDDR,bSDA		; SDA driven low
	rcall	I2CDelay	
	sbi		I2CPORT,bSCL	; Clock line high (ready to stop)
	rcall	I2CDelay	
	cbi		I2CDDR,bSDA		; Data line floats high (stop bit)
	rcall	I2CDelay
	ret

;-----------------------------------------------------------------	
;DATA_write_byte 
;	DATA byte
;	ADR	 adresse byte
DATA_write_byte:
	mov		regA,DATA			; save value
	rcall	I2CStart
	ldi		DATA,(SSD1306<<1)
	rcall	I2CSendAddress
	brne	WriteI2cNoAck	; No ack!
	mov		DATA,regA
	rcall	I2CSendByte
	rcall	I2CStop
	ret	
	
WriteI2cNoAck:
	rcall	I2CStop
	clr		DCounter
WriteI2CErrorDelay:
	dec		DCounter
	brne	WriteI2CErrorDelay
	mov		DATA,regA 	; restore data value
	rjmp	DATA_write_byte		; and try again
;------------------------------------------------------------------
; I2CSendByte
; Sends 8 bits of data from DATA and listens for an ACK at the end. 
; Returns Z if ack received, else NZ.
; Assumes a start condition has already been sent, and SDA and SCL
; are low Leaves SCL low, SDA not driven. Uses DCounter and DATA.
I2CSendAddress:
I2CSendByte:
	push	regA
	ldi		regA,8
	mov		DCounter,regA
	pop		regA
I2CSendBits:
	add		DATA,DATA	;*2 décalage à gauche
	brcc	I2CSendBits0	; si carry=0 I2CSendBits0
	cbi		I2CDDR,bSDA		; send 1 (floats high)
	rjmp	I2CSendBits1
I2CSendBits0:
	sbi		I2CDDR,bSDA		; send 0 (drives low)
I2CSendBits1:	
	rcall	I2CDelay
	sbi		I2CPORT,bSCL	; clock high
	rcall	I2CDelay
	cbi		I2CPORT,bSCL	; clock low
	dec		DCounter
	brne	I2CSendBits
	cbi		I2CDDR,bSDA		; stop driving data bus
	rcall	I2CDelay
	sbi		I2CPORT,bSCL	; clock high
	rcall	I2CDelay
	in		DATA,I2CPIN	; sample data bus
	cbi		I2CPORT,bSCL	; clock low
	rcall	I2CDelay
	andi	DATA,mSDA	; check ack bit (z set if OK)
	
	ret
	/*
;------------------------------------------------------------------
; I2CReadByte Read a byte from the I2C bus and acknowledge
; Si DATA est nul, ACK est envoyé, sinon non.
; Byte is returned in A
; Leaves SCL low, I2C bus not driven.
I2CReadByte:
	ldi		regA,8
	mov		DCounter,regA
	clr		regA
	cbi		I2CDDR,bSDA		; release bus (floats high)	
I2CReadBits:
	sbi		I2CPORT,bSCL	; clock high
	rcall	I2CDelay	
	add		regA,regA				;<<1
	sbic	I2CPIN,bSDA		; if SDA clear, skip increment
	inc		regA	
	cbi		I2CPORT,bSCL	; clock low
	rcall	I2CDelay
	dec		DCounter
	brne	I2CReadBits

	tst		DATA			; Send an ACK...?
	brne	I2CReadBitsNack	
	sbi		I2CDDR,bSDA		; yes... drive data bus low
I2CReadBitsNack:
	sbi		I2CPORT,bSCL	; clock high
	rcall	I2CDelay
	cbi		I2CPORT,bSCL	; clock low
	rcall	I2CDelay
	cbi		I2CDDR,bSDA		; release bus (floats high)
	ret
	*/     

number_16x32.inc

    number_16x32:
.db 0x80, 0xff, 0xc0, 0xff, 0xe0, 0xff, 0xf0, 0xff, 0xf0, 0x00, 0x70, 0xf0, 0x30, 0xf8, 0x30, 0xf8, 0x70, 0xf0, 0xf0, 0x00, 0xf0, 0xff, 0xe0, 0xff, 0xc0, 0xff, 0x80, 0xff, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x3f, 0x00, 0x7f, 0x00, 0xff, 0x00, 0xf0, 0x00, 0xe0, 0x00, 0xc1, 0x00, 0xc1, 0x00, 0xe0, 0x00, 0xf0, 0x00, 0xff, 0x00, 0x7f, 0x00, 0x3f, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00; 0
.db 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x80, 0x01, 0xc0, 0x01, 0xe0, 0x01, 0xf0, 0xff, 0xf0, 0xff, 0xf0, 0xff, 0xf0, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00; 1
.db 0xc0, 0x01, 0xe0, 0x01, 0xf0, 0x01, 0xf0, 0x00, 0x70, 0x80, 0x30, 0xc0, 0x30, 0xe0, 0x30, 0xf0, 0x30, 0xf8, 0x70, 0x7c, 0xf0, 0x3f, 0xf0, 0x1f, 0xe0, 0x0f, 0xc0, 0x07, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x00, 0xfc, 0x00, 0xfe, 0x00, 0xff, 0x00, 0xcf, 0x00, 0xc7, 0x00, 0xc3, 0x00, 0xc1, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00; 2
.db 0xc0, 0x00, 0xe0, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0x70, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x70, 0x78, 0xf0, 0xff, 0xf0, 0xff, 0xe0, 0xcf, 0xc0, 0x87, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x70, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xe0, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xe0, 0x00, 0xff, 0x00, 0xff, 0x00, 0x7f, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00; 3
.db 0x00, 0xf0, 0x00, 0xf8, 0x00, 0xfc, 0x00, 0xfe, 0x00, 0xdf, 0x80, 0xcf, 0xc0, 0xc7, 0xe0, 0xc3, 0xf0, 0xff, 0xf0, 0xff, 0xf0, 0xff, 0xf0, 0xff, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00; 4
.db 0xf0, 0x3f, 0xf0, 0x3f, 0xf0, 0x3f, 0xf0, 0x3f, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x70, 0x30, 0xf0, 0x30, 0xf0, 0x30, 0xe0, 0x30, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x70, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xe0, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xe0, 0x00, 0xff, 0x00, 0xff, 0x00, 0x7f, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00; 5
.db 0x00, 0xff, 0x80, 0xff, 0xc0, 0xff, 0xe0, 0xff, 0xf0, 0x71, 0xf0, 0x30, 0x70, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x70, 0x30, 0xf0, 0x30, 0xf0, 0x00, 0xe0, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x7f, 0x00, 0xff, 0x00, 0xff, 0x00, 0xe0, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xe0, 0x00, 0xff, 0x00, 0xff, 0x00, 0x7f, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00; 6
.db 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0x30, 0x80, 0x30, 0xc0, 0x30, 0xe0, 0x30, 0xf0, 0x30, 0xf8, 0x30, 0x7c, 0xf0, 0x3f, 0xf0, 0x1f, 0xf0, 0x0f, 0xf0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00; 7
.db 0xc0, 0x87, 0xe0, 0xcf, 0xf0, 0xff, 0xf0, 0xff, 0x70, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x70, 0x78, 0xf0, 0xff, 0xf0, 0xff, 0xe0, 0xcf, 0xc0, 0x87, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x7f, 0x00, 0xff, 0x00, 0xff, 0x00, 0xe0, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xe0, 0x00, 0xff, 0x00, 0xff, 0x00, 0x7f, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00; 8
.db 0xc0, 0x0f, 0xe0, 0x1f, 0xf0, 0x3f, 0xf0, 0x3f, 0x70, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x70, 0x38, 0xf0, 0xff, 0xf0, 0xff, 0xe0, 0xff, 0xc0, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xe0, 0x00, 0xf0, 0x00, 0xf8, 0x00, 0x7f, 0x00, 0x3f, 0x00, 0x1f, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00; 9     

oled.inc

    ;.def    State		=r20
;bit 0 color text 0 normal, 1 inversé
;bit 1 cadre 0 non 1 oui
.def	posX		= r6
.def	posY		= r7
;.def    regB    =R19
;.def    loopC   =R22    ;loop registers
.equ	SSD1306		= 0x3C	;Adresse I2C
.equ	 SSD1306_LCDWIDTH =128
.equ	 SSD1306_LCDHEIGHT =64
.equ	maxligne=7
.include "i2c.inc"
;.include "font5x8.inc"
;.include "font_rpm.inc"
.include "number_16x32.inc"
SSD1306_INIT:
	rcall	I2CInit				;INIT I2C
	
	ldi		regA,100
	rcall   WaitMiliseconds
	ldz		SSD1306_config
	rcall	ssd1306_write_cmd
	rcall	ssd1306_clearDisplay
	ret

;______________________________________
; ssd1306_write_cmd	
; DATA
;______________________________________
ssd1306_write_cmd:
	lpm 	DATA, Z+		;DATA=(Z) FLASH Z=Z+1
	cpi		DATA,0xFF			;Si egal fin
	breq	end_write_cmd
	rcall	DATA_write_cmd		;Ecrire la donnée commande
	
	;ldi		regA,10				;A voir si supprimer?
	;rcall   WaitMiliseconds
		
	rjmp 	ssd1306_write_cmd
end_write_cmd:
	ret
;______________________________________
;ssd1306_write_data Envoyer 
;-regB octets pointé par Z
;______________________________________
ssd1306_write_data:
	rcall	I2CStart
	ldi		DATA,(SSD1306<<1)	;Adresse
	rcall	I2CSendByte
	ldi		DATA,0x40		;Write_DATA
	rcall	I2CSendByte
overdata:
	cpi		regB,1
	brne	suiteoverdata		
	clr		DATA
	rjmp	clroverdata
suiteoverdata:
	lpm		DATA,Z+
clroverdata:
	sbrc	State,0	;Skip if Bit 0 in Register State is clear
	com		DATA	;inverse les bits
	sbrc	State,1	;Skip if Bit 1 in Register State is clear
	ori		DATA,0x81 ; cadre
	rcall	I2CSendByte
	dec		regB
	brne	overdata
	rcall	I2CStop
	ret
;______________________________________	
;DATA_write_cmd 
;______________________________________
DATA_write_cmd:
	push	DATA
	rcall	I2CStart
	ldi		DATA,(SSD1306<<1)	;Adresse
	rcall	I2CSendByte
	clr		DATA				;Commande envoyer 0 avant
	rcall	I2CSendByte
	pop		DATA
	rcall	I2CSendByte			;Envoyer commande
	rcall	I2CStop				;End transmission
	ret

	
;______________________________________
;	SETPOS	X,Y   soit R12,R13
;______________________________________
ssd1306_setpos: ;Entrée X Y dans les registres  R12 et R13
	rcall	I2CStart
	ldi		DATA,0xb0
	add		DATA,posY
	rcall	DATA_write_cmd
	mov		DATA,posX
	andi	DATA,0x0f	;0x02+(posX & 0x0f)
	subi	DATA,0xFE	;Sets 4 lower bits of column address of display RAM in register.  Set Lower Column Start Address for Page Addressing Mode 
	rcall	DATA_write_cmd
	mov		DATA,posX
	andi	DATA,0xf0
	swap	DATA		;(0x10+(posX >>4)
	ori		DATA,0x10	;Sets 4 higher bits of column address of display RAM in register. colonne 0x02 Set Higher Column Start Address for Page Addressing Mode
	rcall	DATA_write_cmd
	rcall	I2CStop
	ret
	/*
;______________________________________
; ssd1306_write_string_flash
; flag T = color
;______________________________________
ssd1306_write_string_flash:
	lpm 	DATA, Z+		;DATA=(Z) FLASH Z=Z+1
	tst		DATA			;Si egal fin
	breq	end_write_str_flash
	rcall	ssd1306_char_font16x16	;Écrire caractère
	rjmp	ssd1306_write_string_flash
end_write_str_flash:
	ret
	*/
;______________________________________
; ssd1306_write_string
; flag T = color
;______________________________________
ssd1306_write_string:			
	ld		DATA,Z+			;DATA=(Z) RAM Z=Z+1
	tst		DATA			;Si egal fin
	breq	end_write_str
	rcall	ssd1306_char_font16x32	;Écrire caractère
	rjmp	ssd1306_write_string
end_write_str:
	ret
/*
;______________________________________
; ssd1306_write_string
;______________________________________
ssd1306_char_font5x8:
	push	ZL
	push	ZH
	subi	DATA,32	
	ldz		ssd1306xled_font5x8
	ldi		regA,5
	mul		DATA,regA
	add		ZL,r0
	adc		ZH,r1
	ldi		regB,6 	;5 octets  pour les données+1 espace
	rcall	ssd1306_write_data
	pop		ZH
	pop 	ZL
	ret
*/

;______________________________________
; ssd1306_char_font16x32
; font 16x32
;______________________________________
ssd1306_char_font16x32:
	push	ZL
	push	ZH
	cpi		DATA,32
	breq	skipchar
	subi	DATA,48	
	ldz		number_16x32
	ldi		regA,64	;32 octets par ligne font
mul32:
	add		ZL,regA
	adc		ZH,zero
	dec		DATA
	brne	mul32
	ldi		regC,4		;4 blocs par caractère
	clr		posY
blc_4_fois:
	ldi		regB,16 	;16 octets  pour les données première ligne
	rcall	ssd1306_write_data
	inc		posY
	rcall	ssd1306_setpos
	dec		regC
	brne	blc_4_fois
skipchar:
	clr		posY
	ldi		regB,16
	add		posX,regB
	rcall	ssd1306_setpos
	pop		ZH
	pop 	ZL
	ret
/*
;______________________________________
; ssd1306_char_font16x16
; font 16x16
;______________________________________
ssd1306_char_font16x16:
	push	ZL
	push	ZH
	subi	DATA,32	
	ldz		ssd1306led_font16x16
	ldi		regA,32	;32 octets par ligne font
mul32:
	add		ZL,regA
	adc		ZH,zero
	dec		DATA
	brne	mul32

	ldi		regB,16 	;16 octets  pour les données première ligne
	rcall	ssd1306_write_data
	inc		posY
	rcall	ssd1306_setpos
	ldi		regB,16 	;16 octets  pour les données deuxième ligne
	rcall	ssd1306_write_data
	dec		posY
	ldi		regB,16
	add		posX,regA
	rcall	ssd1306_setpos
	pop		ZH
	pop 	ZL
	ret
	*/
;______________________________________
; ssd1306_clearDisplay
;______________________________________
ssd1306_clearDisplay:
	push	regA
	push	DATA
	ldi		regA,4
	mov		posY,regA
	clr		posX
allrow:
	rcall	ssd1306_setpos
	rcall	I2CStart
	ldi		DATA,(SSD1306<<1)	;Adresse
	rcall	I2CSendByte
	ldi		DATA,0x40				;Write_DATA  Specifies RAM display line for COM0.
	rcall	I2CSendByte
	ldi		regA,128			;16*4
display0:
	push	regA
	clr		DATA			;0
	rcall	I2CSendByte
	pop		regA
	dec		regA
	brne	display0

	rcall	I2CStop

	dec		posY
	brne	allrow
	clr		posY
	rcall	ssd1306_setpos
	pop		DATA
	pop		regA
	ret
/*
newline:
	inc		posY
	rcall	ssd1306_setpos
	rcall	ssd1306_write_string
	ret
	*/
	/*
;----------------------------------------
;bargraph
;entrée 
;DATA = valeur entre 0 et 120
display_txt:
;SETPOS	X,Y   soit R12,R13
	push	DATA
	push	regB
	push	regC
	ldi		DATA,0
	mov		posY,DATA 
	ldi		DATA,(6*6) ;6 caractères
	mov		posX,DATA
	rcall	BIN2DCB32 			;afficher la valeur du restant de fichier
	pop		regC
	pop		regB
	pop		DATA	
	ret
	*/
;----------------------------------------
ssd1306_sendCRLF:
	push	regA
	ldi		regA,6
	inc		posY
	cp		posY,regA
	brlo	crlfnormal			;posY<6
	;ldi		regA,250
	;rcall	Waitcentiseconds
	rcall	ssd1306_clearDisplay
	clr		posY
crlfnormal:	
	clr		posX
	rcall	ssd1306_setpos
	pop		regA
	ret

.include "BIN2DCB32.inc"
SSD1306_config:
.db 0xAE,0xD5,0x80,0xA8,0x3F,0xD3,0x0,0x40,0xb0,0x02,0x10,0x8D,0x14,0x20,0x00,0xA1,0xC8,0xDA,0x12,0x81,0xCF,0xD9,0xF1,0xDB,0x40,0xA4,0xA6,0x2E,0xAF,0xFF

;.db 0xAE,0xD5,0x80,0xA8,0x3F,0xD3,0x0,0x40,0x8D,0x14,0x20,0x00
;.db 0xA1,0xC8,0xDA,0x12,0x81,0xCF,0xD9,0xF1,0xDB,0x40,0xA4,0xA6,0x2E,0xAF,0xFF,0xFF
;.dseg
;.org 0x100
;buffertxt:
;.byte 40
     

wait.inc

    ;______________________________________
;         MODULE Wait
; Matériel : 	ATtiny 45/85 4MHz à 20Mhz 5V
; (c) sammy76.free.fr
;	V1.0 2016/11/06
;______________________________________

#ifndef F_CPU
	#define F_CPU 16000000 ;16MHz
	#error "F_CPU must be defined!"
#endif


#if F_CPU < 4000000
	#message "Processeur beaucoup trop lent"
	#warning "F_CPU too low, possible wrong delay"
#endif

#define CYCLES_PER_US (F_CPU/1000000) ;Nombre de cycles par us
#define C4PUS (F_CPU/4000000) ;/4 nombre de périodes par us attention aux approximation
#define FOR1MS 1000;us par ms 

;.define DVUS(x) (C4PUS*x)

;------------------------------------------------------------------------------
; Input : XH:XL - number of CPU cycles to wait (divided by four)
;------------------------------------------------------------------------------
Wait4xCycles: ;(rcall 3cycle)
	sbiw	XL, 1		; x-- (2 cycles)
	brne	Wait4xCycles	; jump if not zero (2 cycles)
	ret		;(4 cycles )
;------------------------------------------------------------------------------
; Input : A - number of miliseconds to wait
;------------------------------------------------------------------------------
;Attention:
;Approximation pour 1ms = 4*1000*4cyc*1000rep*3mult/16.5E6 soit 0.969ms 
;donc avec les répétitions on cumul l'erreur
;
WaitMiliseconds:
	push	XH
	push	XL
	push	regA
WaitMsLoop:	
	ldi		XH,HIGH(C4PUS*FOR1MS) ;1000us soit 1ms en fait avec 16.5MHz mettre 1031
	ldi		XL,LOW(C4PUS*FOR1MS)
	rcall	Wait4xCycles
	dec		regA
	brne	WaitMsLoop
	pop		regA
	pop		XL
	pop		XH
	ret
	
;------------------------------------------------------------------------------
;Input : A - number of seconds to wait
;------------------------------------------------------------------------------
waitseconds:
	push	regA
	push	YL
	push	YH
	push	XL
	push	XH

waitsec:
		ldi		YL,10	;1s
		push 	regA
		waitms:
			ldi 	regA,100	;0,1s
			rcall  WaitMiliseconds
			dec	YL
			brne   waitms
		pop		regA
		dec    regA
		brne   waitsec
	pop		XH
	pop		XL
	pop		YH
	pop		YL
	pop    regA
ret
/*
;------------------------------------------------------------------------------
;Input : A - number of minutes to wait
;------------------------------------------------------------------------------
waitminute:
	push	regA
	ldi		regA,60
onesecond:
	rcall	waitseconds
	pop		regA
	dec		regA
	brne	waitminute
	ret
*/ 

• Dimensions : 45 mm x 20 mm x 15 mm
• Plage de mesure : 2 cm à 400 cm
• Résolutionde la mesure: 0.3 cm
• Angle de mesure efficace : 15°
• Largeur d'impulsion sur l'entrée de déclenchement : 10 μs (Trigger Input Pulse width)
• Tension d'alimentation : 5V nominal ±0.5V
• Courant de repos : 2mA nominal ±0.5mA
• Courant de fonctionnement : 15mA nominal ±5mA
• Fréquence des ultrasons : 40kHz

Broches de connection

• Vcc= Alimentation +5 V DC
• Trig= Entrée de déclenchement de la mesure (Trigger input)
• Echo= Sortie de mesure donnée en écho (Echo output)
• GND= Masse de l'alimentation

Fonctionnement

Distance de l'objet

Programme

;                      ATtiny85-PU20
;                         +-\/-+
;                    PB5 1|-  -|8  Vcc
;             TRIG - PB3 2|-  -|7  PB2
;             ECHO - PB4 3|-  -|6  PB1
;                    GND 4|-  -|5  PB0
;                         +----+
    #define F_CPU 20000000 ;20MHz
    #define C4PUS (F_CPU/4000000) ;/4 nombre de périodes par us attention aux approximation
    .def    zero   = r10
    .def    regA   = R16       ; GENERAL PURPOSE ACCUMULATOR
    .def    VL      =r22
    .def    VH      =r23
    .equ    V=17010*10  ;Vitesse du son A/R en cm/s *10us
    .equ    US4CM=(F_CPU/V) ;us pas cm
    .equ    TRIG=PORTB3       ;  Sensor TRIG pin (Output on AVR, input on sensor)
    .equ    ECHO=PORTB4       ;  Sensor ECHO pin (Input on AVR, output on sensor)

    .cseg
.include "tn85def.inc"
    .org 0x0000

    rjmp  RESET_vect    ;  Reset Handler
    reti                ;  External Interrupt 0

    RESET_vect:
    clr     zero

loop:
    rcall   HCSR04

    rjmp    loop

HCSR04:
    ldi     XH,HIGH(C4PUS*10) ;10us
    ldi     XL,LOW(C4PUS*10)
    SBI     PORTB,TRIG        ; Start 10µs trigger pulse by setting TRIG high.
    rcall   Wait4xCycles      ; Run the delay.
    CBI     PORTB,TRIG        ; Turn off the trigger.

    clr     VH                ;Initialise le compteur de longueur
    clr     VL

;  Waits for echo to start from ultrasonic sensor.
WAIT4ONECHO:
    sbis     PINB, ECHO       ; Check ECHO line of sensor and skip if high
    rjmp     WAIT4ONECHO
    ;retour d'une longueur d'impulsion d'écho dans V .
    ; À ce stade, V aura soit le nombre de 0
    ; 512cm intervalles à l'objet ou seront nuls ,
    ; indiquant l'objet n'a pas été détecté .
GETECHOPULSE:
    inc     VL              ; [1] V=V+1 (1cm)
    adc     VH,zero         ; [1]
    cpi     VH,2            ; [1]=3 VH>=2
    brge    GEPret          ; [1]/2=4 If CNT overflows to zero, exit routine.
                            ;     Timing: false:1clk, true:2clk
    ldi     XH,HIGH(C4PUS*US4CM-1) ;us (-7) call+ret
    ldi     XL,LOW(C4PUS*US4CM-1)
    rcall   Wait4xCycles     ; Run the delay for 1cm

    sbic     PINB, ECHO     ; [1]/2=6 Check ECHO pin. If no ECHO, skip over next instruction.
                            ;     Timing: false:1clk, true:2clk
    rjmp     GETECHOPULSE   ; [2]=8
GEPret:

    cpi     VH,2            ;Sinon si XH>=2 (>511cm); objet non détecté
    brge    NoObj
    tst     VL
    brne    OBJETOK
NoObj:
    clr     VL              ;Si 0 pas d'objet
    clr     VH
OBJETOK:
    ret

;------------------------------------------------------------------------------
; Input : XH:XL - number of CPU cycles to wait (divided by four)
;------------------------------------------------------------------------------
Wait4xCycles:
    sbiw    XH:XL, 1        ; x-- (2 cycles)
    brne    Wait4xCycles    ; jump if not zero (2 cycles)
    ret
    

Détails des octets

Les Alarmes

1. La première fois que l'alimentation est appliquée.
2. Les tensions présentes à la fois sur VCC et VBAT sont insuffisantes pour supporter l'oscillation.
3. Le bit EOSC est désactivé en mode alimenté par batterie.
4. Influences externes sur le cristal (c.-à-d. , bruit, fuite, etc.).

Température

Caractéristique du HMC5883L

Modes de fonctionnnements

Continuous-Measurement Mode

Single-Measurement Mode

Idle Mode

Les registres

Accès aux registres

Configuration Register A

Configuration Register B

Mode Register

Data Output X, Y, Z Registers A and B

Status Register

LOCK

• les six octets ont été lus ou le mode a changé
• le mode est changé.
• la configuration de mesure est modifiée.

RDY

Identification Register A, B, C

Calibration

Bonus guidage

En bonus, ci-dessous un petit programme de guidage par boussole

    #include <Wire.h>
#include <HMC5883L.h>

HMC5883L compass;

float angle=0;
//Calculate magnetic declination according to your location
//See http://magnetic-declination.com
//Or https://www.ngdc.noaa.gov/geomag/calculators/magcalc.shtml?#declination

float declinationAngle = (0.0 + (48.0 / 60.0)) / (180 / PI);
//Ajoute 0.11
//Pour les moteurs
int target=180;
int cap=0;
int speedLeft;
int speedRight;
void setup()
{
  Serial.begin(9600);
  // Initialize Initialize HMC5883L
  while (!compass.begin())
  {
    delay(500);
  }
  //Serial.println(F("Signature HMC5883L : 'A48'"));
  // Set measurement range
  compass.setRange(HMC5883L_RANGE_1_3GA);
  // Set measurement mode
  compass.setMeasurementMode(HMC5883L_CONTINOUS);
  // Set data rate
  compass.setDataRate(HMC5883L_DATARATE_30HZ);
  // Set number of samples averaged
  compass.setSamples(HMC5883L_SAMPLES_8);
}

void loop()
{
  Vector mag = compass.readRaw();
  
  angle=atan2((mag.YAxis*1.02407002188184+ 180),(mag.XAxis -105))*180/PI;
  angle -= declinationAngle;
  if (angle<0) angle+=360;

  /* 
   *  
   *  Pilotage du véhicule
   *  
   *  
  */
  cap=(int)angle;
  // how many degrees are we off
  int diff = cap-target;
  
  // modify degress
  if (diff > 180) {
    diff = -360 + diff;
  } else if (diff < -180) {
    diff = 360 + diff;
  }

  // Make the robot turn to its proper orientation
  diff = map(diff, -180, 180, -255, 255);

 if (diff > 0) {
    // keep the right wheel spinning,
    // change the speed of the left wheel
    speedLeft = 255 - diff;
    speedRight = 255;
  } else {
    // keep the right left spinning,
    // change the speed of the left wheel
    speedLeft = 255;
    speedRight = 255 + diff;
  }
  Serial.print(F("XY:"));
  Serial.print(angle);
  Serial.print(F("°\tTarget:"));
  Serial.print(target);
  Serial.print(F("\tCap:"));
  Serial.print(cap);
  Serial.print(F("\tGauche:"));
  Serial.print(speedLeft);
  Serial.print(F("\tDroite:"));
  Serial.println(speedRight);
  delay(250);
}

	Ce LiDAR fait maison a un Ø52mm pour une longueur de 78,5mm Il fonctionne sous 5V. Protocoles de liaisons point à point série UART a 115200bauds, parité "none", 8 bits,1 bit de stop. Suivant la vitesse de rotation du motoréducteur N20, la vitesse de balayage $Z_{moteur}=10dts, Z_{couronne}=32dts$ $N_{couronne}=\dfrac{N_{moteur}\cdot Z_{moteur}}{Z_{couronne}}$ Mon motoréducteur tourne a 40min-1, donc ma couronne tourne à 12,50 min-1. soit $0,21tr\cdot s^{-1}$, ce qui représente 75°/s. Avec une mesure à 30Hz, entre chaque mesure 2,5°. A une distance de 3m, cela représente 130,9mm, de default de lecture.
	Le LiDAR (Light Detection And Ranging),est une méthode de télédétection et de télémétrie semblable au radar, mais qui émet des impulsions de lumière infrarouge, au lieu d'ondes radio, puis en mesure le temps de retour après avoir été réfléchies sur des objets à proximité.

Liste du matériel

Image	Désignation	Fournisseur	Prix	Stock	Nécessaire
	Module de capteur de distance Laser, TOF400C VL53L1X 4m I²C library : VL53L0X adresse : (0x29)	aliexpress	6,35€	1	1
	3-6V DC Arbre court Couple type N20 reducteur Moteur de Boite a vitesse Vitesse de rotation à vide : 40 ± 10% tr/min Dimensions 33 x 13 x 10 mm Ø arbre 3 mm	amazone	1,51€	2	1
	Anneau de glissement de Capsule 10 canaux 2A 22mm, Ø22mm de diamètre, 10 voies 2A, aiguille de brosse interne plaquée or et bague de glissement, fils avant et arrière 90mm Le courant nominal de chaque canal est de 2A et la tension nominale est de 240VAC. Vitesse jusqu'à 300 RPM. Les signaux analogiques et numériques peuvent être transmis. Rotation et transmission fluides illimitées de 360o.	aliexpress	4,76€	1	1
	Balles de tir en acier inoxydable, Ø5mm	aliexpress	0,023€	200	10
	Ensembles broche à angle Droit Pas 2.54mm Pin Header Connecteur Adaptateur JST XH 4P M/F	aliexpress	0,056€	20	1
	US1881 TO92 capteur d'effet Hall détecteur magnétique 3.5V à 24V 5mA	aliexpress	0,10€	10	1
	Aimant Rectangle Néodyme N52 Terres Rares Taille: N52 40x10x4mm	aliexpress	0,714€	6	1
	Un microcontrolleur				1
	Un module de pilote de moteur à courant continu				1

Le cablage

	Les branchement du LiDAR, après reflection, les informations en entrée et en sortie. Choix du protocole : Série, pour sa simplicité d'émission et réception des informations. En entrée: Possibilité d'envoyer une commande via le bus série 3.3V ou 5V, pour ne tenir en compte que de certains angles seul secteur. En sortie: Liste de données comportant l'angle et la distance uniquement.

Le nombre de fils