Bewegungssteuerungs-Gimbal - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:15

Hallo zusammen, mein Name ist Harji Nagi. Ich studiere derzeit im zweiten Jahr Elektronik und Nachrichtentechnik am Pranveer Singh Institute of Technology, Kanpur (UP). Ich interessiere mich sehr für Robotik, Arduino, künstliche Intelligenz und analoge Elektronik.

Das Wort „Gimbal“ist als schwenkbarer Träger definiert, der die Drehung jedes Objekts in einer einzigen Achse ermöglicht. Ein dreiachsiger Gimbal ermöglicht es also, dass jedes auf dem Gimbal montierte Objekt unabhängig von der Bewegung desjenigen ist, der den Gimbal hält. Der Gimbal bestimmt die Bewegung des Objekts, nicht dasjenige, das es trägt.

Es besteht aus 3 MG996R-Servomotoren für die 3-Achsen-Steuerung und einer Basis, auf der der MPU6050-Sensor, das Arduino und der Akku platziert werden. Es wird verwendet, um die Kamera vibrationsfrei zu stabilisieren. Ein 3-Achsen-Gimbal sorgt dafür, dass die Bewegung der Kamera stabilisiert wird, auch wenn der Kamerahalter nach oben und unten, links und rechts, vorne und hinten fährt. Dies ist, was wir als Gier-, Nick- und Wankstabilisierung bezeichnen.

Schritt 1: Komponentenliste

Die Komponentenliste sind:

1) Arduino Uno

2) 8V, 1,5 Ampere Batterie zur Stromversorgung von Arduino Uno

3) 7805 Spannungsregler Ic oder Sie können einen Abwärtswandler verwenden

4)MPU 6050

5)3*(MG995 SERVO-Motoren)

6) Überbrückungsdrähte

Andere Ausrüstungen:

1) Lötkolben

2)Klebepistole

3) Bohrmaschine

4) Essensdose

Anstatt Brot zu verwenden, habe ich ein kleines benutzerdefiniertes Perfboard für die positive und negative Busverbindung verwendet

Schritt 2: Zusammenbauen

Foamcore, Foamboard oder Paper-faced Foamboard ist ein leichtes und leicht zu schneidendes Material, das zur Montage des Servomotors und zur Herstellung von maßstabsgetreuen Modellen verwendet wird.

Zuerst habe ich eine DIY-L-Form-Halterung gemacht, um den Servomotor mit Hilfe von Schaumstoffplatten zu montieren.

Schritt 3:

Der Zusammenbau des Gimbals war recht einfach. Ich begann mit der Installation des Yaw-Servos, des MPU 6050-Sensors und des EIN-AUS-Schalters. Mit Schrauben und Muttern habe ich es an der Basis befestigt

Schritt 4: Als nächstes habe ich den Roll-Servo mit der gleichen Methode gesichert. die Teile sind speziell für die einfache Montage der MG995-Servos ausgelegt

Schritt 5: Als nächstes habe ich den Roll-Servo mit der gleichen Methode gesichert. die Teile sind speziell für die einfache Montage der MG995-Servos ausgelegt

Schritt 6: Verbindungen

Im Schaltplan können Sie entweder einen Abwärtswandler oder einen 7805-Spannungsregler-IC verwenden, um 8 V in 5 V umzuwandeln. Der Mikrocontroller, der das Schaltbild erhält, ist Arduino Nano. Sie können auch Arduino Uno, Arduino Mega verwenden.

Die SCL- und SDA-Pins der MPU 6050 sind mit den Arduino-Analogpins A5 und A4 verbunden. (SCL- und SDA-Pins können variieren, also schauen Sie sich das Datenblatt für SCl- und SDA-Pins für andere Mikrocontroller an)

Schritt 7: Verbindung mit 7805 Spannungsregler IC

Dieser Schaltplan ist für den Anschluss von 7805 Spannungsregler ic, schließen Sie die 8V Batterie an Vin an und Sie erhalten eine Ausgangsspannung von 5V.

Schritt 8: Codierung

Sie müssen die folgenden Bibliotheken einschließen:

1)#includeKlicken Sie hier, um die Zip-Datei herunterzuladen

2)#includeKlicken Sie hier, um die Zip-Datei herunterzuladen

Nachdem Sie die Zip-Datei heruntergeladen haben, fügen Sie die Zip-Bibliothek in der Arduino-Skizze hinzu

