Diy selbstausgleichender Roboter mit Arduino

Nachdem ich mich von RYNO-Motoren und anderen selbstausgleichenden Rollern von Segway inspirieren ließ, wollte ich immer etwas für meinen eigenen Arduino Segway-Roboter bauen. Ich dachte eine Weile nach und beschloss, mit Arduino einen selbstausgleichenden Roboter zu bauen. Auf diese Weise könnte ich das zugrunde liegende Konzept hinter all diesen Rollern erfassen und auch lernen, wie der PID-Algorithmus funktioniert.

Als ich anfing zu bauen, wurde mir klar, dass dieser Bot eine Herausforderung ist. Es stehen so viele Optionen zur Auswahl, dass die Verwirrung bei der Auswahl der Motoren richtig beginnt und bis zur Einstellung der PID-Werte bestehen bleibt. Und es gibt so viele Dinge zu beachten, wie Batterietyp, Position der Batterie, Radgriff, Art des Motortreibers, Aufrechterhaltung des CoG (Schwerpunkt) und vieles mehr.

Aber lassen Sie es mich Ihnen sagen, sobald Sie es gebaut haben, werden Sie zustimmen, dass es nicht so schwer ist, wie es sich anhört. Seien wir ehrlich, in diesem Tutorial werde ich meine Erfahrungen beim Bau des selbstausgleichenden Roboters dokumentieren. Sie könnten ein absoluter Anfänger sein, der gerade erst anfängt, oder nach einer langen Frustration, Ihren Bot nicht zum Laufen zu bringen, hier gelandet sein. Dieser Ort soll Ihr Endziel sein. Also lasst uns anfangen……

Auswahl der Teile für den selbstausgleichenden Roboter

Bevor ich Ihnen alle Optionen zum Erstellen des Bots erkläre, möchte ich die Elemente auflisten, die ich in diesem selbstausgleichenden Roboterprojekt verwendet habe

Arduino UNO
Getriebemotoren (gelb gefärbt) - 2Nr
L298N Motortreibermodul
MPU6050
Ein Paar Räder
7,4 V Li-Ionen-Akku
Kabel anschließen
3D gedruckter Körper

Sie können je nach Verfügbarkeit eine der oben genannten Komponenten mischen und auswählen, um Ihr eigenes selbstausgleichendes Roboterkit zu erstellen. Stellen Sie lediglich sicher, dass die Komponenten den folgenden Kriterien entsprechen.

Controller: Der Controller, den ich hier verwendet habe, ist Arduino UNO, warum, weil es einfach zu bedienen ist. Sie können auch einen Arduino Nano oder Arduino mini verwenden, aber ich würde Ihnen empfehlen, bei UNO zu bleiben, da wir ihn direkt ohne externe Hardware programmieren können.

Motoren: Die beste Wahl für einen Motor, den Sie ohne Zweifel für einen selbstausgleichenden Roboter verwenden können, ist der Schrittmotor. Aber um die Sache einfach zu halten, habe ich einen Gleichstrommotor verwendet. Ja, ein Stepper ist nicht zwingend erforderlich. Der Bot funktioniert auch mit diesen billigen, allgemein erhältlichen, gelb gefärbten Gleichstrommotoren.

Motortreiber: Wenn Sie die DC-Getriebemotoren wie meine ausgewählt haben, können Sie entweder das L298N-Treibermodul wie ich verwenden, oder sogar ein L293D sollte einwandfrei funktionieren. Erfahren Sie mehr über die Steuerung von Gleichstrommotoren mit L293D und Arduino.

Räder: Unterschätzen Sie diese Typen nicht; Es fiel mir schwer herauszufinden, dass das Problem bei meinen Rädern lag. Stellen Sie also sicher, dass Ihre Räder den Boden, den Sie verwenden, gut greifen. Beobachten Sie genau, Ihr Griff sollte niemals zulassen, dass Ihre Räder auf dem Boden rutschen.

