DIY-Arduino-Gimbal | Selbststabilisierende Plattform

In diesem Tutorial lernen wir, wie man einen Arduino Gimbal oder eine selbststabilisierende Plattform mit Servomotoren baut. Dieses Tutorial ist eigentlich eine Erweiterung des vorherigen Tutorials über das MPU6050-Tutorial.

Sie können sich das folgende Video ansehen oder das schriftliche Tutorial unten lesen.

Übersicht

Ich habe den Gimbal mit einer 3D-Modellierungssoftware entworfen. Es besteht aus 3 MG996R-Servomotoren für die 3-Achsen-Steuerung und einer Basis, auf der der MPU6050-Sensor, das Arduino und die Batterie platziert werden.

Sie können dieses 3D-Modell finden und herunterladen sowie es in Ihrem Browser unter Thangs erkunden.

STL-Dateien:

Mit meinem Creality CR-10 3D-Drucker habe ich alle Teile in 3D gedruckt und sie kamen einfach perfekt heraus.

Zusammenbau

Der Zusammenbau des Gimbals war recht einfach. Ich begann mit der Installation des Yaw-Servos. Mit M3-Schrauben und Muttern befestigte ich es an der Basis.

Als nächstes sicherte ich mit der gleichen Methode das Rollservo. Die Teile wurden speziell entwickelt, um problemlos in die MG996R-Servos zu passen.

Zum Verbinden der Teile untereinander habe ich die runden Hörner verwendet, die den Servos als Zubehör beiliegen.

Zuerst müssen wir das runde Horn mit zwei Schrauben an der Basis befestigen und es dann mit einer weiteren Schraube am vorherigen Servo befestigen.

Ich wiederholte diesen Vorgang für die Montage der restlichen Komponenten, des Pitch-Servos und der oberen Plattform.

Als nächstes führte ich die Servodrähte durch die Halteröffnungen, um sie organisiert zu halten. Dann habe ich den MPU6050-Sensor eingesetzt und mit einer Schraube und einer Mutter an der Basis befestigt.

Für die Stromversorgung des Projekts habe ich 2 Li-Ionen-Batterien verwendet, die ich in diesen Batteriehalter gelegt habe. Ich habe den Batteriehalter mit zwei Schrauben und Muttern an der Basis befestigt.

Die 2 Li-Ionen-Batterien erzeugen etwa 7,4 V, aber wir benötigen 5 V, um den Arduino und die Servos mit Strom zu versorgen.

Deshalb habe ich einen Abwärtswandler verwendet, der 7,4 V in 5 V umwandelt.

Arduino-Gimbal-Schaltplan

Was jetzt noch übrig bleibt, ist, alles miteinander zu verbinden. Hier ist der Schaltplan dieses Projekts und wie alles angeschlossen werden muss.

Die für dieses Arduino-Tutorial benötigten Komponenten erhalten Sie über die folgenden Links:

MPU6050 IMU ………………………………. Amazon / Banggood / AliExpress
MG996R-Servo ………………………………. Amazon / Banggood / AliExpress
Abwärtswandler ………………………………
Arduino-Board …………………………..…..
Steckbrett und Schaltdrähte …………

Am Ende drückte ich die Elektronikkomponenten und die Drähte in die Basis und bedeckte sie mit dieser Abdeckung unten.

Damit ist die selbstbalancierende Plattform oder der Arduino-Gimbal fertig und es funktioniert wie erwartet gut. Was bleibt, ist einen Blick ins Programm zu werfen.

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:

Codebeschreibung: Also verwenden wir das lesbare Gieren, Nicken und Rollen der Ausgabe.

