Mesura de velocitat, distància i angle per a robots mòbils mitjançant arduino i sensor de velocitat lm393 (h206)

Els robots han començat poc a poc a introduir-se en la nostra societat per simplificar la nostra vida. Ja podem trobar els sis robots de lliurament de menjar de Starship a les carreteres del Regne Unit, navegant intel·ligentment entre els civils per arribar a la seva destinació. Tots els robots mòbils que naveguen cap a l’entorn sempre han de ser conscients de la seva posició i orientació respecte al món real. Hi ha moltes maneres d’aconseguir-ho mitjançant diferents tecnologies com GPS, triangulació de RF, acceleròmetres, giroscopis, etc. Cada tècnica té el seu propi avantatge i és única per si mateixa. En aquest tutorial del sensor de velocitat Arduino LM393, farem servir el mòdul senzill de velocitat LM393 senzill i fàcilment disponibleper mesurar alguns paràmetres vitals com la velocitat, la distància recorreguda i l'angle del robot mitjançant Arduino. Amb aquests paràmetres, el robot podrà conèixer el seu estat real i el pot utilitzar per navegar amb seguretat.

Arduino és l'elecció més popular entre els aficionats a la construcció de robots, des d'un simple seguidor de línia fins a un robot més complex d'equilibri personal o de neteja de terres. Podeu consultar tot tipus de robots a la secció Robòtica.

Construirem un petit robot que funciona amb una bateria de liti i el conduirem amb un joystick. Durant el temps d’execució podem mesurar la velocitat, la distància i l’angle del robot i mostrar-lo en temps real a la pantalla LCD connectada a Arduino. Aquest projecte només us ajuda a mesurar aquests paràmetres, un cop hàgiu acabat amb això, podeu utilitzar aquests paràmetres per operar el bot de forma autònoma segons sigui necessari. Sona interessant oi? Comencem doncs.

Mòdul del sensor de velocitat LM393 (H206)

Abans d’entrar en el diagrama de circuits i el codi del projecte, entenem el mòdul del sensor de velocitat LM393, ja que té un paper vital en el projecte. El mòdul del sensor de velocitat H206 consisteix en un sensor de llum infraroja integrat amb un IC comparador de voltatge LM393, d’aquí el nom de sensor de velocitat LM393. El mòdul també consta d'una placa de reixeta que s'ha de muntar a l'eix giratori del motor. Tots els components estan etiquetats a la imatge següent.

El sensor de llum infraroja està format per un LED IR i un fototransistor separat per un petit gab. Tota la disposició del sensor es col·loca en una carcassa negra com es mostra a la part superior. La placa de la xarxa consisteix en ranures, la placa està disposada entre la bretxa del sensor de llum infraroja de manera que el sensor pugui detectar els buits de la placa de la xarxa. Cada buit de la placa de la xarxa activa el sensor IR quan passa per la bretxa; aquests activadors es converteixen en senyals de tensió mitjançant el comparador. El comparador no és res més que un IC LM393 de semiconductors ON. El mòdul té tres pins, dos dels quals s'utilitzen per alimentar el mòdul i un pin de sortida s'utilitza per comptar el nombre de disparadors.

Disposició de muntatge del sensor H206

Muntar aquest tipus de sensors és una mica complicat. Es pot muntar només a motors amb eix sobresortit a banda i banda. Un dels costats de l’eix està connectat a la roda, mentre que l’altre costat s’utilitza per muntar la placa de reixeta, tal com es mostra més amunt.

Com que la roda i la placa estan connectades al mateix eix, ambdues giren a la mateixa velocitat i, per tant, mesurant la velocitat de la placa podem mesurar la velocitat de la roda. Assegureu-vos que els buits de la placa de la xarxa passen pel sensor IR, només llavors el sensor podrà comptar el nombre de buits que hagi passat. També podeu crear la vostra pròpia disposició mecànica per muntar el sensor sempre que compleixi les condicions especificades. El sensor IR es fa servir generalment en molts projectes de robòtica per guiar el robot sobre els obstacles.

