DIY önkiegyensúlyozó robot arduino használatával

Miután a RYNO motorjai és a Segway egyéb önkiegyensúlyozó robogói inspiráltak, mindig szerettem volna valami saját Arduino Segway robotot építeni. Gondolkodva egy ideig, úgy döntöttem, hogy építek egy önkiegyensúlyozó robotot az Arduino segítségével. Így képes lennék megérteni a robogók mögött álló koncepciót, és megtudnám a PID algoritmus működését is.

Miután elkezdtem építeni, rájöttem, hogy ezt a botot egy kis kihívás felépíteni. Olyan sok lehetőség közül lehet választani, és ezért a zavarok a motorok kiválasztásakor kezdődnek, és a PID értékek beállításáig maradnak. És nagyon sok szempontot figyelembe kell venni, mint például az akkumulátor típusa, az akkumulátor helyzete, a kerék fogása, a motorvezérlő típusa, az CoG (súlypont) fenntartása és még sok más.

De hadd mondjam el neked, ha elkészíted, elfogadod, hogy nem olyan nehéz, mint amilyennek hangzik. Tehát valljuk be, ebben a bemutatóban dokumentálom az önkiegyensúlyozó robot felépítésével kapcsolatos tapasztalataimat. Lehet, hogy abszolút kezdő vagy, aki még csak most kezdi, vagy esetleg hosszú csalódás után landolt idefelé, hogy a botod nem működik. Ennek a helynek az a célja, hogy végső úti célja legyen. Tehát kezdjük……

Az önkiegyensúlyozó robot alkatrészeinek kiválasztása

Mielőtt elmondanám a bot felépítésének összes lehetőségét, hadd soroljam fel azokat az elemeket, amelyeket ebben az önkiegyensúlyozó robotprojektben használtam

Arduino UNO
Fogaskerekes egyenáramú motorok (sárga) - 2
L298N motorvezérlő modul
MPU6050
Egy pár kerék
7,4 V-os Li-ion akkumulátor
Csatlakozó vezetékek
3D nyomtatott törzs

Keverheti és választhatja a fenti összetevőket a rendelkezésre állás alapján, hogy elkészíthesse saját önkiegyensúlyozó robotkészletét, csak ellenőrizze, hogy az alkatrészek megfelelnek-e a következő feltételeknek.

Vezérlő: Az itt használt vezérlő az Arduino UNO, miért, mert egyszerűen egyszerűen használható. Használhat Arduino Nano vagy Arduino mini készüléket is, de azt javaslom, hogy ragaszkodjon az UNO-hoz, mivel közvetlenül külső hardver nélkül programozhatjuk.

Motorok: A legjobb motorválasztás, amelyet önkiegyensúlyozó robotokhoz használhat, kétségtelenül a Stepper motor lesz. De hogy a dolgok egyszerűek legyenek, DC-motorot használtam. Igen, nem kötelező lépcső lenni; a bot jól működik ezekkel az olcsón elérhető, sárga színű egyenáramú motorokkal is.

Motorvezérlő: Ha olyan DC motorokat választott, mint az enyém, akkor használhatja az L298N meghajtó modult, mint én, vagy akár egy L293D készüléknek is jól kell működnie. Tudjon meg többet az egyenáramú motor vezérléséről az L293D és az Arduino segítségével.

Kerekek: Ne becsüld alá ezeket a srácokat; Nehezen tapasztaltam, hogy a kerekeimmel van a probléma. Tehát győződjön meg arról, hogy kerekei jól tapadnak-e a használt padlón. Figyelje jól, a tapadása soha nem engedheti, hogy kerekei a padlón csúszjanak.

Gyorsulásmérő és giroszkóp: A leghatékonyabb gyorsulásmérő és giroszkóp az Ön robotjának az MPU6050 lesz. Tehát ne próbáljon meg olyan normál gyorsulásmérővel építeni, mint az ADXL345, vagy valami hasonló, csak nem fog működni. A cikk végén tudni fogja, miért. Az MPU6050 és az Arduino együttes használatáról szóló külön cikkünket is megtekintheti.

Akkumulátor: A lehető legkönnyebb akkumulátorra van szükségünk, és az üzemi feszültségnek 5 V-nál nagyobbnak kell lennie, hogy az Arduino-t közvetlenül egy boost modul nélkül tudjuk táplálni. Tehát az ideális választás egy 7,4 V-os Li-polimer akkumulátor lesz. Itt volt, mivel volt egy 7,4 V-os Li-ion akkumulátorom, így könnyen használható. De ne feledje, hogy a Li-po előnyösebb, mint a Li-ion.

