Zelfbalancerende robot met Arduino

Nadat ik geïnspireerd was door RYNO-motoren en andere zelfbalancerende scooters van Segway, wilde ik altijd al iets bouwen, mijn eigen Arduino Segway Robot. Terwijl ik even nadacht, besloot ik om een zelfbalancerende robot te bouwen met Arduino. Op deze manier zou ik het onderliggende concept achter al deze scooters kunnen begrijpen en ook kunnen leren hoe het PID-algoritme werkt.

Toen ik eenmaal begon met bouwen, realiseerde ik me dat deze bot een beetje een uitdaging is om te bouwen. Er zijn zoveel opties om uit te kiezen en daarom beginnen de verwarring bij het selecteren van de motoren en blijft dit tot het afstemmen van PID-waarden. En er zijn zoveel dingen waar u rekening mee moet houden, zoals het type batterij, de positie van de batterij, de wielgreep, het type motoraandrijving, het handhaven van de CoG (zwaartepunt) en nog veel meer.

Maar laat me het je vertellen, als je het eenmaal hebt gebouwd, zul je het ermee eens zijn dat het niet zo moeilijk is als het klinkt. Dus laten we eerlijk zijn, in deze tutorial zal ik mijn ervaring met het bouwen van de zelfbalancerende robot documenteren. Misschien ben je een absolute beginner die net is begonnen of ben je hier terechtgekomen na een lange frustratie omdat je je bot niet aan het werk kreeg. Deze plaats wil je eindbestemming zijn. Dus laten we beginnen……

De onderdelen selecteren voor zelfbalancerende robot

Voordat ik je alle opties voor het bouwen van de bot vertel, wil ik eerst een lijst maken van de items die ik heb gebruikt in dit zelfbalancerende robotproject

Arduino UNO
DC-motoren met tandwieloverbrenging (geel gekleurd) - 2 nrs
L298N Motorbesturingsmodule
MPU6050
Een paar wielen
7,4 V Li-ionbatterij
Draden aansluiten
3D geprint lichaam

U kunt elk van de bovenstaande componenten mixen en kiezen op basis van de beschikbaarheid om uw eigen zelfbalancerende robotkit te maken, maar zorg ervoor dat de componenten voldoen aan de volgende criteria.

Controller: De controller die ik hier heb gebruikt, is Arduino UNO, waarom omdat hij eenvoudig te gebruiken is. Je kunt ook een Arduino Nano of Arduino mini gebruiken, maar ik zou je aanraden om bij UNO te blijven, omdat we het rechtstreeks kunnen programmeren zonder externe hardware.

Motoren: De beste motorkeuze die u kunt gebruiken voor een zelfbalancerende robot, is ongetwijfeld de stappenmotor. Maar om het simpel te houden heb ik een DC-reductiemotor gebruikt. Ja, het is niet verplicht om een stepper te hebben; de bot werkt ook prima met deze goedkope algemeen verkrijgbare geelgekleurde DC-reductiemotoren.

Motorstuurprogramma: als je de DC-reductiemotoren zoals de mijne hebt geselecteerd, kun je de L298N-drivermodule gebruiken zoals ik, of zelfs een L293D zou prima moeten werken. Lees meer over het besturen van DC-motoren met behulp van L293D en Arduino.

Wielen: onderschat deze jongens niet; Ik vond het moeilijk om erachter te komen dat het probleem bij mijn wielen zat. Zorg er dus voor dat uw wielen een goede grip hebben op de vloer die u gebruikt. Let goed op, uw grip mag uw wielen nooit over de grond laten schaatsen.

Versnellingsmeter en gyroscoop: de beste keuze van versnellingsmeter en gyroscoop voor uw bot is de MPU6050. Dus probeer er niet een te bouwen met een normale Accelerometer zoals ADXL345 of iets dergelijks, het werkt gewoon niet. Aan het einde van dit artikel weet u waarom. U kunt ook ons speciale artikel over het gebruik van MPU6050 met Arduino bekijken.

