Selbststabilisierendes Arduino Gimbal mit 3-Achs-Servo-Steuerung bauen

In diesem Tutorial lernen wir, wie man ein Arduino Gimbal bzw. eine selbststabilisierende Plattform mit Servomotoren baut. Dieses Tutorial ist eine Erweiterung des vorherigen MPU6050-Tutorials.

Sie können das folgende Video ansehen oder die schriftliche Anleitung unten lesen.

Überblick

Ich entwarf das Gimbal in einer 3D-Modellierungssoftware. Es besteht aus 3 MG996R-Servomotoren für die 3-Achsen-Steuerung (Gier, Nick, Roll) und einer Basis, auf der der MPU6050-Sensor, der Arduino und der Akku Platz finden.

Das 3D-Modell finden Sie auf Thangs zum Download und zur Browser-Ansicht.

STL-Dateien:

Mit meinem Creality CR-10 3D-Drucker druckte ich alle Teile – sie kamen perfekt heraus.

Zusammenbau

Der Gimbal-Zusammenbau war recht einfach. Ich begann mit dem Yaw-Servo (Gierachse). Mit M3-Schrauben und Muttern an der Basis befestigt.

Dann den Roll-Servo (Rollachse)同样方法 befestigt. Die Teile sind passgenau für MG996R-Servos designed.

Für die Verbindung der Teile untereinander nutze ich die mitgelieferten Rundhörner der Servos.

Zuerst Rundhorn mit zwei Schrauben an der Basis fixieren, dann per weiterer Schraube am vorherigen Servo befestigen.

Diesen Vorgang für die restlichen Komponenten wiederholen: Pitch-Servo (Nickachse) und obere Plattform.

Dann die Servokabel durch die vorgesehenen Halteöffnungen führen für Ordnung. MPU6050-Sensor einsetzen und per Schraube/Mutter an der Basis fixieren.

Zur Stromversorgung nutze ich 2 Li-Ion-Akkus in einem Batteriehalter, den ich mit zwei Schrauben/Muttern an der Basis befestige.

Zwei Li-Ion-Akkus liefern ca. 7,4V, aber Arduino und Servos brauchen 5V.

Daher ein Step-Down-Wandler (Buck Converter), der 7,4V auf 5V wandelt.

Schaltplan des Arduino Gimbal

Nun alles verbinden. Hier der Schaltplan:

Benötigte Komponenten:

• MPU6050 IMU Amazon / Banggood / AliExpress
• MG996R Servo Amazon / Banggood / AliExpress
• Buck Converter
• Arduino Board
• Steckbrett und Jumper-Kabel

Zum Schluss die Elektronik und Kabel in die Basis drücken und mit dem Boden-Deckel abdecken.

Damit ist die selbstbalancierende Plattform bzw. das Arduino Gimbal fertig und funktioniert wie erwartet. Was bleibt, ist ein Blick auf das Programm.

Arduino-Code

Der Arduino-Code für dieses Beispiel ist eine Modifikation des MPU6050_DMP6-Beispiels aus der i2cdevlib-Bibliothek von Jeff Rowberg.

Hier können Sie den Code herunterladen:

Code-Erklärung: Wir nutzen die lesbaren Yaw-, Pitch- und Roll-Ausgabewerte.

// Yaw, Pitch und Roll Werte erhalten
#ifdef OUTPUT_READABLE_YAWPITCHROLL
  mpu.dmpGetQuaternion(&q, fifoBuffer);
  mpu.dmpGetGravity(&gravity, &q);
  mpu.dmpGetYawPitchRoll(ypr, &q, &gravity);
  // Yaw, Pitch, Roll Werte - Radiant in Grad
  ypr[0] = ypr[0] * 180 / M_PI;
  ypr[1] = ypr[1] * 180 / M_PI;
  ypr[2] = ypr[2] * 180 / M_PI;
  // 300 Messwerte überspringen (Selbstkalibrierung)
  if (j <= 300) {
    correct = ypr[0]; // Yaw startet mit Zufallswert, letzten Wert nach 300 Messungen erfassen
    j++;
  }
  // Nach 300 Messungen
  else {
    ypr[0] = ypr[0] - correct; // Yaw auf 0° setzen - letzten zufälligen Yaw-Wert vom aktuellen abziehen
    // MPU6050 Werte von -90 bis +90 auf für Servo passende 0-180 mappen
    int servo0Value = map(ypr[0], -90, 90, 0, 180);
    int servo1Value = map(ypr[1], -90, 90, 0, 180);
    int servo2Value = map(ypr[2], -90, 90, 180, 0); // Invertiert für eine Achse
    // Servos laut MPU6050-Orientierung steuern
    servo0.write(servo0Value);
    servo1.write(servo1Value);
    servo2.write(servo2Value);
  }
#endifCode language: Arduino (arduino)

Nach Erhalt der Werte wandeln wir sie erst von Radiant in Grad um.

// Yaw, Pitch, Roll Werte - Radiant in Grad
ypr[0] = ypr[0] * 180 / M_PI;
ypr[1] = ypr[1] * 180 / M_PI;
ypr[2] = ypr[2] * 180 / M_PI;Code language: Arduino (arduino)

Dann warten wir 300 Messwerte, da der Sensor noch im Selbstkalibrierungsprozess ist. Auch erfassen wir den Yaw-Wert, der anfangs nicht 0 ist wie Pitch und Roll, sondern ein zufälliger Wert.

// 300 Messwerte überspringen (Selbstkalibrierung)
if (j <= 300) {
  correct = ypr[0]; // Yaw startet mit Zufallswert, letzten Wert nach 300 Messungen erfassen
  j++;
}Code language: Arduino (arduino)

Nach den 300 Messungen setzen wir Yaw auf 0, indem wir den erfassten Zufallswert subtrahieren. Dann mappen wir Yaw, Pitch, Roll von -90° bis +90° auf 0-180 für die Servosteuerung.

// Nach 300 Messungen
else {
  ypr[0] = ypr[0] - correct; // Yaw auf 0° setzen
  int servo0Value = map(ypr[0], -90, 90, 0, 180);
  int servo1Value = map(ypr[1], -90, 90, 0, 180);
  int servo2Value = map(ypr[2], -90, 90, 180, 0);
  servo0.write(servo0Value);
  servo1.write(servo1Value);
  servo2.write(servo2Value);
}Code language: Arduino (arduino)

Schließlich senden wir per write() diese Werte als Steuersignale an die Servos. Man kann den Yaw-Servo deaktivieren, wenn man nur X/Y-Stabilisierung will (Kamera-Gimbal).

Hinweis: Dies ist weit von einem guten Kamera-Gimbal entfernt. Die Bewegungen sind nicht flüssig, da diese Servos nicht dafür ausgelegt sind. Echte Kamera-Gimbals nutzen spezielle BLDC-Motoren für weiche Bewegungen. Betrachten Sie dieses Projekt nur zu Lernzwecken.

Das war alles für dieses Tutorial. Ich hoffe, es hat Ihnen gefallen und Sie haben etwas Neues gelernt. Fragen gerne in den Kommentaren und schauen Sie in meine Arduino-Projektsammlung.