Hastigheds-, afstands- og vinkelmåling for mobile robotter ved hjælp af arduino- og lm393-hastighedssensor (h206)

Robotter er langsomt begyndt at kravle ind i vores samfund for at gøre vores liv enklere. Vi kan allerede finde de seks hjulleveringsrobotter fra Starship på vejene i Storbritannien, der smart navigerer blandt civile for at nå sin destination. Enhver mobil robot, der navigerer ind i miljøet, skal altid være opmærksom på sin position og orientering i forhold til den virkelige verden. Der er mange måder at opnå dette på ved hjælp af forskellige teknologier som GPS, RF-triangulering, accelerometre, gyroskoper osv. Hver teknik har sin egen fordel og er unik i sig selv. I denne Arduino LM393 hastighedssensor tutorial bruger vi det enkle og let tilgængelige LM393 hastigheds sensormodultil at måle nogle vitale parametre som hastighed, tilbagelagt afstand og robotens vinkel ved hjælp af Arduino. Med disse parametre vil robotten være i stand til at kende sin virkelige verdensstatus og kan bruge den til at navigere sikkert.

Arduino er det mest populære valg blandt hobbyister til at bygge robotter, fra en simpel linjefølger til en mere kompleks selvbalancerende eller gulvrengøringsrobot. Du kan kontrollere alle slags robotter i sektionen Robotics.

Vi bygger en lille robot, der drives af et lithiumbatteri og kører den ved hjælp af et joystick. I løbet af løbetiden kan vi måle hastigheden, afstanden og vinklen på robotten og vise den i realtid på LCD- skærmen tilsluttet Arduino. Dette projekt hjælper dig bare med at måle disse parametre, når du er færdig med dette, kan du bruge disse parametre til at betjene din bot autonomt efter behov. Lyder interessant, ikke? Så lad os komme i gang.

LM393 Speed ​​Sensor Module (H206)

Før vi går ind i kredsløbsdiagrammet og koder til projektet, lad os forstå LM393 Speed ​​sensor Module, da det spiller en vigtig rolle i projektet. Den H206 Hastighedsføler modul består af en infrarød Lyssensor integreret med en LM393 Spænding komparator IC deraf navnet LM393 Speed sensor. Modulet består også af en gitterplade, der skal monteres på motorens roterende aksel. Alle komponenter er mærket i nedenstående billede.

Den infrarøde lyssensor består af en IR-LED og en fototransistor adskilt af en lille gab. Hele sensorarrangementet er placeret i et sort hus som vist ovenfor. Gitterpladen består af slots, pladen er anbragt mellem afstanden til den infrarøde lyssensor på en sådan måde, at sensoren kan mærke hullerne i gitterpladen. Hvert hul i gitterpladen udløser IR-sensoren, når den passerer gennem gabet; disse udløsere konverteres derefter til spændingssignaler ved hjælp af komparatoren. Komparatoren er intet andet end en LM393 IC fra ON-halvledere. Modulet har tre ben, hvoraf to bruges til at tænde for modulet, og en udgangsstift bruges til at tælle antallet af udløsere.

H206 Sensor monteringsarrangement

Montering af disse typer sensorer er lidt vanskelig. Den kan kun monteres på motorer, der har stak ud på begge sider. Den ene side af skaftet er forbundet med hjulet, mens den anden side bruges til at montere gitterpladen som vist ovenfor.

Da hjulet og pladen er forbundet til den samme aksel, roterer begge i samme hastighed, og ved at måle pladens hastighed kan vi måle hjulets hastighed. Sørg for, at hullerne i gitterpladen passerer gennem IR-sensoren, kun da vil sensoren være i stand til at tælle antallet af huller, der er passeret igennem. Du kan også komme med dit eget mekaniske arrangement til montering af sensoren, så længe den opfylder den specificerede tilstand. IR-sensor bruges generelt i mange robottekniske projekter til at guide robotten om forhindringerne.