La placa de quadrícula que es mostra a sobre té 20 ranures (quadrícules). Això significa que el sensor trobarà 20 espais per a una rotació completa de la roda. Comptant el nombre de buits que el sensor ha detectat, podem calcular la distància recorreguda per la roda, de manera similar mesurant la velocitat amb què el sensor troba els buits, podem detectar la velocitat de la roda. Al nostre robot tindrem aquest sensor muntat a les dues rodes i, per tant, també podem trobar l’angle del robot. Tanmateix, l'angle de rotació es pot calcular amb més intel·ligència mitjançant l'acceleròmetre o el giroscopi, apreneu aquí a relacionar l'acceleròmetre i el giroscopi amb Arduino i proveu de mesurar l'angle de rotació amb ells.

Diagrama de circuits del robot del sensor de velocitat Arduino LM393 de bricolatge

A continuació es mostra el diagrama complet del circuit d’aquest robot de detecció de velocitat i distància. El Bot consisteix en Arduino Nano com a cervell, els dos motors de corrent continu de les rodes són accionats pel mòdul L298N H-Bridge Motor Driver. El joystick s’utilitza per controlar la velocitat i la direcció del bot i els dos sensors de velocitat H206 s’utilitzen per mesurar la velocitat, la distància i l’àngel del bot. Els valors mesurats es mostren al mòdul LCD de 16x2. El potenciòmetre connectat a la pantalla LCD es pot utilitzar per ajustar el contrast de la pantalla LCD i la resistència s’utilitza per limitar el corrent que flueix a la llum de fons de la pantalla LCD.

El circuit complet és alimentat per una cèl·lula de 7,4 V de liti. Aquest 7.4V es subministra al pin de 12V del mòdul del controlador del motor. El regulador de voltatge del mòdul del controlador del motor converteix el 7.4V a regulat + 5V que s’utilitza per alimentar l’Arduino, el LCD, els sensors i el joystick.

El motor està controlat pels pins digitals 8,9,10 i 11 de l'Arduino. Com que la velocitat del motor també s'ha de controlar, hauríem de subministrar senyals PWM al terminal positiu del motor. Per tant, tenim els pins 9 i 10, que són tots dos pins capaços de PWM. Els valors X i Y del joystick es llegeixen mitjançant els pins analògics A2 i A3 respectivament.

Com sabem, el sensor H206 genera un disparador quan es detecta la bretxa a la placa de la xarxa. Atès que aquests activadors no sempre s’han de llegir amb precisió per calcular la velocitat i la distància correctes, tots dos pins d’activació (sortida) estan connectats al pin d’interrupció extern 2 i 3 de la placa Arduino. Munteu tot el circuit en un xassís i munteu el sensor de velocitat tal com s’explica, el meu robot semblava semblant a sota després de completar les connexions. També podeu veure el vídeo al final d’aquesta pàgina per saber com s’ha muntat el sensor.

Ara que la part del maquinari s'ha completat, entrem a la lògica de com mesurarem la velocitat, la distància i el senzill del bot i, a continuació, anem a la secció de programació.

Lògica darrere de la mesura de la velocitat amb el mòdul del sensor de velocitat LM393

Des de la configuració del muntatge del sensor, heu de tenir en compte que el mòdul del sensor de velocitat LM393 (H206) només mesura els buits presents a la placa de la xarxa. Durant el muntatge, s’ha d’assegurar que la roda (la velocitat de la qual s’hauria de mesurar) i la placa de la graella giren a la mateixa velocitat. Igual que aquí, ja que hem muntat la roda i la placa al mateix eix, òbviament giraran amb la mateixa velocitat.