Beschleunigungsmesser und Gyroskop: Die beste Wahl für Beschleunigungsmesser und Gyroskop für Ihren Bot ist die MPU6050. Versuchen Sie also nicht, einen mit einem normalen Beschleunigungsmesser wie ADXL345 oder ähnlichem zu bauen, es funktioniert einfach nicht. Sie werden am Ende dieses Artikels wissen, warum. Sie können auch unseren speziellen Artikel über die Verwendung von MPU6050 mit Arduino lesen.

Batterie: Wir benötigen eine Batterie, die so leicht wie möglich ist und deren Betriebsspannung mehr als 5 V betragen sollte, damit wir unseren Arduino direkt ohne Boost-Modul mit Strom versorgen können. Die ideale Wahl ist also ein 7,4-V-Li-Polymer-Akku. Da ich hier einen 7,4-V-Li-Ionen-Akku zur Verfügung hatte, habe ich ihn verwendet. Denken Sie jedoch daran, dass ein Li-Po vorteilhafter ist als ein Li-Ion.

Chassis: Ein weiterer Ort, an dem Sie keine Kompromisse eingehen sollten, ist das Bots-Chassis. Sie können alles verwenden, mit dem Sie gut umgehen können. Stellen Sie jedoch sicher, dass das Chassis stabil ist und nicht wackelt, wenn der Bot versucht, das Gleichgewicht zu halten. Ich habe ein eigenes Chassis für Solidworks entworfen, das von den anderen Bots abgeleitet und in 3D gedruckt wurde. Wenn Sie einen Drucker haben, können Sie das Design auch drucken. Die Designdateien werden in der nächsten Überschrift angehängt.

3D-Druck und Montage unseres selbstausgleichenden Roboters

Wenn Sie sich entschieden haben, dasselbe Gehäuse, mit dem ich meinen Bot erstellt habe, in 3D zu drucken, können die STL-Dateien von thingiverse heruntergeladen werden. Ich habe auch die Designdateien hinzugefügt, damit Sie sie auch gemäß Ihren Personaleinstellungen ändern können.

Die Teile haben keine überhängenden Strukturen, sodass Sie sie problemlos ohne Stützen drucken können. Eine Füllung von 25% funktioniert einwandfrei. Die Designs sind ziemlich schlicht und jeder Basisdrucker sollte problemlos damit umgehen können. Ich habe das Modell mit der Cura-Software in Scheiben geschnitten und mit meiner Tevo-Vogelspinne gedruckt. Die Einstellungen sind unten dargestellt.

Sie müssten das Körperteil sowie vier Motorbefestigungsteile drucken. Die Montage ist ziemlich einfach; Verwenden Sie 3-mm-Schrauben und Muttern, um den Motor und die Platinen zu befestigen. Nach dem Zusammenbau sollte es ungefähr so aussehen (siehe Abbildung unten).

Das eigentliche Design wurde mit dem L298N-Antriebsmodul im unteren Rack des Arduino und der Batterie darüber geplant, wie oben gezeigt. Wenn Sie der gleichen Reihenfolge folgen, können Sie die Platine direkt durch die dafür vorgesehenen Löcher schrauben und ein Kabeletikett für den Li-Po-Akku verwenden. Diese Anordnung sollte auch funktionieren, mit Ausnahme der Super-Plain-Räder, die ich später wechseln musste.

In meinem Bot habe ich die Position der Batterie und der Arduino UNO-Karte vertauscht, um die Programmierung zu vereinfachen, und musste auch eine Perf-Karte einführen, um die Verbindungen herzustellen. Mein Bot sah also nicht so aus, wie ich es in der Anfangsphase geplant hatte. Nach Abschluss der Verkabelungsprogrammierung und allem sieht mein Zweiradroboter endlich so aus

Schaltplan