Ovenstående gitterplade har 20 slots (gitre). Dette betyder, at sensoren finder 20 huller til en fuldstændig rotation af hjulet. Ved at tælle antallet af huller, som sensoren har registreret, kan vi beregne afstanden, som hjulet har kørt, ligesom ved at måle, hvor hurtigt sensoren finder hullerne, vi kan registrere hjulets hastighed. I vores robot har vi denne sensor monteret på begge hjul, og derfor kan vi også finde vinklen på robotten. Rotationsvinklen kan dog beregnes mere fornuftigt ved hjælp af Accelerometer eller Gyroskop, lær her at grænseflade Accelerometer og gyroskop med Arduino og prøv at måle rotationsvinkel ved hjælp af dem.

DIY Arduino LM393 Speed ​​Sensor Robot Circuit Diagram

Det komplette kredsløbsdiagram for denne hastigheds- og afstandsregistreringsrobot er vist nedenfor. Bot består af Arduino Nano som hjerne, de to jævnstrømsmotorer til hjulene drives af L298N H-Bridge Motor Driver-modulet. Joystick bruges til at styre hastigheden og retningen af ​​boten, og de to hastighedssensorer H206 bruges til at måle hastigheden, afstanden og vinklen på boten. De målte værdier vises derefter i 16x2 LCD-modulet. Potentiometeret, der er tilsluttet LCD-skærmen, kan bruges til at justere LCD-kontrasten, og modstanden bruges til at begrænse strømmen, der strømmer til LCD-baggrundsbelysningen.

Det komplette kredsløb er drevet af en 7,4 V Lithium-celle. Denne 7.4V leveres til 12V-stiften i motordrivermodulet. Spændingsregulatoren på motordrivermodulet konverterer derefter 7.4V til reguleret + 5V, som bruges til at drive Arduino, LCD, sensorer og joystick.

Motoren styres af de digitale ben 8,9,10 og 11 fra Arduino. Da motorens hastighed også skal kontrolleres, skal vi levere PWM-signaler til den positive terminal på motoren. Derfor har vi pin 9 og 10, som begge er PWM-kompatible ben. X- og Y-værdierne danner joysticket, der læses ved hjælp af henholdsvis de analoge ben A2 og A3.

Som vi kender genererer H206-sensoren en trigger, når spalten i gitterpladen detekteres. Da disse udløsere ikke altid skal læses nøjagtigt for at beregne den korrekte hastighed og afstand, er begge udløserstifterne (output) forbundet til den eksterne afbrydestift 2 og 3 på Arduino Board. Saml hele kredsløbet på et chassis, og monter hastighedssensoren som forklaret, min bot så ud som nedenfor, efter at forbindelserne blev gennemført. Du kan også se videoen i slutningen af ​​denne side for at vide, hvordan sensoren blev monteret.

Nu hvor hardwaredelen er afsluttet, lad os komme ind i logikken om, hvordan vi skal måle hastigheden, afstanden og singlen for bot og derefter gå videre til programmeringsafsnittet.

Logik bag måling af hastighed med LM393 hastighedsføler modul

Fra opsætningen af ​​sensormontering skal du være opmærksom på, at LM393-hastighedssensormodulet (H206) kun måler hullerne i gitterpladen. Under montering skal det sørges for, at hjulet (hvis hastighed skal måles) og gitterpladen roterer i samme hastighed. Som her, da vi har monteret både hjulet og pladen på samme aksel, vil de naturligvis begge rotere med samme hastighed.

I vores opsætning har vi monteret to sensorer til hvert hjul for at måle botens vinkel. Men hvis dit mål er kun at måle hastighed og afstand, kan vi montere sensoren på et hvilket som helst hjul. Outputtet fra sensoren (udløsersignaler) forbindes oftest til en ekstern afbrydelsesstift på en mikrocontroller. Hver gang hullet i gitterpladen detekteres, udløses en afbrydelse, og koden i ISR ​​(Interrupt service Routine) udføres. Hvis vi er i stand til at beregne tidsintervallet mellem to sådanne udløsere, kan vi beregne hjulets hastighed.

