- LM393 hastighetssensormodul (H206)
- H206 Sensormonteringsarrangement
- DIY Arduino LM393 Speed Sensor Robot Circuit Diagram
- Logikk bak målehastighet med LM393 hastighetssensormodul
- Logikk bak å måle avstanden som rattet
- Logikk bak å måle vinkelen på bot
- Arduino robotkode
- Testing av Arduino-roboten for måling av avstand, hastighet og vinkel
Roboter har sakte begynt å krype inn i samfunnet vårt for å gjøre livet vårt enklere. Vi kan allerede finne de seks matleveringsrobotene fra Starship på veiene i Storbritannia, og navigerer smart mellom sivile for å nå målet. Hver mobil robot som navigerer inn i miljøet, bør alltid være klar over sin posisjon og orientering i forhold til den virkelige verden. Det er mange måter å oppnå dette ved å bruke forskjellige teknologier som GPS, RF-triangulering, akselerometre, gyroskop etc. Hver teknikk har sin egen fordel og er unik i seg selv. I denne Arduino LM393 hastighetssensoropplæringen vil vi bruke den enkle og lett tilgjengelige LM393 hastighetssensormodulenfor å måle viktige parametere som hastighet, tilbakelagt avstand og vinkel på roboten ved hjelp av Arduino. Med disse parametrene vil roboten kunne kjenne sin virkelige verdensstatus og kan bruke den til å navigere trygt.
Arduino er det mest populære valget blant hobbyister for å bygge roboter, fra en enkel linjefølger til en mer kompleks selvbalanserende eller gulvrengjøringsrobot. Du kan sjekke alle slags roboter i seksjonen Robotics.
Vi vil bygge en liten robot som drives av et litiumbatteri og kjøre den med joystick. I løpet av løpetiden kan vi måle hastigheten, avstanden og vinkelen til roboten og vise den i sanntid på LCD- skjermen som er koblet til Arduino. Dette prosjektet hjelper deg bare med å måle disse parametrene. Når du er ferdig med dette, kan du bruke disse parametrene til å betjene boten din autonomt etter behov. Høres interessant ut, ikke sant? Så la oss komme i gang.
LM393 hastighetssensormodul (H206)
Før vi går inn i kretsskjemaet og koden for prosjektet, la oss forstå LM393 Hastighetssensormodul da den spiller en viktig rolle i prosjektet. Den H206 Speed sensormodul består av et infrarødt lys sensor integrert med en LM393 Spenning komparator IC derav navnet LM393 Speed sensor. Modulen består også av en gitterplate som må monteres på motorens roterende aksel. Alle komponentene er merket i bildet nedenfor.
Den infrarøde lyssensoren består av en IR-LED og en fototransistor adskilt av en liten gab. Hele sensorarrangementet er plassert i et svart hus som vist ovenfor. Rutenettplaten består av spor, platen er anordnet mellom gapet til den infrarøde lyssensoren på en slik måte at sensoren kan registrere hullene i rutenettet. Hvert gap i gitterplaten utløser IR-sensoren når den går gjennom gapet; disse utløserne blir deretter konvertert til spenningssignaler ved hjelp av komparatoren. Komparatoren er ingenting annet enn en LM393 IC fra ON-halvledere. Modulen har tre pinner, hvorav to brukes til å drive modulen og en utgangspinne brukes til å telle antall utløsere.
H206 Sensormonteringsarrangement
Det er litt vanskelig å montere denne typen sensorer. Den kan bare monteres på motorer som har stikket ut på begge sider. Den ene siden av skaftet er koblet til hjulet mens den andre siden brukes til å montere gitterplaten som vist ovenfor.
Siden hjulet og platen er koblet til samme aksel roterer begge i samme hastighet, og ved å måle platens hastighet kan vi måle hastigheten på hjulet. Forsikre deg om at hullene i gitterplaten passerer gjennom IR-sensoren, bare da vil sensoren kunne telle antall hull som har gått gjennom. Du kan også komme med din egen mekaniske ordning for å montere sensoren så lenge den tilfredsstiller den spesifiserte tilstanden. IR-sensor brukes vanligvis i mange robotprosjekter for å veilede roboten om hindringene.
Gitterplaten vist ovenfor har 20 spor (rutenett). Dette betyr at sensoren vil finne 20 hull for en fullstendig rotasjon av hjulet. Ved å telle antall hull sensoren har oppdaget, kan vi beregne avstanden som hjulet har gått, på samme måte ved å måle hvor raskt sensoren finner hullene vi kan oppdage hjulets hastighet. I roboten vår vil vi ha denne sensoren montert på begge hjulene, og dermed kan vi også finne vinkelen til roboten. Rotasjonsvinkelen kan imidlertid beregnes mer fornuftig ved hjelp av akselerometer eller gyroskop, lær her å grensesnitt akselerometer og gyroskop med Arduino og prøv å måle rotasjonsvinkelen ved hjelp av dem.
DIY Arduino LM393 Speed Sensor Robot Circuit Diagram
Det komplette kretsskjemaet til denne hastighets- og avstandsregistreringsroboten er vist nedenfor. Bot består av Arduino Nano som hjerne, de to DC-motorene for hjulene drives av L298N H-Bridge Motor Driver-modulen. Styrespaken brukes til å kontrollere hastigheten og retningen til boten, og de to hastighetssensorene H206 brukes til å måle hastigheten, avstanden og vinkelen til boten. De målte verdiene vises deretter i 16x2 LCD-modulen. Potensiometeret som er koblet til LCD-skjermen kan brukes til å justere kontrasten til LCD-skjermen, og motstanden brukes til å begrense strømmen som strømmer til bakgrunnsbelysningen på LCD-skjermen.
Hele kretsen drives av en 7,4V litiumcelle. Denne 7,4 V leveres til 12 V-stiften på motordrivermodulen. Spenningsregulatoren på motordrivermodulen konverterer deretter 7.4V til regulert + 5V som brukes til å drive Arduino, LCD, sensorer og joystick.
Motoren styres av de digitale pinnene 8,9,10 og 11 på Arduino. Siden motorens hastighet også må kontrolleres, bør vi levere PWM-signaler til den positive terminalen på motoren. Derfor har vi pin 9 og 10 som begge er PWM-kompatible pinner. X- og Y-verdiene danner styrespaken som leses med henholdsvis de analoge pinnene A2 og A3.
Som vi vet genererer H206-sensoren en utløser når gapet i rutenettet oppdages. Siden disse utløserne ikke alltid skal leses nøyaktig for å beregne riktig hastighet og avstand, er begge utløserpinnene koblet til den eksterne avbruddspinnen 2 og 3 på Arduino Board. Monter hele kretsen på et chassis og monter hastighetssensoren som forklart, min bot så ut som nedenfor etter at tilkoblingene ble fullført. Du kan også se videoen på slutten av denne siden for å vite hvordan sensoren ble montert.
Nå som maskinvaredelen er fullført, la oss gå inn i logikken om hvordan vi skal måle hastigheten, avstanden og singelen til boten, og fortsett deretter til programmeringsdelen.
Logikk bak målehastighet med LM393 hastighetssensormodul
Fra monteringen av sensoren bør du være oppmerksom på at LM393 hastighetssensormodulen (H206) bare måler hullene i nettplaten. Ved montering bør det sørges for at hjulet (hvis hastighet skal måles) og gitterplaten roterer i samme hastighet. Som her, siden vi har montert både hjulet og platen på samme aksel, vil de åpenbart rotere med samme hastighet.
I vårt oppsett har vi montert to sensorer for hvert hjul for å måle vinkelen på bot. Men hvis målet ditt er å bare måle hastighet og avstand, kan vi montere sensoren på et hvilket som helst hjul. Utgangen fra sensoren (utløsersignaler) vil oftest være koblet til en ekstern avbryterpinne på en mikrokontroller. Hver gang gapet i nettplaten oppdages vil en avbrudd utløses og koden i ISR (Interrupt service Routine) vil bli utført. Hvis vi klarer å beregne tidsintervallet mellom to slike utløsere, kan vi beregne hastigheten på hjulet.
I Arduino kan vi enkelt beregne dette tidsintervallet ved å bruke millis () -funksjonen. Denne millis-funksjonen vil fortsette å øke med 1 for hvert millisekund fra enheten slås på. Så når den første avbruddet oppstår, kan vi lagre verdien av millis () i en dummyvariabel (som pevtime i denne koden), og når den andre avbruddet oppstår, kan vi beregne tiden det tar ved å trekke pevtime- verdien fra millis ().
Tid tatt = nåværende tid - forrige tidsplan = millis () - pevtime ; // timetaken i millisek
Når vi har beregnet tiden det tar, kan vi ganske enkelt beregne verdien av rpm ved å bruke formlene nedenfor, der (1000 / timetaken) gir RPS (revolusjoner per sekund) og det multipliseres med 60 for å konvertere RPS til RPM (revolusjoner per minutt).
rpm = (1000 / tidsplan) * 60;
Etter å ha beregnet turtallet kan vi beregne kjøretøyets hastighet ved hjelp av formlene nedenfor, forutsatt at vi kjenner hjulets radius.
Hastighet = 2π × RPS × hjulets radius. v = radius_hjul * o / min * 0.104
Merk, formelen ovenfor er for å beregne hastigheten i m / s. Hvis du vil beregne i km / t, erstatt deretter 0,0104 med 0,376. Hvis du er nysgjerrig på å vite hvordan verdien 0.104 ble oppnådd, kan du prøve å forenkle formelen V = 2π × RPS × hjulets radius.
Den samme teknikken brukes selv om en hallsensor brukes til å måle hastigheten til et roterende objekt. Men for H206-sensoren er det en fangst, nettplaten har 20 spor, og for å måle tiden mellom to spaltehull vil det overbelaste mikrokontrolleren. Derfor måler vi bare hastigheten ved full rotasjon av et hjul. Siden to avbrudd vil bli generert for hvert gap (ett ved start og et annet ved slutten av gap), vil vi få totalt 40 avbrudd for at hjulet skal gjøre en fullstendig rotasjon. Så vi venter på 40 avbrudd før vi faktisk beregner hastigheten på hjulet. Koden for det samme er vist nedenfor
hvis (rotasjon> = 40) { timetaken = millis () - pevtime; // timetaken i millisec rpm = (1000 / timetaken) * 60; // formler for å beregne rpm pevtime = millis (); rotasjon = 0; }
En annen ulempe med denne metoden er at verdien av hastigheten ikke vil falle til null siden avbruddet alltid vil vente på at hjulet skal fullføre en rotasjon for å beregne omdr./min. Denne ulempen kan lett overvinnes ved å legge til en enkel kode som overvåker tidsintervallet mellom to avbrudd, og hvis den overskrider enn normalt, kan vi tvinge verdien av rpm og hastighet til å være null. Kobling i koden nedenfor, vi har brukt variabel dtid for å sjekke tidsforskjellen, og hvis den overstiger 500 milli sekunder, blir verdien av hastighet og rpm tvunget til å være null.
/ * Å falle til null hvis kjøretøyet stoppet * / hvis (millis () - dtime> 500) // ingen innbrudd funnet i 500 ms { rpm = v = 0; // lag rpm og hastighet som null dtime = millis (); }
Logikk bak å måle avstanden som rattet
Vi vet allerede at Arduino vil føle 40 avbrudd når hjulet gjør en fullstendig rotasjon. Så for hver rotasjon som gjøres av hjulet, er det tydelig at avstanden som hjulet kjører er lik hjulets omkrets. Siden vi allerede kjenner radiusen på hjulet, kan vi enkelt beregne avstanden som er tilbakelagt ved hjelp av formelen nedenfor
Avstand = 2πr * antall rotasjonsavstand = (2 * 3.141 * radius_ av hjul) * (venstre_intr / 40)
Der hvor hjulets omkrets beregnes med formelen 2πr, multipliseres den med antall rotasjoner som gjøres av hjulet.
Logikk bak å måle vinkelen på bot
Det er mange måter å bestemme robotens engel på. Akselerometre og gyroskop brukes normalt til å bestemme disse verdiene. Men en annen billig tilnærming er å bruke H206-sensoren på begge hjulene. På denne måten ville vi vite hvor mange svinger hvert hjul har gjort. Figuren nedenfor illustrerer hvordan vinkelen beregnes.
Når roboten initialiseres, blir vinkelen den vender betraktet som 0 °. Derfra roterer den til venstre, vinkelen økes negativt, og hvis den roterer til høyre, økes engelen positivt. For forståelse, la oss vurdere området fra -90 til +90 som vist i figuren. I et slikt arrangement, siden begge hjulene har samme diameter, hvis noen av hjulene gjør en fullstendig rotasjon av boten, snur vi oss i en vinkel på 90 °.
For eksempel hvis venstre hjul gjør en fullstendig rotasjon (80 avbryter), vil bot dreie 90 ° mot venstre, og på samme måte hvis høyre hjul gjør en fullstendig rotasjon (80 avbryter), vil bot dreie -90 ° mot høyre. Nå vet vi at hvis Arduino oppdager 80 avbrudd på ett hjul, så har boten snudd 90 ° og basert på hvilket hjul vi kan fortelle om boten har snudd med positiv (høyre) eller negativ (venstre). Så venstre og høyre vinkel kan beregnes ved hjelp av formlene nedenfor
int angle_left = (left_intr% 360) * (90/80); int angle_right = (right_intr% 360) * (90/80);
Hvor 90 er vinkelen dekket når du gjør et avbrudd på 80. Den resulterende verdien er multiplisert antall avbrudd. Vi har også brukt en modul på 360 slik at den resulterende verdien aldri overstiger 36. Når vi har beregnet både venstre og høyre vinkel, kan den effektive vinkelen som boten vender mot, ganske enkelt oppnås ved å trekke fra venstre vinkel fra riktig vinkel.
vinkel = vinkel_høyre - vinkel_til venstre;
Arduino robotkode
Den komplette Arduino-koden for denne hastighets- og vinkelmålingsroboten finner du på slutten av denne siden. Målet med programmet er å beregne hastigheten, avstanden og vinkelen til boten ved hjelp av ovennevnte logikk og vise den på LCD-skjermen. Bortsett fra at det skal gi et alternativ å kontrollere boten ved hjelp av styrespaken.
Vi starter programmet med å definere de digitale I / O-pinnene for de to motorene. Vær oppmerksom på at vi også må kontrollere motorens hastighet, og derfor må vi bruke PWM-pinnene på Arduino for å kontrollere motorene. Her har vi brukt pinnen 8,9,10 og 11.
#define LM_pos 9 // left motor #define LM_neg 8 // left motor #define RM_pos 10 // right motor #define RM_neg 11 // right motor #define joyX A2 #define joyY A3
For å måle hastigheten og avstanden som dekkes, må vi kjenne hjulets radius, måle verdien og angi den i meter som vist nedenfor. For min bot var radiusen 0,033 meter, men det kan variere for deg basert på bot.
flyteradius_ av_hjul = 0,033; // Mål hjulets radius og skriv den inn her i cm
Inne i oppsettfunksjonen initialiserer vi alle verdiene til å være null og viser deretter en introtekst på LCD-skjermen. Vi har også initialisert den serielle skjermen for feilsøking. Så har vi nevnt at hastighetssensorene H206 er koblet til pin 2 og 3 som eksterne avbrudd. Det er der avbruddet oppdages, vil ISR-funksjonen Left_ISR og Right_ISR bli utført tilsvarende.
ugyldig oppsett () { rotation = rpm = pevtime = 0; // Initialiser alle variabler til null Serial.begin (9600); lcd.begin (16, 2); // Initialiser 16 * 2 LCD lcd.print ("Bot Monitor"); // Intro Meldingslinje 1 lcd.setCursor (0, 1); lcd.print ("- CircuitDigest"); // Intro Message line 2 delay (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 kalles når venstre hjulsensor utløses attachInterrupt (digitalPinToInterrupt (3), Right_ISR, CHANGE); // Right_ISR kalles når høyre hjulsensor utløses }
Inne i Left_ISR-rutinen øker vi ganske enkelt en variabel kalt left_intr som senere vil bli brukt til å måle vinkelen på bot. Inne i Right_ISR gjør vi det samme, men i tillegg beregner vi også hastigheten her. Den variable rotasjonen økes for hvert avbrudd, og deretter brukes logikken ovenfor for å beregne hastigheten.
ugyldig Left_ISR () { left_intr ++; delay (10); } ugyldig Right_ISR () { right_intr ++; forsinkelse (10); rotasjon ++; dtime = millis (); hvis (rotasjon> = 40) { timetaken = millis () - pevtime; // timetaken i millisec rpm = (1000 / timetaken) * 60; // formler for å beregne rpm pevtime = millis (); rotasjon = 0; } }
Inne i den viktigste uendelige sløyfefunksjonen overvåker vi verdiene til X og Y fra styrespaken. Basert på verdien hvis joystick flyttes, kontrollerer vi boten tilsvarende. Hastigheten på boten avhenger av hvor langt joysticken skyves.
int xValue = analogRead (joyX); int yValue = analogRead (joyY); int-akselerasjon = kart (xValue, 500, 0, 0, 200); hvis (xValue <500) { analogWrite (LM_pos, akselerasjon); analogWrite (RM_pos, akselerasjon); } annet { analogWrite (LM_pos, 0); analogWrite (RM_pos, 0); } hvis (yValue> 550) analogWrite (RM_pos, 80); hvis (yValue <500) analogWrite (LM_pos, 100);
Dette vil hjelpe brukeren til å flytte boten og sjekke om de oppnådde verdiene er som forventet. Til slutt kan vi beregne hastigheten, avstanden og vinkelen til boten ved hjelp av ovennevnte logikk og vise den på LCD-skjermen ved hjelp av koden nedenfor.
v = radius_hjul * o / min * 0,104; //0.033 er hjulets radius i meteravstand = (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); vinkel = vinkel_høyre - vinkel_til venstre; lcd.setCursor (3, 0); lcd.print (""); lcd.setCursor (3, 0); lcd.print (venstre_intr); lcd.setCursor (11, 0); lcd.print (""); lcd.setCursor (11, 0); lcd.print (høyre_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 (avstand); lcd.setCursor (13, 1); lcd.print (""); lcd.setCursor (13, 1); lcd.print (vinkel);
Testing av Arduino-roboten for måling av avstand, hastighet og vinkel
Når maskinvaren din er klar, laster du opp koden til Arduino og bruker styrespaken til å flytte boten. hastigheten på bot, avstand dekket av den og vinkelen vises i LCD-skjermen som vist nedenfor.
På LCD-skjermen representerer begrepet Lt og Rt henholdsvis Left Interrupt Count og Right Interrupt Count. Du kan finne at disse verdiene økes for hvert gap som detekteres av sensoren. Temet S angir hastigheten på botten i m / sek og begrepet D indikerer avstand dekket i meter. Vinkelen til bot vises på slutten der 0 ° er for rett og det går negativt for moturs rotasjon og positivt for medurs rotasjon.
Du kan også se videoen på slutten av denne siden for å forstå hvordan boten fungerer. Håper du forsto prosjektet og likte å bygge det. Hvis du har noen bekymringer, la dem være i kommentarfeltet, og jeg vil best prøve å svare tilbake. Du kan også bruke fora for rask teknisk hjelp.