Das Herstellen der Verbindungen für diesen Arduino-basierten selbstausgleichenden Roboter ist ziemlich einfach. Dies ist ein selbstausgleichender Roboter, der Arduino und MPU6050 verwendet. Daher müssen wir die MPU6050 mit Arduino verbinden und die Motoren über das Motortreibermodul verbinden. Das gesamte Setup wird von der 7,4-V-Li-Ionen-Batterie gespeist. Das Schaltbild dafür ist unten dargestellt.

Das Arduino- und das L298N-Motortreibermodul werden direkt über den Vin-Pin bzw. den 12-V-Anschluss mit Strom versorgt. Der integrierte Regler auf der Arduino-Karte wandelt den Eingang 7,4 V in 5 V um, und der ATmega IC und die MPU6050 werden von diesem mit Strom versorgt. Die Gleichstrommotoren können mit einer Spannung von 5 V bis 12 V betrieben werden. Wir werden jedoch das 7,4-V-Pluskabel von der Batterie an die 12-V-Eingangsklemme des Motortreibermoduls anschließen. Dadurch werden die Motoren mit 7,4 V betrieben. In der folgenden Tabelle ist aufgeführt, wie das Motortreibermodul MPU6050 und L298N mit Arduino verbunden ist.

Komponentenstift	Arduino Pin
MPU6050
Vcc	+ 5V
Boden	Gnd
SCL	A5
SDA	A4
INT	D2
L298N
IN 1	D6
IN 2	D9
IN3	D10
IN4	D11

Die MPU6050 kommuniziert mit Arduino über die I2C-Schnittstelle, daher verwenden wir die SPI-Pins A4 und A5 von Arduino. Die Gleichstrommotoren sind mit den PWM-Pins D6, D9, D10 bzw. D11 verbunden. Wir müssen sie an PWM-Pins anschließen, da wir die Drehzahl des Gleichstrommotors durch Variieren des Arbeitszyklus der PWM-Signale steuern. Wenn Sie mit diesen beiden Komponenten nicht vertraut sind, wird empfohlen, das Lernprogramm für MPU6050-Schnittstellen und L298N-Motortreiber zu lesen.

Selbstausgleichender Robotercode

Jetzt müssen wir unser Arduino UNO Board programmieren, um den Roboter auszugleichen. Hier geschieht die ganze Magie; Das Konzept dahinter ist einfach. Wir müssen mit der MPU6050 prüfen, ob sich der Bot nach vorne oder nach hinten neigt. Wenn er sich nach vorne neigt, müssen wir die Räder nach vorne drehen. Wenn er sich nach hinten neigt, müssen wir die Räder drehen in umgekehrter Richtung.

Gleichzeitig müssen wir auch die Geschwindigkeit steuern, mit der sich die Räder drehen. Wenn der Bot leicht von der Mittelposition desorientiert ist, drehen sich die Räder langsam und die Geschwindigkeit steigt, wenn er sich mehr von der Mittelposition entfernt. Um diese Logik zu erreichen, verwenden wir den PID-Algorithmus, der die Mittelposition als Sollwert und den Grad der Desorientierung als Ausgang hat.

Um die aktuelle Position des Bots zu ermitteln, verwenden wir die MPU6050, einen 6-Achsen-Beschleunigungsmesser und einen Gyroskopsensor in Kombination. Um einen zuverlässigen Positionswert vom Sensor zu erhalten, müssen wir den Wert sowohl des Beschleunigungsmessers als auch des Gyroskops verwenden, da die Werte des Beschleunigungsmessers Rauschprobleme aufweisen und die Werte des Gyroskops dazu neigen, mit der Zeit zu driften. Wir müssen also beide kombinieren und den Wert der Gierneigung und -rolle unseres Roboters ermitteln, von denen wir nur den Wert des Gierens verwenden.

