Misurazione di velocità, distanza e angolo per robot mobili che utilizzano arduino e sensore di velocità lm393 (h206)

I robot hanno iniziato lentamente a strisciare nella nostra società per rendere la nostra vita più semplice. Possiamo già trovare i robot per la consegna di cibo a sei ruote di Starship sulle strade del Regno Unito, che navigano abilmente tra i civili per raggiungere la sua destinazione. Ogni robot mobile che naviga nell'ambiente dovrebbe essere sempre consapevole della sua posizione e orientamento rispetto al mondo reale. Ci sono molti modi per ottenere questo risultato utilizzando diverse tecnologie come GPS, triangolazione RF, accelerometri, giroscopi, ecc. Ogni tecnica ha il suo vantaggio ed è unica di per sé. In questo tutorial sul sensore di velocità Arduino LM393 useremo il modulo del sensore di velocità LM393 semplice e facilmente disponibileper misurare alcuni parametri vitali come Velocità, Distanza percorsa e Angolo del robot utilizzando Arduino. Con questi parametri il robot sarà in grado di conoscere il suo stato nel mondo reale e potrà utilizzarlo per navigare in sicurezza.

Arduino è la scelta più popolare tra gli hobbisti per la costruzione di robot, da un semplice seguace di linea a un più complesso robot autobilanciante o lavapavimenti. Puoi controllare tutti i tipi di robot nella sezione Robotica.

Costruiremo un piccolo robot alimentato da una batteria al litio e lo guideremo utilizzando un joystick. Durante il runtime possiamo misurare la velocità, la distanza e l'angolo del robot e visualizzarli in tempo reale sul display LCD collegato ad Arduino. Questo progetto ti aiuta solo a misurare questi parametri, una volta che hai finito puoi usare questi parametri per far funzionare il tuo bot in modo autonomo come richiesto. Sembra interessante, vero? Quindi iniziamo.

Modulo sensore di velocità LM393 (H206)

Prima di entrare nello schema circuitale e nel codice per il progetto, comprendiamo il modulo sensore di velocità LM393 poiché svolge un ruolo vitale nel progetto. Il modulo sensore di velocità H206 è costituito da un sensore di luce a infrarossi integrato con un IC comparatore di tensione LM393 da cui il nome sensore di velocità LM393. Il modulo è costituito anche da una piastra a griglia che deve essere montata sull'albero rotante del motore. Tutti i componenti sono etichettati nell'immagine sottostante.

Il sensore di luce a infrarossi è costituito da un LED IR e un fototransistor separati da una piccola gabbia. L'intera disposizione del sensore è collocata in un alloggiamento nero come mostrato sopra. La piastra della griglia è costituita da fessure, la piastra è disposta tra lo spazio del sensore di luce a infrarossi in modo tale che il sensore possa rilevare gli spazi nella piastra della griglia. Ogni fessura nella piastra della griglia attiva il sensore IR quando passa attraverso la fessura; questi trigger vengono quindi convertiti in segnali di tensione utilizzando il comparatore. Il comparatore non è altro che un IC LM393 di ON Semiconductors. Il modulo ha tre pin, due dei quali vengono utilizzati per alimentare il modulo e un pin di uscita viene utilizzato per contare il numero di trigger.

Disposizione di montaggio del sensore H206

Il montaggio di questi tipi di sensori è un po 'complicato. Può essere montato solo su motori con albero sporgente su entrambi i lati. Un lato dell'albero è collegato alla ruota mentre l'altro lato è utilizzato per montare la piastra della griglia come mostrato sopra.

Poiché la ruota e la piastra sono collegate allo stesso albero, entrambe ruotano alla stessa velocità e quindi misurando la velocità della piastra possiamo misurare la velocità della ruota. Assicurati che gli spazi nella piastra della griglia passino attraverso il sensore IR, solo allora il sensore sarà in grado di contare il numero di spazi che è passato attraverso. È inoltre possibile creare una propria disposizione meccanica per montare il sensore purché soddisfi le condizioni specificate. Il sensore IR viene generalmente utilizzato in molti progetti di robotica per guidare il robot sugli ostacoli.