I Arduino kan vi nemt beregne dette tidsinterval ved hjælp af millis () -funktionen. Denne millis-funktion fortsætter med at øges med 1 for hvert milliarsekund fra det tidspunkt, hvor enheden tændes. Så når den første afbrydelse opstår, kan vi gemme værdien af ​​millis () i en dummyvariabel (som pevtime i denne kode), og når den anden afbrydelse opstår, kan vi beregne den tid, det tager at trække pevtime- værdien fra millis ().

Tid taget = aktuel tid - foregående tidsplan = millis () - pevtime ; // tidsplan i millisek

Når vi har beregnet den tid, vi tager, kan vi simpelthen beregne værdien af ​​omdrejninger pr. Minut ved hjælp af nedenstående formler, hvor (1000 / timetaken) giver RPS (Omdrejninger pr. Sekund), og det ganges med 60 for at konvertere RPS til RPM (Omdrejninger pr. Minut).

rpm = (1000 / tidsplan) * 60;

Efter beregning af omdrejningstallet kan vi beregne køretøjets hastighed ved hjælp af nedenstående formler, forudsat at vi kender hjulets radius.

Hastighed = 2π × RPS × hjulets radius. v = radius_af_hjul * o / min * 0.104

Bemærk, ovenstående formel er til beregning af hastigheden i m / s. Hvis du vil beregne i km / t, skal du udskifte 0,0104 med 0,376. Hvis du er nysgerrig efter at vide, hvordan værdien 0,104 blev opnået, så prøv at forenkle formlen V = 2π × RPS × hjulets radius.

Den samme teknik anvendes, selvom en hallsensor bruges til at måle hastigheden på en roterende genstand. Men for H206-sensoren er der en fangst, gitterpladen har 20 slots, og derfor må tid til mellem to slothuller overbelastes til mikrocontrolleren til måling af tiden. Derfor måler vi kun hastigheden ved en fuld rotation af et hjul. Da der genereres to afbrydelser for hvert hul (et ved start og et andet i slutningen af ​​mellemrum), får vi i alt 40 afbrydelser for hjulet til at foretage en fuldstændig rotation. Så vi venter på 40 afbrydelser, før vi faktisk beregner hjulets hastighed. Koden for det samme er vist nedenfor