A la nostra configuració hem muntat dos sensors per a cada roda per mesurar l’angle del bot. Però si el vostre objectiu és mesurar només la velocitat i la distància, podem muntar el sensor en qualsevol roda. La sortida del sensor (senyals d’activació) es connectarà amb més freqüència a un pin d’interrupció extern d’un microcontrolador. Cada vegada que es detecta la bretxa a la placa de la graella, s'activarà una interrupció i s'executarà el codi de la ISR (Interrupt service Routine). Si som capaços de calcular l’interval de temps entre dos activadors d’aquest tipus, podem calcular la velocitat de la roda.

A Arduino podem calcular fàcilment aquest interval de temps mitjançant la funció millis () . Aquesta funció millis es mantindrà incrementant-se en 1 per cada milisegon des del moment d’engegar el dispositiu. Així, quan es produeix la primera interrupció, podem guardar el valor de millis () en una variable fictícia (com pevtime en aquest codi) i, després, quan es produeix la segona interrupció, podem calcular el temps que restem restant el valor de pevtime del millis ().

Temps emprat = hora actual - temps anterior timetaken = Millis () - pevtime ; // temporitzat en mil·lisegons

Un cop calculat el temps necessari, simplement podem calcular el valor de rpm mitjançant les fórmules següents, on (1000 / temporades) dóna el RPS (revolucions per segon) i es multiplica per 60 per convertir RPS a RPM (revolucions per minut).

rpm = (1000 / temporades) * 60;

Després de calcular la rpm podem calcular la velocitat del vehicle mitjançant les fórmules següents, sempre que coneguem el radi de la roda.

Velocitat = 2π × RPS × radi de la roda. v = radi_de_roda * rpm * 0,104

Tingueu en compte que la fórmula anterior serveix per calcular la velocitat en m / s, si voleu calcular en km / h, substituïu 0,0104 per 0,376. Si teniu curiositat per saber com es va obtenir el valor 0,104, proveu de simplificar la fórmula V = 2π × RPS × radi de la roda.

La mateixa tècnica s’utilitza fins i tot si s’utilitza un sensor de sala per mesurar la velocitat d’un objecte en rotació. Però per al sensor H206 hi ha una captura, la placa de la xarxa té 20 ranures i, per tant, per mesurar el temps entre dos buits de ranura es sobrecarregarà el microcontrolador. Per tant, mesurem la velocitat només amb una rotació completa d’una roda. Atès que es generaran dues interrupcions per cada buit (una al començament i una altra al final del buit) obtindrem un total de 40 interrupcions perquè la roda faci una rotació completa. Per tant, esperem 40 interrupcions abans de calcular la velocitat de la roda. A continuació es mostra el codi del mateix