Alváz: Egy másik hely, ahol nem szabad kompromisszumokat kötni, a botok alváza. Használhat kartont, fát, műanyagot, bármit, amivel jó vagy. De csak győződjön meg arról, hogy a futómű stabil, és nem szabad megingania, amikor a bot megpróbálja egyensúlyba hozni. Saját alvázon terveztem a Solidworks-en, a többi botból következtetve és 3D-re nyomtattam. Ha van nyomtatója, akkor a tervet is kinyomtathatja, a tervfájlok a következő fejlécben lesznek csatolva.

3D önkiegyensúlyozó robotunk nyomtatása és összeszerelése

Ha úgy döntött, hogy ugyanazt a házat nyomtatja 3D-vel, mint amivel a botot építem, akkor az STL fájlok letölthetők a thingiverse-ről. Hozzáadtam a tervfájlokat is, így személyzeti preferenciáinak megfelelően módosíthatja is.

Az alkatrészeknek nincsenek túlnyúló szerkezetei, így könnyen kinyomtathatja őket támaszok nélkül, és a 25% -os kitöltés jól fog működni. A kivitel meglehetősen egyszerű, és minden alapvető nyomtatónak képesnek kell lennie arra, hogy könnyedén kezelje. A Cura szoftvert használtam a modell szeleteléséhez, és a Tevo Tarantula segítségével nyomtattam, a beállítás az alábbiakban látható.

Ki kellene nyomtatnia a testrészt, valamint a motor négy rögzítő részét. Az összeállítás elég egyenesen halad; 3 mm-es anyákkal és csavarokkal rögzítse a motort és a táblákat a helyén. Összeszerelés után valami ilyennek kell kinéznie, amely az alábbi képen látható.

A tényleges kialakítást úgy tervezték, hogy az L298N meghajtó modul az alsó állványon található Arduino-val és a tetején lévő akkumulátorral, a fentiek szerint. Ha ugyanazt a sorrendet követi, akkor közvetlenül csavarja be a táblát a mellékelt furatokon keresztül, és használjon drótcímkét a Li-po akkumulátorhoz. Ennek az elrendezésnek működnie kell, kivéve a szuper sima kerekeket, amelyeket később cserélnem kellett.

A botomban kicseréltem az akkumulátor és az Arduino UNO kártya helyzetét a programozás megkönnyítése érdekében, és egy tökéletes táblát is be kellett vezetnem a kapcsolatok befejezéséhez. Tehát a botom nem úgy nézett ki, ahogy a kezdeti szakaszban terveztem. Miután befejezte a vezetékek programozásának tesztelését és mindent, a kétkerekű robotom végül így néz ki

Kördiagramm

Ennek az Arduino alapú önkiegyensúlyozó robotnak a csatlakoztatása meglehetősen egyszerű. Ez egy önkiegyensúlyozó robot, amely Arduino-t és MPU6050-t használ, így össze kell kapcsolnunk az MPU6050-et az Arduino-val, és a motorokat a Motor meghajtó modulon keresztül csatlakoztatjuk. Az egész berendezést a 7,4 V-os li-ion akkumulátor táplálja. Az alábbiakban a kapcsolási rajz látható.

Az Arduino és az L298N Motor meghajtó modult közvetlenül a Vin tű és a 12 V terminál táplálja. Az Arduino táblán található fedélzeti szabályozó átalakítja a 7,4 V bemenetet 5 V-ra, és az ATmega IC-t és az MPU6050-et ez táplálja. Az egyenáramú motorok 5 V-12 V feszültségről működhetnek. De csatlakoztatjuk az akkumulátor 7,4 V pozitív vezetékét a motorvezérlő modul 12 V-os bemenetéhez. Ezáltal a motorok 7,4 V feszültséggel működnek. Az alábbi táblázat felsorolja, hogy az MPU6050 és az L298N motorillesztő modul hogyan kapcsolódik az Arduino-hoz.

Alkatrészcsap	Arduino Pin
MPU6050
Vcc	+ 5V
Talaj	Gnd
SCL	A5
SDA	A4
INT	D2
L298N
IN1	D6
IN2	D9
IN3	D10
IN4	D11

