Gimbal per il controllo del movimento: 12 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:00

Ciao a tutti, mi chiamo Harji Nagi. Attualmente sono uno studente del secondo anno che studia elettronica e ingegneria della comunicazione presso il Pranveer Singh Institute Of Technology, Kanpur (UP). Ho un vivo interesse per la robotica, arduino, l'intelligenza artificiale e l'elettronica analogica.

La parola "gimbal" è definita come un supporto imperniato che consente la rotazione di qualsiasi oggetto in un unico asse. Quindi un gimbal a tre assi consente a qualsiasi oggetto montato sul gimbal di essere indipendente dal movimento di chi tiene il gimbal. Il gimbal detta il movimento dell'oggetto, non quello che lo trasporta.

Si compone di 3 servomotori MG996R per il controllo a 3 assi, e una base su cui verranno posizionati il sensore MPU6050, l'Arduino e la batteria. Serve per mantenere la telecamera stabilizzata senza vibrazioni. Un gimbal a 3 assi assicura che il movimento della fotocamera sia stabilizzato anche se chi la tiene sta andando su e giù, sinistra e destra, davanti e dietro. Questo è ciò che chiamiamo stabilizzazione di imbardata, beccheggio e rollio.

Passaggio 1: elenco dei componenti

L'elenco dei componenti sono:

1) Arduino Uno

2) Batteria 8V, 1,5 Amp per alimentare Arduino Uno

3) 7805 Regolatore di tensione Ic oppure puoi usare buck conveter

4)MPU 6050

5)3*(Motori SERVO MG995)

6) Cavi per ponticelli

Altre attrezzature:

1) Saldatore

2) Pistola per colla

3) Trapano

4)Il cibo può

Invece di usare breadborad, ho usato una piccola scheda perf coustom per la connessione bus positiva e negativa

Passaggio 2: assemblaggio

Foamcore, pannello in schiuma o pannello in schiuma con rivestimento in carta è un materiale leggero e facilmente tagliabile utilizzato per il montaggio del servomotore e per la realizzazione di modelli in scala.

Per prima cosa ho realizzato una staffa a forma di L fai-da-te per montare il servomotore con l'aiuto di un pannello di gommapiuma.

Passaggio 3:

Il montaggio del gimbal è stato abbastanza semplice. Ho iniziato con l'installazione del servo Yaw, del sensore MPU 6050 e dell'interruttore ON-OFF. Usando bulloni e dadi l'ho fissato alla base

Passaggio 4: quindi, utilizzando lo stesso metodo, ho fissato il servo del rullo. le parti sono specificamente progettate per adattarsi facilmente ai servi MG995

Passaggio 5: quindi, utilizzando lo stesso metodo, ho fissato il servo del rullo. le parti sono specificamente progettate per adattarsi facilmente ai servi MG995

Passaggio 6: connessioni

Nello schema del circuito è possibile utilizzare il convertitore buck o il regolatore di tensione 7805 IC per convertire da 8 V a 5 V. Il microcontrollore a cui viene fornito lo schema del circuito è Arduino Nano, è inoltre possibile utilizzare Arduino Uno, Arduino Mega.

I pin SCL e SDA dell'MPU 6050 sono collegati al pin analogico Arduino A5 e A4. (I pin SCL e SDA possono variare, quindi controlla la scheda tecnica per i pin SCl e SDA per altri microcontrollori)

Passaggio 7: collegamento con il regolatore di tensione 7805 IC

Questo schema elettrico è per il collegamento del regolatore di tensione 7805 ic, collega la batteria da 8v a Vin e otterrai una tensione di uscita di 5v.

Passaggio 8: codifica

È necessario includere le seguenti librerie:

1)#includeClicca qui per scaricare il file zip

2)#includeClicca qui per scaricare il file zip

Dopo aver scaricato il file zip, aggiungi la libreria zip in arduino sketch

Per il codice

