- LM393 sebességérzékelő modul (H206)
- H206 érzékelő felszerelésének elrendezése
- Barkács Arduino LM393 sebességérzékelő robot áramköri ábra
- A sebesség mérésének logikája az LM393 sebességérzékelő modul segítségével
- Logika a kerék által megtett távolság mérése mögött
- Logika a bot szögének mérése mögött
- Arduino robot kód
- Az Arduino robot tesztelése a távolság, a sebesség és a szög mérésére
A robotok lassan beindultak társadalmunkba, hogy egyszerűbbé tegyük életünket. Az Egyesült Királyság útjain már megtalálhatjuk a Starship hat kerekes élelmiszer-szállító robotját, amelyek okosan navigálnak a civilek között, hogy elérjék célját. Minden mobil robotnak, aki a környezetbe navigál, mindig tisztában kell lennie helyzetével és helyzetével a való világ szempontjából. Sokféle módon érhetjük el ezt különböző technológiák, például GPS, RF háromszögelés, gyorsulásmérők, giroszkópok stb. Használatával. Minden technikának megvan a maga előnye, és önmagában is egyedülálló. Ebben az Arduino LM393 sebességérzékelő oktatóanyagban az egyszerű és könnyen elérhető LM393 sebességérzékelő modult fogjuk használnimérni néhány létfontosságú paramétert, például a sebességet, a megtett távolságot és a robot szögét az Arduino segítségével. Ezekkel a paraméterekkel a robot képes lesz megismerni valós állapotát, és felhasználhatja a biztonságos navigáláshoz.
Az Arduino a legnépszerűbb választás a hobbisták körében a robotok építéséhez, az egyszerű vonalkövetőtől a bonyolultabb önkiegyensúlyozó vagy padlótisztító robotig. Mindenféle robotot a Robotika részben ellenőrizhet.
Építünk egy kis robotot, amelyet lítium akkumulátor működtet, és egy botkormány segítségével hajtjuk meg. Futás közben mérhetjük a robot sebességét, távolságát és szögét, és valós időben megjeleníthetjük az Arduino-hoz csatlakoztatott LCD kijelzőn. Ez a projekt csak segít ezeknek a paramétereknek a mérésében, miután ezzel végzett, ezeket a paramétereket használhatja a bot önálló működtetésére, ha szükséges. Érdekesen hangzik, igaz? Tehát kezdjük.
LM393 sebességérzékelő modul (H206)
Mielőtt belekezdenénk a projekt kapcsolási rajzába és kódjába, értsük meg az LM393 sebességérzékelő modult, mivel ez kulcsfontosságú szerepet játszik a projektben. A H206 sebességérzékelő modul egy infravörös fényérzékelőből áll, amely egy LM393 feszültség-komparátor IC-be van integrálva, ezért az LM393 sebesség-érzékelő neve. A modul egy rácslemezből is áll, amelyet fel kell szerelni a motor forgótengelyére. Az összes alkotóelemet a kép alatt jelölik.
Az infravörös fényérzékelő egy IR LED-ből és egy fototranzisztorból áll, amelyet egy kis darab választ el. A teljes érzékelőelrendezést fekete házba kell helyezni, a fent látható módon. A rácslemez résekből áll, a lemez az infravörös fényérzékelő rése közé van elrendezve oly módon, hogy az érzékelő érzékelje a rácslemez réseit. A rácslemez minden egyes rése kiváltja az IR-érzékelőt, amikor áthalad a résen; ezeket az indítókat az összehasonlító segítségével feszültségjelekké alakítják. Az összehasonlító nem más, mint egy LM393 IC az ON félvezetőktől. A modulnak három érintkezõje van, amelyek közül kettõt a modul táplálására használnak, és egy kimeneti csapot használnak az indítók számának számlálására.
H206 érzékelő felszerelésének elrendezése
Az ilyen típusú érzékelők felszerelése kissé bonyolult. Csak olyan motorokra szerelhető fel, amelyek tengelye mindkét oldalon ki van állítva. A tengely egyik oldala a kerékhez van csatlakoztatva, míg a másik oldala a rácslemez felszerelésére szolgál a fent látható módon.
Mivel a kerék és a lemez ugyanazon tengelyhez csatlakozik, mindkettő azonos sebességgel forog, és így a lemez sebességének mérésével megmérhetjük a kerék sebességét. Győződjön meg arról, hogy a rácslemez rései áthaladnak az infravörös érzékelőn, csak akkor képes az érzékelő megszámolni az áthaladt rések számát. Ön is előállhat saját mechanikus elrendezésével az érzékelő felszereléséhez, amennyiben az megfelel a megadott feltételeknek. Az infravörös érzékelőt általában számos robotikai projektben használják a robot vezetésére az akadályok felismerésében.
A fenti rácslemez 20 résszel rendelkezik. Ez azt jelenti, hogy az érzékelő 20 rést talál a kerék egy teljes forgatásához. Az érzékelő által észlelt rések számának kiszámításával kiszámíthatjuk a kerék által megtett távolságot, hasonlóan azzal is, hogy megmérjük, hogy az érzékelő milyen gyorsan találja meg a hézagokat, és a kerék sebességét. Robotunkban ezt az érzékelőt a kerekekre rögzítjük, így megtalálhatjuk a robot szögét is. Azonban a forgásszöget ésszerűbben ki lehet számítani a gyorsulásmérő vagy a giroszkóp segítségével. Tanulja meg itt, hogyan kapcsolja össze a gyorsulásmérőt és a giroszkópot az Arduino-val, és próbáljon meg mérni forgásszöget ezek segítségével.
Barkács Arduino LM393 sebességérzékelő robot áramköri ábra
A sebesség- és távolságérzékelő robot teljes kapcsolási rajza alább látható. A Bot agya az Arduino Nano áll, a kerekek két egyenáramú motorját az L298N H-Bridge Motor Driver modul hajtja. A botkormány a bot sebességének és irányának szabályozására szolgál, a két H206 sebességérzékelő pedig a bot sebességének, távolságának és angyalának mérésére. Ezután a mért értékek megjelennek a 16x2 LCD modulban. Az LCD-re csatlakoztatott potenciométerrel az LCD kontrasztját állíthatjuk be, az ellenállást pedig az LCD háttérvilágításához áramló áram korlátozására.
A teljes áramkört egy 7,4 V-os lítium cella táplálja. Ezt a 7,4 V-ot a motorvezérlő modul 12 V-os tűjéhez kapjuk. Ezután a motorvezérlő modul feszültségszabályozója átalakítja a 7,4 V-ot szabályozott + 5 V-ra, amelyet az Arduino, az LCD, az érzékelők és a joystick táplálására használnak.
A motort az Arduino 8, 9, 10 és 11 digitális csapjai vezérlik. Mivel a motor fordulatszámát is szabályozni kell, PWM jeleket kell juttatnunk a motor pozitív kapcsa felé. Ezért van egy 9-es és 10-es tű, amelyek mind PWM-képes csapok. Az X és Y értékek alkotják a joystick beolvasását az A2 és A3 analóg csapok segítségével.
Mint tudjuk, a H206 szenzor kiváltja a ravaszt, amikor a rácslemez rése észlelhető. Mivel ezeket a triggereket nem kell mindig pontosan elolvasni a helyes sebesség és távolság kiszámításához, mind a ravaszt (kimenetet) az Arduino Board 2. és 3. külső megszakító tűjéhez kell csatlakoztatni. Szerelje össze az egész áramkört egy alvázon, és szerelje be a sebességérzékelőt a magyarázat szerint. Az oldal végén található videót is megnézheti, hogy megtudja, hogyan szerelték fel az érzékelőt.
Most, hogy a hardver rész befejeződött, menjünk bele a logikába, hogy miként fogjuk mérni a bot sebességét, távolságát és egyét, majd folytassuk a programozással.
A sebesség mérésének logikája az LM393 sebességérzékelő modul segítségével
Az érzékelő szerelési beállításaiból tudnia kell, hogy az LM393 sebességérzékelő modul (H206) csak a rácslapon lévő réseket méri. Szerelés közben meg kell győződnie arról, hogy a kerék (amelynek sebességét meg kell mérni) és a rácslap ugyanolyan sebességgel forog. Mint itt, mivel mind a kereket, mind a lemezt ugyanarra a tengelyre szereltük fel, nyilvánvalóan ugyanolyan sebességgel fognak forogni.
Beállításunkban minden kerékhez két érzékelőt szereltünk fel a bot szögének mérésére. De ha csak a sebesség és a távolság mérése a cél, akkor az érzékelőt bármelyik kerékre felszerelhetjük. Az érzékelő kimenetét (kiváltó jeleket) a mikrovezérlő külső megszakító tűjéhez kell leggyakrabban csatlakoztatni. Minden alkalommal, amikor a rácslemezen lévő rést észlelik, megszakítás lép működésbe, és az ISR (Interrupt service Routine) kód végrehajtásra kerül. Ha képesek vagyunk kiszámítani két ilyen kiváltó tényező közötti időintervallumot, akkor kiszámíthatjuk a kerék sebességét.
Az Arduino-ban ezt az időintervallumot egyszerűen kiszámíthatjuk a millis () függvény használatával. Ez a millis funkció folyamatosan növekszik 1 millimásodpercenként az eszköz bekapcsolásától számítva. Tehát amikor az első megszakítás bekövetkezik, akkor a millis () értékét el tudjuk menteni egy dummy változóban (mint például a pevtime ebben a kódban), majd amikor a második megszakítás bekövetkezik, kiszámíthatjuk az időt, ha kivonjuk a millis () pevtime értékét ().
Idő = az aktuális időt - korábbi alkalommal timetaken = Millis () - pevtime ; // timetaken az ms
Miután kiszámoltuk az elvárt időt, egyszerűen kiszámíthatjuk az rpm értékét az alábbi képletek segítségével, ahol (1000 / timetaken) megadja az RPS-t (Revolutions per second), és ezt megszorozzuk 60-mal, hogy az RPS-t RPM-re (Revolutions per minute) konvertáljuk..
fordulat / perc = (1000 / bevett) * 60;
A fordulatszám kiszámítása után kiszámíthatjuk a jármű sebességét az alábbi képletek segítségével, feltéve, hogy tudjuk a kerék sugarát.
Sebesség = 2π × RPS × a kerék sugara. v = a kerék sugara * fordulat / perc * 0,104
Ne feledje, hogy a fenti képlet a sebesség m / s-ban történő kiszámítására szolgál, ha km / h-ban akarja kiszámítani, akkor a 0,0104-et cserélje le 0,376-ra. Ha kíváncsi arra, hogyan nyertük a 0,104 értéket, próbálkozzon a V = 2π × RPS × kerék sugara képlet egyszerűsítésével.
Ugyanezt a technikát alkalmazzák akkor is, ha hall érzékelőt használnak egy forgó tárgy sebességének mérésére. De a H206 érzékelőnél van egy retesz, a rácslemeznek 20 nyílása van, ezért a két rés közötti idő méréséhez túlterheli a mikrovezérlőt. Ezért csak a kerék teljes forgásakor mérjük a sebességet. Mivel minden egyes réshez két megszakítás jön létre (egy az elején, a másik pedig a rés végén) , összesen 40 megszakítást kapunk, hogy a kerék egy teljes elfordulást hajtson végre. Tehát várunk 40 megszakítást, mielőtt kiszámítanánk a kerék sebességét. Ugyanennek a kódja az alábbiakban látható
if (forgás> = 40) { időmérés = millis () - pevtime; // milliszekundumos fordulat / perc = (1000 / bevett) * 60; // képletek az rpm kiszámításához pevtime = millis (); forgás = 0; }
Egy másik hátránya ennek a módszernek az, hogy a sebesség értéke nem csökken nullára, mivel a megszakítás mindig arra vár, hogy a kerék befejezzen egy forgást a fordulatszám érték kiszámításához. Ez a hátrány könnyen leküzdhető egy egyszerű kód hozzáadásával, amely figyeli a két megszakítás közötti időintervallumot, és ha meghaladja a normálist, akkor nullára kényszeríthetjük az rpm és a sebesség értékét. Link az alábbi kódban a dtime változót alkalmaztuk az időbeli különbség ellenőrzésére, és ha ez meghaladja az 500 milli másodpercet, akkor a sebesség és az rpm értéke nulla.
/ * Nullára csökken, ha a jármű leáll * / if (millis () - dtime> 500) // 500 ms-nál nem található megszakítás { rpm = v = 0; // készítsen fordulatszámot és sebességet nulla dtime = millis (); }
Logika a kerék által megtett távolság mérése mögött
Már tudjuk, hogy az Arduino érzékeli a 40 megszakítást, amikor a kerék egy teljes fordulatot tesz. Tehát a kerék minden egyes forgatásakor nyilvánvaló, hogy a kerék által megtett távolság megegyezik a kerék kerületével. Mivel már tudjuk a kerék sugarát, az alábbi képlet segítségével könnyen kiszámíthatjuk a megtett távolságot
Távolság = 2πr * forgások száma távolság = (2 * 3,141 * kerekes sugár) * (bal_intr / 40)
Ahol a kerék kerületét a 2πr képlet segítségével számoljuk ki, majd megszorozzuk a kerék által végrehajtott forgások számával.
Logika a bot szögének mérése mögött
Sokféle módon lehet meghatározni a robot angyalát. Ezen értékek meghatározásához általában gyorsulásmérőket és giroszkópokat használnak. De egy másik olcsó megközelítés a H206 érzékelő használata mindkét keréken. Így megtudnánk, hogy hány kerék fordult el. Az alábbi ábra szemlélteti a szög kiszámítását.
A robot inicializálásakor a szöge 0 °. Innen balra forog, a szög negatívan növekszik, és ha jobbra fordul, akkor az angyal pozitív lesz. A megértéshez vegyük figyelembe az -90 és +90 közötti tartományt, amint az az ábrán látható. Ilyen elrendezésben, mivel mindkét kerék azonos átmérőjű, ha a kerék bármelyike teljesen elfordul, akkor a botot 90 ° -os szögben fordítjuk.
Például, ha a bal kerék egy teljes elfordulást (80 megszakítást) végez, akkor a bot 90 ° -kal balra fordul, és hasonlóan, ha a Jobb kerék egy teljes fordulatot (80 megszakít), akkor a bot -90 ° -kal jobbra fordul. Most már tudjuk, hogy ha az Arduino 80 megszakítást észlel egy keréken, akkor a bot 90 ° -kal elfordult, és melyik kerék alapján tudjuk megmondani, hogy a bot pozitív (jobbra) vagy negatív (balra) fordult-e. Tehát a bal és a jobb szöget az alábbi képletekkel lehet kiszámítani
int szög_balra = (bal_intr% 360) * (90/80); int szög_jobb = (jobb_intr% 360) * (90/80);
Ahol 90 a lefedett szög a 80-as megszakításkor. Használtunk egy 360-as modulust is, így az eredő érték soha nem haladja meg a 36-ot. Miután kiszámítottuk mind a bal, mind a jobb szöget, akkor a bot szögének tényleges szöge egyszerűen megszerezhető a bal szög kivonásával a derékszögből.
szög = szög_jobb - szög_bal;
Arduino robot kód
Ennek a sebesség- és szögmérő robotnak a teljes Arduino kódja az oldal végén található. A program célja a bot sebességének, távolságának és szögének kiszámítása a fenti logikák felhasználásával, és az LCD képernyőn való megjelenítése. Ettől eltekintve lehetőséget kell biztosítania a bot vezérlésére a Joystick segítségével.
A programot a két motor digitális I / O csapjainak meghatározásával kezdjük. Ne feledje, hogy a motor sebességét is szabályoznunk kell, ezért az Arduino PWM csapjait kell használnunk a motorok vezérléséhez. Itt használtuk a 8,9,10 és 11 csapot.
#define LM_pos 9 // bal motor #define LM_neg 8 // bal motor #define RM_pos 10 // jobb motor #define RM_neg 11 // jobb motor #define joyX A2 #define defYY A3
A megtett sebesség és távolság méréséhez meg kell ismernünk a kerék sugarát, meg kell mérnünk az értéket és méterben kell megadnunk az alábbiak szerint. A botom számára a sugár 0,033 méter volt, de a botod alapján eltérhet.
úszó kerekes sugár = 0,033; // Mérje meg a kerék sugarát, és írja be ide cm-ben
A beállítási funkción belül minden értéket nullára inicializálunk, majd egy Intro Text-t jelenítünk meg az LCD-n. A soros monitort hibakeresés céljából is inicializáltuk. Aztán megemlítettük, hogy a H206 sebességérzékelők külső megszakításként a 2. és 3. érintkezőhöz vannak csatlakoztatva. Itt észlelik a megszakítást, a Left_ISR és a Right_ISR ISR függvényeket ennek megfelelően hajtják végre.
void setup () { rotation = rpm = pevtime = 0; // Inicializálja az összes változót nullára Serial.begin (9600); lcdbegin (16, 2); // Inicializálja a 16 * 2 LCD lcd.print ("Bot Monitor"); // Intro Message line 1 lcd.setCursor (0, 1); lcd.print ("- CircuitDigest"); // Intro Message line 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), Bal_ISR, CHANGE); // A bal_ISR-t akkor hívják meg, amikor a bal kerékérzékelő beindul. AttachInterrupt (digitalPinToInterrupt (3), Jobb_ISR, CHANGE); // Jobb_ISR hívódik, ha a jobb oldali kerékérzékelő aktiválódik }
A Left_ISR rutinon belül egyszerűen növeljük a left_intr nevű változót, amelyet később felhasználunk a bot szögének mérésére. A Right_ISR belsejében ugyanezt tesszük, de utána itt is kiszámoljuk a sebességet. A változó forgást minden megszakításnál növekszik, majd a fenti logikát alkalmazzák a sebesség kiszámításához.
void Left_ISR () { left_intr ++; késés (10); } void Right_ISR () { right_intr ++; késés (10); forgatás ++; dtime = millisz (); if (forgás> = 40) { időmérés = millis () - pevtime; // milliszekundumos fordulat / perc = (1000 / bevett) * 60; // képletek az rpm kiszámításához pevtime = millis (); forgás = 0; } }
A fő végtelen hurok funkción belül a joystick segítségével figyeljük X és Y értékeit. A botkormány mozgatásának értéke alapján ennek megfelelően irányítjuk a botot. A bot sebessége attól függ, hogy meddig tolják a joystickot.
int xValue = analogRead (joyX); int yValue = analogRead (örömY); int gyorsulás = térkép (xValue, 500, 0, 0, 200); if (xérték <500) { analogWrite (LM_pos, gyorsulás); analogWrite (RM_pos, gyorsulás); } else { analogWrite (LM_pos, 0); analogWrite (RM_pos, 0); } if (yValue> 550) analogWrite (RM_pos, 80); if (yValue <500) analogWrite (LM_pos, 100);
Ez segít a felhasználónak a bot mozgatásában és annak ellenőrzésében, hogy a kapott értékek megfelelnek-e a vártnak. Végül kiszámíthatjuk a bot sebességét, távolságát és szögét a fenti logika segítségével, és az alábbi kód segítségével megjeleníthetjük az LCD-n.
v = a kerék sugara * fordulat / perc * 0,104; //0.033 a kerék sugara méteres távolságban = (2 * 3,141 * kerekes sugár) * (left_intr / 40); int szög_balra = (bal_intr% 360) * (90/80); int szög_jobb = (jobb_intr% 360) * (90/80); szög = szög_jobb - szög_bal; 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 (távolság); lcd.setCursor (13, 1); lcd.print (""); lcd.setCursor (13, 1); lcd.print (szög);
Az Arduino robot tesztelése a távolság, a sebesség és a szög mérésére
Miután a hardver készen áll, töltse fel a kódot az Arduino-ba, és a bot segítségével mozgassa a botot. a bot sebessége, az általa megtett távolság és a szög az alábbiak szerint jelenik meg az LCD-n.
Az LCD kijelzőn az Lt és az Rt kifejezés a bal és a jobb oldali megszakítás számát jelenti. Megállapíthatja, hogy ezek az értékek növekszenek minden érzékelő által észlelt rés után. A tem S a bot sebességét m / sec-ban, a D kifejezés pedig a megtett távolságot mutatja méterben. A bot szöge abban a végén jelenik meg, ahol a 0 ° egyenes, negatív az óramutató járásával ellentétes és pozitív az óramutató járásával megegyező irányban.
Megtekintheti az oldal végén található videót is, hogy megértse a bot működését. Remélem, megértette a projektet, és élvezte az építését. Ha bármilyen kérdése van, hagyja őket a megjegyzés részben, és megpróbálok a legjobban válaszolni. Fórumokat is használhat a gyors technikai segítségnyújtáshoz.