Hört sich ein bisschen nach Kopf an, oder? Aber keine Sorge, dank der Arduino-Community verfügen wir über leicht verfügbare Bibliotheken, die die PID-Berechnung durchführen und auch den Gierwert von der MPU6050 erhalten können. Die Bibliothek wird von br3ttb bzw. jrowberg entwickelt. Bevor Sie fortfahren, laden Sie ihre Bibliotheken über den folgenden Link herunter und fügen Sie sie Ihrem Arduino lib-Verzeichnis hinzu.

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

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

Jetzt haben wir die Bibliotheken zu unserer Arduino IDE hinzugefügt. Beginnen wir mit der Programmierung für unseren selbstausgleichenden Roboter. Wie immer finden Sie den vollständigen Code für den Auswuchtroboter MPU6050 am Ende dieser Seite. Hier erkläre ich nur die wichtigsten Ausschnitte im Code. Wie bereits erwähnt, basiert der Code auf dem MPU6050-Beispielcode. Wir werden den Code nur für unseren Zweck optimieren und die PID- und Steuerungstechnik für unseren selbstausgleichenden Roboter hinzufügen.

Zuerst fügen wir die Bibliotheken hinzu, die erforderlich sind, damit dieses Programm funktioniert. Dazu gehören die integrierte I2C-Bibliothek, die PID-Bibliothek und die MPU6050-Bibliothek, die wir gerade heruntergeladen haben.

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

Dann deklarieren wir die Variablen, die erforderlich sind, um die Daten vom MPU6050-Sensor abzurufen. Wir lesen sowohl den Schwerkraftvektor als auch die Quaternionswerte und berechnen dann den Gierneigungs- und Rollwert des Bots. Das Float-Array ypr enthält das Endergebnis.

// MPU-Steuerung / Status vars bool dmpReady = false; // setze true wenn DMP init erfolgreich war uint8_t mpuIntStatus; // enthält das aktuelle Interrupt- Statusbyte der MPU uint8_t devStatus; // Status nach jeder Geräteoperation zurückgeben (0 = Erfolg,! 0 = Fehler) uint16_t packetSize; // erwartete DMP-Paketgröße (Standard ist 42 Byte) uint16_t fifoCount; // Anzahl aller aktuell im FIFO befindlichen Bytes uint8_t fifoBuffer; // FIFO-Speicherpuffer // Orientierungs- / Bewegungsvariablen Quaternion q; // Quaternion Container VectorFloat Schwerkraft; // Schwerkraftvektor float ypr; // Gier- / Nick- / Rollcontainer und Schwerkraftvektor

Als nächstes kommt das sehr wichtige Segment des Codes, und hier werden Sie lange Zeit damit verbringen, die richtigen Werte zu finden. Wenn Ihr Roboter mit einem sehr guten Schwerpunkt gebaut ist und die Komponenten symmetrisch angeordnet sind (was in den meisten Fällen nicht der Fall ist), beträgt der Wert Ihres Sollwerts 180. Andernfalls schließen Sie Ihren Bot an den seriellen Arduino-Monitor an und kippen Sie ihn bis Sie finden eine gute Ausgleichsposition, lesen den auf dem seriellen Monitor angezeigten Wert und dies ist Ihr Sollwert. Der Wert von Kp, Kd und Ki muss entsprechend Ihrem Bot eingestellt werden. Keine zwei identischen Bots haben die gleichen Werte von Kp, Kd und Ki, so dass es kein Entkommen gibt. Sehen Sie sich das Video am Ende dieser Seite an, um eine Vorstellung davon zu bekommen, wie diese Werte angepasst werden können.

/ ********* Stimmen Sie diese 4 Werte für Ihren BOT ab ********* / double setpoint = 176; // setze den Wert, wenn der Bot senkrecht zum Boden steht, mit dem seriellen Monitor. // Lesen Sie die Projektdokumentation auf Circuitdigest.com, um zu erfahren, wie Sie diese Werte festlegen. Double Kp = 21; // Setze dieses erste Doppel Kd = 0.8; // Setze dieses zweite Doppel Ki = 140; // Zum Schluss setzen Sie diese / ****** Ende der Werteinstellung ********* /