/*

Gimbal fai da te - MPU6050 Arduino Tutorial Codice basato sull'esempio MPU6050_DMP6 dalla libreria i2cdevlib di Jeff Rowberg: https://github.com/jrowberg/i2cdevlib */ // I2Cdev e MPU6050 devono essere installati come librerie, altrimenti il .cpp/ I file.h // per entrambe le classi devono trovarsi nel percorso di inclusione del progetto #include "I2Cdev.h" #include "MPU6050_6Axis_MotionApps20.h" //#include "MPU6050.h" // non necessario se si utilizza il file di inclusione di MotionApps / / La libreria Arduino Wire è necessaria se l'implementazione I2Cdev I2CDEV_ARDUINO_WIRE // è utilizzata in I2Cdev.h #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE #include "Wire.h" #endif #include // L'indirizzo I2C predefinito della classe è 0x68 // possono essere specifici indirizzi I2C passato come parametro qui // AD0 basso = 0x68 (predefinito per breakout SparkFun e scheda di valutazione InvenSense) // AD0 alto = 0x69 MPU6050 mpu; //MPU6050 mpu(0x69); // <-- use for AD0 high // Definisce i 3 servomotori Servo servo0; Servo servo1; Servo servo2; galleggiante corretto; intj = 0; #define OUTPUT_READABLE_YAWPITCHROLL #define INTERRUPT_PIN 2 // usa il pin 2 su Arduino Uno e sulla maggior parte delle schede bool blinkState = false; // Controllo/stato MPU vars bool dmpReady = false; // imposta true se DMP init ha avuto successo uint8_t mpuIntStatus; // mantiene il byte di stato dell'interrupt effettivo dalla MPU uint8_t devStatus; // restituisce lo stato dopo ogni operazione del dispositivo (0 = successo, !0 = errore) uint16_t packetSize; // dimensione prevista del pacchetto DMP (il valore predefinito è 42 byte) uint16_t fifoCount; // conteggio di tutti i byte attualmente in FIFO uint8_t fifoBuffer[64]; // Buffer di memorizzazione FIFO // vars di orientamento/movimento Quaternion q; // [w, x, y, z] contenitore di quaternioni VectorInt16 aa; // [x, y, z] misurazioni del sensore di accelerazione VectorInt16 aaReal; // [x, y, z] misurazioni del sensore di accelerazione senza gravità VectorInt16 aaWorld; // [x, y, z] misurazioni del sensore di accelerazione world-frame VectorFloat gravità; // [x, y, z] vettore gravità float eulero[3]; // [psi, theta, phi] contenitore dell'angolo di Eulero float ypr[3]; // [yaw, pitch, roll] contenitore di imbardata/beccheggio/rotazione e vettore di gravità // struttura del pacchetto per la demo della teiera InvenSense uint8_t teapotPacket[14] = { '$', 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0x00, 0x00, '\r', '\n' }; // =============================================== ================ // === ROUTINE DI RILEVAMENTO INTERRUZIONI === // ===================== =========================================== volatile bool mpuInterrupt = false; // indica se il pin di interruzione MPU è andato alto void dmpDataReady() { mpuInterrupt = true; } // ============================================== ================= // === IMPOSTAZIONE INIZIALE === // ===================== =========================================== void setup() { // unisciti al bus I2C (la libreria I2Cdev non lo fa automaticamente) #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE Wire.begin(); Wire.setClock(400000); // Orologio I2C a 400kHz. Commenta questa riga se hai difficoltà di compilazione #elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE Fastwire::setup(400, true); #endif // inizializza la comunicazione seriale // (115200 scelto perché è richiesto per l'output di Teapot Demo, ma dipende // davvero da te a seconda del tuo progetto) Serial.begin(38400); mentre (!Seriale); // attendi l'enumerazione di Leonardo, gli altri continuano immediatamente // inizializza dispositivo //Serial.println(F("Inizializzazione dispositivi I2C…")); mpu.initialize(); pinMode(INTERRUPT_PIN, INPUT); devStatus = mpu.dmpInitialize(); // fornisci qui i tuoi offset giroscopici, scalati per la sensibilità minima mpu.setXGyroOffset(17); mpu.setYGyroOffset(-69); mpu.setZGyroOffset(27); mpu.setZAccelOffset(1551); // 1688 default di fabbrica per il mio chip di prova // assicurati che funzioni (restituisce 0 in caso affermativo) if (devStatus == 0) { // attiva il DMP, ora che è pronto // Serial.println(F("Abilitazione DMP…")); mpu.setDMPEnabled(true); attachInterrupt(digitalPinToInterrupt(INTERRUPT_PIN), dmpDataReady, RISING); mpuIntStatus = mpu.getIntStatus(); // imposta il nostro flag DMP Ready in modo che la funzione main loop() sappia che va bene usarla //Serial.println(F("DMP ready! Waiting for first interrupt…")); dmpReady = vero; // ottiene la dimensione del pacchetto DMP prevista per un confronto successivo packetSize = mpu.dmpGetFIFOPacketSize(); } else { // ERRORE! // 1 = caricamento della memoria iniziale non riuscito // 2 = aggiornamenti della configurazione DMP non riusciti // (se si interrompe, di solito il codice sarà 1) // Serial.print(F("Inizializzazione DMP non riuscita (codice ")); //Serial.print(devStatus); //Serial.println(F(")")); } // Definisce i pin a cui sono collegati i 3 servomotori servo0.attach(10); servo1.attach(9); servo2.attach(8); } // ============================================== ================= // === CICLO DEL PROGRAMMA PRINCIPALE === // ==================== ============================================ loop vuoto() { / / se la programmazione fallisce, non provare a fare nulla se (!dmpReady) ritorna; // attende l'interruzione MPU oi pacchetti aggiuntivi disponibili while (!mpuInterrupt && fifoCount < packetSize) { if (mpuInterrupt && fifoCount

