- Modul senzor de viteză LM393 (H206)
- Aranjament de montare a senzorului H206
- DIY Arduino LM393 Diagrama circuitului robotului senzorului de viteză
- Logică în spatele măsurării vitezei cu modulul senzor de viteză LM393
- Logică în spatele măsurării distanței parcurse de roată
- Logică în spatele măsurării unghiului botului
- Codul robotului Arduino
- Testarea robotului Arduino pentru măsurarea distanței, vitezei și unghiului
Roboții au început încet să se târască în societatea noastră pentru a ne simplifica viața. Putem găsi deja roboții cu șase roți pentru livrarea de alimente de pe Starship pe drumurile din Marea Britanie, navigând inteligent printre civili pentru a ajunge la destinația sa. Fiecare robot mobil care navighează în mediu ar trebui să fie întotdeauna conștient de poziția și orientarea sa față de lumea reală. Există multe modalități de a realiza acest lucru utilizând diferite tehnologii precum GPS, triangulare RF, accelerometre, giroscop etc. Fiecare tehnică are propriul avantaj și este unică de la sine. În acest tutorial pentru senzorul de viteză Arduino LM393 vom folosi modulul senzorului de viteză LM393 simplu și ușor de utilizatpentru a măsura unii parametri vitali precum Viteza, Distanța parcursă și Unghiul robotului folosind Arduino. Cu acești parametri, robotul își va putea cunoaște starea reală și îl poate folosi pentru a naviga în siguranță.
Arduino este cea mai populară alegere în rândul pasionaților de construcție de roboți, de la un simplu adept de linie la un robot mai complex de auto-echilibrare sau de curățare a podelei. Puteți verifica tot felul de roboți în secțiunea Robotică.
Vom construi un mic robot alimentat de o baterie cu litiu și îl vom conduce cu ajutorul unui joystick. În timpul rulării putem măsura viteza, distanța și unghiul robotului și îl putem afișa în timp real pe ecranul LCD conectat la Arduino. Acest proiect vă ajută doar cu măsurarea acestor parametri, odată ce ați terminat cu acest lucru, puteți utiliza acești parametri pentru a vă opera automat botul, după cum este necesar. Sună interesant nu? Deci sa începem.
Modul senzor de viteză LM393 (H206)
Înainte de a intra în schema și codul circuitului pentru proiect, permiteți-ne să înțelegem modulul senzorului de viteză LM393, deoarece joacă un rol vital în proiect. Modulul H206 senzor de viteză este format dintr - un senzor de lumină în infraroșu integrat cu un comparator de tensiune LM393 IC, prin urmare, numele senzorului de viteză LM393. Modulul este, de asemenea, format dintr-o placă de rețea care trebuie montată pe arborele rotativ al motorului. Toate componentele sunt etichetate în imaginea de mai jos.
Senzorul de lumină în infraroșu este alcătuit dintr - un LED IR și un foto-tranzistor separate printr - un GAB mic. Întregul aranjament al senzorului este plasat într-o carcasă neagră așa cum se arată mai sus. Placa de rețea constă din fante, placa este aranjată între spațiul senzorului de lumină cu infraroșu în așa fel încât senzorul să poată percepe golurile din placa de rețea. Fiecare spațiu din placa de rețea declanșează senzorul IR atunci când trece prin spațiu; acești declanșatori sunt apoi convertiți în semnale de tensiune folosind comparatorul. Comparatorul nu este altceva decât un IC LM393 de la semiconductorii ON. Modulul are trei pini, dintre care doi sunt utilizați pentru alimentarea modulului și un pin de ieșire este utilizat pentru a număra numărul de declanșatoare.
Aranjament de montare a senzorului H206
Montarea acestor tipuri de senzori este cam dificilă. Poate fi montat numai pe motoare care au ax proeminent pe ambele părți. O parte a arborelui este conectată la roată, în timp ce cealaltă parte este utilizată pentru a monta placa de rețea așa cum se arată mai sus.
Deoarece roata și placa sunt conectate la același arbore, ambele se rotește cu aceeași viteză și astfel prin măsurarea vitezei plăcii putem măsura viteza roții. Asigurați-vă că golurile din placa de rețea trec prin senzorul IR, doar atunci senzorul va putea să numere numărul de goluri care a trecut. De asemenea, puteți veni cu propriul aranjament mecanic pentru a monta senzorul atâta timp cât îndeplinește condiția specificată. Senzorul IR este utilizat în general în multe proiecte de robotică pentru a ghida robotul cu privire la obstacole.
Placa de grilă prezentată mai sus are 20 de fante (grile). Aceasta înseamnă că senzorul va găsi 20 de goluri pentru o rotație completă a roții. Numărând numărul de goluri pe care le-a detectat senzorul putem calcula distanța parcursă de roată, în mod similar, măsurând cât de rapid senzorul găsește golurile, putem detecta viteza roții. În robotul nostru vom avea acest senzor montat pe ambele roți și, prin urmare, putem găsi și unghiul robotului. Cu toate acestea, unghiul de rotație poate fi calculat mai sensibil folosind accelerometrul sau giroscopul, învățați aici să interfațați accelerometrul și giroscopul cu Arduino și încercați să măsurați unghiul de rotație folosindu-le.
DIY Arduino LM393 Diagrama circuitului robotului senzorului de viteză
Schema completă a circuitului acestui robot de detectare a vitezei și a distanței este prezentată mai jos. Botul este format din Arduino Nano ca creier, cele două motoare de curent continuu pentru roți sunt acționate de modulul L298N H-Bridge Motor Driver. Joystick-ul este utilizat pentru a controla viteza și direcția botului, iar cei doi senzori de viteză H206 sunt utilizați pentru a măsura viteza, distanța și îngerul botului. Valorile măsurate sunt apoi afișate în modulul LCD 16x2. Potențiometrul conectat la LCD poate fi folosit pentru a regla contrastul LCD-ului, iar rezistorul este utilizat pentru a limita curentul care curge spre lumina de fundal a LCD-ului.
Circuitul complet este alimentat de o celulă de litiu de 7,4V. Acest 7.4V este furnizat pinului de 12V al modulului driverului motorului. Regulatorul de tensiune de pe modulul driverului motorului convertește apoi 7,4V în reglat + 5V, care este utilizat pentru alimentarea Arduino, LCD, senzori și joystick.
Motorul este controlat de pinii digitali 8,9,10 și 11 ai Arduino. Deoarece viteza motorului trebuie controlată, ar trebui să furnizăm semnale PWM către terminalul pozitiv al motorului. Prin urmare, avem pinii 9 și 10, ambii fiind pinii capabili de PWM. Valorile X și Y din joystick sunt citite folosind pinii analogici A2 și respectiv A3.
După cum știm, senzorul H206 generează un declanșator atunci când este detectat golul din placa de rețea. Deoarece aceste declanșatoare nu trebuie citite întotdeauna cu exactitate pentru a calcula viteza și distanța corecte, ambii pini de declanșare (ieșire) sunt conectați la pinul de întrerupere extern 2 și 3 al plăcii Arduino. Asamblați întregul circuit pe un șasiu și montați senzorul de viteză așa cum s-a explicat, botul meu arăta cam ca mai jos după ce conexiunile au fost finalizate. De asemenea, puteți viziona videoclipul de la sfârșitul acestei pagini pentru a afla cum a fost montat senzorul.
Acum, după ce partea hardware este finalizată, permiteți-ne să intrăm în logica modului în care vom măsura viteza, distanța și unicul bot și apoi să trecem la secțiunea de programare.
Logică în spatele măsurării vitezei cu modulul senzor de viteză LM393
Din setarea montării senzorului, trebuie să știți că modulul senzorului de viteză LM393 (H206) măsoară doar golurile prezente în placa de rețea. În timpul montării, trebuie să vă asigurați că roata (a cărei viteză trebuie măsurată) și placa de rețea se rotesc cu aceeași viteză. Ca și aici, deoarece am montat atât roata, cât și placa pe același arbore, ambele se vor roti cu aceeași viteză, evident.
În set-up-ul nostru am montat doi senzori pentru fiecare roată pentru a măsura unghiul botului. Dar dacă scopul dvs. este să măsurați doar viteza și distanța, putem monta senzorul pe orice roată. Ieșirea senzorului (semnalele de declanșare) va fi cel mai frecvent conectată la un pin extern de întrerupere al unui microcontroler. De fiecare dată când este detectat golul din placa de rețea, se va declanșa o întrerupere și se va executa codul din ISR (Interrupt service Routine). Dacă suntem capabili să calculăm intervalul de timp dintre două astfel de declanșatoare putem calcula viteza roții.
În Arduino putem calcula cu ușurință acest interval de timp utilizând funcția millis () . Această funcție de milis va continua să crească cu 1 pentru fiecare milisecundă de la momentul pornirii dispozitivului. Deci, atunci când apare prima întrerupere, putem salva valoarea milis () într-o variabilă falsă (cum ar fi pevtime în acest cod) și atunci când apare a doua întrerupere, putem calcula timpul scăzut scăzând valoarea pevtime din milis ().
Timpul necesar = timpul curent - timp anterior timetaken = Millis () - pevtime ; // timetaken în millisec
Odată ce am calculat timpul necesar, putem calcula pur și simplu valoarea rpm folosind formulele de mai jos, unde (1000 / timp) dă RPS (Revoluții pe secundă) și se înmulțește cu 60 pentru a converti RPS în RPM (Revoluții pe minut).
rpm = (1000 / temporizat) * 60;
După calcularea rpm, putem calcula viteza vehiculului folosind formulele de mai jos, cu condiția să cunoaștem raza roții.
Viteza = 2π × RPS × raza roții. v = radius_of_wheel * rpm * 0.104
Rețineți, formula de mai sus este pentru calcularea vitezei în m / s, dacă doriți să calculați în km / oră, apoi înlocuiți 0,0104 cu 0,376. Dacă sunteți curioși să știți cum a fost obținută valoarea 0.104, încercați să simplificați formula V = 2π × RPS × raza roții.
Aceeași tehnică este utilizată chiar dacă un senzor de hol este utilizat pentru a măsura viteza unui obiect rotativ. Dar pentru senzorul H206 există o prindere, placa de rețea are 20 de sloturi și, prin urmare, pentru măsurarea timpului dintre două spații de slot, va supraîncărca microcontrolerul. Prin urmare, măsurăm viteza numai la o rotație completă a unei roți. Deoarece vor fi generate două întreruperi pentru fiecare decalaj (unul la început și altul la sfârșitul decalajului) vom obține un total de 40 de întreruperi pentru ca roata să facă o rotație completă. Deci, așteptăm 40 de întreruperi înainte de a calcula efectiv viteza roții. Codul pentru același lucru este prezentat mai jos
if (rotație> = 40) { timetaken = millis () - pevtime; // timetaken în milisec rpm = (1000 / timetaken) * 60; // formule pentru calcularea rpm pevtime = millis (); rotație = 0; }
Un alt dezavantaj al acestei metode este că, valoarea vitezei nu va scădea la zero, deoarece întreruperea va aștepta întotdeauna ca roata să finalizeze o rotație pentru calcularea valorii rpm. Acest dezavantaj poate fi depășit cu ușurință prin adăugarea unui cod simplu care monitorizează intervalul de timp dintre două întreruperi și dacă depășește normal decât putem forța valoarea rpm și viteza să fie zero. Legătura din codul de mai jos am folosit variabila dtime pentru a verifica diferența de timp și dacă depășește 500 de mili secunde, valoarea vitezei și rpm este forțată să fie zero.
/ * Pentru a scădea la zero dacă vehiculul s-a oprit * / if (millis () - dtime> 500) // nu s-a găsit nicio întrerupere pentru 500ms { rpm = v = 0; // faceți rpm și viteza ca zero dtime = milis (); }
Logică în spatele măsurării distanței parcurse de roată
Știm deja că Arduino va simți 40 de întreruperi atunci când roata face o rotație completă. Deci, pentru fiecare rotație făcută de roată, este evident că distanța parcursă de roată este egală cu circumferința roții. Deoarece știm deja raza roții, putem calcula cu ușurință distanța parcursă folosind formula de mai jos
Distanța = 2πr * numărul de rotații distanța = (2 * 3,141 * raza_de_ roată) * (stânga_intr / 40)
În cazul în care circumferința roții este calculată folosind formula 2πr și apoi se înmulțește cu numărul de rotații făcute de roată.
Logică în spatele măsurării unghiului botului
Există multe modalități de a determina îngerul robotului. Accelerometrele și giroscopurile sunt utilizate în mod normal pentru a determina aceste valori. Dar o altă abordare ieftină este utilizarea senzorului H206 pe ambele roți. Astfel vom ști câte rotații a făcut fiecare roată. Figura de mai jos ilustrează modul în care este calculat unghiul.
Când robotul este inițializat, unghiul spre care este orientat este considerat 0 °. De acolo se rotește la stânga unghiul este incrementat în negativ și dacă se rotește la dreapta, îngerul este incrementat în pozitiv. Pentru înțelegere, să luăm în considerare intervalul de la -90 la +90 așa cum se arată în figură. Într-un astfel de aranjament, deoarece ambele roți au același diametru, dacă oricare dintre roți face o rotație completă, botul îl rotim la un unghi de 90 °.
De exemplu, dacă roata din stânga face o rotație completă (80 de întreruperi), atunci robotul se va întoarce cu 90 ° spre stânga și, în mod similar, dacă roata din dreapta face o rotație completă (80 de întreruperi), atunci robotul se va întoarce -90 ° spre dreapta. Acum știm că dacă Arduino detectează 80 de întreruperi pe o roată, atunci robotul s-a rotit cu 90 ° și pe baza cărui roată putem spune dacă robotul s-a transformat pozitiv (dreapta) sau negativ (stânga). Deci unghiul stâng și drept pot fi calculate folosind formulele de mai jos
int angle_left = (left_intr% 360) * (90/80); int angle_right = (right_intr% 360) * (90/80);
Unde 90 este unghiul acoperit atunci când se face o întrerupere de 80. Valoarea rezultată este numărul de întreruperi multiplicate. De asemenea, am folosit un modul de 360, astfel încât valoarea rezultată să nu depășească niciodată 36. Odată ce am calculat atât unghiul stâng, cât și unghiul drept, unghiul efectiv la care se confruntă botul poate fi simplu obținut prin scăderea unghiului stâng din unghiul drept.
angle = angle_right - angle_left;
Codul robotului Arduino
Codul complet Arduino pentru acest robot de măsurare a vitezei și a unghiului poate fi găsit la sfârșitul acestei pagini. Scopul programului este să calculeze viteza, distanța și unghiul botului folosind logica de mai sus și să o afișeze pe ecranul LCD. În afară de aceasta, ar trebui să ofere o opțiune de control al botului folosind joystick-ul.
Începem programul definind pinii I / O digitale pentru cele două motoare. Rețineți că trebuie să controlăm și viteza motorului și, prin urmare, trebuie să folosim pinii PWM de pe Arduino pentru a controla motoarele. Aici am folosit pinul 8,9,10 și 11.
#define LM_pos 9 // motor stânga #define LM_neg 8 // motor stânga #define RM_pos 10 // motor dreapta #define RM_neg 11 // motor dreapta #define joyX A2 #define joyY A3
Pentru a măsura viteza și distanța parcursă, trebuie să cunoaștem raza roții, să măsurăm valoarea și să o introducem în metri așa cum se arată mai jos. Pentru botul meu, raza a fost de 0,033 metri, dar ar putea diferi pentru dvs. în funcție de botul dvs.
float radius_of_wheel = 0,033; // Măsurați raza roții și introduceți-o aici în cm
În cadrul funcției de configurare , inițializăm toată valoarea la zero și apoi afișăm un text introductiv pe ecranul LCD. De asemenea, am inițializat monitorul serial în scopul depanării. Apoi am menționat că senzorii de viteză H206 sunt conectați la pinii 2 și 3 ca întreruperi externe. Acolo unde este detectată vreodată întreruperea, funcția ISR Left_ISR și Right_ISR vor fi executate în consecință.
setare nulă () { rotație = rpm = pevtime = 0; // Inițializați toate variabilele la zero Serial.begin (9600); lcd.inceput (16, 2); // Inițializați 16 * 2 LCD lcd.print ("Bot Monitor"); // Intro Mesaj linia 1 lcd.setCursor (0, 1); lcd.print ("- CircuitDigest"); // Intro mesaj linie 2 întârziere (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 este apelat când senzorul roții stânga este declanșat attachInterrupt (digitalPinToInterrupt (3), Right_ISR, CHANGE); // Right_ISR este apelat atunci când senzorul roții stânga este declanșat }
În cadrul rutinei Left_ISR, pur și simplu incrementăm o variabilă numită left_intr care va fi folosită ulterior în măsurarea unghiului botului. În cadrul Right_ISR facem același lucru, dar apoi calculăm și viteza aici. Rotația variabilă este incrementată pentru fiecare întrerupere și apoi logica de mai sus este utilizată pentru a calcula viteza.
void Left_ISR () { left_intr ++; delay (10); } void Right_ISR () { right_intr ++; întârziere (10); rotație ++; dtime = milis (); if (rotație> = 40) { timetaken = millis () - pevtime; // temporizat în milisecunde rpm = (1000 / temporizat) * 60; // formule pentru calcularea rpm pevtime = millis (); rotație = 0; } }
În interiorul funcției principale de buclă infinită monitorizăm valorile lui X și Y din joystick. Pe baza valorii dacă joystick-ul este mutat, controlăm robotul în consecință. Viteza robotului depinde de cât de departe este împins joystick-ul.
int xValue = analogRead (joyX); int yValue = analogRead (bucurieY); accelerare int = hartă (xValue, 500, 0, 0, 200); if (xValue <500) { analogWrite (LM_pos, accelerare); analogWrite (RM_pos, accelerație); } else { analogWrite (LM_pos, 0); analogWrite (RM_pos, 0); } if (yValue> 550) analogWrite (RM_pos, 80); if (yValue <500) analogWrite (LM_pos, 100);
Acest lucru îl va ajuta pe utilizator să mute botul și să verifice dacă valorile obținute sunt cele așteptate. În cele din urmă putem calcula viteza, distanța și unghiul botului folosind logica de mai sus și îl putem afișa pe ecranul LCD folosind codul de mai jos.
v = radius_of_wheel * rpm * 0,104; //0.033 este raza roții în distanță de metri = (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); 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.set (v); lcd.setCursor (9, 1); lcd.print (""); lcd.setCursor (9, 1); lcd.set (distanță); lcd.setCursor (13, 1); lcd.print (""); lcd.setCursor (13, 1); lcd.set (unghi);
Testarea robotului Arduino pentru măsurarea distanței, vitezei și unghiului
Odată ce hardware-ul dvs. este gata, încărcați codul în Arduino și utilizați joystick-ul pentru a vă deplasa botul. viteza robotului, distanța parcursă de acesta și unghiul vor fi afișate pe ecranul LCD, așa cum se arată mai jos.
Pe ecranul LCD termenii Lt și Rt reprezintă numărul de întreruperi la stânga și respectiv numărul de întreruperi la dreapta. Puteți găsi aceste valori crescând pentru fiecare decalaj detectat de senzor. Temperatura S indică Viteza botului în m / sec, iar termenul D indică Distanța parcursă în metri. Unghiul botului este afișat la sfârșitul locului, unde 0 ° este pentru dreapta și merge negativ pentru rotația în sens invers acelor de ceasornic și pozitiv pentru rotația în sensul acelor de ceasornic.
De asemenea, puteți viziona videoclipul de la sfârșitul acestei pagini pentru a înțelege cum funcționează botul. Sper că ați înțeles proiectul și v-a plăcut să îl construiți. Dacă aveți nelămuriri, lăsați-le în secțiunea de comentarii și voi încerca cel mai bine să răspund. De asemenea, puteți utiliza forumuri pentru ajutor tehnic rapid.