- LM393 ātruma sensora modulis (H206)
- H206 Sensora montāžas izkārtojums
- DIY Arduino LM393 ātruma sensora robotu shēmas diagramma
- Ātruma mērīšanas loģika ar ātruma sensora moduli LM393
- Loģika aiz riteņa nobrauktā attāluma mērīšanas
- Loģika aiz robota leņķa mērīšanas
- Arduino robotu kods
- Arduino robota pārbaude attāluma, ātruma un leņķa mērīšanai
Roboti lēnām sāka rāpot mūsu sabiedrībā, lai padarītu mūsu dzīvi vienkāršāku. Mēs jau varam atrast sešus riteņu pārtikas piegādes robotus no Starship uz Lielbritānijas ceļiem, gudri pārvietojoties starp civiliedzīvotājiem, lai sasniegtu galamērķi. Katram mobilajam robotam, kurš pārvietojas vidē, vienmēr jāapzinās sava atrašanās vieta un orientācija attiecībā uz reālo pasauli. Ir dažādi veidi, kā to panākt, izmantojot dažādas tehnoloģijas, piemēram, GPS, RF trīsstūrus, akselerometrus, žiroskopus utt. Katrai tehnikai ir savas priekšrocības, un tā ir unikāla. Šajā Arduino LM393 ātruma sensora apmācībā mēs izmantosim vienkāršo un viegli pieejamo LM393 ātruma sensora modulilai izmērītu dažus vitāli svarīgus parametrus, piemēram, ātrumu, nobraukto attālumu un robota leņķi, izmantojot Arduino. Izmantojot šos parametrus, robots varēs uzzināt savu reālo stāvokli pasaulē un varēs to izmantot, lai droši pārvietotos.
Arduino ir vispopulārākā izvēle hobijiem robotu būvei, sākot no vienkārša līnijas sekotāja līdz sarežģītākam pašbalansējošam vai grīdas tīrīšanas robotam. Sadaļā Robotika varat pārbaudīt visu veidu robotus.
Mēs uzbūvēsim nelielu robotu, kuru darbina litija akumulators, un vadīsim to, izmantojot kursorsviru. Izpildes laikā mēs varam izmērīt robota ātrumu, attālumu un leņķi un to reāllaikā parādīt LCD displejā, kas savienots ar Arduino. Šis projekts vienkārši palīdz jums izmērīt šos parametrus. Kad tas būs paveikts, jūs varat izmantot šos parametrus, lai pēc vajadzības autonomi darbinātu robotu. Izklausās interesanti vai ne? Tātad sāksim.
LM393 ātruma sensora modulis (H206)
Pirms mēs iekļaujam projekta shēmā un kodā, ļaujiet mums saprast LM393 ātruma sensora moduli, jo tam ir būtiska loma projektā. Par H206 ātruma sensors modulis sastāv no infrasarkano starojumu sensors integrēta ar LM393 sprieguma salīdzinājuma IC līdz ar to nosaukumu LM393 Speed sensoru. Modulis sastāv arī no režģa plāksnes, kas jāuzstāda uz motora rotējošās vārpstas. Visi komponenti ir marķēti zem attēla.
Infrared Gaismas sensors sastāv no IS LED un foto-tranzistors atdalīta ar nelielu gab. Viss sensora izvietojums ir ievietots melnā korpusā, kā parādīts iepriekš. Režģa plāksne sastāv no spraugām, plāksne ir izvietota starp infrasarkanās gaismas sensora spraugu tā, lai sensors varētu nojaust režģa plāksnes atstarpes. Katra atstarpe režģa plāksnē iedarbina IR sensoru, kad iet caur spraugu; šie trigeri pēc tam tiek pārveidoti sprieguma signālos, izmantojot salīdzinātāju. Salīdzinātājs ir nekas cits kā LM393 IC no ON pusvadītājiem. Modulim ir trīs tapas, no kurām divas tiek izmantotas moduļa darbināšanai, un vienu izejas tapu izmanto, lai uzskaitītu trigeru skaitu.
H206 Sensora montāžas izkārtojums
Šāda veida sensoru uzstādīšana ir mazliet grūts. To var uzstādīt tikai motoriem, kuru vārpsta ir izvirzīta abās pusēs. Viena vārpstas puse ir savienota ar riteni, bet otru pusi izmanto režģa plāksnes montāžai, kā parādīts iepriekš.
Tā kā ritenis un plāksne ir savienoti ar vienu un to pašu vārpstu, abi rotē vienā ātrumā un tādējādi, mērot plāksnes ātrumu, mēs varam izmērīt riteņa ātrumu. Pārliecinieties, ka režģa plāksnes spraugas šķērso infrasarkano sensoru, tikai tad sensors varēs saskaitīt izlaisto spraugu skaitu. Jūs varat arī izdomāt savu mehānisko uzstādījumu sensora uzstādīšanai, ja vien tas atbilst norādītajam nosacījumam. IR sensoru parasti izmanto daudzos robotikas projektos, lai vadītu robotu par šķēršļiem.
Iepriekš redzamajā režģa plāksnē ir 20 sloti (režģi). Tas nozīmē, ka sensors atradīs 20 atstarpes vienai pilnīgai riteņa rotācijai. Uzskaitot sensora noteikto atstarpju skaitu, mēs varam aprēķināt riteņa nobraukto attālumu, līdzīgi mērot, cik ātri sensors atrod spraugas, kuras mēs varam noteikt riteņa ātrumu. Mūsu robotā šis sensors būs uzstādīts abiem riteņiem, un tādējādi mēs varēsim atrast arī robota leņķi. Tomēr rotācijas leņķi var saprātīgāk aprēķināt, izmantojot akselerometru vai žiroskopu. Uzziniet šeit, kā savienot akselerometru un žiroskopu ar Arduino, un mēģiniet izmērīt rotācijas leņķi, izmantojot tos.
DIY Arduino LM393 ātruma sensora robotu shēmas diagramma
Šī ātruma un attāluma uztveršanas robota pilnīga shēma ir parādīta zemāk. Bot sastāv no Arduino Nano kā tās smadzenēm. Divus līdzstrāvas motorus riteņiem vada L298N H-Bridge Motor Driver modulis. Sviru izmanto, lai kontrolētu robota ātrumu un virzienu, un divus ātruma sensorus H206 izmanto, lai mērītu robota ātrumu, attālumu un eņģeli. Pēc tam izmērītās vērtības tiek parādītas 16x2 LCD modulī. LCD pieslēgto potenciometru var izmantot, lai noregulētu LCD kontrastu, un rezistoru izmanto, lai ierobežotu strāvu, kas plūst uz LCD fona apgaismojumu.
Visu ķēdi darbina 7,4 V litija elements. Šis 7,4 V tiek piegādāts motora draivera moduļa 12 V tapai. Pēc tam motora draivera moduļa sprieguma regulators pārveido 7,4 V uz regulētu + 5 V, ko izmanto Arduino, LCD, sensoru un kursorsviras darbināšanai.
Motoru kontrolē Arduino digitālās tapas 8,9,10 un 11. Tā kā ir jākontrolē arī motora ātrums, mums PWM signāli jāpiegādā motora pozitīvajam terminālim. Tādējādi mums ir 9. un 10. tapa, kas abi ir PWM spraudņi. X un Y vērtības veido, ka kursorsviru nolasa, izmantojot attiecīgi analogās tapas A2 un A3.
Kā mēs zinām, H206 sensors rada sprūdu, kad tiek atklāta atstarpe režģa plāksnē. Tā kā šie trigerus ne vienmēr vajadzētu precīzi nolasīt, lai aprēķinātu pareizo ātrumu un attālumu, abi sprūda (izejas) tapas ir savienotas ar Arduino dēļa ārējā pārtraukuma tapām 2 un 3. Salieciet visu ķēdi uz šasijas un piestipriniet ātruma sensoru, kā paskaidrots, mans bots pēc savienojumu pabeigšanas izskatījās kaut kas līdzīgs zemāk. Varat arī noskatīties video šīs lapas beigās, lai uzzinātu, kā sensors tika uzstādīts.
Tagad, kad aparatūras daļa ir pabeigta, ļaujiet mums iekļūt loģikā par to, kā mēs mērīsim robota ātrumu, attālumu un vienu un pēc tam pārejiet uz programmēšanas sadaļu.
Ātruma mērīšanas loģika ar ātruma sensora moduli LM393
Sensora uzstādīšanas laikā jums jāzina, ka ātruma sensora modulis LM393 (H206) mēra tikai atstarpes, kas atrodas režģa plāksnē. Uzstādot, jāpārliecinās, ka ritenis (kura ātrums jāmēra) un režģa plāksne griežas tādā pašā ātrumā. Tāpat kā šeit, tā kā mēs esam uzstādījuši gan riteni, gan plāksni uz vienas vārpstas, viņi abi acīmredzami griezīsies ar tādu pašu ātrumu.
Savā komplektācijā katram ritenim esam uzstādījuši divus sensorus, lai izmērītu robota leņķi. Bet, ja jūsu mērķis ir izmērīt tikai ātrumu un attālumu, mēs varam uzstādīt sensoru uz jebkura riteņa. Sensora izeja (sprūda signāli) visbiežāk tiks savienota ar mikrokontrollera ārējo pārtraukšanas tapu. Katru reizi, kad tiek atklāta atstarpe režģa plāksnē, tiks aktivizēts pārtraukums un tiks izpildīts kods ISR (Interrupt service Routine). Ja mēs varam aprēķināt laika intervālu starp diviem šādiem izraisītājiem, mēs varam aprēķināt riteņa ātrumu.
Arduino mēs varam viegli aprēķināt šo laika intervālu, izmantojot funkciju milis () . Šī milis funkcija turpinās pieaugt par 1 par katru mili sekundi no ierīces ieslēgšanas brīža. Tātad, kad notiek pirmais pārtraukums, mēs varam saglabāt milis () vērtību manekena mainīgajā (piemēram, pevtime šajā kodā), un tad, kad notiek otrais pārtraukums, mēs varam aprēķināt laiku, atņemot pevtime vērtību no milis ().
Laiks, kas = pašreizējais laiks - iepriekšējais laika timetaken = Millis () - pevtime ; // timetaken in millisec
Kad esam aprēķinājuši nepieciešamo laiku, mēs varam vienkārši aprēķināt apgr./min vērtību, izmantojot tālāk norādītās formulas, kur (1000 / timetaken) dod RPS (apgriezieni sekundē), un tas tiek reizināts ar 60, lai pārvērstu RPS par RPM (apgriezieni minūtē).
apgr./min = (1000 / plānotais) * 60;
Pēc apgriezienu aprēķināšanas mēs varam aprēķināt transportlīdzekļa ātrumu, izmantojot tālāk norādītās formulas, ja vien mēs zinām riteņa rādiusu.
Ātrums = 2π × RPS × riteņa rādiuss. v = riteņa rādiuss * apgr./min * 0,104
Ņemiet vērā, ka iepriekš minētā formula ir paredzēta ātruma aprēķināšanai m / s, ja vēlaties aprēķināt km / h, tad 0,0104 aizstājiet ar 0,376. Ja vēlaties zināt, kā tika iegūta vērtība 0,104, mēģiniet vienkāršot formulu V = 2π × RPS × riteņa rādiuss.
To pašu paņēmienu izmanto arī tad, ja rotējoša objekta ātruma mērīšanai tiek izmantots zāles sensors. Bet H206 sensoram ir fiksators, režģa plāksnei ir 20 sloti, un tādējādi laika mērīšanai starp divām spraugām mikrokontrolleris tiks pārslogots. Tādējādi mēs mēra ātrumu tikai ar pilnu riteņa rotāciju. Tā kā katrai atstarpei tiks ģenerēti divi pārtraukumi (viens sākumā un cits atstarpes galā), mēs kopā saņemsim 40 pārtraukumus, lai ritenis veiktu vienu pilnīgu rotāciju. Tāpēc mēs gaidām 40 pārtraukumus, pirms mēs faktiski aprēķinām riteņa ātrumu. Tālāk ir parādīts tā paša kods
if (rotācija> = 40) { timetaken = milis () - pevtime; // laikraksts milisekundu apgr./min = (1000 / plānotais) * 60; // formulas, lai aprēķinātu apgr./min. pevtime = milis (); rotācija = 0; }
Vēl viens šīs metodes trūkums ir tāds, ka ātruma vērtība nesamazināsies līdz nullei, jo pārtraukums vienmēr gaida, kamēr ritenis apgūs vienu pagriezienu, lai aprēķinātu apgriezienu skaitu. Šo trūkumu var viegli pārvarēt, pievienojot vienkāršu kodu, kas uzrauga laika intervālu starp diviem pārtraukumiem un, ja tas pārsniedz normu, tad mēs varam piespiest apgriezienu un ātruma vērtību būt nulle. Saite zemāk esošajā kodā esam izmantojuši mainīgo dtime, lai pārbaudītu laika starpību, un, ja tas pārsniedz 500 mili sekundes, ātruma un apgr./min vērtība ir spiesta būt nulle.
/ * Lai samazinātu līdz nullei, ja transportlīdzeklis tiek apstādināts * / ja (milis () - dtime> 500) // 500ms laikā nav atrasts pārtraukums { rpm = v = 0; // veikt apgriezienus un ātrumu kā nulli dtime = milis (); }
Loģika aiz riteņa nobrauktā attāluma mērīšanas
Mēs jau zinām, ka Arduino sajutīs 40 pārtraukumus, kad ritenis pilnībā pagriezīsies. Tātad katram riteņa pagriezienam ir skaidrs, ka riteņa nobrauktais attālums ir vienāds ar riteņa apkārtmēru. Tā kā mēs jau zinām riteņa rādiusu, mēs varam viegli aprēķināt nobraukto attālumu, izmantojot šo formulu
Attālums = 2πr * pagriezienu skaits attālums = (2 * 3,141 * riteņa rādiuss) * (pa kreisi_intr / 40)
Ja riteņa apkārtmēru aprēķina, izmantojot formulu 2πr, un pēc tam to reizina ar riteņa veikto rotāciju skaitu.
Loģika aiz robota leņķa mērīšanas
Ir daudz veidu, kā noteikt robota eņģeli. Šo vērtību noteikšanai parasti izmanto akselerometrus un žiroskopus. Bet vēl viena lēta pieeja ir H206 sensora izmantošana uz abiem riteņiem. Tādā veidā mēs zinātu, cik daudz pagriezienu ir veicis katrs ritenis. Zemāk redzamais attēls parāda, kā tiek aprēķināts leņķis.
Inicializējot robotu, leņķis, ar kuru tas saskaras, tiek uzskatīts par 0 °. No turienes tas pagriežas pa kreisi, leņķis tiek palielināts negatīvā stāvoklī, un, ja tas pagriežas pa labi, eņģelis tiek palielināts ar pozitīvu. Lai saprastu, ņemsim vērā diapazonu no -90 līdz +90, kā parādīts attēlā. Šādā izvietojumā, jo abiem riteņiem ir vienāds diametrs, ja kāds no riteņiem pilnīgi pagriež botu, mēs pagriežamies 90 ° leņķī.
Piemēram, ja kreisais ritenis veic vienu pilnīgu pagriezienu (80 pārtraukumi), bots pagriezīsies par 90 ° pa kreisi un līdzīgi, ja labais ritenis gūs vienu pilnīgu griešanos (80 pārtraukumi), tad bots pagriezīsies -90 ° uz labo pusi. Tagad mēs zinām, ka, ja Arduino uz viena riteņa konstatē 80 pārtraukumus, bots ir pagriezies par 90 ° un, pamatojoties uz to, kurš ritenis mēs varam pateikt, vai bots ir pagriezies ar pozitīvu (pa labi) vai negatīvu (pa kreisi). Tātad kreiso un labo leņķi var aprēķināt, izmantojot tālāk norādītās formulas
int leņķis pa kreisi = (left_intr% 360) * (90/80); int angle_right = (pa labi_intr% 360) * (90/80);
Kur 90 ir pārklājuma leņķis, veicot 80 pārtraukumu. Rezultātā iegūtā vērtība tiek reizināta ar skaitļa pārtraukumiem. Mēs izmantojām arī moduli 360, lai iegūtā vērtība nekad nepārsniegtu 36. Kad esam aprēķinājuši gan kreiso, gan labo leņķi, efektīvo leņķi, pie kura bot ir vērsts, var vienkārši iegūt, atņemot kreiso leņķi no taisnā leņķa.
leņķis = leņķis pa labi - leņķis pa kreisi;
Arduino robotu kods
Pilnīgs Arduino kods šim ātruma un leņķa mērīšanas robotam ir atrodams šīs lapas beigās. Programmas mērķis ir aprēķināt robota ātrumu, attālumu un leņķi, izmantojot iepriekšminēto loģiku, un parādīt to LCD ekrānā. Papildus tam tam jānodrošina iespēja vadīt robotu, izmantojot kursorsviru.
Mēs sākam programmu, definējot digitālos I / O tapas diviem motoriem. Ņemiet vērā, ka mums ir jākontrolē arī motora ātrums, un tāpēc mums ir jāizmanto PWM tapas uz Arduino, lai kontrolētu motorus. Šeit mēs izmantojām tapas 8,9,10 un 11.
#define LM_pos 9 // kreisais motors #define LM_neg 8 // kreisais motors #define RM_pos 10 // labais motors #define RM_neg 11 // labais motors #define prieksX A2 #define prieksY A3
Lai izmērītu nobraukto ātrumu un attālumu, mums jāzina riteņa rādiuss, jāmēra vērtība un jāievada metros, kā parādīts zemāk. Manam robotam rādiuss bija 0,033 metri, taču tas jums varētu atšķirties, ņemot vērā jūsu robotu.
pludiņa rādiuss_rats = 0,033; // Izmēriet sava riteņa rādiusu un ievadiet to šeit cm
Inside iestatīšanas funkciju, mēs sāktu visu vērtību nulle, un pēc tam parādīt Intro teksts uz LCD. Mēs arī esam inicializējuši sērijveida monitoru atkļūdošanas nolūkos. Tad mēs esam minējuši, ka ātruma sensori H206 ir savienoti ar 2. un 3. tapu kā ārēji pārtraucoši. Tieši tur tiek konstatēts pārtraukums, attiecīgi tiks izpildītas ISR funkcijas Left_ISR un Right_ISR .
void setup () { rotation = rpm = pevtime = 0; // Inicializējiet visu mainīgo līdz nullei Serial.begin (9600); lcd.begin (16, 2); // Inicializējiet 16 * 2 LCD lcd.print ("Bot Monitor"); // Intro Message line 1 lcd.setCursor (0, 1); lcd.print ("- CircuitDigest"); // Intro Message line 2. aizkave (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), pa kreisi_ISR, CHANGE); // Left_ISR tiek izsaukts, kreisais ritenis sensors aktivizē attachInterrupt (digitalPinToInterrupt (3), Right_ISR, CHANGE); // Right_ISR sauc, kad labais ritenis sensors ir iedarbināta }
Rutīnas Left_ISR iekšpusē mēs vienkārši palielinām mainīgo ar nosaukumu left_intr, kas vēlāk tiks izmantots robota leņķa mērīšanai. Right_ISR iekšpusē mēs darām to pašu, bet pēc tam šeit papildus aprēķinām arī ātrumu. Mainīgais rotācija tiek palielināta par katru pārtraukumu, un pēc tam ātruma aprēķināšanai tiek izmantota iepriekš minētā loģika.
void Left_ISR () { left_intr ++; kavēšanās (10); } anulēt Right_ISR () { right_intr ++; kavēšanās (10); rotācija ++; dtime = milis (); if (rotācija> = 40) { timetaken = milis () - pevtime; // laikraksts milisekundu apgr./min = (1000 / plānotais) * 60; // formulas, lai aprēķinātu apgr./min. pevtime = milis (); rotācija = 0; } }
Galvenās bezgalīgās cilpas funkcijas iekšpusē mēs ar kursorsviru kontrolējam X un Y vērtības. Pamatojoties uz vērtību, ja kursorsviru pārvieto, mēs attiecīgi kontrolējam botu. Bota ātrums ir atkarīgs no tā, cik tālu tiek virzīta kursorsviru.
int xValue = analogRead (prieksX); int yValue = analogRead (prieksY); int paātrinājums = karte (xValue, 500, 0, 0, 200); if (xValue <500) { analogWrite (LM_pos, paātrinājums); analogWrite (RM_pos, paātrinājums); } else { analogWrite (LM_pos, 0); analogWrite (RM_pos, 0); } if (yValue> 550) analogWrite (RM_pos, 80); if (yValue <500) analogWrite (LM_pos, 100);
Tas palīdzēs lietotājam pārvietot robotu un pārbaudīt, vai iegūtās vērtības atbilst gaidītajam. Visbeidzot, izmantojot iepriekšminēto loģiku, mēs varam aprēķināt robota ātrumu, attālumu un leņķi un parādīt to LCD, izmantojot zemāk esošo kodu.
v = rata rādiuss * apgr./min * 0,104; //0.033 ir riteņa rādiuss metru attālumā = (2 * 3,141 * riteņa rādiuss) * (left_intr / 40); int leņķis pa kreisi = (left_intr% 360) * (90/80); int angle_right = (pa labi_intr% 360) * (90/80); leņķis = leņķis pa labi - leņķis pa kreisi; 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 (attālums); lcd.setCursor (13, 1); lcd.print (""); lcd.setCursor (13, 1); lcd.print (leņķis);
Arduino robota pārbaude attāluma, ātruma un leņķa mērīšanai
Kad aparatūra ir gatava, augšupielādējiet kodu savā Arduino un izmantojiet kursorsviru, lai pārvietotu robotu. bota ātrums, tā veiktais attālums un leņķis tiks parādīti LCD, kā parādīts zemāk.
LCD ekrānā termins Lt un Rt apzīmē attiecīgi kreisās un labās puses pārtraukumu skaitu. Varat atrast, ka šīs vērtības tiek palielinātas par katru atstarpi, ko atklāj sensors. Tem S norāda robota ātrumu m / s un termins D norāda veikto attālumu metros. Bota leņķis tiek parādīts beigās, kur 0 ° ir taisns, un tas ir negatīvs pretēji pulksteņrādītāja kustības virzienam un pozitīvs pagriezienam pulksteņrādītāja virzienā.
Varat arī noskatīties video šīs lapas beigās, lai saprastu, kā darbojas robots. Ceru, ka sapratāt projektu un patika to veidot. Ja jums ir kādas bažas, atstājiet tos komentāru sadaļā, un es centīšos vislabāk atbildēt. Ātrai tehniskai palīdzībai varat izmantot arī forumus.