La piastra della griglia mostrata sopra ha 20 slot (griglie). Ciò significa che il sensore troverà 20 spazi per una rotazione completa della ruota. Contando il numero di spazi che il sensore ha rilevato possiamo calcolare la distanza percorsa dalla ruota, allo stesso modo misurando la velocità con cui il sensore trova gli spazi possiamo rilevare la velocità della ruota. Nel nostro robot avremo questo sensore montato su entrambe le ruote e quindi possiamo trovare anche l'angolo del robot. Tuttavia, l'angolo di rotazione può essere calcolato in modo più sensato utilizzando l'accelerometro o il giroscopio, impara qui a interfacciare l'accelerometro e il giroscopio con Arduino e prova a misurare l'angolo di rotazione usandoli.

Schema del circuito del robot del sensore di velocità Arduino LM393 fai-da-te

Di seguito è mostrato lo schema circuitale completo di questo robot di rilevamento della velocità e della distanza. Il Bot è costituito da Arduino Nano come il suo cervello, i due motori DC per le ruote sono azionati dal modulo H-Bridge Motor Driver L298N. Il Joystick viene utilizzato per controllare la velocità e la direzione del bot e i due sensori di velocità H206 vengono utilizzati per misurare la velocità, la distanza e l'angolo del bot. I valori misurati vengono quindi visualizzati nel modulo LCD 16x2. Il potenziometro collegato all'LCD può essere utilizzato per regolare il contrasto dell'LCD e la resistenza viene utilizzata per limitare la corrente che fluisce alla retroilluminazione dell'LCD.

Il circuito completo è alimentato da una cella 7.4V litio. Questo 7.4V è fornito al pin 12V del modulo driver del motore. Il regolatore di tensione sul modulo del driver del motore converte quindi il 7,4 V in + 5 V regolato che viene utilizzato per alimentare Arduino, LCD, sensori e joystick.

Il motore è controllato dai pin digitali 8,9,10 e 11 di Arduino. Poiché anche la velocità del motore deve essere controllata, dovremmo fornire segnali PWM al terminale positivo del motore. Quindi abbiamo i pin 9 e 10 che sono entrambi pin compatibili con PWM. I valori X e Y del joystick vengono letti utilizzando rispettivamente i pin analogici A2 e A3.

Come sappiamo, il sensore H206 genera un trigger quando viene rilevato il divario nella piastra della griglia. Poiché questi trigger non devono essere sempre letti in modo accurato per calcolare la velocità e la distanza corrette, entrambi i pin di trigger (output) sono collegati ai pin 2 e 3 di interrupt esterni della scheda Arduino. Assembla l'intero circuito su un telaio e monta il sensore di velocità come spiegato, il mio bot sembrava qualcosa di simile sotto dopo che le connessioni sono state completate. Puoi anche guardare il video alla fine di questa pagina per sapere come è stato montato il sensore.

Ora che la parte hardware è completata entriamo nelle logiche di come misureremo la velocità, la distanza e il singolo del bot e poi procediamo alla sezione di programmazione.

Logica dietro la misurazione della velocità con il modulo sensore di velocità LM393

Dalla configurazione di montaggio del sensore è necessario essere consapevoli che il modulo del sensore di velocità LM393 (H206) misura solo gli spazi presenti nella piastra della griglia. Durante il montaggio è necessario assicurarsi che la ruota (la cui velocità deve essere misurata) e la piastra della griglia ruotino alla stessa velocità. Come qui, poiché abbiamo montato sia la ruota che la piastra sullo stesso albero, ovviamente ruoteranno entrambe con la stessa velocità.

Nella nostra configurazione abbiamo montato due sensori per ogni ruota per misurare l'angolo del robot. Ma se il tuo obiettivo è misurare solo la velocità e la distanza, possiamo montare il sensore su qualsiasi ruota. L'uscita del sensore (segnali di trigger) sarà più comunemente collegata a un pin di interrupt esterno di un microcontrollore. Ogni volta che viene rilevato lo spazio vuoto nella piastra della griglia verrà attivato un interrupt e verrà eseguito il codice nella ISR (Interrupt service Routine). Se siamo in grado di calcolare l'intervallo di tempo tra due di questi trigger, possiamo calcolare la velocità della ruota.