In der nächsten Zeile initialisieren wir den PID-Algorithmus, indem wir die Eingangsvariablen input, output, set point, Kp, Ki und Kd übergeben. Von diesen haben wir bereits die Werte der Sollwerte Kp, Ki und Kd im obigen Codeausschnitt festgelegt. Der Eingabewert ist der aktuelle Gierwert, der vom MPU6050-Sensor gelesen wird, und der Ausgabewert ist der Wert, der vom PID-Algorithmus berechnet wird. Grundsätzlich gibt uns der PID-Algorithmus einen Ausgabewert, der verwendet werden sollte, um den Eingabewert so zu korrigieren, dass er nahe am Sollwert liegt.

PID pid (& Eingabe & Ausgabe & Sollwert, Kp, Ki, Kd, DIREKT);

Innerhalb der Void-Setup- Funktion initialisieren wir die MPU6050 durch Konfiguration des DMP (Digital Motion Processor). Dies hilft uns bei der Kombination der Beschleunigungsmesserdaten mit Gyroskopdaten und liefert einen zuverlässigen Wert für Gieren, Neigen und Rollen. Wir werden nicht viel tiefer darauf eingehen, da es weit über das Thema hinausgehen wird. Ein Codesegment, das Sie in der Setup-Funktion nachschlagen müssen, sind die Kreiselversatzwerte. Jeder MPU6050-Sensor hat seine eigenen Versatzwerte. Mit dieser Arduino-Skizze können Sie den Versatzwert Ihres Sensors berechnen und die folgenden Zeilen in Ihrem Programm entsprechend aktualisieren.

// Geben Sie hier Ihre eigenen Kreisel-Offsets an, skaliert für minimale Empfindlichkeit mpu.setXGyroOffset (220); mpu.setYGyroOffset (76); mpu.setZGyroOffset (-85); mpu.setZAccelOffset (1688);

Wir müssen auch die digitalen PWM-Pins initialisieren, mit denen wir unsere Motoren verbinden. In unserem Fall sind es D6, D9, D10 und D11. Daher initialisieren wir diese Pins, da die Ausgangs-Pins sie standardmäßig auf LOW setzen.

// Initialisieren der Motor outpu Stifte pinMode (6, OUTPUT); PinMode (9, OUTPUT); PinMode (10, OUTPUT); PinMode (11, OUTPUT); // Standardmäßig beide Motoren ausschalten analogWrite (6, LOW); analogWrite (9, LOW); analogWrite (10, LOW); analogWrite (11, LOW);

Innerhalb der Hauptschleife Funktion überprüfen wir, ob die Daten aus dem MPU6050 bereit ist, gelesen zu werden . Wenn ja, verwenden wir es, um den PID-Wert zu berechnen und dann den Eingangs- und Ausgangswert der PID auf dem seriellen Monitor anzuzeigen, um zu überprüfen, wie die PID reagiert. Dann entscheiden wir basierend auf dem Wert der Ausgabe, ob sich der Bot vorwärts oder rückwärts bewegen oder still stehen muss.

Da wir davon ausgehen, dass die MPU6050 180 zurückgibt, wenn der Bot aufrecht steht. Wir erhalten positive Korrekturwerte, wenn der Bot nach vorne fällt, und wir erhalten negative Werte, wenn der Bot nach hinten fällt. Also prüfen wir diesen Zustand und rufen die entsprechenden Funktionen auf, um den Bot vorwärts oder rückwärts zu bewegen.