= 1024) {

// resetta così possiamo continuare in modo pulito mpu.resetFIFO(); fifoCount = mpu.getFIFOCount(); Serial.println(F("Fifo overflow!")); // altrimenti, controlla l'interruzione di DMP data ready (questo dovrebbe accadere frequentemente) } else if (mpuIntStatus & _BV(MPU6050_INTERRUPT_DMP_INT_BIT)) { // attendi la corretta lunghezza dei dati disponibili, dovrebbe essere un'attesa MOLTO breve mentre (pacchetto fifoCount 1 disponibile / / (questo ci permette di leggere immediatamente di più senza aspettare un'interruzione) fifoCount -= packetSize; // Ottieni i valori di imbardata, beccheggio e rollio #ifdef OUTPUT_READABLE_YAWPITCHROLL mpu.dmpGetQuaternion(&q, fifoBuffer); mpu.dmpGetGravity(&gravity, &q); mpu.dmpGetYawPitchRoll(ypr, &q, &gravity); // Valori di imbardata, beccheggio, rollio - Radianti in gradi ypr[0] = ypr[0] * 180 / M_PI;ypr[1] = ypr[1] * 180 / M_PI; ypr[2] = ypr[2] * 180 / M_PI; // Salta 300 letture (processo di autocalibrazione) if (j <= 300) { corretto = ypr[0]; // L'imbardata inizia con un valore casuale, quindi cattura l'ultimo valore dopo 300 letture j++; } // Dopo 300 letture else { ypr[0] = ypr[0] - corretto; // Imposta l'imbardata a 0 gradi - sottrai l'ultimo valore casuale di imbardata dal valore corrente per rendere il Imbardata 0 gradi es // Mappa i valori del sensore MPU6050 da -90 a 90 a valori adatti al servocomando da 0 a 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); // Controlla i servi secondo l'orientamento dell'MPU6050 servo0.write(servo0Value); servo1.write(servo1Value); servo2.write(servo2Value); } #finisci se } }

Infine, utilizzando la funzione di scrittura, inviamo questi valori ai servi come segnali di controllo. Ovviamente, puoi disabilitare il servo Yaw se vuoi solo la stabilizzazione per gli assi X e Y e utilizzare questa piattaforma come gimbal della fotocamera

Passaggio 9: quando tutti i componenti sono collegati, il suo aspetto è simile a questa immagine

Passaggio 10: ora inserisci tutto il materiale base all'interno della lattina per alimenti

Passaggio 11: quando tutti i fili e i componenti sono posizionati all'interno di una lattina per alimenti, applicare la pistola per colla alla base del pannello di schiuma

Passaggio 12: Conclusione

Si prega di notare che questo è tutt'altro che un buon gimbal della fotocamera. I movimenti non sono fluidi perché questi servi non sono pensati per tale scopo. I gimbal per fotocamere reali utilizzano un tipo speciale di motore BLDC per ottenere movimenti fluidi. Quindi, considera questo progetto solo a scopo educativo.

Questo sarebbe tutto per questo tutorial, spero che ti sia piaciuto e che abbia imparato qualcosa di nuovo. Sentiti libero di fare qualsiasi domanda nella sezione commenti qui sotto e non dimenticare di controllare le mie raccolte di progetti