Az MPU6050 az I2C interfészen keresztül kommunikál az Arduinóval, ezért az Arduino A4 és A5 SPI csatlakozóit használjuk. Az egyenáramú motorok a D6, D9 D10 és D11 PWM csapokhoz vannak csatlakoztatva. Csatlakoztatnunk kell őket a PWM csapokhoz, mert a DC motor fordulatszámát a PWM jelek munkaciklusának változtatásával fogjuk szabályozni. Ha még nem ismeri ezt a két alkatrészt, akkor javasoljuk, hogy olvassa el az MPU6050 Interfacing és az L298N Motor illesztőprogram oktatóanyagát.

Önkiegyensúlyozó robot kód

Most be kell programoznunk az Arduino UNO táblánkat, hogy egyensúlyba hozzuk a robotot. Itt történik minden varázslat; a mögötte álló koncepció egyszerű. Meg kell vizsgálnunk, hogy a bot elöl vagy hátul hajlik-e az MPU6050 segítségével, majd ha elöl hajlik, akkor elõre kell forgatnunk a kerekeket, és ha hátra hajlik, akkor el kell forgatnunk a kerekeket fordított irányban.

Ugyanakkor szabályoznunk kell a kerekek forgási sebességét is, ha a bot kissé eltérül a középső helyzetből, a kerekek lassan forognak, és a sebesség növekszik, ha egyre távolabb kerül a középponttól. Ennek a logikának az eléréséhez a PID algoritmust használjuk, amelynek középpontja alapjel, kimeneteként a dezorientáció szintje.

A bot jelenlegi helyzetének megismeréséhez az MPU6050-et használjuk, amely egy 6 tengelyes gyorsulásmérő és giroszkóp érzékelő együtt. Annak érdekében, hogy megbízható helyzetértéket kapjunk az érzékelőtől, mind a gyorsulásmérő, mind a giroszkóp értékét fel kell használnunk, mivel a gyorsulásmérő értékei zajproblémákkal rendelkeznek, és a giroszkóp értékei idővel hajlamosak sodródni. Tehát kombinálnunk kell mindkettőt, és meg kell szereznünk robotunk ívmagasságának és gördülésének értékét, amelyből csak az ásítás értékét fogjuk használni.

Kicsit fejgörgőnek tűnik? De ne aggódjon, az Arduino közösségnek köszönhetően könnyen elérhető könyvtárak állnak rendelkezésünkre, amelyek képesek elvégezni a PID számítását, és az MPU6050-től megkapják az ásítás értékét is. A könyvtárat a br3ttb és a jrowberg fejlesztette ki. Mielőtt folytatná, töltse le a könyvtárakat a következő linkről, és adja hozzá őket az Arduino lib könyvtárához.

github.com/br3ttb/Arduino-PID-Library/blob/master/PID_v1.h

github.com/jrowberg/i2cdevlib/tree/master/Arduino/MPU6050

Most, hogy hozzáadtuk a könyvtárakat az Arduino IDE-hez. Kezdjük el programozni az önkiegyensúlyozó robotunkat. Mint mindig, az MPU6050 kiegyensúlyozó robot teljes kódja ennek az oldalnak a végén található, itt csak a legfontosabb részleteket fejtem ki a kódban. Korábban elmondtuk, hogy a kód az MPU6050 példakód tetejére épül, a célunknak megfelelően optimalizálni fogjuk a kódot, és hozzáadjuk az önkiegyensúlyozó robotunk PID-jét és vezérlési technikáját.

Először felsoroljuk azokat a könyvtárakat, amelyek szükségesek a program működéséhez. Ide tartoznak a beépített I2C könyvtár, a PID könyvtár és az MPU6050 könyvtár, amelyet éppen letöltöttünk.

#include "I2Cdev.h" #include // A https://github.com/br3ttb/Arduino-PID-Library/blob/master/PID_v1.h oldalról #include "MPU6050_6Axis_MotionApps20.h" //https://github.com/jrowberg/i2cdevlib/tree/master/Arduino/MPU6050

Ezután deklaráljuk azokat a változókat, amelyek szükségesek az adatok MPU6050 érzékelőtől történő megszerzéséhez. Olvassuk mind a gravitációs vektor, mind a kvaternion értékeket, majd kiszámoljuk a bot kanyarodási és dőlési értékét. Az ypr lebegő tömb fogja tartani a végeredményt.