hvis (rotation> = 40) { timetaken = millis () - pevtime; // tidsplan i millisek omdrejninger pr. minut = (1000 / tidsplan) * 60; // formler til beregning af rpm pevtime = millis (); rotation = 0; }

En anden ulempe ved denne metode er, at værdien af ​​hastigheden ikke falder til nul, da afbrydelsen altid venter på, at hjulet gennemfører en rotation til beregning af omdrejningstalværdien. Denne ulempe kan let overvindes ved at tilføje en simpel kode, der overvåger tidsintervallet mellem to afbrydelser, og hvis den overstiger end normalt, kan vi tvinge værdien af ​​omdrejningstal og hastighed til at være nul. Link i nedenstående kode, vi har brugt variabel dtime til at kontrollere tidsforskellen, og hvis den overstiger 500 milli sekunder, tvanges værdien af ​​hastighed og omdrejningstal til at være nul.

/ * At falde til nul, hvis køretøjet stoppede * / hvis (millis () - dtid> 500) // ingen indbrud fundet i 500 ms { rpm = v = 0; // lav omdrejningstal og hastighed som nul dtid = millis (); }

Logik bag måling af afstanden med hjulet

Vi ved allerede, at Arduino vil føle 40 afbrydelser, når hjulet drejer en fuldstændig rotation. Så for hver rotation, der foretages af hjulet, er det tydeligt, at afstanden med hjulet er lig med hjulets omkreds. Da vi allerede kender hjulets radius, kan vi nemt beregne den tilbagelagte afstand ved hjælp af nedenstående formel

Afstand = 2πr * antal rotationsafstand = (2 * 3.141 * radius af hjul) * (venstre_intr / 40)

Hvor hjulets omkreds beregnes ved hjælp af formlen 2πr og derefter ganges den med antallet af drejninger foretaget af hjulet.

Logik bag måling af botens vinkel

Der er mange måder at bestemme robotens engel på. Accelerometre og gyroskoper bruges normalt til at bestemme disse værdier. Men en anden billig tilgang er at bruge H206-sensoren på begge hjul. På denne måde ville vi vide, hvor mange drejninger hvert hjul har foretaget. Nedenstående figur illustrerer, hvordan vinklen beregnes.

Når robotten initialiseres, betragtes vinklen, som den vender, som 0 °. Derfra roterer den til venstre, vinklen forøges negativt, og hvis den roterer til højre, er englen forøget i positiv. For forståelse, lad os overveje området fra -90 til +90 som vist i figuren. I et sådant arrangement, da begge hjul har samme diameter, hvis nogen af ​​hjulet drejer botten fuldstændigt, drejer vi i en vinkel på 90 °.

For eksempel hvis venstre hjul drejer en fuldstændig rotation (80 afbrydelser), vil bot dreje 90 ° mod venstre, og på samme måde, hvis højre hjul drejer en komplet rotation (80 afbrydelser), vil bot dreje -90 ° mod højre. Nu ved vi, at hvis Arduino registrerer 80 afbrydelser på det ene hjul, så har bot drejet 90 ° og baseret på hvilket hjul, vi kan fortælle, om bot har drejet med positiv (højre) eller negativ (venstre). Så venstre og højre vinkel kan beregnes ved hjælp af nedenstående formler

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

Hvor 90 er den vinkel, der er dækket, når der foretages en afbrydelse på 80. Den resulterende værdi multipliceres med antal afbrydelser. Vi har også brugt et modul på 360, så den resulterende værdi aldrig overstiger 36. Når vi har beregnet både venstre og højre vinkel, kan den effektive vinkel, som bot vender, simpelthen opnås ved at trække den venstre vinkel fra den rigtige vinkel.

vinkel = vinkel-højre - vinkel-venstre;

Arduino robotkode

Den komplette Arduino-kode til denne hastigheds- og vinkelmålingsrobot kan findes i slutningen af ​​denne side. Programmets mål er at beregne hastigheden, afstanden og vinklen på botten ved hjælp af ovenstående logik og vise den på LCD-skærmen. Bortset fra det skal det give en mulighed for at kontrollere bot ved hjælp af joysticket.

Vi starter programmet med at definere de digitale I / O-ben til de to motorer. Bemærk, at vi også skal kontrollere motorens hastighed, og derfor skal vi bruge PWM-benene på Arduino til at kontrollere motorerne. Her har vi brugt stiften 8,9,10 og 11.

#definer LM_pos 9 // venstre motor #definer LM_neg 8 // venstre motor # definer RM_pos 10 // højre motor # definer RM_neg 11 // højre motor # definer joyX A2 # definer joyY A3

For at måle hastigheden og den tilbagelagte afstand skal vi kende hjulets radius, måle værdien og indtaste den i meter som vist nedenfor. For min bot var radiusen 0,033 meter, men den kunne variere for dig baseret på din bot.

flyderadius_af_hjul = 0,033; // Mål radius på dit hjul, og indtast det her i cm

Inde i opsætningsfunktionen initialiserer vi al værdi til at være nul og viser derefter en Intro-tekst på LCD'et. Vi har også initialiseret den serielle skærm til fejlfindingsformål. Så har vi nævnt, at hastighedssensorerne H206 er forbundet til pin 2 og 3 som eksterne afbrydelser. Det er her, hvor afbrydelsen detekteres, ISR-funktionen Left_ISR og Right_ISR vil blive udført i overensstemmelse hermed.

ugyldig opsætning () { rotation = rpm = pevtime = 0; // Initialiser alle variable til nul Serial.begin (9600); lcd.begin (16, 2); // Initialiser 16 * 2 LCD lcd.print ("Bot Monitor"); // Intro meddelelseslinje 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 kaldes, når venstre hjulsensor udløses attachInterrupt (digitalPinToInterrupt (3), Right_ISR, CHANGE); // Right_ISR kaldes når højre hjulsensor udløses }

Inde i Left_ISR-rutinen øger vi simpelthen en variabel kaldet left_intr, som senere vil blive brugt til at måle botens vinkel. Inde i Right_ISR gør vi det samme, men derefter beregner vi også hastigheden her. Den variable rotation øges for hver afbrydelse, og derefter bruges ovenstående logik til at beregne hastigheden.

ugyldig Left_ISR () { left_intr ++; forsinkelse (10); } ugyldigt Right_ISR () { right_intr ++; forsinkelse (10); rotation ++; dtime = millis (); hvis (rotation> = 40) { timetaken = millis () - pevtime; // tidsplan i millisek omdr./min = (1000 / tidsplan) * 60; // formler til beregning af rpm pevtime = millis (); rotation = 0; } }

Inde i den vigtigste uendelige sløjfefunktion overvåger vi værdierne for X og Y fra joysticket. Baseret på værdien, hvis joystick flyttes, styrer vi bot i overensstemmelse hermed. Botens hastighed afhænger af, hvor langt joysticket skubbes.

int xValue = analogRead (joyX); int yVærdi = analogRead (joyY); int-acceleration = kort (xValue, 500, 0, 0, 200); hvis (xValue <500) { analogWrite (LM_pos, acceleration); analogWrite (RM_pos, acceleration); } andet { analogWrite (LM_pos, 0); analogWrite (RM_pos, 0); } hvis (yValue> 550) analogWrite (RM_pos, 80); hvis (yVærdi <500) analogWrite (LM_pos, 100);

Dette hjælper brugeren med at flytte botten og kontrollere, om de opnåede værdier er som forventet. Endelig kan vi beregne hastigheden, afstanden og vinklen på bot ved hjælp af ovenstående logik og vise det på LCD'et ved hjælp af nedenstående kode.

v = radius_hjul * o / min * 0,104; //0.033 er hjulets radius i meterafstand = (2 * 3.141 * radius_ af hjul) * (venstre_intr / 40); int angle_left = (left_intr% 360) * (90/80); int angle_right = (right_intr% 360) * (90/80); vinkel = vinkel-højre - vinkel-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øjre_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 (afstand); lcd.setCursor (13, 1); lcd.print (""); lcd.setCursor (13, 1); lcd.print (vinkel);

Test af Arduino-robotten til måling af afstand, hastighed og vinkel

Når din hardware er klar, skal du uploade koden til din Arduino og bruge joysticket til at flytte din bot. botens hastighed, afstand dækket af den og vinklen vises i LCD'et som vist nedenfor.

På LCD'et repræsenterer udtrykket Lt og Rt henholdsvis Left Interrupt Count og Right Interrupt Count. Du kan finde disse værdier stigende for hvert hul, der registreres af sensoren. Temet S angiver botens hastighed i m / sek, og udtrykket D angiver afstand, der er dækket i meter. Vinklen på bot vises i slutningen, hvor 0 ° er for lige, og den går negativ for rotation mod uret og positiv for rotation med uret.

Du kan også se videoen i slutningen af ​​denne side for at forstå, hvordan bot fungerer. Håber du forstod projektet og nød at bygge det. Hvis du har nogen bekymringer, skal du lade dem være i kommentarfeltet, og jeg vil bedst prøve at svare tilbage. Du kan også bruge fora til hurtig teknisk hjælp.