Batterij: we hebben een zo licht mogelijke batterij nodig en de bedrijfsspanning moet meer dan 5V zijn, zodat we onze Arduino rechtstreeks kunnen voeden zonder een boost-module. De ideale keuze is dus een Li-polymeerbatterij van 7,4 V. Hier, aangezien ik een 7.4V Li-ion-batterij direct beschikbaar had, heb ik deze gebruikt. Maar vergeet niet dat een Li-po voordeliger is dan Li-ion.

Chassis: Een andere plaats waar u geen compromissen moet sluiten, is met uw botschassis. U kunt karton, hout, plastic alles gebruiken waar u goed in bent. Maar zorg ervoor dat het chassis stevig is en niet wiebelt wanneer de bot probeert te balanceren. Ik heb een eigen chassis op Solidworks ontworpen op basis van de andere bots en het 3D geprint. Als u een printer heeft, kunt u het ontwerp ook afdrukken, de ontwerpbestanden worden in de volgende rubriek bijgevoegd.

3D printen en assembleren van onze zelfbalancerende robot

Als je hebt besloten om hetzelfde chassis 3D te printen dat ik gebruik om mijn bot te bouwen, dan kunnen de STL-bestanden worden gedownload van Thingiverse. Ik heb ook de ontwerpbestanden erbij toegevoegd, zodat u deze ook kunt wijzigen volgens uw personeelsvoorkeuren.

De onderdelen hebben geen overhangende structuren dus je kunt ze gemakkelijk printen zonder ondersteuning en een vulling van 25% werkt prima. De ontwerpen zijn vrij eenvoudig en elke basisprinter zou er gemakkelijk mee moeten kunnen omgaan. Ik heb de Cura-software gebruikt om het model in plakjes te snijden en met mijn Tevo Tarantula af te drukken, de instelling wordt hieronder weergegeven.

U zou het lichaamsdeel en vier motorbevestigingsonderdelen moeten afdrukken. De montage is vrij eenvoudig; Gebruik 3 mm moeren en bouten om de motor en de platen op hun plaats te bevestigen. Na montage zou het er ongeveer zo uit moeten zien als in de onderstaande afbeelding.

Het daadwerkelijke ontwerp was gepland met de L298N-aandrijfmodule in het onderste rek, de Arduino en de batterij erop, zoals hierboven weergegeven. Als u dezelfde bestelling volgt, kunt u het bord rechtstreeks door de daarvoor bestemde gaten schroeven en een draadlabel voor de Li-po-batterij gebruiken. Deze opstelling zou ook moeten werken, behalve de supergladde wielen die ik later moest vervangen.

In mijn bot heb ik de positie van de batterij en het Arduino UNO-bord verwisseld voor het gemak van programmeren en moest ik ook een perf-bord introduceren om de verbindingen te voltooien. Dus mijn bot zag er niet uit zoals ik in de beginfase had gepland. Na het voltooien van het testen van de bedrading en alles, ziet mijn tweewielige robot er eindelijk zo uit

Schakelschema

Het maken van de verbindingen voor deze op Arduino gebaseerde zelfbalancerende robot is vrij eenvoudig. Dit is een zelfbalancerende robot die Arduino en MPU6050 gebruikt, dus we moeten de MPU6050 met Arduino verbinden en de motoren aansluiten via de Motor driver module. De hele opstelling wordt gevoed door de 7,4 V li-ionbatterij. Het schakelschema voor hetzelfde wordt hieronder getoond.

De Arduino en de L298N-motordriver-module worden rechtstreeks gevoed via respectievelijk de Vin-pin en de 12V-aansluiting. De ingebouwde regulator op het Arduino-bord converteert de ingang van 7,4 V naar 5 V en de ATmega IC en MPU6050 worden hierdoor gevoed. De DC-motoren kunnen lopen van 5V tot 12V. Maar we zullen de 7,4 V positieve draad van de batterij aansluiten op de 12 V-ingang van de motorbesturingsmodule. Hierdoor werken de motoren met 7,4 V. De volgende tabel laat zien hoe de MPU6050 en L298N motor driver module is verbonden met Arduino.

Component Pin	Arduino-pin
MPU6050
Vcc	+ 5V
Grond	GND
SCL	A5
SDA	A4
INT	D2
L298N
IN 1	D6
IN 2	D9
IN3	D10
IN4	D11

