- LM393 Hastighetssensormodul (H206)
- H206 Sensormonteringsarrangemang
- DIY Arduino LM393 Speed Sensor Robot Circuit Diagram
- Logik bakom Mäthastighet med LM393 hastighetssensormodul
- Logik bakom att mäta avståndet med ratten
- Logik bakom att mäta bottenvinkeln
- Arduino robotkod
- Testar Arduino-roboten för att mäta avstånd, hastighet och vinkel
Robotar har långsamt börjat krypa in i vårt samhälle för att göra vårt liv enklare. Vi kan redan hitta de sex hjulleveransrobotarna från Starship på Storbritanniens vägar, som smart navigerar bland civila för att nå sin destination. Varje mobilrobot som navigerar in i miljön bör alltid vara medveten om sin position och orientering i förhållande till den verkliga världen. Det finns många sätt att uppnå detta genom att använda olika tekniker som GPS, RF-triangulering, accelerometrar, gyroskop etc. Varje teknik har sin egen fördel och är unik i sig. I denna Arduino LM393-hastighetssensorhandledning använder vi den enkla och lättillgängliga LM393-hastighetssensormodulenför att mäta några viktiga parametrar som hastighet, körd sträcka och vinkel på roboten med Arduino. Med dessa parametrar kan roboten känna till sin verkliga status och kan använda den för att navigera säkert.
Arduino är det mest populära valet bland hobbyister för att bygga robotar, från en enkel linjeföljare till en mer komplex självbalanserings- eller golvrengöringsrobot. Du kan kontrollera alla typer av robotar i avsnittet Robotics.
Vi bygger en liten robot som drivs av ett litiumbatteri och kör den med en joystick. Under körtiden kan vi mäta robotens hastighet, avstånd och vinkel och visa den i realtid på LCD- skärmen ansluten till Arduino. Detta projekt hjälper dig bara med att mäta dessa parametrar, när du är klar med detta kan du använda dessa parametrar för att hantera din bot autonomt efter behov. Låter intressant, eller hur? Så låt oss komma igång.
LM393 Hastighetssensormodul (H206)
Innan vi går in i kretsschemat och kodar för projektet, låt oss förstå LM393-hastighetssensormodulen eftersom den spelar en viktig roll i projektet. Den H206 hastighet Sensormodulen består av en infraröd ljussensor integrerad med en LM393 spänningskomparator IC därav namnet LM393 hastighetssensorn. Modulen består också av en gallerplatta som måste monteras på motorns roterande axel. Alla komponenter är märkta i bilden nedan.
Den infraröda ljussensor består av en IR LED och en fototransistor separerade av en liten gab. Hela sensorarrangemanget är placerat i ett svart hölje som visas ovan. Gallerplattan består av slitsar, plattan är anordnad mellan gapet på den infraröda ljussensorn på ett sådant sätt att sensorn kan känna av luckorna i gallerplattan. Varje mellanrum i gallerplattan utlöser IR-sensorn när den passerar genom springan; dessa utlösare omvandlas sedan till spänningssignaler med hjälp av komparatorn. Jämföraren är inget annat än en LM393 IC från ON-halvledare. Modulen har tre stift, varav två används för att driva modulen och en utgångsstift används för att räkna antalet utlösare.
H206 Sensormonteringsarrangemang
Att montera dessa typer av sensorer är lite knepigt. Den kan endast monteras på motorer som har utskjutande axel på båda sidorna. Ena sidan av axeln är ansluten till hjulet medan den andra sidan används för att montera gallerplattan som visas ovan.
Eftersom hjulet och plattan är ansluten till samma axel roterar båda med samma hastighet och därmed genom att mäta plattans hastighet kan vi mäta hjulets hastighet. Se till att luckorna i gallerplattan passerar genom IR-sensorn, först då kan sensorn räkna antalet luckor som har passerat igenom. Du kan också komma med ditt eget mekaniska arrangemang för att montera sensorn så länge den uppfyller det angivna villkoret. IR-sensor används vanligtvis i många robotprojekt för att vägleda roboten om hindren.
Gallerplattan som visas ovan har 20 slitsar (galler). Detta innebär att sensorn hittar 20 luckor för en fullständig rotation av hjulet. Genom att räkna antalet luckor som sensorn har upptäckt kan vi beräkna hjulets avstånd, på samma sätt genom att mäta hur snabbt sensorn hittar luckorna vi kan upptäcka hjulets hastighet. I vår robot kommer vi att ha den här sensorn monterad på båda hjulen och därmed kan vi också hitta robotens vinkel. Rotationsvinkeln kan dock beräknas mer förnuftigt med hjälp av Accelerometer eller Gyroscope, lär dig här att gränssnitt Accelerometer och gyroskop med Arduino och försök att mäta rotationsvinkel med dem.
DIY Arduino LM393 Speed Sensor Robot Circuit Diagram
Det fullständiga kretsschemat för denna hastighets- och avståndsavkännande robot visas nedan. Bot består av Arduino Nano som hjärna, de två likströmsmotorerna för hjulen drivs av L298N H-Bridge Motor Driver-modulen. Styrspaken används för att styra hastigheten och riktningen på botten och de två hastighetssensorerna H206 används för att mäta hastigheten, sträckan och ängeln på botten. De uppmätta värdena visas sedan i 16x2 LCD-modulen. Potentiometern ansluten till LCD-skärmen kan användas för att justera LCD-skärmens kontrast och motståndet används för att begränsa strömmen som flyter till LCD-skärmens bakgrundsbelysning.
Den kompletta kretsen drivs av ett 7.4V Litium-cell. Denna 7,4 V levereras till 12V-stiftet på motordrivrutinmodulen. Spänningsregulatorn på motordrivmodulen omvandlar sedan 7.4V till reglerad + 5V som används för att driva Arduino, LCD, sensorer och joystick.
Motorn styrs av de digitala stiften 8,9,10 och 11 på Arduino. Eftersom motorns hastighet också måste kontrolleras bör vi leverera PWM-signaler till motorns positiva terminal. Därför har vi stift 9 och 10 som båda är stift med PWM-kapacitet. X- och Y-värdena bildar joysticken avläses med de analoga stiften A2 respektive A3.
Som vi vet genererar H206-sensorn en utlösare när gapet i nätplattan detekteras. Eftersom dessa utlösare inte alltid bör läsas exakt för att beräkna rätt hastighet och avstånd är båda utlösarstiften anslutna till det externa avbrottsstiftet 2 och 3 på Arduino-kortet. Montera hela kretsen på ett chassi och montera hastighetssensorn enligt förklaringen, min bot såg ut som nedan efter anslutningarna slutfördes. Du kan också titta på videon i slutet av denna sida för att veta hur sensorn var monterad.
Nu när hårdvarudelen är klar kan vi gå in i logiken för hur vi kommer att mäta hastigheten, sträckan och singeln för botten och fortsätt sedan till programmeringsavsnittet.
Logik bakom Mäthastighet med LM393 hastighetssensormodul
Från sensormonteringsinställningarna bör du vara medveten om att LM393-hastighetssensormodulen (H206) endast mäter luckorna i nätplattan. Vid montering bör det säkerställas att hjulet (vars hastighet ska mätas) och gallerplattan roterar i samma hastighet. Som här, eftersom vi har monterat både hjulet och plattan på samma axel kommer de uppenbarligen att rotera med samma hastighet.
I vår inställning har vi monterat två sensorer för varje hjul för att mäta bottenvinkeln. Men om ditt mål är att bara mäta hastighet och avstånd kan vi montera sensorn på valfritt hjul. Utgången från sensorn (utlösarsignaler) kommer oftast att vara ansluten till en extern brytstift på en mikrokontroller. Varje gång gapet i nätplattan detekteras kommer ett avbrott att utlösas och koden i ISR (Interrupt service Routine) kommer att köras. Om vi kan beräkna tidsintervallet mellan två sådana utlösare kan vi beräkna hjulets hastighet.
I Arduino kan vi enkelt beräkna detta tidsintervall med hjälp av funktionen millis () . Denna millisfunktion fortsätter att öka med 1 för varje milli sekund från det att enheten startas. Så när det första avbrottet inträffar kan vi spara värdet av millis () i en dummyvariabel (som pevtime i den här koden) och sedan när det andra avbrottet inträffar kan vi beräkna den tid det tar genom att subtrahera pevtime- värdet från millis ().
Tid som tagits = aktuell tid - tidtabellen tidigare = millis () - pevtime ; // tidsplanerad i millisek
När vi väl har beräknat den tid det tar kan vi helt enkelt beräkna varvtalet med hjälp av nedanstående formler, där (1000 / tidsplan) ger RPS (Varv per sekund) och det multipliceras med 60 för att omvandla RPS till RPM (Varv per minut).
rpm = (1000 / tidtabell) * 60;
Efter beräkning av varvtalet kan vi beräkna fordonets hastighet med formlerna nedan förutsatt att vi känner till hjulets radie.
Hastighet = 2π × RPS × hjulets radie. v = radie_hjul * varv / min * 0.104
Observera, ovanstående formel är för beräkning av hastigheten i m / s. Om du vill beräkna i km / tim ersätt sedan 0,0104 med 0,376. Om du är nyfiken på hur värdet 0.104 erhölls, försök att förenkla formeln V = 2π × RPS × hjulets radie.
Samma teknik används även om en hallsensor används för att mäta hastigheten på ett roterande objekt. Men för H206-sensorn finns det en hake, nätplattan har 20 platser och därmed för att mäta tiden mellan två luckor kommer det att överbelasta mikrokontrollern. Därför mäter vi bara hastigheten vid en full rotation av ett hjul. Eftersom två avbrott kommer att genereras för varje mellanrum (ett i början och ett annat i slutet av avståndet) får vi totalt 40 avbrott för att hjulet ska göra en fullständig rotation. Så vi väntar på 40 avbrott innan vi faktiskt beräknar hjulets hastighet. Koden för detsamma visas nedan
if (rotation> = 40) { timetaken = millis () - pevtime; // tidtabell i millisekvpm = (1000 / tidtabell) * 60; // formler för att beräkna rpm pevtime = millis (); rotation = 0; }
En annan nackdel med denna metod är att hastighetens värde inte kommer att sjunka till noll eftersom avbrottet alltid kommer att vänta på att hjulet ska slutföra en rotation för att beräkna varvtalet. Denna nackdel kan lätt övervinnas genom att lägga till en enkel kod som övervakar tidsintervallet mellan två avbrott och om den överstiger än normalt så kan vi tvinga varvtalet och hastigheten att vara noll. Länk i koden nedan har vi använt variabel dtid för att kontrollera tidsskillnaden och om den överstiger 500 milli sekunder tvingas hastigheten och varvtalet vara noll.
/ * Att sjunka till noll om fordonet stannade * / om (millis () - dtid> 500) // ingen inbrott hittades under 500 ms { rpm = v = 0; // gör varv / minut och hastighet som noll dtid = millis (); }
Logik bakom att mäta avståndet med ratten
Vi vet redan att Arduino kommer att känna 40 avbrott när hjulet gör en komplett rotation. Så för varje enskild rotation som görs av hjulet är det uppenbart att avståndet med hjulet är lika med hjulets omkrets. Eftersom vi redan känner till hjulets radie kan vi enkelt beräkna avståndet som täcks med formeln nedan
Avstånd = 2πr * antal rotationsavstånd = (2 * 3.141 * radie_av_hjul) * (vänster_intr / 40)
Där hjulets omkrets beräknas med formeln 2πr multipliceras den med antalet rotationer som görs av hjulet.
Logik bakom att mäta bottenvinkeln
Det finns många sätt att bestämma robotens ängel. Accelerometrar och gyroskop används normalt för att bestämma dessa värden. Men en annan billig metod är att använda H206-sensorn på båda hjulen. På så sätt skulle vi veta hur många varv varje hjul har gjort. Figuren nedan illustrerar hur vinkeln beräknas.
När roboten initialiseras betraktas vinkeln mot den som 0 °. Därifrån roterar den åt vänster, vinkeln ökas negativt och om den roterar åt höjden ökas ängeln positivt. För att förstå, låt oss överväga intervallet -90 till +90 som visas i figuren. I ett sådant arrangemang eftersom båda hjulen har samma diameter, om någon av hjulen gör en fullständig rotation av botten vrider vi oss i en vinkel på 90 °.
Till exempel om det vänstra hjulet gör en fullständig rotation (80 avbrott) kommer botten att rotera 90 ° åt vänster och på samma sätt om det högra hjulet gör en fullständig rotation (80 avbrott) kommer botten att svänga -90 ° åt höger. Nu vet vi att om Arduino upptäcker 80 avbrott på ett hjul så har botten vridit 90 ° och baserat på vilket hjul kan vi se om botten har vänt med positivt (höger) eller negativt (vänster). Så vänster och höger vinkel kan beräknas med formlerna nedan
int angle_left = (left_intr% 360) * (90/80); int angle_right = (right_intr% 360) * (90/80);
Där 90 är den vinkel som täcks vid ett avbrott på 80. Det resulterande värdet multipliceras med antal avbrott. Vi har också använt en modul på 360 så att det resulterande värdet aldrig överstiger 36. När vi väl har beräknat både den vänstra och högra vinkeln kan den effektiva vinkeln mot vilken botten vänds helt enkelt erhållas genom att subtrahera den vänstra vinkeln från rätt vinkel.
vinkel = vinkel-höger - vinkel-vänster;
Arduino robotkod
Den kompletta Arduino-koden för denna hastighets- och vinkelmätrobot finns i slutet av denna sida. Målet med programmet är att beräkna botten, hastigheten och vinkeln med hjälp av ovanstående logik och visa den på LCD-skärmen. Bortsett från det bör det ge ett alternativ att styra botten med joysticken.
Vi startar programmet med att definiera de digitala I / O-stiften för de två motorerna. Observera att vi också måste styra motorns hastighet och därför måste vi använda PWM-stiften på Arduino för att styra motorerna. Här har vi använt stiftet 8,9,10 och 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
För att mäta hastigheten och sträckan som täcks måste vi känna hjulets radie, mäta värdet och ange det i meter enligt nedan. För min bot var radien 0,033 meter men det kan skilja sig åt för dig baserat på din bot.
flottörradie_hjul = 0,033; // Mät radiens hjul och ange det här i cm
Inuti installationsfunktionen initialiserar vi allt värde till noll och visar sedan en introduktionstext på LCD-skärmen. Vi har också initierat den seriella bildskärmen för felsökningsändamål. Sedan har vi nämnt att hastighetssensorerna H206 är anslutna till stift 2 och 3 som externa avbrott. Det är där avbrottet detekteras kommer ISR-funktionen Left_ISR och Right_ISR att köras i enlighet därmed.
ogiltig installation () { rotation = rpm = pevtime = 0; // Initiera alla variabler till noll Serial.begin (9600); lcd.begin (16, 2); // Initiera 16 * 2 LCD lcd.print ("Bot Monitor"); // Intro Meddelandelinje 1 lcd.setCursor (0, 1); lcd.print ("- CircuitDigest"); // Intro Meddelandelinje 2 fördröjning (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); // Vänster_ISR anropas när vänster hjulsensor utlöses attachInterrupt (digitalPinToInterrupt (3), Right_ISR, CHANGE); // Höger_ISR anropas när höger hjulsensor utlöses }
Inuti Left_ISR-rutinen ökar vi helt enkelt en variabel som heter left_intr som senare kommer att användas för att mäta bottenvinkeln. Inuti Right_ISR gör vi samma sak men sedan beräknar vi också hastigheten här. Den variabla rotationen ökas för varje avbrott och sedan används logiken ovan för att beräkna hastigheten.
ogiltig Left_ISR () { left_intr ++; delay (10); } ogiltig Right_ISR () { right_intr ++; fördröjning (10); rotation ++; dtid = millis (); if (rotation> = 40) { timetaken = millis () - pevtime; // tidtabell i millisekvpm = (1000 / tidtabell) * 60; // formler för att beräkna rpm pevtime = millis (); rotation = 0; } }
Inuti den huvudsakliga oändliga slingfunktionen övervakar vi värdena på X och Y från joysticken. Baserat på värdet om joysticken flyttas kontrollerar vi botten i enlighet därmed. Hastigheten på botten beror på hur långt joysticken trycks in.
int xValue = analogRead (joyX); int yValue = analogRead (joyY); int-acceleration = karta (xValue, 500, 0, 0, 200); om (xValue <500) { analogWrite (LM_pos, acceleration); analogWrite (RM_pos, acceleration); } annat { analogWrite (LM_pos, 0); analogWrite (RM_pos, 0); } om (yValue> 550) analogWrite (RM_pos, 80); if (yValue <500) analogWrite (LM_pos, 100);
Detta hjälper användaren att flytta botten och kontrollera om de erhållna värdena är som förväntat. Slutligen kan vi beräkna hastigheten, avståndet och vinkeln för botten med hjälp av ovanstående logik och visa den på LCD-skärmen med hjälp av nedanstående kod.
v = radie_hjul * varv / min * 0.104; //0.033 är hjulets radie i meteravstånd = (2 * 3.141 * radie_av_hjul) * (vänster_intr / 40); int angle_left = (left_intr% 360) * (90/80); int angle_right = (right_intr% 360) * (90/80); vinkel = vinkel-höger - vinkel-vänster; 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 (höger_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 (avstånd); lcd.setCursor (13, 1); lcd.print (""); lcd.setCursor (13, 1); lcd.print (vinkel);
Testar Arduino-roboten för att mäta avstånd, hastighet och vinkel
När din hårdvara är klar laddar du upp koden till din Arduino och använder joysticken för att flytta din bot. botens hastighet, avstånd täckt av den och vinkeln visas på LCD-skärmen som visas nedan.
På LCD-skärmen representerar termen Lt och Rt antal vänsteravbrott respektive högeravbrott. Du kan hitta dessa värden ökas för varje gap som detekteras av sensorn. Temet S anger hastigheten på botten i m / sek och termen D indikerar avstånd täckt i meter. Botens vinkel visas i slutet där 0 ° är för rak och den går negativ för rotation moturs och positiv för medurs rotation.
Du kan också titta på videon i slutet av denna sida för att förstå hur bot fungerar. Hoppas att du förstod projektet och gillade att bygga det. Om du har några problem lämnar du dem i kommentarsektionen och jag kommer att försöka bäst att svara tillbaka. Du kan också använda forum för snabb teknisk hjälp.