Nopeuden, etäisyyden ja kulman mittaus mobiiliroboteille, joissa käytetään Arduino- ja LM393-nopeusanturia (h206)

Robotit ovat alkaneet hitaasti ryömiä yhteiskuntaamme helpottaaksemme elämäämme. Voimme jo löytää kuusi pyörällistä ruoanjakelurobottia Starshipilta Ison-Britannian teiltä, ​​jotka liikkuvat älykkäästi siviilien joukossa saavuttaakseen määränpäänsä. Jokaisen liikkuvan robotin, joka liikkuu ympäristöön, tulisi aina olla tietoinen sijainnistaan ​​ja suuntautumisestaan ​​todelliseen maailmaan. On monia tapoja saavuttaa tämä käyttämällä erilaisia ​​tekniikoita, kuten GPS, RF-kolmio, kiihtyvyysmittarit, gyroskoopit jne. Jokaisella tekniikalla on oma etunsa ja se on itsessään ainutlaatuinen. Tässä Arduino LM393 -nopeusanturin opetusohjelmassa käytämme yksinkertaista ja helposti saatavaa LM393-nopeusanturimoduuliamitata joitain elintärkeitä parametreja, kuten nopeus, kuljettu matka ja robotin kulma Arduinon avulla. Näiden parametrien avulla robotti voi tietää todellisen asemansa maailmassa ja käyttää sitä turvalliseen navigointiin.

Arduino on suosituin valinta harrastajien keskuudessa robottien rakentamiseen yksinkertaisesta linjan seuraajasta monimutkaisempaan itsetasapainottavaan tai lattianpuhdistusrobottiin. Voit tarkistaa kaikenlaiset robotit Robotiikka-osiosta.

Rakennamme pienen robotin, joka saa virtansa litiumakusta, ja ajamme sitä ohjaussauvalla. Ajon aikana voimme mitata robotin nopeuden, etäisyyden ja kulman ja näyttää sen reaaliaikaisesti Arduinoon liitetyllä LCD- näytöllä. Tämä projekti auttaa vain näiden parametrien mittaamisessa, kun olet valmis, voit käyttää näitä parametreja botin automaattiseen ohjaamiseen tarpeen mukaan. Kuulostaa mielenkiintoiselta? Joten aloitetaan.

LM393-nopeusanturimoduuli (H206)

Ennen kuin pääsemme piirikaavioon ja projektin koodiin, ymmärretään LM393-nopeusanturimoduuli, koska sillä on tärkeä rooli projektissa. H206 Nopeusanturin moduuli koostuu Infrapuna Valoanturi integroitu LM393 Jännite vertailuryhmässä IC tästä nimi LM393 Nopeusanturin. Moduuli koostuu myös ristikkolevystä, joka on asennettava moottorin pyörivään akseliin. Kaikki komponentit on merkitty kuvan alapuolelle.

Infrapuna Valoanturi koostuu IR-LED ja valoherkkä transistori erotettu pieni gab. Koko anturijärjestely on sijoitettu mustaan ​​koteloon yllä olevan kuvan mukaisesti. Ristikkolevy koostuu rakoista, levy on järjestetty infrapunavalosensorin raon väliin siten, että anturi tunnistaa aukot ristikkolevyssä. Jokainen aukko ristikkolevyssä laukaisee IR-anturin, kun se kulkee aukon läpi; nämä laukaisimet muunnetaan sitten jännitesignaaleiksi vertailijan avulla. Vertailija ei ole muuta kuin ON-puolijohteiden LM393-IC. Moduulissa on kolme nastaa, joista kahta käytetään moduulin virtalähteeseen ja yhtä ulostulotappia käytetään liipaisimien määrän laskemiseen.

H206-anturin kiinnitysjärjestely

Tämän tyyppisten antureiden asentaminen on vähän hankalaa. Se voidaan asentaa vain moottoreihin, joiden akseli on ulkoneva molemmin puolin. Akselin toinen puoli on kytketty pyörään, kun taas toista puolta käytetään ristikkolevyn asentamiseen yllä esitetyllä tavalla.

Koska pyörä ja levy on kytketty samaan akseliin, molemmat pyörivät samalla nopeudella ja siten mittaamalla levyn nopeutta voimme mitata pyörän nopeuden. Varmista, että ristikkolevyn aukot kulkevat infrapunatunnistimen läpi, vasta sitten anturi pystyy laskemaan läpikulkujen määrän. Voit myös keksiä oman mekaanisen järjestelysi anturin asentamiseksi niin kauan kuin se täyttää määritetyn ehdon. Infrapunatunnistinta käytetään yleensä monissa robottihankkeissa robotin ohjaamiseksi esteistä.

