- Valg af dele til selvbalancerende robot
- 3D-udskrivning og samling af vores selvbalancerende robot
- Kredsløbsdiagram
- Selvbalancerende robotkode
- Arbejde med Arduino Self Balancing Robot
Efter at have været inspireret af RYNO-motorer og andre selvbalancerende scootere fra Segway, ville jeg altid bygge noget min egen Arduino Segway-robot. Når jeg tænkte et stykke tid, besluttede jeg at bygge en selvbalancerende robot ved hjælp af Arduino. På denne måde ville jeg være i stand til at forstå det underliggende koncept bag alle disse scootere og også lære, hvordan PID-algoritmen fungerer.
Når jeg begyndte at bygge, indså jeg, at denne bot er lidt af en udfordring at bygge. Der er så mange muligheder at vælge imellem, og derfor begynder forvirringerne rigtigt fra valg af motorer og forbliver indtil indstilling af PID-værdier. Og der er så mange ting at overveje som type batteri, batteriets position, hjulgreb, type motordriver, vedligeholdelse af CoG (tyngdepunkt) og meget mere.
Men lad mig bryde det til dig, når du først har bygget det, er du enig i, at det ikke er så svært, som det lyder at være. Så lad os indse det, i denne vejledning vil jeg dokumentere min erfaring med at opbygge den selvbalancerende robot. Du er muligvis en absolut nybegynder, der lige er kommet i gang eller måske er landet her efter en lang frustration over ikke at få din bot til at arbejde. Dette sted sigter mod at være din endelige destination. Så lad os komme i gang……
Valg af dele til selvbalancerende robot
Før jeg fortæller dig alle mulighederne for at oprette boten, så lad mig angive de emner, som jeg har brugt i dette selvbalancerende robotprojekt
- Arduino UNO
- Gearede DC-motorer (gulfarvet) - 2Nr
- L298N Motordrivermodul
- MPU6050
- Et par hjul
- 7.4V Li-ion batteri
- Tilslutning af ledninger
- 3D-printet krop
Du kan blande og vælge en af ovenstående komponenter på baggrund af tilgængeligheden til at lave dit eget selvbalancerende robotsæt, bare sørg for at komponenterne opfylder følgende kriterier.
Controller: Den controller, jeg har brugt her, er Arduino UNO, hvorfor fordi den simpelthen er nem at bruge. Du kan også bruge en Arduino Nano eller Arduino mini, men jeg vil anbefale dig at holde fast ved UNO, da vi kan programmere det direkte uden ekstern hardware.
Motorer: Det bedste valg af motor, som du kan bruge til en selvbalancerende robot, er uden tvivl trinmotor. Men for at holde tingene enkle har jeg brugt en DC-gearmotor. Ja, det er ikke obligatorisk at have en stepper; bot fungerer også fint med disse billige almindeligt tilgængelige gulfarvede DC-gearmotorer.
Motordriver: Hvis du har valgt DC-gearmotorer som min, kan du enten bruge L298N-drivermodulet som mig, eller endda en L293D skal fungere fint. Lær mere om styring af jævnstrømsmotor ved hjælp af L293D og Arduino.
Hjul: Undervurder ikke disse fyre; Jeg havde svært ved at finde ud af, at problemet var med mine hjul. Så sørg for, at dine hjul har godt greb over gulvet, du bruger. Hold øje med, dit greb bør aldrig lade dine hjul glide på gulvet.
Accelerometer og gyroskop: Det bedste valg af accelerometer og gyroskop til din bot er MPU6050. Så prøv ikke at bygge en med et normalt accelerometer som ADXL345 eller noget lignende, det virker bare ikke. Du ved, hvorfor i slutningen af denne artikel. Du kan også tjekke vores dedikerede artikel om brug af MPU6050 med Arduino.
Batteri: Vi har brug for et batteri, der er så let som muligt, og driftsspændingen skal være mere end 5V, så vi kan drive vores Arduino direkte uden et boost-modul. Så det ideelle valg er et 7,4V Li-polymer batteri. Her har jeg brugt det, da jeg havde et 7.4V Li-ion-batteri, der var tilgængeligt. Men husk, at en Li-po er fordelagtig end Li-ion.
Chassis: Et andet sted, hvor du ikke skal gå på kompromis med dit robotchassis. Du kan bruge pap, træ, plastik alt, hvad du er god med. Men bare sørg for, at chassiset er robust og ikke skal vrikke, når boten prøver at balancere. Jeg har designet med eget chassis på Solidworks, der er udledt fra de andre bots og 3D udskrevet det. Hvis du har en printer, kan du også udskrive designet. Designfilerne vedhæftes i den kommende overskrift.
3D-udskrivning og samling af vores selvbalancerende robot
Hvis du har besluttet at 3D udskrive det samme chassis, som jeg bruger til at bygge min bot, så kan STL-filerne downloades fra thingiverse. Jeg har også tilføjet designfilerne sammen med det, så du også kan ændre det i henhold til dine personalepræferencer.
Delene har ingen overhængende strukturer, så du nemt kan udskrive dem uden understøtninger, og en udfyldning på 25% fungerer fint. Designene er ret almindelige, og enhver grundlæggende printer skal være i stand til at håndtere det med lethed. Jeg brugte Cura-softwaren til at skære modellen ud og udskrevet ved hjælp af min Tevo Tarantula. Indstillingen er vist nedenfor.
Du bliver nødt til at udskrive karosseridelen samt fire motormonteringsdele. Samlingen er ret ligetil; Brug 3 mm møtrikker og bolte til at fastgøre motoren og pladerne på plads. Efter montering skal det se sådan ud som vist på billedet nedenfor.
Det faktiske design blev planlagt med L298N-drevmodulet i det nederste rack Arduino og batteriet oven på det som vist ovenfor. Hvis du følger den samme ordre, kan du skrue tavlen direkte gennem de medfølgende huller og bruge et ledningsmærke til Li-po-batteriet. Dette arrangement skal også fungere, bortset fra de super almindelige hjul, som jeg måtte ændre senere.
I min bot har jeg byttet batteriets og Arduino UNO-kortets position for at lette programmeringen og måtte også introducere et perf-kort til at gennemføre forbindelserne. Så min bot så ikke ud som jeg planlagde i den indledende fase. Efter at have gennemført testning af ledningsføringsprogrammering og alt, ser min tohjulede robot endelig sådan ud
Kredsløbsdiagram
Det er ret simpelt at oprette forbindelserne til denne Arduino-baserede selvbalancerende robot. Dette er en selvbalancerende robot, der bruger Arduino og MPU6050, så vi skal interface MPU6050 med Arduino og forbinde motorerne gennem Motor Driver-modulet. Hele opsætningen drives af 7.4V li-ion-batteri. Kredsløbsdiagrammet for det samme er vist nedenfor.
Arduino og L298N-motordrivermodulet får direkte strøm via henholdsvis Vin-pin og 12V-terminal. Den indbyggede regulator på Arduino-kortet konverterer input 7.4V til 5V, og ATmega IC og MPU6050 får strøm fra den. DC-motorerne kan køre fra spænding 5V til 12V. Men vi tilslutter den 7.4V positive ledning fra batteri til 12V indgangsterminal på motordrivermodulet. Dette får motorerne til at køre med 7,4 V. Den følgende tabel viser, hvordan MPU6050- og L298N-motordrivermodulet er forbundet med Arduino.
|
Komponentstift |
Arduino Pin |
|
MPU6050 |
|
|
Vcc |
+ 5V |
|
Jord |
Gnd |
|
SCL |
A5 |
|
SDA |
A4 |
|
INT |
D2 |
|
L298N |
|
|
IN1 |
D6 |
|
IN2 |
D9 |
|
IN3 |
D10 |
|
IN4 |
D11 |
MPU6050 kommunikerer med Arduino gennem I2C-interface, så vi bruger SPI-stifterne A4 og A5 i Arduino. DC-motorerne er tilsluttet henholdsvis PWM-stifterne D6, D9 D10 og D11. Vi er nødt til at forbinde dem til PWM-ben, fordi vi styrer DC-motorens hastighed ved at variere PWM-signalernes driftscyklus. Hvis du ikke er fortrolig med disse to komponenter, anbefales det at læse MPU6050 Interfacing og L298N Motor driver tutorial.
Selvbalancerende robotkode
Nu er vi nødt til at programmere vores Arduino UNO-kort til at balancere robotten. Det er her, al magien sker; konceptet bag det er simpelt. Vi er nødt til at kontrollere, om botten læner sig fremad eller bagud ved hjælp af MPU6050, og hvis den læner sig fremad, skal vi dreje hjulene fremad, og hvis den læner sig bagud, skal vi dreje hjulene i omvendt retning.
Samtidig skal vi også styre den hastighed, hvormed hjulene roterer, hvis botten er let desorienteret fra midterposition, drejer hjulene langsomt, og hastigheden stiger, når den kommer mere væk fra midterpositionen. For at opnå denne logik bruger vi PID-algoritmen, som har centerpositionen som setpunkt og desorienteringsniveauet som output.
For at kende botens aktuelle position bruger vi MPU6050, som er et 6-akset accelerometer og gyroskopføler kombineret. For at få en pålidelig værdi af positionen fra sensoren er vi nødt til at bruge værdien af både accelerometer og gyroskop, fordi værdierne fra accelerometer har støjproblemer, og værdierne fra gyroskop har tendens til at glide med tiden. Så vi er nødt til at kombinere begge dele og få værdien af yaw pitch and roll af vores robot, hvoraf vi kun bruger værdien af yaw.
Det lyder lidt af hovedet, ikke? Men bekymre dig ikke, takket være Arduino-samfundet har vi let tilgængelige biblioteker, der kan udføre PID-beregningen og også få værdien af yaw fra MPU6050. Biblioteket er udviklet af henholdsvis br3ttb og jrowberg. Inden du fortsætter med at downloade deres biblioteker, skal du danne følgende link og føje dem til din Arduino lib-bibliotek.
github.com/br3ttb/Arduino-PID-Library/blob/master/PID_v1.h
github.com/jrowberg/i2cdevlib/tree/master/Arduino/MPU6050
Nu hvor vi har bibliotekerne føjet til vores Arduino IDE. Lad os begynde at programmere for vores selvbalancerende robot. Som altid er den komplette kode til MPU6050-balanceringsrobotten angivet i slutningen af denne side, her forklarer jeg bare de vigtigste uddrag i koden. En tidligere fortalt koden er bygget oven på MPU6050 eksempelkoden, vi vil bare optimere koden til vores formål og tilføje PID og kontrolteknik til vores selvbalancerende robot.
Først inkluderer vi de biblioteker, der kræves for at dette program skal fungere. De inkluderer det indbyggede I2C-bibliotek, PID-biblioteket og MPU6050-biblioteket, som vi lige har downloadet.
#include "I2Cdev.h" #include
Derefter erklærer vi de variabler, der kræves for at hente dataene fra MPU6050-sensoren. Vi læser både tyngdekraftsvektoren og kvaternionsværdierne og beregner derefter yaw pitch and roll-værdien af bot. Den float-array YPR vil holde det endelige resultat.
// MPU-kontrol / status vars bool dmpReady = false; // sæt sandt, hvis DMP init var vellykket uint8_t mpuIntStatus; // holder faktisk afbrydelsesstatusbyte fra MPU uint8_t devStatus; // returner status efter hver enhedshandling (0 = succes ,! 0 = fejl) uint16_t packetSize; // forventet DMP-pakkestørrelse (standard er 42 byte) uint16_t fifoCount; // optælling af alle bytes, der aktuelt er i FIFO uint8_t fifoBuffer; // FIFO-opbevaringsbuffer // orientering / bevægelse vars Quaternion q; // kvaternion container VectorFloat tyngdekraft; // tyngdekraftsvektor float ypr; // yaw / pitch / roll container og tyngdekraftsvektor
Dernæst kommer det meget vigtige segment af koden, og det er her, du vil bruge lang tid på at tune til det rigtige sæt værdier. Hvis din robot er bygget med et meget godt tyngdepunkt, og komponenterne er symmetrisk arrangeret (hvilket i de fleste tilfælde ikke er), vil værdien af dit sætpunkt være 180. Ellers skal du slutte din bot til Arduino seriel skærm og vippe den til du finder en god afbalanceringsposition, skal du læse den værdi, der vises på den serielle skærm, og dette er din indstillingsværdi. Værdien af Kp, Kd og Ki skal indstilles i henhold til din bot. Ingen to identiske bots vil have de samme værdier som Kp, Kd og Ki, så der er ingen undslip fra den. Se videoen i slutningen af denne side for at få en idé om, hvordan du justerer disse værdier.
/ ********* Tune disse 4 værdier til din BOT ********* / dobbelt sætpunkt = 176; // indstil værdien, når bot er vinkelret på jorden ved hjælp af seriel skærm. // Læs projektdokumentationen på circuitdigest.com for at lære at indstille disse værdier dobbelt Kp = 21; // Indstil denne første dobbelte Kd = 0,8; // Indstil denne sekund dobbelte Ki = 140; // Indstil endelig dette / ****** Indstilling af slutningen af værdier ********* /
I den næste linje initialiserer vi PID-algoritmen ved at sende inputvariablerne input, output, sætpunkt, Kp, Ki og Kd. Ud af disse har vi allerede indstillet værdierne for sætpunkt Kp, Ki og Kd i ovenstående kodestykke. Værdien af input vil være den aktuelle værdi af yaw, der læses fra MPU6050-sensoren, og outputværdien er den værdi, der beregnes af PID-algoritmen. Så grundlæggende giver PID-algoritmen os en outputværdi, der skal bruges til at korrigere inputværdien til at være tæt på sætpunktet.
PID pid (& input, & output, & setpoint, Kp, Ki, Kd, DIRECT);
Inde i tomrum setup funktionen vi initialisere MPU6050 ved at konfigurere DMP (Digital Motion Processor). Dette vil hjælpe os med at kombinere Accelerometer-data med Gyroscope-data og give en pålidelig værdi af Yaw, Pitch and Roll. Vi går ikke meget dybt ind i dette, da det vil være langt ud over emnet. Under alle omstændigheder er et kodesegment, som du skal slå op i installationsfunktionen, gyroforskydningsværdierne. Hver MPU6050-sensor har sine egne forskydningsværdier, du kan bruge denne Arduino-skitse til at beregne offsetværdien af din sensor og opdatere følgende linjer i overensstemmelse hermed i dit program.
// lever dine egne gyroforskydninger her, skaleret til min følsomhed mpu.setXGyroOffset (220); mpu.setYGyroOffset (76); mpu.setZGyroOffset (-85); mpu.setZAccelOffset (1688);
Vi er også nødt til at initialisere de digitale PWM-ben, som vi bruger til at forbinde vores motorer til. I vores tilfælde er det D6, D9, D10 og D11. Så vi initialiserer disse stifter, da outputstifter gør dem LAVE som standard.
// Initialiser Motor outpu pins pinMode (6, OUTPUT); pinMode (9, OUTPUT); pinMode (10, OUTPUT); pinMode (11, OUTPUT); // Som standard slukker begge motorer analogWrite (6, LOW); analogWrite (9, LAV); analogWrite (10, LAV); analogWrite (11, LAV);
Inde i vigtigste loop funktion vi kontrollere, om data fra MPU6050 er klar til at blive læst. Hvis ja, bruger vi det til at beregne PID-værdien og derefter vise input- og outputværdien af PID på seriel skærm bare for at kontrollere, hvordan PID reagerer. Baseret på outputværdien beslutter vi, om boten skal bevæge sig fremad eller bagud eller stå stille.
Da vi antager, at MPU6050 vender tilbage 180, når bot er oprejst. Vi får korrektionsværdier positive, når bot falder foran, og vi får negative værdier, hvis bot falder bagud. Så vi kontrollerer for denne tilstand og kalder de relevante funktioner for at flytte botten frem eller tilbage.
while (! mpuInterrupt && fifoCount <packetSize) { // ingen mpu-data - udfører PID-beregninger og output til motorer pid.Compute (); // Udskriv værdien af input og output på seriel skærm for at kontrollere, hvordan den fungerer. Serial.print (input); Serial.print ("=>"); Serial.println (output); if (input> 150 && input <200) {// Hvis Bot falder, hvis (output> 0) // Faller mod front Fremad (); // Drej hjulene fremad ellers, hvis (output <0) // Faller bagud baglæns (); // Drej hjulene bagud } ellers // Hvis Bot ikke falder Stop (); // hold hjulene stille }
Den PID-udgang variabel beslutter også, hvor hurtigt motoren skal roteres. Hvis boten lige er ved at falde, foretager vi mindre korrektion ved at dreje hjulet langsomt. Hvis disse mindre korrektioner ikke fungerer, og stadig hvis boten falder ned, øger vi motorens hastighed. Værdien af, hvor hurtigt hjulene roterer, bestemmes af PI-algoritmen. Bemærk, at vi for funktionen Reverse har ganget outputværdien med -1, så vi kan konvertere den negative værdi til positiv.
void Forward () // Kode for at dreje hjulet fremad { analogWrite (6, output); analogWrite (9,0); analogWrite (10, output); analogWrite (11,0); Serial.print ("F"); // Fejlretningsoplysninger } ugyldig Reverse () // Kode for at dreje hjulet bagud { analogWrite (6,0); analogWrite (9, output * -1); analogWrite (10,0); analogWrite (11, output * -1); Serial.print ("R"); } ugyldigt Stop () // Kode for at stoppe begge hjul { analogWrite (6,0); analogWrite (9,0); analogWrite (10,0); analogWrite (11,0); Serial.print ("S"); }
Arbejde med Arduino Self Balancing Robot
Når du er klar med hardware, kan du uploade koden til dit Arduino-kort. Sørg for, at forbindelserne er korrekte, da vi bruger et Li-ion-batteri, der er ekstrem forsigtighed. Så dobbelttjek for kortslutninger, og sørg for, at terminalerne ikke kommer i kontakt, selvom din bot oplever nogle små påvirkninger. Tænd dit modul, og åbn din serielle skærm, hvis din Arduino kunne kommunikere med MPU6050 med succes, og hvis alt fungerer som forventet, skal du se følgende skærmbillede.
Her ser vi input- og outputværdierne for PID-algoritmen i formatet input => output . Hvis bot er perfekt balance, vil outputværdien være 0. Indgangsværdien er den aktuelle værdi fra MPU6050-sensoren. Alfabetet “F” repræsenterer, at bot bevæger sig fremad, og “R” repræsenterer, at bot i omvendt retning.
I de indledende faser af PID anbefaler jeg at lade dit Arduino-kabel være tilsluttet boten, så du nemt kan overvåge værdierne for input og output, og det vil også være let at rette og uploade dit program til Kp-, Ki- og Kd-værdier. Den Videoen nedenfor viser den komplette arbejdsforhold af bot og viser også hvordan man kan rette dine PID-værdier.
Håber dette hjælper med at opbygge din egen selvbalancerende robot, hvis du har problemer med at få den til at arbejde, så lad dine spørgsmål være i kommentarfeltet nedenfor eller brug foraerne til mere tekniske spørgsmål. Hvis du vil have mere sjov, kan du også bruge den samme logik til at opbygge en kuglebalanceringsrobot.