Für Code

/*

DIY Gimbal - MPU6050 Arduino Tutorial Code basierend auf dem MPU6050_DMP6 Beispiel aus der i2cdevlib Bibliothek von Jeff Rowberg: https://github.com/jrowberg/i2cdevlib */ // I2Cdev und MPU6050 müssen als Bibliotheken installiert sein, sonst die.cpp/.h-Dateien // für beide Klassen müssen sich im Include-Pfad Ihres Projekts befinden #include "I2Cdev.h" #include "MPU6050_6Axis_MotionApps20.h" //#include "MPU6050.h" // nicht erforderlich bei Verwendung der MotionApps-Include-Datei / / Arduino Wire-Bibliothek ist erforderlich, wenn I2Cdev I2CDEV_ARDUINO_WIRE-Implementierung // in I2Cdev.h verwendet wird hier als Parameter übergeben // AD0 low = 0x68 (Standard für SparkFun Breakout und InvenSense Evaluation Board) // AD0 high = 0x69 MPU6050 mpu; // MPU6050 mpu (0x69); // <-- für AD0 High verwenden // Definieren Sie die 3 Servomotoren Servo servo0; Servoservo1; Servo-Servo2; Schwimmer richtig; intj = 0; #define OUTPUT_READABLE_YAWPITCHROLL #define INTERRUPT_PIN 2 // Pin 2 auf Arduino Uno und den meisten Boards verwenden bool blinkState = false; // MPU-Steuerung/Status vars bool dmpReady = false; // auf true setzen, wenn DMP-Init erfolgreich war uint8_t mpuIntStatus; // hält das aktuelle Interrupt-Statusbyte von 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 Bytes, die sich derzeit im FIFO befinden uint8_t fifoBuffer[64]; // FIFO-Speicherpuffer // Orientierung/Bewegung vars Quaternion q; // [w, x, y, z] Quaternion-Container VectorInt16 aa; // [x, y, z] Beschleunigungssensormessungen VectorInt16 aaReal; // [x, y, z] schwerkraftfreie Beschleunigungssensormessungen VectorInt16 aaWorld; // [x, y, z] Weltbild-Beschleunigungssensormessungen VectorFloat Gravitation; // [x, y, z] Schwerkraftvektor float euler[3]; // [psi, theta, phi] Euler-Winkelcontainer float ypr[3]; // [Gieren, Nicken, Rollen] Gieren/Neigen/Rollen-Container und Gravitationsvektor // Paketstruktur für InvenSense-Teekannen-Demo uint8_t teapotPacket[14] = { '$', 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0x00, 0x00, '\r', '\n' }; // =============================================== ================ // === UNTERBRECHUNGSERKENNUNGSROUTINE === // ===================== ========================================== volatile bool mpuInterrupt = false; // zeigt an, ob der MPU-Interrupt-Pin hoch gegangen ist void dmpDataReady () { mpuInterrupt = true; } // ============================================== ================= // === ERSTEINRICHTUNG === // ===================== ========================================== Void setup () {// I2C-Bus beitreten (die I2Cdev-Bibliothek macht dies nicht automatisch) #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE Wire.begin(); Wire.setClock(400000); // 400kHz I2C-Takt. Kommentieren Sie diese Zeile, wenn Sie Schwierigkeiten beim Kompilieren haben #elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE Fastwire::setup(400, true); #endif // Initialisieren der seriellen Kommunikation // (115200 ausgewählt, weil es für die Ausgabe der Teapot-Demo erforderlich ist, aber es liegt // wirklich an Ihnen, abhängig von Ihrem Projekt) Serial.begin(38400); while (!Seriell); // auf Leonardo-Aufzählung warten, andere fahren sofort fort // Gerät initialisieren //Serial.println(F("Initializing I2C devices…")); mpu.initialize(); pinMode (INTERRUPT_PIN, INPUT); devStatus = mpu.dmpInitialize(); // Geben Sie hier Ihre eigenen Gyro-Offsets an, skaliert für die minimale Empfindlichkeit mpu.setXGyroOffset (17); mpu.setYGyroOffset(-69); mpu.setZGyroOffset(27); mpu.setZAccelOffset(1551); // 1688 Werkseinstellung für meinen Testchip // Stellen Sie sicher, dass es funktioniert (gibt 0 zurück, wenn ja) if (devStatus == 0) {// schalten Sie den DMP ein, jetzt, da er bereit ist // Serial.println (F ("Aktivieren") DMP…")); mpu.setDMPEnabled(true); attachInterrupt(digitalPinToInterrupt(INTERRUPT_PIN), dmpDataReady, RISING); mpuIntStatus = mpu.getIntStatus(); // Setzen Sie unser DMP-Ready-Flag, damit die Hauptfunktion loop() weiß, dass es in Ordnung ist, es zu verwenden //Serial.println(F("DMP ready! Waiting for first Interrupt…")); dmpReady = wahr; // Erwartete DMP-Paketgröße für späteren Vergleich abrufen packetSize = mpu.dmpGetFIFOPacketSize(); } else { // FEHLER! // 1 = anfängliches Laden des Speichers fehlgeschlagen // 2 = DMP-Konfigurationsaktualisierungen fehlgeschlagen // (wenn es kaputt geht, ist der Code normalerweise 1) // Serial.print (F ("DMP-Initialisierung fehlgeschlagen (code")); //Serial.print(devStatus); //Serial.println(F(")")); } // Definieren Sie die Pins, an die die 3 Servomotoren angeschlossen sind servo0.attach (10); servo1.attach(9); servo2.attach(8); } // ============================================= ================= // === HAUPTPROGRAMMSCHLEIFE === // ==================== =========================================== Leere Schleife () {/ / Wenn die Programmierung fehlgeschlagen ist, versuchen Sie nichts zu tun if (!dmpReady) return; // auf MPU-Interrupt oder zusätzliche Pakete warten, die verfügbar sind while (!mpuInterrupt && fifoCount < packetSize) { if (mpuInterrupt && fifoCount