De MPU6050 communiceert met Arduino via de I2C-interface, dus we gebruiken de SPI-pinnen A4 en A5 van Arduino. De gelijkstroommotoren zijn verbonden met respectievelijk PWM-pinnen D6, D9 D10 en D11. We moeten ze verbinden met PWM-pinnen omdat we de snelheid van de DC-motor regelen door de duty-cycle van de PWM-signalen te variëren. Als u niet bekend bent met deze twee componenten, is het raadzaam om de zelfstudie MPU6050-interface en L298N-motordriver te lezen.

Zelfbalancerende robotcode

Nu moeten we ons Arduino UNO-bord programmeren om de robot in evenwicht te brengen. Dit is waar alle magie gebeurt; het concept erachter is eenvoudig. We moeten controleren of de bot naar voren of naar achteren leunt met behulp van de MPU6050 en of hij naar voren leunt, moeten we de wielen in voorwaartse richting draaien en of hij naar achteren leunt, moeten we de wielen draaien in omgekeerde richting.

Tegelijkertijd moeten we ook de snelheid regelen waarmee de wielen draaien, als de bot enigszins gedesoriënteerd is vanuit de middenpositie, draaien de wielen langzaam en neemt de snelheid toe naarmate hij verder weg komt van de middenpositie. Om deze logica te bereiken gebruiken we het PID-algoritme, dat de middenpositie als instelpunt heeft en het niveau van desoriëntatie als de output.

Om de huidige positie van de bot te weten, gebruiken we de MPU6050, een 6-assige accelerometer en gyroscoopsensor gecombineerd. Om een betrouwbare positiewaarde van de sensor te krijgen, moeten we de waarde van zowel de versnellingsmeter als de gyroscoop gebruiken, omdat de waarden van de versnellingsmeter geluidsproblemen hebben en de waarden van de gyroscoop de neiging hebben om met de tijd af te wijken. Dus we moeten beide combineren en de waarde van de gierhoek en de rol van onze robot krijgen, waarvan we alleen de waarde van gieren zullen gebruiken.

Klinkt een beetje afgehaspeld toch? Maar maak je geen zorgen, dankzij de Arduino-community hebben we direct beschikbare bibliotheken die de PID-berekening kunnen uitvoeren en ook de waarde van gieren van de MPU6050 kunnen halen. De bibliotheek is ontwikkeld door respectievelijk br3ttb en jrowberg. Voordat u doorgaat met het downloaden van hun bibliotheken, maakt u gebruik van de volgende link en voegt u ze toe aan uw Arduino-bibliotheekmap.

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

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

Nu hebben we de bibliotheken toegevoegd aan onze Arduino IDE. Laten we beginnen met programmeren voor onze zelfbalancerende robot. Zoals altijd staat de volledige code voor de MPU6050-balanceerrobot aan het einde van deze pagina, hier leg ik alleen de belangrijkste fragmenten in de code uit. Zoals eerder verteld, is de code gebouwd bovenop de MPU6050-voorbeeldcode, we gaan gewoon de code optimaliseren voor ons doel en de PID en besturingstechniek toevoegen voor onze zelfbalancerende robot.

Eerst nemen we de bibliotheken op die nodig zijn om dit programma te laten werken. Ze omvatten de ingebouwde I2C-bibliotheek, PID-bibliotheek en MPU6050-bibliotheek die we zojuist hebben gedownload.

#include "I2Cdev.h" #include // Van #include "MPU6050_6Axis_MotionApps20.h" //https://github.com/jrowberg/i2cdevlib/tree/master/Arduino/MPU6050

Vervolgens declareren we de variabelen die nodig zijn om de gegevens van de MPU6050-sensor te krijgen. We lezen zowel de zwaartekrachtvector als de quaternionwaarden en berekenen vervolgens de gierhoek en de rolwaarde van de bot. De float-array ypr bevat het eindresultaat.

// MPU-controle / statusvars bool dmpReady = false; // set true als DMP init succesvol was uint8_t mpuIntStatus; // bevat de actuele interruptstatusbyte van MPU uint8_t devStatus; // retourstatus na elke apparaatbewerking (0 = geslaagd ,! 0 = fout) uint16_t packetSize; // verwachte DMP-pakketgrootte (standaard is 42 bytes) uint16_t fifoCount; // aantal bytes momenteel in FIFO uint8_t fifoBuffer; // FIFO-opslagbuffer // oriëntatie / bewegingsvars Quaternion q; // quaternion container VectorFloat zwaartekracht; // zwaartekracht vector zweven ypr; // gier / pitch / rolcontainer en zwaartekrachtvector