while (! mpuInterrupt && fifoCount <packetSize) { // keine mpu-Daten - PID-Berechnungen durchführen und an Motoren ausgeben pid.Compute (); // Drucke den Wert von Input und Output auf dem seriellen Monitor, um zu überprüfen, wie es funktioniert. Serial.print (Eingabe); Serial.print ("=>"); Serial.println (Ausgabe); if (Eingabe> 150 && Eingabe <200) {// Wenn der Bot fällt if (Ausgabe> 0) // Nach vorne fallen Forward (); // Drehe die Räder vorwärts, sonst wenn (Ausgang <0) // Nach hinten fallen Reverse (); // Drehe die Räder nach hinten } else // Wenn der Bot nicht fällt Stop (); // Halte die Räder still }

Die PID-Ausgangsvariable entscheidet auch, wie schnell der Motor gedreht werden muss. Wenn der Bot gerade fällt, nehmen wir eine geringfügige Korrektur vor, indem wir das Rad langsam drehen. Wenn diese geringfügigen Korrekturen nicht funktionieren und der Bot dennoch herunterfällt, erhöhen wir die Drehzahl des Motors. Der Wert, wie schnell sich die Räder drehen, wird vom PI-Algorithmus bestimmt. Beachten Sie, dass wir für die Umkehrfunktion den Wert der Ausgabe mit -1 multipliziert haben, damit wir den negativen Wert in einen positiven Wert umwandeln können.

void Forward () // Code zum Vorwärtsdrehen des Rades { analogWrite (6, output); analogWrite (9,0); analogWrite (10, Ausgabe); analogWrite (11,0); Serial.print ("F"); // Debugging-Informationen } void Reverse () // Code zum Drehen des Rads nach hinten { analogWrite (6,0); analogWrite (9, Ausgabe * -1); analogWrite (10,0); analogWrite (11, Ausgabe * -1); Serial.print ("R"); } void Stop () // Code zum Stoppen beider Räder { analogWrite (6,0); analogWrite (9,0); analogWrite (10,0); analogWrite (11,0); Serial.print ("S"); }}

Arbeiten des selbstausgleichenden Arduino-Roboters

Sobald Sie mit der Hardware fertig sind, können Sie den Code auf Ihr Arduino-Board hochladen. Stellen Sie sicher, dass die Anschlüsse korrekt sind, da wir einen Li-Ionen-Akku verwenden. Es ist äußerste Vorsicht geboten. Überprüfen Sie daher, ob Kurzschlüsse vorliegen, und stellen Sie sicher, dass die Terminals auch dann nicht in Kontakt kommen, wenn Ihr Bot geringfügige Auswirkungen hat. Schalten Sie Ihr Modul ein und öffnen Sie Ihren seriellen Monitor. Wenn Ihr Arduino erfolgreich mit der MPU6050 kommunizieren konnte und alles wie erwartet funktioniert, sollte der folgende Bildschirm angezeigt werden.

Hier sehen wir die Eingabe- und Ausgabewerte des PID-Algorithmus im Format input => output . Wenn der Bot perfekt ausbalanciert ist, ist der Wert der Ausgabe 0. Der Eingabewert ist der aktuelle Wert vom MPU6050-Sensor. Das Alphabet "F" steht für die Vorwärtsbewegung des Bots und "R" für die Rückwärtsbewegung des Bots.

In der Anfangsphase von PID empfehle ich, das Arduino-Kabel an den Bot angeschlossen zu lassen, damit Sie die Werte von Ein- und Ausgang einfach überwachen und Ihr Programm für Kp-, Ki- und Kd-Werte leicht korrigieren und hochladen können. Das folgende Video zeigt die vollständige Funktionsweise des Bots und zeigt auch, wie Sie Ihre PID-Werte korrigieren.

Ich hoffe, dies hilft Ihnen dabei, Ihren eigenen selbstausgleichenden Roboter zu bauen, wenn Sie Probleme haben, ihn zum Laufen zu bringen. Lassen Sie Ihre Fragen dann im Kommentarbereich unten oder nutzen Sie die Foren für weitere technische Fragen. Wenn Sie mehr Spaß haben möchten, können Sie mit derselben Logik auch einen Ballausgleichsroboter bauen.