// MPU vezérlő / status vars bool dmpReady = false; // true, ha a DMP init sikeres volt uint8_t mpuIntStatus; // tényleges megszakítási állapot bájtot tartalmaz az MPU-ból uint8_t devStatus; // visszatérési állapot minden eszközművelet után (0 = siker ,! 0 = hiba) uint16_t packetSize; // várható DMP csomagméret (alapértelmezés szerint 42 bájt) uint16_t fifoCount; // az összes bájt száma jelenleg a FIFO-ban uint8_t fifoBuffer; // FIFO tároló puffer // orientáció / mozgás változó Quaternion q; // kvaternion konténer VectorFloat gravity; // gravitációs vektor úszó ypr; // ásítás / szurok / tekercs tartály és gravitációs vektor

Ezután következik a kód nagyon fontos szegmense, és itt fog sokáig tölteni a megfelelő értékkészletet. Ha a robotja nagyon jó súlyponttal van felépítve, és az alkatrészek szimmetrikusan vannak elrendezve (ami a legtöbb esetben nem így van), akkor az alapérték értéke 180 lesz. Egyébként csatlakoztassa botját az Arduino soros monitorhoz, és döntse addig, amíg jó egyensúlyozási pozíciót talál, olvassa el a soros monitoron megjelenített értéket, és ez az Ön beállított értéke. A Kp, Kd és Ki értékét a botodnak megfelelően kell beállítani. Nincs két azonos robotnak ugyanaz az értéke, mint Kp, Kd és Ki, így nem lehet elmenekülni belőle. Nézze meg az oldal végén található videót, hogy képet kapjon ezekről az értékekről.

/ ********* Hangolja be ezt a 4 értéket a BOT-ra ********* / dupla alapérték = 176; // soros monitor segítségével állítsa be az értéket, amikor a bot merőleges a talajra . // Olvassa el a projektdokumentációt az circuitdigest.com oldalon, hogy megtudja, hogyan állíthatja be ezeket az értékeket duplán Kp = 21; // Állítsa be ezt az első dupla Kd = 0,8; // Állítsa be ezt a másodlagos dupla Ki = 140 értéket; // Végül állítsa be ezt / ****** Az értékek végének vége ********* /

A következő sorban inicializáljuk a PID algoritmust az input, output, set point, Kp, Ki és Kd bemeneti változók átadásával. Ezek közül a fenti kódrészletben már beállítottuk a Kp, Ki és Kd alapértékeket. A bemenet értéke az MPU6050 érzékelőből leolvasott áramlás aktuális értéke, a kimenet pedig a PID algoritmus által kiszámított érték lesz. Tehát alapvetően a PID algoritmus ad nekünk egy kimeneti értéket, amelyet fel kell használni az Input érték korrigálására, hogy az a beállított ponthoz közel legyen.

PID pid (& input, & output, & alapjel, Kp, Ki, Kd, DIRECT);

A void beállítási funkción belül inicializáljuk az MPU6050-et a DMP (digitális mozgásprocesszor) konfigurálásával. Ez segít nekünk az Accelerometer és a Gyroscope adatok kombinálásában, és megbízható értéket nyújt a Yaw, Pitch and Roll értékekből. Nem fogunk nagyon elmélyülni ebben, mivel messze túlmutat a témán. Mindenesetre a kód egyik szegmense, amelyet meg kell keresnie a beállítási funkcióban, a giroszkóp eltolás értékei. Minden MPU6050 érzékelőnek megvan a saját eltolásértéke. Ezzel az Arduino vázlattal kiszámíthatja az érzékelő eltolásának értékét, és ennek megfelelően frissítheti a következő sorokat a programjában.

// itt adhatja meg saját gyro eltolását , min érzékenységre méretezve mpu.setXGyroOffset (220); mpu.setYGyroOffset (76); mpu.setZGyroOffset (-85); mpu.setZAccelOffset (1688);

Azt is meg kell inicializálja a digitális PWM csapok, hogy mi használ csatlakozni a motorok. Esetünkben D6, D9, D10 és D11. Tehát inicializáljuk ezeket a csapokat, mivel a kimeneti csapok alapértelmezés szerint LOW-k lesznek.

// Kalibrálja a Motor outpu csapok pinMode (6, kimenetet); pinMode (9, OUTPUT); pinMode (10, OUTPUT); pinMode (11, OUTPUT); // Alapértelmezés szerint kapcsolja ki mindkét motort analogWrite (6, LOW); analogWrite (9, LOW); analogWrite (10, LOW); analogWrite (11, LOW);

A fő hurok funkción belül ellenőrizzük, hogy az MPU6050 adatai készen állnak-e az olvasásra. Ha igen, akkor a PID érték kiszámításához használjuk, majd a soros monitoron a PID bemeneti és kimeneti értékét jelenítjük meg, hogy ellenőrizzük a PID válaszát. Ezután a kimenet értéke alapján döntjük el, hogy a botnak előre vagy hátra kell-e haladnia, vagy mozdulatlanul kell állnia.

