- Välja delar för självbalanserande robot
- 3D-utskrift och montering av vår självbalanserande robot
- Kretsschema
- Självbalanserande robotkod
- Arbeta med Arduino Self Balancing Robot
Efter att ha inspirerats av RYNO-motorer och andra självbalanserande skotrar från Segway, ville jag alltid bygga något åt min egen Arduino Segway Robot. Tänker en stund bestämde jag mig för att bygga en självbalanserande robot med Arduino. På detta sätt skulle jag kunna förstå det underliggande konceptet bakom alla dessa skotrar och också lära mig hur PID-algoritmen fungerar.
När jag började bygga insåg jag att den här botten är lite av en utmaning att bygga. Det finns så många alternativ att välja mellan och följaktligen börjar förvirringarna i rätt form genom att välja motorer och stannar tills PID-värden ställs in. Och det finns så många saker att tänka på som typ av batteri, batteriets position, hjulgrepp, typ av motorförare, underhåll av CoG (tyngdpunkten) och mycket mer.
Men låt mig bryta det till dig, när du väl har byggt det kommer du att hålla med om att det inte är så svårt som det låter att vara. Så låt oss inse det, i denna handledning kommer jag att dokumentera min erfarenhet av att bygga den självbalanserande roboten. Du kanske är en nybörjare som precis har börjat eller kanske har hamnat här efter en lång frustration över att inte få din bot att fungera. Denna plats syftar till att vara din slutdestination. Så låt oss komma igång……
Välja delar för självbalanserande robot
Innan jag berättar om alla alternativ för att bygga botten, låt mig lista de objekt som jag har använt i detta självbalanserande robotprojekt
- Arduino UNO
- Växlade likströmsmotorer (gul färg) - 2Nr
- L298N Motor Driver Module
- MPU6050
- Ett par hjul
- 7.4V Li-ion-batteri
- Anslutande ledningar
- 3D-tryckt kropp
Du kan mixa och välja någon av ovanstående komponenter baserat på tillgängligheten för att skapa ditt eget självbalanserande robotpaket, se bara till att komponenterna uppfyller följande kriterier.
Controller: Styrenheten som jag har använt här är Arduino UNO, varför det är helt enkelt lätt att använda. Du kan också använda en Arduino Nano eller Arduino mini men jag skulle rekommendera dig att hålla fast vid UNO eftersom vi kan programmera den direkt utan någon extern hårdvara.
Motorer: Det bästa valet av motor som du kan använda för en självbalanserande robot, utan tvekan är Stepper motor. Men för att göra det enkelt har jag använt en likströmsmotor. Ja, det är inte obligatoriskt att ha en stepper. bot fungerar också bra med dessa billiga allmänt tillgängliga gulfärgade växelmotorer.
Motor Driver: Om du har valt DC-växelmotorer som mina kan du antingen använda L298N-drivarmodulen som jag, eller till och med en L293D skulle fungera bra. Lär dig mer om att styra likströmsmotor med L293D och Arduino.
Hjul: Underskatt inte dessa killar; Jag hade svårt att räkna ut att problemet var med mina hjul. Så se till att dina hjul har bra grepp över golvet du använder. Titta noga, ditt grepp ska aldrig låta dina hjul glida på golvet.
Accelerometer och gyroskop: Det bästa valet av accelerometer och gyroskop för din bot är MPU6050. Så försök inte bygga en med en vanlig accelerometer som ADXL345 eller något liknande, det fungerar bara inte. Du kommer att veta varför i slutet av den här artikeln. Du kan också kolla vår dedikerade artikel om att använda MPU6050 med Arduino.
Batteri: Vi behöver ett så lätt batteri som möjligt och driftspänningen bör vara mer än 5V så att vi kan driva vår Arduino direkt utan en boostmodul. Så det perfekta valet är ett 7,4 V Li-polymerbatteri. Här, eftersom jag hade ett 7.4V Li-ion-batteri som är tillgängligt har jag använt det. Men kom ihåg att en Li-po är fördelaktig än Li-ion.
Chassi: En annan plats där du inte ska kompromissa är med ditt botschassi. Du kan använda kartong, trä, plast allt du är bra med. Men se bara till att chassit är robust och inte ska vicka när botten försöker balansera. Jag har designat av ett eget chassi på Solidworks och har härledt från andra bots och 3D-skrivit ut det. Om du har en skrivare kan du också skriva ut designen, designfilerna bifogas i den kommande rubriken.
3D-utskrift och montering av vår självbalanserande robot
Om du har bestämt dig för att 3D skriva ut samma chassi som jag använder för att bygga min bot kan STL-filerna laddas ner från thingiverse. Jag har också lagt till designfilerna tillsammans med den så att du också kan ändra den enligt dina personliga preferenser.
Delarna har inga överhängande strukturer så att du enkelt kan skriva ut dem utan stöd och en fyllning på 25% fungerar bra. Mönstren är ganska vanliga och alla grundläggande skrivare borde kunna hantera den med lätthet. Jag använde Cura-programvaran för att skära modellen och tryckte med min Tevo Tarantula, inställningen visas nedan.
Du måste skriva ut karossdelen samt fyra motormonteringsdelar. Monteringen är ganska rakt framåt; använd 3 mm muttrar och bultar för att fästa motorn och brädorna på plats. Efter montering ska det se ut ungefär så som visas på bilden nedan.
Den faktiska designen planerades med drivenhetsmodulen L298N i det nedre racket Arduino och batteriet ovanpå det som visas ovan. Om du följer samma order kan du skruva in kortet direkt genom de medföljande hålen och använda en trådmärke för Li-po-batteriet. Detta arrangemang borde också fungera, förutom de superplatta hjul som jag var tvungen att byta senare.
I min bot har jag bytt batteriläge och Arduino UNO-kort för enkel programmering och var också tvungen att införa ett perfekt kort för att slutföra anslutningarna. Så min bot såg inte ut som jag planerade i det inledande skedet. Efter att ha slutfört testning av ledningar och allt ser min tvåhjulrobot äntligen så ut
Kretsschema
Det är ganska enkelt att skapa anslutningar för den här Arduino-baserade självbalanseringsroboten. Detta är en självbalanserande robot med Arduino och MPU6050, så vi ska ansluta MPU6050 med Arduino och ansluta motorerna genom motordrivrutinmodulen. Hela installationen drivs av 7,4 V litiumjonbatteri. Kretsschemat för detsamma visas nedan.
Arduino- och L298N-motordrivmodulen drivs direkt via Vin-stift respektive 12V-terminalen. Den inbyggda regulatorn på Arduino-kortet omvandlar ingången 7.4V till 5V och ATmega IC och MPU6050 kommer att drivas av den. DC-motorerna kan gå från spänning 5V till 12V. Men vi kommer att ansluta den 7.4V positiva kabeln från batteriet till 12V ingångsterminalen på motorförare-modulen. Detta kommer att få motorerna att arbeta med 7,4 V. Följande tabell visar hur MPU6050- och L298N-motordrivmodulen är ansluten till Arduino.
|
Komponentstift |
Arduino Pin |
|
MPU6050 |
|
|
Vcc |
+ 5V |
|
Jord |
Gnd |
|
SCL |
A5 |
|
SDA |
A4 |
|
INT |
D2 |
|
L298N |
|
|
I 1 |
D6 |
|
IN2 |
D9 |
|
IN3 |
D10 |
|
IN4 |
D11 |
MPU6050 kommunicerar med Arduino via I2C-gränssnittet, så vi använder SPI-stiften A4 och A5 på Arduino. DC-motorerna är anslutna till PWM-stiften D6, D9 D10 respektive D11. Vi måste ansluta dem till PWM-stift eftersom vi kommer att styra DC-motorns hastighet genom att variera PWM-signalernas arbetscykel. Om du inte känner till dessa två komponenter rekommenderas det att du läser igenom MPU6050 Interfacing och L298N Motor driver tutorial.
Självbalanserande robotkod
Nu måste vi programmera vårt Arduino UNO-kort för att balansera roboten. Det är här all magi händer; konceptet bakom det är enkelt. Vi måste kontrollera om botten lutar framåt eller bakåt med MPU6050 och om den lutar framåt måste vi rotera hjulen framåt och om den lutar bakåt måste vi rotera hjulen i omvänd riktning.
Samtidigt måste vi också styra hastigheten på vilken hjulen roterar, om botten är lite desorienterad från mittläget roterar hjulen långsamt och hastigheten ökar när den kommer mer bort från mittläget. För att uppnå denna logik använder vi PID-algoritmen, som har mittpositionen som börvärde och desorienteringsnivån som utgång.
För att veta botens nuvarande position använder vi MPU6050, som är en 6-axlig accelerometer och gyroskopsensor kombinerad. För att få ett tillförlitligt positionsvärde från sensorn måste vi använda värdet på både accelerometer och gyroskop, eftersom värdena från accelerometern har brusproblem och värdena från gyroskop tenderar att glida med tiden. Så vi måste kombinera båda och få värdet av vridning av vår robot, av vilken vi bara använder värdet av gir.
Låter lite av huvudet snurra, eller hur? Men oroa dig inte, tack vare Arduino-communityn har vi lätt tillgängliga bibliotek som kan utföra PID-beräkningen och också få värdet av yaw från MPU6050. Biblioteket är utvecklat av br3ttb respektive jrowberg. Innan du fortsätter ladda ner deras bibliotek bildar du följande länk och lägger till dem i din Arduino lib-katalog.
github.com/br3ttb/Arduino-PID-Library/blob/master/PID_v1.h
github.com/jrowberg/i2cdevlib/tree/master/Arduino/MPU6050
Nu när vi har lagt till biblioteken i vår Arduino IDE. Låt oss börja programmera för vår självbalanserande robot. Som alltid ges den fullständiga koden för MPU6050 balanseringsrobot i slutet av denna sida, här förklarar jag bara de viktigaste utdragen i koden. En tidigare sagt att koden bygger på MPU6050-exempelkoden, vi kommer bara att optimera koden för vårt syfte och lägga till PID och styrteknik för vår självbalanserande robot.
Först inkluderar vi de bibliotek som krävs för att programmet ska fungera. De inkluderar det inbyggda I2C-biblioteket, PID-biblioteket och MPU6050-biblioteket som vi just laddade ner.
#include "I2Cdev.h" #include
Sedan deklarerar vi de variabler som krävs för att hämta data från MPU6050-sensorn. Vi läser både tyngdkraftsvektorn och kvaternionsvärdena och beräknar sedan botten och rullvärdet för botten. Den float array YPR kommer att hålla det slutliga resultatet.
// MPU-kontroll / status vars bool dmpReady = falsk; // set true om DMP init lyckades uint8_t mpuIntStatus; // innehar faktisk avbrottsstatusbyte från MPU uint8_t devStatus; // returnera status efter varje enhetsåtgärd (0 = framgång ,! 0 = fel) uint16_t packetSize; // förväntad DMP-paketstorlek (standard är 42 byte) uint16_t fifoCount; // antal alla byte som för närvarande finns i FIFO uint8_t fifoBuffer; // FIFO-lagringsbuffert // orientering / rörelse vars Quaternion q; // kvaternionsbehållare VectorFloat gravitation; // gravitation vector float ypr; // yaw / pitch / roll container och gravitation vector
Därefter kommer det mycket viktiga segmentet av koden, och det är här du kommer att spendera lång tid på att ställa in rätt värden. Om din robot är byggd med ett mycket bra tyngdpunkt och komponenterna är symmetriskt ordnade (vilket i de flesta fall inte är) kommer värdet på ditt börvärde att vara 180. Anslut annars din bot till Arduino seriell bildskärm och luta den till du hittar en bra balanseringsposition, läs värdet som visas på seriell bildskärm och detta är ditt börvärde. Värdet på Kp, Kd och Ki måste ställas in enligt din bot. Inga två identiska bots kommer att ha samma värden som Kp, Kd och Ki så det går inte att fly från det. Titta på videon i slutet av denna sida för att få en uppfattning om hur du justerar dessa värden.
/ ********* Ställ in dessa 4 värden för din BOT ********* / dubbel börvärde = 176; // ställ in värdet när botten är vinkelrätt mot marken med hjälp av seriell bildskärm. // Läs projektdokumentationen på circuitdigest.com för att lära dig hur du ställer in dessa värden dubbla Kp = 21; // Ställ in denna första dubbla Kd = 0,8; // Ställ in denna sekund dubbla Ki = 140; // Ställ äntligen detta / ****** Värdenes slut inställning ********* /
I nästa rad initierar vi PID-algoritmen genom att skicka ingångsvariablerna input, output, börvärde, Kp, Ki och Kd. Av dessa har vi redan ställt in värdena för börvärdet Kp, Ki och Kd i ovanstående kodavsnitt. Ingångsvärdet kommer att vara det aktuella värdet på gir som läses från MPU6050-sensorn och värdet på utgången är det värde som beräknas av PID-algoritmen. Så i grund och botten kommer PID-algoritmen att ge oss ett utgångsvärde som ska användas för att korrigera ingångsvärdet till att vara nära börvärdet.
PID pid (& input, & output, & setpoint, Kp, Ki, Kd, DIRECT);
Inne i tomrummet inställningsfunktion vi initiera MPU6050 genom att konfigurera DMP (Digital Motion Processor). Detta kommer att hjälpa oss att kombinera accelerometerdata med gyroskopdata och ge ett tillförlitligt värde på Yaw, Pitch and Roll. Vi kommer inte att gå mycket djupt in i detta eftersom det kommer att vara långt bortom ämnet. Hur som helst ett kodsegment som du måste slå upp i installationsfunktionen är gyroförskjutningsvärdena. Varje MPU6050-sensor har sina egna förskjutningsvärden. Du kan använda denna Arduino-skiss för att beräkna offsetvärdet för din sensor och uppdatera följande rader i enlighet med detta i ditt program.
// leverera dina egna gyroförskjutningar här, skalad för min känslighet mpu.setXGyroOffset (220); mpu.setYGyroOffset (76); mpu.setZGyroOffset (-85); mpu.setZAccelOffset (1688);
Vi måste också initialisera de digitala PWM-stiften som vi använder för att ansluta våra motorer till. I vårt fall är det D6, D9, D10 och D11. Så vi initialiserar dessa stift eftersom utgångsstift gör dem LÅGA som standard.
// Initiera Motor outpu stiften pinMode (6, OUTPUT); pinMode (9, OUTPUT); pinMode (10, OUTPUT); pinMode (11, OUTPUT); // Som standard stäng av båda motorerna analogWrite (6, LOW); analogWrite (9, LOW); analogWrite (10, LOW); analogWrite (11, LOW);
Inne i huvudslingan funktionen vi kontrollera om data från MPU6050 är redo att läsas . Om ja, använder vi det för att beräkna PID-värdet och sedan visa in- och utgångsvärdet för PID på seriell bildskärm bara för att kontrollera hur PID svarar. Sedan bestämmer vi oss om botten måste gå framåt eller bakåt eller stå stilla baserat på output-värdet.
Eftersom vi antar att MPU6050 kommer att returnera 180 när botten är upprätt. Vi kommer att få korrigeringsvärden positiva när botten faller framåt och vi kommer att få negativa värden om botten faller bakåt. Så vi letar efter detta tillstånd och kallar lämpliga funktioner för att flytta botten framåt eller bakåt.
medan (! mpuInterrupt && fifoCount <packetSize) { // ingen mpu-data - utför PID-beräkningar och utdata till motorerna pid.Compute (); // Skriv ut värdet på Input and Output på seriell bildskärm för att kontrollera hur den fungerar. Serial.print (input); Serial.print ("=>"); Serial.println (utdata); if (input> 150 && input <200) {// If the Bot is fall if (output> 0) // Falling towards front Forward (); // Rotera hjulen framåt om (output <0) // Faller bakåt Bakåt (); // Rotera hjulen bakåt } annat // Om bot inte faller Stopp (); // Håll hjulen stilla }
Den PID utgång variabel bestämmer också hur snabbt motorn måste roteras. Om botten precis ska falla gör vi en mindre korrigering genom att rotera hjulet långsamt. Om dessa mindre korrigeringar inte fungerar och ändå om botten faller ner ökar vi motorns hastighet. Värdet på hur snabbt hjulen roterar bestäms av PI-algoritmen. Observera att för funktionen Omvänd har vi multiplicerat värdet på utdata med -1 så att vi kan konvertera det negativa värdet till positivt.
void Forward () // Kod för att rotera hjulet framåt { analogWrite (6, output); analogWrite (9,0); analogWrite (10, utgång); analogWrite (11,0); Serial.print ("F"); // Felsökningsinformation } ogiltig Reverse () // Kod för att rotera hjulet bakåt { analogWrite (6,0); analogWrite (9, utgång * -1); analogWrite (10,0); analogWrite (11, utgång * -1); Serial.print ("R"); } ogiltig Stop () // Kod för att stoppa båda hjulen { analogWrite (6,0); analogWrite (9,0); analogWrite (10,0); analogWrite (11,0); Serial.print ("S"); }
Arbeta med Arduino Self Balancing Robot
När du är klar med hårdvaran kan du ladda upp koden till ditt Arduino-kort. Se till att anslutningarna är korrekta eftersom vi använder ett Li-ion-batteri. Det krävs ytterst försiktighet. Så dubbelkolla kortslutningar och se till att terminalerna inte kommer i kontakt även om din bot upplever några små stötar. Starta din modul och öppna din seriella bildskärm, om din Arduino kunde kommunicera med MPU6050 framgångsrikt och om allt fungerar som förväntat bör du se följande skärm.
Här ser vi in- och utgångsvärdena för PID-algoritmen i formatet input => output . Om botten är perfekt balans kommer utmatningsvärdet att vara 0. Ingångsvärdet är det aktuella värdet från MPU6050-sensorn. Alfabetet "F" representerar att botten rör sig framåt och "R" representerar att botten är i omvänd ordning.
Under de inledande faserna av PID rekommenderar jag att du lämnar din Arduino-kabel ansluten till botten så att du enkelt kan övervaka värdena för in- och utdata och det blir också lätt att korrigera och ladda upp ditt program för Kp-, Ki- och Kd-värden. Den videon nedan visar hela arbets av bot och även visar hur för att korrigera PID-värden.
Hoppas att detta hjälper till att bygga din egen självbalanserande robot om du har några problem att få den att fungera, lämna sedan dina frågor i kommentarsektionen nedan eller använd forumen för mer tekniska frågor. Om du vill ha mer kul kan du också använda samma logik för att bygga en balbalanseringsrobot.