Edellä esitetyllä ristikkolevyllä on 20 aukkoa (ristikkoa). Tämä tarkoittaa, että anturi löytää 20 aukkoa pyörän täydelle pyörimiselle. Laskemalla anturin havaitsemien aukkojen määrä voimme laskea pyörän kulkeman matkan samalla tavalla mittaamalla kuinka nopeasti anturi löytää aukot, jotka voimme havaita pyörän nopeuden. Robottissamme tämä anturi asennetaan molempiin pyöriin, joten löydämme myös robotin kulman. Kiertokulma voidaan kuitenkin laskea järkevämmin kiihtyvyysmittarilla tai gyroskoopilla, opi täältä liittämään kiihtyvyysmittari ja gyroskooppi Arduinon kanssa ja yritä mitata kiertokulma niiden avulla.

DIY Arduino LM393-nopeusanturin robottipiirikaavio

Tämän nopeutta ja etäisyyttä mittaavan robotin täydellinen piirikaavio on esitetty alla. Bot koostuu aivoista Arduino Nanosta, pyörien kahta tasavirtamoottoria ohjaa L298N H-Bridge Motor Driver -moduuli. Ohjaussauvaa käytetään botin nopeuden ja suunnan säätämiseen ja kahta nopeusanturia H206 käytetään botin nopeuden, etäisyyden ja enkelin mittaamiseen. Mitatut arvot näytetään sitten 16x2 LCD-moduulissa. Nestekidenäyttöön kytkettyä potentiometriä voidaan käyttää nestekidenäytön kontrastin säätämiseen, ja vastusta käytetään rajoittamaan nestekidenäytön taustavaloon virtaavaa virtaa.

Täydellinen piiri saa virtansa 7.4V Litium solu. Tämä 7,4 V toimitetaan moottorin ohjainmoduulin 12 V: n napaan. Moottorin ohjainmoduulin jännitesäädin muuntaa sitten 7,4 V: n säädetyksi + 5 V: ksi, jota käytetään Arduinon, LCD: n, antureiden ja ohjaussauvan virtalähteeseen.

Moottoria ohjaavat Arduinon digitaaliset nastat 8,9, 10 ja 11. Koska moottorin nopeutta on myös kontrolloitava, meidän tulisi toimittaa PWM-signaaleja moottorin positiiviseen napaan. Siksi meillä on tapit 9 ja 10, jotka ovat molemmat PWM-yhteensopivia nastoja. X- ja Y-arvot muodostavat ohjaussauvan lukemisen analogisilla nastoilla A2 ja A3.

Kuten tiedämme, H206-anturi tuottaa liipaisimen, kun ristikkolevyssä oleva aukko havaitaan. Koska näitä liipaisimia ei aina pidä lukea tarkasti oikean nopeuden ja etäisyyden laskemiseksi, molemmat liipaisimen (lähdön) nastat on kytketty Arduino-kortin ulkoiseen keskeytystappiin 2 ja 3. Kokoa koko piiri alustalle ja asenna nopeusanturi selitetyllä tavalla, botti näytti jotain alla olevaa, kun liitännät oli tehty. Voit myös katsella videota tämän sivun lopussa tietääksesi, kuinka anturi asennettiin.

Nyt kun laitteisto-osa on valmis, pääsemme logiikkaan kuinka mitataan botin nopeutta, etäisyyttä ja yksittäistä osaa, ja jatka sitten ohjelmointiosaan.

Nopeuden mittaamisen logiikka LM393-nopeusanturimoduulilla

Anturin asennusasennuksesta tulee olla tietoinen siitä, että LM393-nopeusanturimoduuli (H206) mittaa vain ristikkolevyssä olevat aukot. Asennuksen aikana on varmistettava, että pyörä (jonka nopeus tulisi mitata) ja ristikkolevy pyörivät samalla nopeudella. Kuten täällä, koska olemme asentaneet sekä pyörän että levyn samalle akselille, molemmat pyörivät ilmeisesti samalla nopeudella.