Mivel feltételezzük, hogy az MPU6050 180-at ad vissza, ha a bot függőleges helyzetben van. Pozitív korrekciós értékeket kapunk, amikor a bot eleje felé esik, és negatív értékeket kapunk, ha a bot visszafelé esik. Tehát ellenőrizzük ezt az állapotot, és meghívjuk a megfelelő funkciókat a bot előre vagy hátra mozgatásához.

while (! mpuInterrupt && fifoCount <packetSize) { // nincs mpu adat - PID számítások végrehajtása és kimenet a motorokhoz pid.Compute (); // Nyomja meg az Input and Output értékét soros monitoron, hogy ellenőrizze a működését. Soros.nyomtatás (bemenet); Soros.nyomtatás ("=>"); Soros.println (kimenet); if (bemenet> 150 && bemenet <200) {// Ha a bot esik, ha (kimenet> 0) // Előre esik (); // Egyébként forgassa a kerekeket előre , ha (kimenet <0) // Hátsó irányba esés Hátramenet (); // Forgassa hátra a kerekeket } else // Ha Bot nem esik le (); // tartsa mozdulatlanul a kerekeket }

A PID kimeneti változó eldönti, hogy milyen gyorsan kell forgatni a motort. Ha a bot éppen zuhanni készül, akkor a kerék lassú forgatásával kisebb korrekciókat hajtunk végre. Ha ezek a kisebb korrekciók működnek, és akkor is, ha a bot leesik, növeljük a motor sebességét. A kerekek gyors forgásának értékét a PI algoritmus fogja eldönteni. Ne feledje, hogy a Reverse függvényhez a kimenet értékét megszoroztuk -1-gyel, hogy a negatív értéket pozitívvá alakíthassuk.

void Forward () // Kód a kerék előre forgatásához { analogWrite (6, output); analogWrite (9,0); analogWrite (10, kimenet); analogWrite (11,0); Soros nyomtatás ("F"); // Hibakeresési információk } void Reverse () // Kód a kerék hátrafelé forgatásához { analogWrite (6,0); analogWrite (9, kimenet * -1); analogWrite (10,0); analogWrite (11, kimenet * -1); Soros nyomtatás ("R"); } void Stop () // Kód mindkét kerék leállításához { analogWrite (6,0); analogWrite (9,0); analogWrite (10,0); analogWrite (11,0); Soros nyomtatás ("S"); }

Arduino önkiegyensúlyozó robot működése

Miután elkészült a hardverrel, feltöltheti a kódot az Arduino táblára. Győződjön meg arról, hogy a csatlakozások megfelelőek, mivel lítium-ion akkumulátort használunk, fokozott óvatosság szükséges. Tehát ellenőrizze kétszer a rövidzárlatot, és győződjön meg arról, hogy a terminálok nem kerülnek kapcsolatba, még akkor sem, ha botja kis hatásokat tapasztal. Kapcsolja be a modult, és nyissa meg a soros monitort, ha az Arduino sikeresen képes kommunikálni az MPU6050-vel, és ha minden a várakozásoknak megfelelően működik, akkor a következő képernyőt kell látnia.

Itt látjuk a PID algoritmus bemeneti és kimeneti értékeit az input => output formátumban . Ha a bot tökéletesen egyensúlyban van, akkor a kimenet értéke 0 lesz. A bemeneti érték az MPU6050 érzékelő aktuális értéke. Az „F” ábécé azt jelzi, hogy a bot előre halad, az „R” pedig azt, hogy a bot hátramenetben halad.

A PID kezdeti szakaszában azt javaslom, hogy hagyja az Arduino kábelt csatlakoztatva a bothoz, hogy könnyedén figyelemmel kísérhesse a bemenet és a kimenet értékeit, valamint könnyű javítani és feltölteni a programot a Kp, Ki és Kd értékekre. Az alábbi videó bemutatja a bot teljes működését, és megmutatja, hogyan lehet kijavítani a PID értékeket.

Remélem, hogy ez segít a saját önkiegyensúlyozó robotjának felépítésében, ha bármilyen problémája van a működésével, akkor hagyja meg kérdéseit az alábbi megjegyzés részben, vagy használja a fórumot további technikai kérdésekhez. Ha szórakozásra vágysz, ugyanazt a logikát használhatod a labdaegyensúlyozó robot felépítéséhez is.