if (rotació> = 40) { timetaken = millis () - pevtime; // temps en mil·lisegons rpm = (1000 / temps) * 60; // fórmules per calcular rpm pevtime = millis (); rotació = 0; }

Un altre inconvenient d’aquest mètode és que el valor de la velocitat no caurà a zero, ja que la interrupció sempre estarà esperant que la roda completi una rotació per calcular el valor de rpm. Aquest inconvenient es pot superar fàcilment afegint un codi simple que supervisa l’interval de temps entre dues interrupcions i, si supera el normal, podem forçar el valor de rpm i velocitat a zero. Enllaç al codi següent hem utilitzat la variable dtime per comprovar la diferència de temps i, si supera els 500 mil segons, el valor de la velocitat i rpm és obligatori a ser zero.

/ * Per baixar a zero si el vehicle s'ha aturat * / if (millis () - dtime> 500) // no s'ha trobat cap interrupció durant 500 ms { rpm = v = 0; // fes rpm i velocitat com zero dtime = millis (); }

Lògica darrere de mesurar la distància recorreguda per la roda

Ja sabem que l’Arduino detectarà 40 interrupcions quan la roda fa una rotació completa. Així doncs, per a cada rotació realitzada per la roda és evident que la distància recorreguda per la roda és igual a la circumferència de la roda. Com que ja sabem el radi de la roda, podem calcular fàcilment la distància recorreguda mitjançant la fórmula següent

Distància = 2πr * nombre de rotacions distància = (2 * 3,141 * radi_de_roda) * (esquerra_intr / 40)

On la circumferència de la roda es calcula mitjançant la fórmula 2πr i es multiplica pel nombre de rotacions realitzades per la roda.

Lògica darrere de mesurar l'angle del bot

Hi ha moltes maneres de determinar l’àngel del robot. Normalment s’utilitzen acceleròmetres i giroscopis per determinar aquests valors. Però un altre enfocament econòmic és utilitzar el sensor H206 a les dues rodes. D’aquesta manera sabríem quantes voltes ha fet cada roda. La figura següent il·lustra com es calcula l’angle.

Quan s’inicialitza el robot, l’angle al qual s’enfronta es considera 0 °. A partir d’aquí gira cap a l’esquerra l’angle s’incrementa en negatiu i si gira cap a la dreta l’àngel s’incrementa en positiu. Per comprendre, considerem l'interval de -90 a +90 tal com es mostra a la figura. En aquesta disposició, ja que les dues rodes tenen el mateix diàmetre, si alguna de les rodes fa una rotació completa, el bot girem amb un angle de 90 °.

Per exemple, si la roda esquerra fa una rotació completa (80 interrupcions), el bot girarà 90 ° cap a l'esquerra i, de manera similar, si la roda dreta fa una rotació completa (80 interrupcions), el bot girarà -90 ° cap a la dreta. Ara sabem que si Arduino detecta 80 interrupcions en una roda, el bot ha girat 90 ° i segons quina roda podem saber si el bot ha girat en positiu (dreta) o negatiu (esquerra). Per tant, l’angle esquerre i recte es pot calcular mitjançant les fórmules següents

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

On 90 és l'angle cobert en fer una interrupció de 80. El valor resultant és el nombre multiplicat d'interrupcions. També hem utilitzat un mòdul de 360 ​​perquè el valor resultant mai superi els 36. Un cop calculat l’angle esquerre i el recte, l’angle efectiu al qual s’enfronta el bot es pot obtenir simplement restant l’angle esquerre de l’angle recte.

angle = angle_right - angle_left;

Codi de robot Arduino

Al final d’aquesta pàgina es troba el codi Arduino complet d’aquest robot de mesura de velocitat i angle. L’objectiu del programa és calcular la velocitat, la distància i l’angle del bot mitjançant les lògiques anteriors i mostrar-lo a la pantalla LCD. A part d'això, hauria de proporcionar una opció per controlar el bot mitjançant el joystick.

Comencem el programa definint els pins d'E / S digitals per als dos motors. Tingueu en compte que també hem de controlar la velocitat del motor i, per tant, hem d’utilitzar els pins PWM d’Arduino per controlar els motors. Aquí hem utilitzat el passador 8,9,10 i 11.

#define LM_pos 9 // motor esquerre #define LM_neg 8 // motor esquerre #define RM_pos 10 // motor dret #define RM_neg 11 // motor dret #define joyX A2 #define joyY A3

Per mesurar la velocitat i la distància recorreguda hem de conèixer el radi de la roda, mesurar el valor i introduir-lo en metres tal com es mostra a continuació. Per al meu bot, el radi era de 0,033 metres, però podria variar per a vosaltres en funció del vostre bot.

radius_de_roda de flotació = 0,033; // Mesureu el radi de la vostra roda i introduïu-la aquí en cm

Dins de la funció de configuració , inicialitzem tot el valor a zero i, a continuació, mostrem un text introductori a la pantalla LCD. També hem inicialitzat el monitor sèrie per tal de depurar. A continuació, hem esmentat que els sensors de velocitat H206 estan connectats als pins 2 i 3 com a interrupcions externes. Allà és quan es detecta la interrupció, la funció ISR Left_ISR i Right_ISR s'executaran en conseqüència.

configuració nul·la () { rotation = rpm = pevtime = 0; // Inicialitzar totes les variables a zero Serial.begin (9600); lcd.begin (16, 2); // Inicialitzar 16 * 2 LCD lcd.print ("Monitor de bot"); // Línia inicial del missatge 1 lcd.setCursor (0, 1); lcd.print ("- CircuitDigest"); // Retard de la línia 2 del missatge d'introducció (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, BAIX); digitalWrite (RM_neg, BAIX); attachInterrupt (digitalPinToInterrupt (2), Left_ISR, CHANGE); // Es diu Left_ISR quan s'activa el sensor de la roda esquerra attachInterrupt (digitalPinToInterrupt (3), Right_ISR, CHANGE); // Right_ISR es diu quan s'activa el sensor de la roda dreta }

Dins de la rutina Left_ISR, simplement incrementem una variable anomenada left_intr que posteriorment s’utilitzarà per mesurar l’angle del bot. Dins de Right_ISR fem el mateix, però també calculem aquí la velocitat. La rotació variable s'incrementa per a cada interrupció i després s'utilitza la lògica anterior per calcular la velocitat.

void Left_ISR () { left_intr ++; delay (10); } void Right_ISR () { right_intr ++; retard (10); rotació ++; dtime = millis (); if (rotació> = 40) { timetaken = millis () - pevtime; // temporitzats en mil·lisegons rpm = (1000 / temporitzats) * 60; // fórmules per calcular rpm pevtime = millis (); rotació = 0; } }

Dins de la funció principal de bucle infinit monitoritzem els valors de X i Y des del joystick. Basant-nos en el valor si es mou el joystick, controlem el bot en conseqüència. La velocitat del bot depèn de fins a quin punt s’empeny el joystick.

int xValue = analogRead (joyX); int yValue = analogRead (joyY); int acceleració = mapa (xValue, 500, 0, 0, 200); if (xValue <500) { analogWrite (LM_pos, acceleració); analogWrite (RM_pos, acceleració); } else { analogWrite (LM_pos, 0); analogWrite (RM_pos, 0); } if (yValue> 550) analogWrite (RM_pos, 80); if (yValue <500) analogWrite (LM_pos, 100);

Això ajudarà l'usuari a moure el bot i comprovar si els valors obtinguts són els esperats. Finalment, podem calcular la velocitat, la distància i l'angle del bot mitjançant les lògiques anteriors i mostrar-lo a la pantalla LCD mitjançant el codi següent.

v = radi_de_roda * rpm * 0,104; //0.033 és el radi de la roda en distància de metres = (2 * 3.141 * radi_de_roda) * (left_intr / 40); int angle_left = (left_intr% 360) * (90/80); int angle_right = (right_intr% 360) * (90/80); angle = 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 (distància); lcd.setCursor (13, 1); lcd.print (""); lcd.setCursor (13, 1); lcd.set (angle);

Prova del robot Arduino per mesurar la distància, la velocitat i l'angle

Quan el maquinari estigui a punt, pengeu el codi al vostre Arduino i utilitzeu el joystick per moure el bot. la velocitat del bot, la distància que cobreix i l'angle es mostraran a la pantalla LCD, tal com es mostra a continuació.

A la pantalla LCD, els termes Lt i Rt representen el recompte d'interrupcions esquerra i el recompte d'interrupcions dreta respectivament. Podeu trobar aquests valors augmentant per a cada buit detectat pel sensor. El tem S indica la velocitat del bot en m / seg i el terme D indica la distància coberta en metres. L'angle del bot es mostra al final, on 0 ° és per a la recta i es torna negatiu per a la rotació en sentit antihorari i positiu per a la rotació en sentit horari.

També podeu veure el vídeo al final d’aquesta pàgina per entendre com funciona el bot. Espero que hagueu entès el projecte i us hagi agradat construir-lo. Si teniu cap dubte, deixeu-los a la secció de comentaris i intentaré respondre millor. També podeu utilitzar fòrums per obtenir ajuda tècnica ràpida.