In Arduino possiamo facilmente calcolare questo intervallo di tempo utilizzando la funzione millis () . Questa funzione in millisecondi continuerà ad aumentare di 1 per ogni milli secondo dal momento dell'accensione del dispositivo. Quindi quando si verifica il primo interrupt possiamo salvare il valore di millis () in una variabile fittizia (come pevtime in questo codice) e poi quando si verifica il secondo interrupt possiamo calcolare il tempo impiegato sottraendo il valore pevtime da millis ().

Tempo impiegato = ora corrente - ora precedente timingaken = millis () - pevtime ; // scadenze in millisecondi

Una volta calcolato il tempo impiegato, possiamo semplicemente calcolare il valore di rpm utilizzando le formule seguenti, dove (1000 / timeaken) fornisce l'RPS (giri al secondo) e viene moltiplicato per 60 per convertire gli RPS in RPM (giri al minuto).

rpm = (1000 / tempo impiegato) * 60;

Dopo aver calcolato il numero di giri possiamo calcolare la velocità del veicolo utilizzando le formule sottostanti a condizione di conoscere il raggio della ruota.

Velocità = 2π × RPS × raggio della ruota. v = radius_of_wheel * rpm * 0,104

Nota, la formula sopra è per il calcolo della velocità in m / s, se si desidera calcolare in km / h, sostituire 0,0104 con 0,376. Se sei curioso di sapere come è stato ottenuto il valore 0,104, prova a semplificare la formula V = 2π × RPS × raggio della ruota.

La stessa tecnica viene utilizzata anche se viene utilizzato un sensore Hall per misurare la velocità di un oggetto rotante. Ma per il sensore H206 c'è un fermo, la piastra della griglia ha 20 slot e quindi per misurare il tempo tra due spazi vuoti sovraccaricherà il microcontrollore. Quindi misuriamo la velocità solo a una rotazione completa di una ruota. Poiché verranno generati due interrupt per ogni gap (uno all'inizio e l'altro alla fine del gap) otterremo un totale di 40 interrupt affinché la ruota effettui una rotazione completa. Quindi aspettiamo 40 interruzioni prima di calcolare effettivamente la velocità della ruota. Il codice per lo stesso è mostrato di seguito

