Gimbal de control al mișcării: 12 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:41

Bună ziua tuturor, mă numesc Harji Nagi. În prezent sunt student în anul II care studiază electronică și inginerie de comunicare de la Pranveer Singh Institute Of Technology, Kanpur (UP). Am un interes deosebit pentru robotică, arduino, inteligență artificială și electronică analogică.

Cuvântul „gimbal” este definit ca un suport pivotat care permite rotația oricărui obiect într-o singură axă. Deci, un cardan cu trei axe permite oricărui obiect montat pe cardan să fie independent de mișcarea celui care ține cardanul. Gimbalul dictează mișcarea obiectului, nu cel care îl poartă.

Este format din 3 servo-motoare MG996R pentru controlul pe 3 axe și o bază pe care vor fi așezați senzorul MPU6050, Arduino și bateria. Este folosit pentru a menține camera stabilizată fără vibrații. Un cardan cu 3 axe asigură stabilizarea mișcării camerei chiar dacă cel care o ține merge în sus și în jos, la stânga și la dreapta, în față și în spate. Aceasta este ceea ce ne referim ca stabilizare de gălăgie, înălțime și rulare.

Pasul 1: Lista componentelor

Lista componentelor este:

1) Arduino Uno

2) Baterie de 8V, 1,5 Amp pentru alimentarea Arduino Uno

3) 7805 Regulator de tensiune Ic sau puteți utiliza conveterul buck

4) MPU 6050

5) 3 * (MG995 SERVO Motors)

6) Jumper Wires

Alte echipamente:

1) Fier de lipit

2) Pistol de lipit

3) Mașină de găurit

4) Conserve alimentare

În loc să folosesc breadborad, am folosit o placă de perfecționare mică pentru conexiunea pozitivă și negativă a autobuzului

Pasul 2: Asamblarea

Foamcore, placă de spumă sau placă de spumă cu față de hârtie este un material ușor și ușor de tăiat, utilizat pentru montarea servomotorului și pentru realizarea modelelor la scară mică.

În primul rând, am realizat un suport DIY în formă de L pentru a monta servomotorul cu ajutorul unei plăci de spumă.

Pasul 3:

Asamblarea cardanului a fost destul de ușoară. Am început cu instalarea servo-ului Yaw, a senzorului MPU 6050 și a comutatorului ON-OFF. Folosind șuruburi și piulițe, am fixat-o pe bază

Pasul 4: Apoi, folosind aceeași metodă, am securizat Roll Servo. piesele sunt proiectate special pentru a se potrivi cu ușurință la servoanele MG995

Pasul 5: Apoi, folosind aceeași metodă, am securizat Roll Servo. piesele sunt proiectate special pentru a se potrivi cu ușurință la servoanele MG995

Pasul 6: Conexiuni

În schema de circuite puteți utiliza fie convertorul buck, fie regulatorul de tensiune 7805 IC pentru a converti 8V la 5 V. Microcontrolerul care este dat schemei de circuite este Arduino Nano, puteți utiliza și Arduino Uno, Arduino Mega.

Pinii SCL și SDA ai MPU 6050 sunt conectați la pinii analogici A5 și A4 Arduino (pinii SCL și SDA pot varia, deci consultați fișa tehnică pentru pinii SCl și SDA pentru alte microcontrolere)

Pasul 7: Conexiune cu regulatorul de tensiune 7805 IC

Această schemă de circuit este pentru conectarea regulatorului de tensiune 7805 ic, conectați bateria de 8v la Vin și veți obține o tensiune de ieșire de 5v.

Pasul 8: Codificare

Trebuie să includeți următoarele biblioteci:

1) #includeFă clic pentru a descărca fișierul zip

2) #include Faceți clic aici pentru a descărca fișierul zip

După descărcarea fișierului zip, adăugați biblioteca zip în schița arduino

Pentru Cod