// Get Yaw, Pitch and Roll values
#ifdef OUTPUT_READABLE_YAWPITCHROLL
    mpu.dmpGetQuaternion(&q, fifoBuffer);
    mpu.dmpGetGravity(&gravity, &q);
    mpu.dmpGetYawPitchRoll(ypr, &q, &gravity);

    // Yaw, Pitch, Roll values - Radians to degrees
    ypr[0] = ypr[0] * 180 / M_PI;
    ypr[1] = ypr[1] * 180 / M_PI;
    ypr[2] = ypr[2] * 180 / M_PI;
    
    // Skip 300 readings (self-calibration process)
    if (j <= 300) {
      correct = ypr[0]; // Yaw starts at random value, so we capture last value after 300 readings
      j++;
    }
    // After 300 readings
    else {
      ypr[0] = ypr[0] - correct; // Set the Yaw to 0 deg - subtract  the last random Yaw value from the currrent value to make the Yaw 0 degrees
      // Map the values of the MPU6050 sensor from -90 to 90 to values suatable for the servo control from 0 to 180
      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);
      
      // Control the servos according to the MPU6050 orientation
      servo0.write(servo0Value);
      servo1.write(servo1Value);
      servo2.write(servo2Value);
    }
#endif

Codesprache:Arduino (arduino)

Sobald wir die Werte erhalten haben, wandeln wir sie zuerst von Bogenmaß in Grad um.

// Yaw, Pitch, Roll values - Radians to degrees
    ypr[0] = ypr[0] * 180 / M_PI;
    ypr[1] = ypr[1] * 180 / M_PI;
    ypr[2] = ypr[2] * 180 / M_PI; Codesprache:Arduino (arduino)

Dann warten wir oder führen 300 Messungen durch, da sich der Sensor während dieser Zeit noch im Selbstkalibrierungsprozess befindet. Außerdem erfassen wir den Yaw-Wert, der am Anfang nicht 0 wie die Pitch- und Roll-Werte ist, sondern immer ein zufälliger Wert.

// Skip 300 readings (self-calibration process)
    if (j <= 300) {
      correct = ypr[0]; // Yaw starts at random value, so we capture last value after 300 readings
      j++;
    } Codesprache:Arduino (arduino)

Nach den 300 Messwerten setzen wir zuerst das Gieren auf 0, indem wir den oben erfassten Zufallswert subtrahieren. Dann ordnen wir die Werte von Yaw, Pitch und Roll, von – 90 bis +90 Grad, in Werte von 0 bis 180 zu, die zum Antrieb der Servos verwendet werden.

// After 300 readings
    else {
      ypr[0] = ypr[0] - correct; // Set the Yaw to 0 deg - subtract  the last random Yaw value from the currrent value to make the Yaw 0 degrees
      // Map the values of the MPU6050 sensor from -90 to 90 to values suatable for the servo control from 0 to 180
      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);
      
      // Control the servos according to the MPU6050 orientation
      servo0.write(servo0Value);
      servo1.write(servo1Value);
      servo2.write(servo2Value);
    } Codesprache:Arduino (arduino)

Mit der Write-Funktion senden wir diese Werte schließlich als Steuersignale an die Servos. Natürlich können Sie das Yaw-Servo deaktivieren, wenn Sie nur eine Stabilisierung für die X- und Y-Achse wünschen, und diese Plattform als Kamera-Gimbal verwenden.

Bitte beachten Sie, dass dies alles andere als ein guter Kamera-Gimbal ist. Die Bewegungen sind nicht glatt, weil diese Servos nicht für einen solchen Zweck gedacht sind. Echte Kamera-Gimbals verwenden eine spezielle Art von BLDC-Motoren, um sanfte Bewegungen zu erzielen. Betrachten Sie dieses Projekt also nur für Bildungszwecke.

Das wäre alles für dieses Tutorial. Ich hoffe, es hat Ihnen gefallen und Sie haben etwas Neues gelernt. Fühlen Sie sich frei, Fragen im Kommentarbereich unten zu stellen, und vergessen Sie nicht, meine Sammlung von Arduino-Projekten zu überprüfen.

Arduino Mecanum Wheels Roboter DIY Arduino-basiertes RC Hovercraft