Asennuksessamme olemme asentaneet kaksi anturia kullekin pyörälle botin kulman mittaamiseksi. Mutta jos tavoitteesi on mitata vain nopeus ja etäisyys, voimme asentaa anturin mihin tahansa pyörään. Anturin lähtö (laukaisusignaalit) kytketään yleisimmin mikro-ohjaimen ulkoiseen keskeytystappiin. Joka kerta kun ristikkolevyssä oleva aukko havaitaan, laukaistaan ​​keskeytys ja ISR: n (Interrupt service Routine) koodi suoritetaan. Jos pystymme laskemaan kahden tällaisen laukaisimen välisen aikavälin, voimme laskea pyörän nopeuden.

Arduinossa voimme helposti laskea tämän aikavälin millis () -funktiolla. Tämä millis-toiminto kasvaa 1: llä jokaista millisekuntia kohti laitteen virran kytkemisestä. Joten kun ensimmäinen keskeytys tapahtuu, voimme tallentaa millis () -arvon nuken muuttujaan (kuten pevtime tässä koodissa) ja sitten, kun toinen keskeytys tapahtuu, voimme laskea kuluneen ajan vähentämällä pevtime- arvon millistä ().

Aika = nykyinen aika - edellisen ajan aikataulu = millis () - pevtime ; // timetaken vuonna millisec

Kun olemme laskeneet kuluneen ajan, voimme yksinkertaisesti laskea kierrosluvun arvon alla olevilla kaavoilla, joissa (1000 / timetaken) antaa RPS: n (kierrosta sekunnissa) ja se kerrotaan 60: llä, jotta RPS muunnetaan RPM: ksi (kierrokset minuutissa).

rpm = (1000 / otettu) * 60;

Laskettuamme kierrosluvun voimme laskea ajoneuvon nopeuden alla olevien kaavojen avulla edellyttäen, että tiedämme pyörän säteen.

Nopeus = 2π × RPS × pyörän säde. v = pyörän säde * rpm * 0,104

Huomaa, että yllä oleva kaava on tarkoitettu nopeuden m / s laskemiseen, jos haluat laskea km / h, korvaa sitten 0,0104 luvulla 0,376. Jos haluat tietää, miten arvo 0,104 saatiin, yritä yksinkertaistaa kaavaa V = 2π × RPS × pyörän säde.

Samaa tekniikkaa käytetään, vaikka hall-anturia käytetään pyörivän kohteen nopeuden mittaamiseen. Mutta H206-anturissa on salpa, ristikkolevyssä on 20 aukkoa ja siten kahden aukon välisen ajan mittaamiseksi ylikuormitetaan mikro-ohjain. Siksi mitataan nopeus vain pyörän täydellä pyörimisellä. Koska kutakin aukkoa varten syntyy kaksi keskeytystä (yksi alussa ja toinen aukon lopussa), saamme pyörälle yhteensä 40 keskeytystä yhden täydellisen pyörimisen suorittamiseksi. Joten odotamme 40 keskeytystä, ennen kuin laskemme pyörän nopeuden. Saman koodi näkyy alla