Vervolgens komt het zeer belangrijke segment van de code, en dit is waar u veel tijd zult besteden aan het afstemmen op de juiste set waarden. Als je robot is gebouwd met een zeer goed zwaartepunt en de componenten zijn symmetrisch gerangschikt (wat in de meeste gevallen niet is), dan is de waarde van je setpoint 180. Sluit anders je bot aan op een Arduino seriële monitor en kantel hem tot u vindt een goede balanspositie, leest de waarde af die wordt weergegeven op de seriële monitor en dit is uw instelwaarde. De waarde van Kp, Kd en Ki moet worden afgestemd op uw bot. Geen twee identieke bots hebben dezelfde waarden van Kp, Kd en Ki, dus er is geen ontkomen aan. Bekijk de video aan het einde van deze pagina om een idee te krijgen hoe u deze waarden kunt aanpassen.

/ ********* Stem deze 4 waarden af voor uw BOT ********* / dubbel setpoint = 176; // stel de waarde in wanneer de bot loodrecht op de grond staat met behulp van een seriële monitor. // Lees de projectdocumentatie op circuitdigest.com om te leren hoe u deze waarden dubbel Kp = 21 instelt ; // Stel deze eerste dubbele Kd = 0,8; // Stel deze tweede dubbele Ki = 140; // Stel ten slotte dit / ****** Einde van waarden instelling ********* /

In de volgende regel initialiseren we het PID-algoritme door de invoervariabelen input, output, setpoint, Kp, Ki en Kd door te geven. Hiervan hebben we de waarden van het setpoint Kp, Ki en Kd al in het bovenstaande codefragment ingesteld. De waarde van de invoer is de huidige waarde van de gier die wordt gelezen van de MPU6050-sensor en de waarde van de uitvoer is de waarde die wordt berekend door het PID-algoritme. Dus in feite geeft het PID-algoritme ons een uitvoerwaarde die moet worden gebruikt om de invoerwaarde te corrigeren zodat deze dicht bij het instelpunt ligt.

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

Binnen de void setup- functie initialiseren we de MPU6050 door de DMP (Digital Motion Processor) te configureren. Dit helpt ons bij het combineren van de gegevens van de versnellingsmeter met de gegevens van de gyroscoop en levert een betrouwbare waarde van Yaw, Pitch en Roll. We zullen hier niet veel diep op ingaan, aangezien het veel verder gaat dan het onderwerp. Hoe dan ook, een coderingssegment dat u in de setup-functie moet opzoeken, zijn de gyro-offsetwaarden. Elke MPU6050-sensor heeft zijn eigen waarden van offsets.U kunt deze Arduino-schets gebruiken om de offsetwaarde van uw sensor te berekenen en de volgende regels dienovereenkomstig in uw programma bij te werken.

// lever hier uw eigen gyro-offsets, geschaald voor min gevoeligheid mpu.setXGyroOffset (220); mpu.setYGyroOffset (76); mpu.setZGyroOffset (-85); mpu.setZAccelOffset (1688);

We moeten ook de digitale PWM-pinnen initialiseren die we gebruiken om onze motoren op aan te sluiten. In ons geval is het D6, D9, D10 en D11. Dus initialiseren we deze pinnen omdat uitvoerpinnen ze standaard LAAG maken.

// Initialiseer de motor outpu pennen pinMode (6, OUTPUT); pinMode (9, UITGANG); pinMode (10, UITGANG); pinMode (11, UITGANG); // Schakel standaard beide motoren analogWrite (6, LOW) uit; analogWrite (9, LOW); analogWrite (10, LOW); analogWrite (11, LOW);

Binnen de belangrijkste lus functie controleren we of de gegevens van de MPU6050 is klaar om te worden gelezen. Zo ja, dan gebruiken we het om de PID-waarde te berekenen en vervolgens de invoer- en uitvoerwaarde van PID op een seriële monitor weer te geven om te controleren hoe de PID reageert. Vervolgens beslissen we op basis van de waarde van de output of de bot vooruit of achteruit moet gaan of stil moet staan.