if (rotazione> = 40) { timeaken = millis () - pevtime; // tempo impiegato in millisec giri = (1000 / tempo impiegato) * 60; // formule per calcolare rpm pevtime = millis (); rotazione = 0; }

Un altro svantaggio di questo metodo è che il valore della velocità non scenderà a zero poiché l'interruzione sarà sempre in attesa che la ruota completi una rotazione per calcolare il valore di rpm. Questo inconveniente può essere facilmente superato aggiungendo un semplice codice che monitora l'intervallo di tempo tra due interruzioni e se supera il normale allora possiamo forzare il valore di rpm e velocità a zero. Link nel codice sottostante abbiamo usato la variabile dtime per controllare la differenza di tempo e se supera i 500 milli secondi il valore di velocità e rpm è forzato a zero.

/ * Per scendere a zero se il veicolo si ferma * / if (millis () - dtime> 500) // nessuna interruzione trovata per 500 ms { rpm = v = 0; // rende rpm e velocità zero dtime = millis (); }

Logica dietro la misurazione della distanza percorsa dalla ruota

Sappiamo già che Arduino percepirà 40 interruzioni quando la ruota effettuerà una rotazione completa. Quindi per ogni rotazione effettuata dalla ruota è evidente che la distanza percorsa dalla ruota è uguale alla circonferenza della ruota. Dato che conosciamo già il raggio della ruota possiamo facilmente calcolare la distanza percorsa utilizzando la formula sottostante

Distanza = 2πr * numero di rotazioni distanza = (2 * 3,141 * radius_of_wheel) * (left_intr / 40)

Dove la circonferenza della ruota viene calcolata utilizzando la formula 2πr e poi viene moltiplicata per il numero di rotazioni effettuate dalla ruota.

Logica dietro la misurazione dell'angolo del bot

Esistono molti modi per determinare l'angelo del robot. Gli accelerometri e i giroscopi vengono normalmente utilizzati per determinare questi valori. Ma un altro approccio economico consiste nell'utilizzare il sensore H206 su entrambe le ruote. In questo modo sapremmo quanti giri ha fatto ciascuna ruota. La figura seguente mostra come viene calcolato l'angolo.

Quando il robot viene inizializzato, l'angolo di fronte è considerato 0 °. Da lì ruota a sinistra l'angolo viene incrementato in negativo e se ruota a destra l'angelo viene incrementato in positivo. Per comprensione consideriamo l'intervallo da -90 a +90 come mostrato nella figura. In una tale disposizione poiché entrambe le ruote hanno lo stesso diametro, se una qualsiasi delle ruote fa una rotazione completa, il bot si gira con un angolo di 90 °.

Ad esempio, se la ruota sinistra esegue una rotazione completa (80 interruzioni), il bot ruoterà di 90 ° verso sinistra e allo stesso modo se la ruota destra esegue una rotazione completa (80 interruzioni), il robot ruoterà di -90 ° verso destra. Ora sappiamo che se Arduino rileva 80 interruzioni su una ruota allora il bot si è girato di 90 ° e in base a quale ruota possiamo dire se il bot ha girato in positivo (destra) o in negativo (sinistra). Quindi l'angolo sinistro e destro può essere calcolato utilizzando le formule seguenti

int angle_left = (left_intr% 360) * (90/80); int angle_right = (right_intr% 360) * (90/80);

Dove 90 è l'angolo coperto quando si effettua un'interruzione di 80. Il valore risultante è moltiplicato per numero di interruzioni. Abbiamo anche usato un modulo di 360 in modo che il valore risultante non superi mai 36. Una volta calcolati sia l'angolo sinistro che quello destro, l'angolo effettivo al quale è rivolto il robot può essere ottenuto semplicemente sottraendo l'angolo sinistro dall'angolo destro.

angolo = angle_right - angle_left;

Codice robot Arduino

Il codice Arduino completo per questo robot di misurazione della velocità e dell'angolo si trova alla fine di questa pagina. Lo scopo del programma è calcolare la velocità, la distanza e l'angolo del bot utilizzando le logiche di cui sopra e visualizzarli sullo schermo LCD. A parte questo, dovrebbe fornire un'opzione per controllare il bot usando il Joystick.

Avviamo il programma definendo i pin I / O digitali per i due motori. Nota che dobbiamo anche controllare la velocità del motore e quindi dobbiamo usare i pin PWM su Arduino per controllare i motori. Qui abbiamo usato i pin 8,9,10 e 11.

#define LM_pos 9 // motore sinistro #define LM_neg 8 // motore sinistro #define RM_pos 10 // motore destro #define RM_neg 11 // motore destro #define joyX A2 #define joyY A3

Per misurare la velocità e la distanza percorsa dobbiamo conoscere il raggio della ruota, misurare il valore e inserirlo in metri come mostrato di seguito. Per il mio bot il raggio era di 0,033 metri ma potrebbe differire per te in base al tuo bot.

float radius_of_wheel = 0,033; // Misura il raggio della tua ruota e inseriscilo qui in cm

All'interno della funzione di configurazione , inizializziamo tutto il valore in modo che sia zero e quindi visualizziamo un testo introduttivo sull'LCD. Abbiamo anche inizializzato il monitor seriale a scopo di debug. Poi abbiamo detto che i sensori di velocità H206 sono collegati ai pin 2 e 3 come interrupt esterni. Ovunque venga rilevato l'interrupt, le funzioni ISR Left_ISR e Right_ISR verranno eseguite di conseguenza.

void setup () { rotation = rpm = pevtime = 0; // Inizializza tutte le variabili a zero Serial.begin (9600); lcd.begin (16, 2); // Inizializza 16 * 2 LCD lcd.print ("Bot Monitor"); // Intro Message line 1 lcd.setCursor (0, 1); lcd.print ("- CircuitDigest"); // Ritardo riga 2 messaggio introduttivo (2000); lcd.clear (); lcd.print ("Lt: Rt:"); lcd.setCursor (0, 1); lcd.print ("S: D: A:"); pinMode (LM_pos, OUTPUT); pinMode (LM_neg, OUTPUT); pinMode (RM_pos, OUTPUT); pinMode (RM_neg, OUTPUT); digitalWrite (LM_neg, LOW); digitalWrite (RM_neg, LOW); attachInterrupt (digitalPinToInterrupt (2), Left_ISR, CHANGE); // Left_ISR viene richiamato quando viene attivato il sensore della ruota sinistra attachInterrupt (digitalPinToInterrupt (3), Right_ISR, CHANGE); // Right_ISR viene richiamato quando viene attivato il sensore della ruota destra }

All'interno della routine Left_ISR, incrementiamo semplicemente una variabile chiamata left_intr che verrà successivamente utilizzata per misurare l'angolo del bot. All'interno di Right_ISR facciamo la stessa cosa, ma in aggiunta calcoliamo anche la velocità qui. La rotazione della variabile viene incrementata per ogni interrupt e quindi la logica di cui sopra viene utilizzata per calcolare la velocità.

void Left_ISR () { left_intr ++; delay (10); } void Right_ISR () { right_intr ++; ritardo (10); rotazione ++; dtime = millis (); if (rotazione> = 40) { timeaken = millis () - pevtime; // tempo impiegato in millisec giri = (1000 / tempo impiegato) * 60; // formule per calcolare rpm pevtime = millis (); rotazione = 0; } }

All'interno della funzione di loop infinito principale monitoriamo i valori di X e Y dal joystick. In base al valore, se il joystick viene spostato, controlliamo il bot di conseguenza. La velocità del bot dipende da quanto lontano viene spinto il joystick.

int xValue = analogRead (joyX); int yValue = analogRead (joyY); int acceleration = map (xValue, 500, 0, 0, 200); if (xValue <500) { analogWrite (LM_pos, acceleration); analogWrite (RM_pos, accelerazione); } altro { analogWrite (LM_pos, 0); analogWrite (RM_pos, 0); } if (yValue> 550) analogWrite (RM_pos, 80); se (yValue <500) analogWrite (LM_pos, 100);

Ciò aiuterà l'utente a spostare il bot e verificare se i valori ottenuti sono quelli previsti. Infine possiamo calcolare la velocità, la distanza e l'angolo del bot utilizzando le logiche di cui sopra e visualizzarlo sul display LCD utilizzando il codice sottostante.

v = radius_of_wheel * rpm * 0,104; //0.033 è il raggio della ruota in metri di distanza = (2 * 3.141 * radius_of_wheel) * (left_intr / 40); int angle_left = (left_intr% 360) * (90/80); int angle_right = (right_intr% 360) * (90/80); angolo = angle_right - angle_left; lcd.setCursor (3, 0); lcd.print (""); lcd.setCursor (3, 0); lcd.print (left_intr); lcd.setCursor (11, 0); lcd.print (""); lcd.setCursor (11, 0); lcd.print (right_intr); lcd.setCursor (2, 1); lcd.print (""); lcd.setCursor (2, 1); lcd.print (v); lcd.setCursor (9, 1); lcd.print (""); lcd.setCursor (9, 1); lcd.print (distanza); lcd.setCursor (13, 1); lcd.print (""); lcd.setCursor (13, 1); lcd.print (angolo);

Testare il robot Arduino per misurare la distanza, la velocità e l'angolo

Una volta che l'hardware è pronto, carica il codice nel tuo Arduino e usa il joystick per spostare il tuo bot. la velocità del bot, la distanza percorsa e l'angolo verranno visualizzati nel display LCD come mostrato di seguito.

Sul display LCD il termine Lt e Rt rappresenta rispettivamente il conteggio degli interrupt a sinistra e il conteggio degli interrupt a destra. È possibile trovare questi valori che vengono incrementati per ogni gap rilevato dal sensore. La tem S indica la velocità del bot in m / sec e il termine D indica la distanza percorsa in metri. L'angolo del bot viene visualizzato alla fine dove 0 ° è per la retta e diventa negativo per la rotazione in senso antiorario e positivo per la rotazione in senso orario.

Puoi anche guardare il video alla fine di questa pagina per capire come funziona il bot. Spero che tu abbia capito il progetto e ti sia piaciuto realizzarlo. Se hai dubbi, lasciali nella sezione commenti e cercherò di risponderti al meglio. È inoltre possibile utilizzare i forum per un rapido aiuto tecnico.