/*

DIY Gimbal - Codul tutorial MPU6050 Arduino bazat pe exemplul MPU6050_DMP6 din biblioteca i2cdevlib de Jeff Rowberg: https://github.com/jrowberg/i2cdevlib * / // I2Cdev și MPU6050 trebuie să fie instalate ca biblioteci sau altfel.cpp / fișierele.h // pentru ambele clase trebuie să se afle în calea include a proiectului dvs. #include "I2Cdev.h" #include "MPU6050_6Axis_MotionApps20.h" // # include "MPU6050.h" // nu este necesar dacă se utilizează MotionApps include file / / Biblioteca Arduino Wire este necesară dacă I2Cdev I2CDEV_ARDUINO_WIRE implementarea // este utilizată în I2Cdev.h #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE #includeți "Wire.h" #endif #include // clasa implicită Adresa I2C este 0x68 // Adrese I2C specifice pot fi trecut ca parametru aici // AD0 low = 0x68 (implicit pentru SparkFun breakout și placa de evaluare InvenSense) // AD0 high = 0x69 MPU6050 mpu; // MPU6050 mpu (0x69); // <- utilizați pentru AD0 high // Definiți cele 3 servo-motoare Servo servo0; Servo servo1; Servo servo2; float corect; int j = 0; #define OUTPUT_READABLE_YAWPITCHROLL #define INTERRUPT_PIN 2 // utilizați pinul 2 pe Arduino Uno și majoritatea plăcilor bool blinkState = false; // MPU control / status vars bool dmpReady = false; // setați true dacă inițierea DMP a avut succes uint8_t mpuIntStatus; // deține octetul actual de stare de întrerupere de la MPU uint8_t devStatus; // returnează starea după fiecare operație a dispozitivului (0 = succes,! 0 = eroare) uint16_t pachet Dimensiune; // dimensiunea așteptată a pachetului DMP (implicit este de 42 de octeți) uint16_t fifoCount; // numărul tuturor octeților aflați în prezent în FIFO uint8_t fifoBuffer [64]; // Buffer de stocare FIFO // orientare / mișcare var Quaternion q; // [w, x, y, z] container cuaternar VectorInt16 aa; // [x, y, z] măsurători senzor accel VectorInt16 aaReal; // [x, y, z] măsurătorile senzorului de accel fără gravitație VectorInt16 aaWorld; // [x, y, z] măsurători senzor accelerare cadru-lume VectorFloat gravity; // [x, y, z] vector gravitațional floare euler [3]; // [psi, theta, phi] Euler angle container float ypr [3]; // [yaw, pitch, roll] yaw / pitch / roll container și gravity vector // structura pachetelor pentru demonstrația ceainicului InvenSense uint8_t teapotPacket [14] = {'$', 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0x00, 0x00, '\ r', '\ n'}; // ================================================= ================ // === RUTINA DE DETECTARE A INTERRUPȚIEI === // ===================== =========================================== volatile bool mpuInterrupt = false; // indică dacă pinul de întrerupere a MPU a scăzut ridicat dmpDataReady () {mpuInterrupt = true; } // ================================================ ================= // === INITIAL SETUP === // ====================== ========================================== void setup () {// alăturați-vă autobuzului I2C (biblioteca I2Cdev nu face acest lucru automat) #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE Wire.begin (); Wire.setClock (400000); // Ceas I2C 400kHz. Comentează această linie dacă ai dificultăți de compilare #elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE Fastwire:: setup (400, true); #endif // inițializează comunicarea în serie // (115200 ales pentru că este necesar pentru ieșirea Teapot Demo, dar // depinde de tine în funcție de proiectul tău) Serial.begin (38400); while (! Serial); // așteptați enumerarea Leonardo, alții continuă imediat // inițializați dispozitivul //Serial.println(F("Initializarea dispozitivelor I2C … ")); mpu.initialize (); pinMode (INTERRUPT_PIN, INPUT); devStatus = mpu.dmpInitialize (); // furnizați aici propriile dvs. compensări giroscopice, scalate pentru sensibilitate minimă mpu.setXGyroOffset (17); mpu.setYGyroOffset (-69); mpu.setZGyroOffset (27); mpu.setZAccelOffset (1551); // 1688 implicit din fabrică pentru cipul meu de testare // asigurați-vă că a funcționat (returnează 0 dacă da) dacă (devStatus == 0) {// porniți DMP, acum că este gata // Serial.println (F ("Activare DMP … ")); mpu.setDMPEnabled (adevărat); attachInterrupt (digitalPinToInterrupt (INTERRUPT_PIN), dmpDataReady, RISING); mpuIntStatus = mpu.getIntStatus (); // setați semnalul DMP Ready astfel încât funcția buclă principală () să știe că este în regulă să o utilizați //Serial.println(F("DMP ready! Se așteaptă prima întrerupere … ")); dmpReady = adevărat; // obțineți dimensiunea așteptată a pachetului DMP pentru o comparație ulterioară packetSize = mpu.dmpGetFIFOPacketSize (); } altfel {// EROARE! // 1 = încărcarea inițială a memoriei a eșuat // 2 = actualizările de configurare DMP au eșuat // (dacă se va sparge, de obicei codul va fi 1) // Serial.print (F ("Inițializarea DMP a eșuat (cod")); //Serial.print(devStatus); //Serial.println (F (")")); } // Definiți pinii la care sunt conectate cele 3 servomotoare servo0.attach (10); servo1.attach (9); servo2.attach (8); } // ================================================ ================= // === BUCLĂ PROGRAM PRINCIPAL === // ==================== ============================================ bucla nulă () {/ / dacă programarea a eșuat, nu încercați să faceți nimic dacă (! dmpReady) revine; // așteptați întreruperea MPU sau pachetele suplimentare disponibile în timp ce (! mpuInterrupt && fifoCount <packetSize) {if (mpuInterrupt && fifoCount

= 1024) {

// reset pentru a putea continua curat mpu.resetFIFO (); fifoCount = mpu.getFIFOCount (); Serial.println (F ("FIFO overflow!")); // în caz contrar, verificați dacă există o întrerupere gata de date DMP (acest lucru ar trebui să se întâmple frecvent)} altfel dacă (mpuIntStatus & _BV (MPU6050_INTERRUPT_DMP_INT_BIT)) {// așteptați lungimea corectă a datelor disponibile, ar trebui să fie o AȘTEPTARE foarte scurtă în timp ce (fifoCount 1 pachet disponibil / / (acest lucru ne permite să citim imediat mai multe fără a aștepta o întrerupere) fifoCount - = packetSize; // Obține valorile Yaw, Pitch and Roll #ifdef OUTPUT_READABLE_YAWPITCHROLL mpu.dmpGetQuaternion (& q, fifoBuffer); mpu.dmpGetGravity (& gravity, & q); mpu.dmpGetYawPitchRoll (ypr, & q, & gravity); // Valori Yaw, Pitch, Roll - Radiani în grade ypr [0] = ypr [0] * 180 / M_PI; ypr [1] = ypr [1] * 180 / M_PI; ypr [2] = ypr [2] * 180 / M_PI; // Treceți peste 300 de citiri (proces de autocalibrare) dacă (j <= 300) {corect = ypr [0]; // Yaw începe la o valoare aleatorie, deci captează ultima valoare după 300 de lecturi j ++;} // După 300 de lecturi else {ypr [0] = ypr [0] - corect; // Setați Yaw la 0 deg - scădeți ultima valoare aleatorie Yaw din valoarea curentului pentru a face Yaw 0 grade es // Mapează valorile senzorului MPU6050 de la -90 la 90 la valorile care pot fi utilizate pentru controlul servo de la 0 la 180 int servo0Value = map (ypr [0], -90, 90, 0, 180); int servo1Value = hartă (ypr [1], -90, 90, 0, 180); int servo2Value = hartă (ypr [2], -90, 90, 180, 0); // Controlați servo-urile conform orientării MPU6050 servo0.write (servo0Value); servo1.write (servo1Value); servo2.write (servo2Value); } #endif}}

În cele din urmă folosind funcția de scriere, trimitem aceste valori către servouri ca semnale de control. Desigur, puteți dezactiva servo Yaw dacă doriți doar stabilizare pentru axele X și Y și puteți utiliza această platformă ca cardan pentru cameră

Pasul 9: Când toate componentele sunt conectate, arată similar cu această imagine

Pasul 10: Introduceți acum toate lucrurile de bază în interiorul cutiei pentru alimente

Pasul 11: Când toate firele și componentele sunt plasate în interiorul unui aliment, atunci se poate aplica pistol de lipit la baza plăcii de spumă

Pasul 12: Concluzie

Vă rugăm să rețineți acest lucru departe de cardanul bun al camerei. Mișcările nu sunt netede, deoarece aceste servouri nu sunt destinate unui astfel de scop. Cardanele reale ale camerei utilizează un tip special de motor BLDC pentru a obține mișcări fine. Deci, luați în considerare acest proiect numai în scop educativ.

Asta ar fi totul pentru acest tutorial, sper că ți-a plăcut și ai învățat ceva nou. Nu ezitați să puneți orice întrebare în secțiunea de comentarii de mai jos și nu uitați să verificați colecțiile mele de proiecte