Omdat we aannemen dat de MPU6050 180 terugkeert als de bot rechtop staat. We krijgen positieve correctiewaarden als de bot naar voren valt en we krijgen negatieve waarden als de bot naar achteren valt. Dus we controleren op deze toestand en bellen de juiste functies om de bot vooruit of achteruit te verplaatsen.

while (! mpuInterrupt && fifoCount <packetSize) { // geen mpu-gegevens - uitvoeren van PID-berekeningen en uitvoer naar motoren pid.Compute (); // Druk de waarde van Input en Output op seriële monitor af om te controleren hoe het werkt. Serial.print (invoer); Serial.print ("=>"); Serial.println (uitvoer); if (input> 150 && input <200) {// If the Bot valt if (output> 0) // Falling naar voren Forward (); // Draai de wielen anders naar voren if (output <0) // Vallen naar achteren Reverse (); // Draai de wielen achteruit } else // If Bot valt niet Stop (); // Houd de wielen stil }

De PID-uitgangsvariabele bepaalt ook hoe snel de motor moet worden gedraaid. Als de bot op het punt staat te vallen, maken we een kleine correctie door het wiel langzaam te draaien. Als deze kleine correctie niet werkt en nog steeds als de bot naar beneden valt, verhogen we de snelheid van de motor. De waarde van hoe snel de wielen draaien, wordt bepaald door het PI-algoritme. Merk op dat we voor de functie Omkeren de waarde van de uitvoer hebben vermenigvuldigd met -1, zodat we de negatieve waarde naar een positieve waarde kunnen converteren.

void Forward () // Code om het wiel naar voren te draaien { analogWrite (6, output); analogWrite (9,0); analogWrite (10, uitvoer); analogWrite (11,0); Serial.print ("F"); // Foutopsporingsinformatie } void Reverse () // Code om het wiel achteruit te draaien { analogWrite (6,0); analogWrite (9, output * -1); analogWrite (10,0); analogWrite (11, output * -1); Serial.print ("R"); } void Stop () // Code om beide wielen te stoppen { analogWrite (6,0); analogWrite (9,0); analogWrite (10,0); analogWrite (11,0); Serial.print ("S"); }

Werking van Arduino Self Balancing Robot

Zodra u klaar bent met de hardware, kunt u de code uploaden naar uw Arduino-bord. Zorg ervoor dat de aansluitingen correct zijn, aangezien we een Li-ion-batterij gebruiken, uiterste voorzichtigheid is geboden. Controleer dus dubbel op kortsluiting en zorg ervoor dat de terminals niet in contact komen, zelfs als uw bot enkele kleine impact ondervindt. Schakel uw module in en open uw seriële monitor, als uw Arduino succesvol zou kunnen communiceren met MPU6050 en als alles werkt zoals verwacht, zou u het volgende scherm moeten zien.

Hier zien we de invoer- en uitvoerwaarden van het PID-algoritme in het formaat input => output . Als de bot perfect in balans is, is de waarde van de uitvoer 0. De invoerwaarde is de huidige waarde van de MPU6050-sensor. Het alfabet "F" geeft aan dat de bot vooruit beweegt en "R" geeft aan dat de bot achteruit beweegt.

Tijdens de beginfase van PID raad ik aan om je Arduino-kabel aangesloten te laten op de bot, zodat je gemakkelijk de waarden van invoer en uitvoer kunt volgen en het ook gemakkelijk is om je programma te corrigeren en te uploaden voor Kp-, Ki- en Kd-waarden. De onderstaande video toont de volledige werking van de bot en laat ook zien hoe u uw PID-waarden kunt corrigeren.

Ik hoop dat dit helpt om je eigen zelfbalancerende robot te bouwen als je problemen hebt om hem aan het werk te krijgen, laat dan je vragen achter in het commentaargedeelte hieronder of gebruik de forums voor meer technische vragen. Als je meer plezier wilt kunt u ook dezelfde logica gebruiken om het bouwen van een bal balancing robot.