if (kierto> = 40) { aikataulu = millis () - pevtime; // ajettu millisekunnissa rpm = (1000 / ajettu) * 60; // kaavat rpm laskemiseksi pevtime = millis (); kierto = 0; }

Toinen haitta tällä menetelmällä on, että nopeuden arvo ei putoa nollaan, koska keskeytys odottaa aina pyörän suorittavan yhden pyörityksen pyörimisarvon laskemiseksi. Tämä haittapuoli voidaan helposti voittaa lisäämällä yksinkertainen koodi, joka valvoo kahden keskeytyksen välistä aikaväliä ja jos se ylittää normaalin, voimme pakottaa kierrosluvun ja nopeuden arvon olemaan nolla. Linkki alla olevaan koodiin olemme käyttäneet muuttuvaa dtime- aikaa aikaeron tarkistamiseen, ja jos se ylittää 500 milli sekuntia, nopeuden ja kierrosluvun arvon on pakko olla nolla.

/ * Pudotetaan nollaan, jos ajoneuvo pysähtyy * / if (millis () - dtime> 500) // ei keskeytystä löytynyt 500 ms: n ajalta { rpm = v = 0; // tee kierrosta ja nopeutta nollaksi dtime = millis (); }

Pyörän kulkeman matkan mittaamisen logiikka

Tiedämme jo, että Arduino tunnistaa 40 keskeytystä, kun pyörä pyörittää yhden täydellisesti. Joten jokaisesta pyörän pyörimisestä on ilmeistä, että pyörän kulkema etäisyys on yhtä suuri kuin pyörän kehä. Koska tiedämme jo pyörän säteen, voimme helposti laskea ajetun matkan alla olevan kaavan avulla

Etäisyys = 2πr * kierrosluku etäisyys = (2 * 3,141 * pyörän säde) * (vasen_intr / 40)

Jos pyörän ympärysmitta lasketaan kaavalla 2πr ja kerrotaan pyörän pyörimien lukumäärällä.

Logiikka botin kulman mittaamisen takana

On monia tapoja määrittää robotin enkeli. Kiihtyvyysmittareita ja gyroskooppeja käytetään yleensä näiden arvojen määrittämiseen. Mutta toinen halpa tapa on käyttää H206-anturia molemmissa pyörissä. Tällä tavalla tiedämme, kuinka monta kierrosta kukin pyörä on tehnyt. Seuraava kuva kuvaa kuinka kulma lasketaan.

Kun robotti alustetaan, kulmaksi katsotaan 0 °. Sieltä se pyörii vasemmalle, kulma kasvaa negatiiviseksi ja jos se pyörii oikealle, enkeli kasvaa positiiviseksi. Harkitse ymmärtämistä varten alue -90 - +90, kuten kuvassa on esitetty. Tällaisessa järjestelyssä, koska molemmat pyörät ovat samaa halkaisijaa, jos joku pyöristä pyörittää täydellisesti bottia, käännämme 90 ° kulmassa.

Esimerkiksi jos vasen pyörä tekee yhden täydellisen pyörähdyksen (80 keskeytystä), botti kääntyy 90 ° vasemmalle ja vastaavasti, jos oikea pyörä pyörittää yhden täydellisen pyörähdyksen (80 keskeytystä), botti kääntyy -90 ° oikealle. Nyt tiedämme, että jos Arduino havaitsee 80 keskeytystä yhdellä pyörällä, botti on kääntynyt 90 ° ja minkä pyörän perusteella voimme kertoa, onko botti kääntynyt positiivisella (oikealla) vai negatiivisella (vasemmalla). Joten vasen ja oikea kulma voidaan laskea alla olevien kaavojen avulla

int kulma vasemmalle = (vasen_intr% 360) * (90/80); int kulma_oikea = (oikea_intr% 360) * (90/80);

Missä 90 on kulma, joka katetaan 80: n keskeytystä tehtäessä. Tuloksena oleva arvo kerrotaan lukukeskeytyksillä. Olemme käyttäneet myös moduulia 360 niin, että tuloksena oleva arvo ei koskaan ylitä 36: ta. Kun olemme laskeneet sekä vasemman että oikean kulman, tehollinen kulma, johon botti on edessään, voidaan yksinkertaisesti saada vähentämällä vasen kulma suorasta kulmasta.

kulma = kulma_oikea - kulma_vasen;

Arduino-robottikoodi

Tämän nopeuden ja kulman mittausrobotin täydellinen Arduino-koodi löytyy tämän sivun lopusta. Ohjelman tarkoituksena on laskea botin nopeus, etäisyys ja kulma yllä olevien logiikkojen avulla ja näyttää se LCD-näytöllä. Sen lisäksi sen pitäisi tarjota mahdollisuus hallita bottia ohjaussauvalla.

Aloitamme ohjelman määrittelemällä digitaaliset I / O-nastat kahdelle moottorille. Huomaa, että meidän on myös ohjattava moottorin nopeutta, ja siksi meidän on käytettävä Arduinon PWM-nastoja moottoreiden ohjaamiseen. Tässä olemme käyttäneet nastoja 8,9, 10 ja 11.

#define LM_pos 9 // vasen moottori #define LM_neg 8 // vasen moottori #define RM_pos 10 // oikea moottori #define RM_neg 11 // oikea moottori #define joyX A2 #define joyY A3

Nopeuden ja kuljetun matkan mittaamiseksi meidän on tiedettävä pyörän säde, mitattava arvo ja syötettävä se metreinä alla olevan kuvan mukaisesti. Minun botin säde oli 0,033 metriä, mutta se voi vaihdella sinulle botisi perusteella.

kelluva säde = 0,033; // Mittaa pyörän säde ja kirjoita se senttimetreinä

Sisällä setup toiminto, me alustaa kaikki arvon olevan nolla ja sitten näyttää Esittelyteksti LCD. Olemme myös alustaneet sarjamuotoisen näytön virheenkorjausta varten. Sitten olemme maininneet, että nopeusanturit H206 on kytketty nastoihin 2 ja 3 ulkoisina keskeytyksinä. Siellä aina keskeytys havaitaan, ISR-funktio Left_ISR ja Right_ISR suoritetaan vastaavasti.

void setup () { kierto = rpm = pevtime = 0; // Alusta kaikki muuttujat nollaksi Serial.begin (9600); lcd.begin (16, 2); // Alusta 16 * 2 LCD- lcd.print ("Bot Monitor"); // Johdeviestirivi 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), Vasen_ISR, CHANGE); // Left_ISR kutsutaan, kun vasen pyörä anturi laukeaa attachInterrupt (digitalPinToInterrupt (3), Right_ISR, MUUTA); // Right_ISR kutsutaan, kun oikea pyörä anturi laukeaa }

Left_ISR-rutiinin sisällä lisäämme yksinkertaisesti muuttujaa nimeltä left_intr, jota käytetään myöhemmin botin kulman mittaamiseen. Right_ISR: n sisällä teemme saman asian, mutta laskemme sitten myös nopeuden täältä. Muuttuvaa kiertoa lisätään jokaisen keskeytyksen kohdalla ja sitten yllä olevaa logiikkaa käytetään nopeuden laskemiseen.

void Vasen_ISR () { left_intr ++; viive (10); } void Right_ISR () { right_intr ++; viive (10); kierto ++; dtime = millis (); if (kierto> = 40) { aikataulu = millis () - pevtime; // ajettu millisekunnissa rpm = (1000 / ajettu) * 60; // kaavat rpm laskemiseksi pevtime = millis (); kierto = 0; } }

Infiniittisen silmukan päätoiminnon sisällä seuraamme X: n ja Y: n arvoja ohjaussauvasta. Ohjaussauvaa liikutettaessa olevan arvon perusteella ohjaamme bottia sen mukaan. Botin nopeus riippuu siitä, kuinka pitkälle ohjainta painetaan.

int xArvo = analoginenLue (joyX); int yArvo = analoginenLue (iloY); int-kiihtyvyys = kartta (xValue, 500, 0, 0, 200); if (xValue <500) { analogWrite (LM_pos, kiihtyvyys); analogWrite (RM_pos, kiihtyvyys); } else { analogWrite (LM_pos, 0); analogWrite (RM_pos, 0); } if (yValue> 550) analogWrite (RM_pos, 80); if (yValue <500) analogWrite (LM_pos, 100);

Tämä auttaa käyttäjää siirtämään botin ja tarkistamaan, ovatko saadut arvot odotusten mukaisia. Lopuksi voimme laskea botin nopeuden, etäisyyden ja kulman yllä olevan logiikan avulla ja näyttää sen nestekidenäytössä alla olevan koodin avulla.

v = pyörän säde * rpm * 0,104; //0.033 on pyörän säde metrin etäisyydellä = (2 * 3,141 * pyörän säde) * (vasen_intr / 40); int kulma vasemmalle = (vasen_intr% 360) * (90/80); int kulma_oikea = (oikea_intr% 360) * (90/80); kulma = kulma_oikea - kulma_vasen; lcd.setCursor (3, 0); lcd.print (""); lcd.setCursor (3, 0); lcd.print (vasen_intr); lcd.setCursor (11, 0); lcd.print (""); lcd.setCursor (11, 0); lcd.print (oikea_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 (etäisyys); lcd.setCursor (13, 1); lcd.print (""); lcd.setCursor (13, 1); lcd.print (kulma);

Arduino-robotin testaaminen etäisyyden, nopeuden ja kulman mittaamiseksi

Kun laitteistosi on valmis, lähetä koodi Arduinoon ja siirrä bottia ohjaussauvalla. botin nopeus, sen kulkema etäisyys ja kulma näytetään nestekidenäytössä alla olevan kuvan mukaisesti.

Nestekidenäytössä termi Lt ja Rt edustavat vasemmanpuoleista keskeytyslaskua ja oikeaa keskeytyslaskentaa. Näet näiden arvojen kasvavan jokaisen anturin havaitseman aukon kohdalla. Tem S ilmaisee botin nopeuden yksikköinä m / s ja termi D ilmaisee etäisyyden metreinä. Pisteen kulma näytetään lopussa, jossa 0 ° on suora, ja se menee negatiiviseksi vastapäivään ja positiiviseksi myötäpäivään.

Voit myös katsoa tämän sivun lopussa olevan videon ymmärtääksesi botin toiminnan. Toivottavasti ymmärrät projektin ja nautit sen rakentamisesta. Jos sinulla on kysyttävää, jätä ne kommenttiosioon ja yritän parhaiten vastata takaisin. Voit myös käyttää foorumeita nopeaan tekniseen apuun.