= 1024) {

// zurücksetzen, damit wir sauber weitermachen können mpu.resetFIFO(); fifoCount = mpu.getFIFOCount(); Serial.println (F ("FIFO-Überlauf!")); // andernfalls auf DMP-Daten-Ready-Interrupt prüfen (dies sollte häufig vorkommen) } else if (mpuIntStatus & _BV(MPU6050_INTERRUPT_DMP_INT_BIT)) { // auf korrekte verfügbare Datenlänge warten, sollte eine SEHR kurze Wartezeit sein, während (fifoCount 1 Paket verfügbar / / (damit können wir sofort weiterlesen, ohne auf einen Interrupt zu warten) fifoCount -= packetSize; // Werte für Yaw, Pitch und Roll abrufen #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 (Selbstkalibrierungsprozess) if (j <= 300) { korrekt = ypr[0]; // Gier beginnt bei zufälligem Wert, also wir Letzten Wert nach 300 Messwerten erfassen j++; } // Nach 300 Messwerten else { ypr[0] = ypr[0] - richtig; // Setze den Gier auf 0 Grad - subtrahiere den letzten zufälligen Gierwert vom aktuellen Wert, um den Gier 0 Grad es // Die Werte des MPU6050-Sensors von -90 bis 90 auf für die Servosteuerung geeignete Werte von 0 bis 180 abbilden 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); // Steuern Sie die Servos gemäß der MPU6050-Orientierung servo0.write (servo0Value); servo1.write (servo1Value); servo2.write (servo2Value); } #endif } }

Mit der Schreibfunktion senden wir diese Werte schließlich als Steuersignale an die Servos. Natürlich können Sie das Yaw-Servo deaktivieren, wenn Sie nur die X- und Y-Achse stabilisieren möchten, und diese Plattform als Kamera-Gimbal verwenden

Schritt 9: Wenn alle Komponenten verbunden sind, sieht es ähnlich aus wie dieses Bild

Schritt 10: Fügen Sie nun alle Basismaterialien in die Lebensmitteldose ein

Schritt 11: Wenn alle Drähte und Komponenten in einer Lebensmitteldose platziert sind, wird eine Klebepistole an der Basis der Schaumstoffplatte angebracht

Schritt 12: Fazit

Bitte beachten Sie, dass dies alles andere als ein guter Kamera-Gimbal ist. Die Bewegungen sind nicht glatt, da diese Servos nicht für einen solchen Zweck gedacht sind. Echte Kamera-Gimbals verwenden einen speziellen BLDC-Motor für reibungslose Bewegungen. Betrachten Sie dieses Projekt also nur zu Bildungszwecken.

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 Projektsammlungen zu überprüfen