Cardan de control de moviment: 12 passos

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:11

Hola a tothom, em dic Harji Nagi. Actualment sóc estudiant de segon any que estudia enginyeria electrònica i de comunicacions a l’Institut de Tecnologia Pranveer Singh de Kanpur (UP). Tinc un gran interès per la robòtica, l’arduino, la intel·ligència artificial i l’electrònica analògica.

La paraula "cardan" es defineix com un suport pivotat que permet la rotació de qualsevol objecte en un únic eix. Per tant, un cardà de tres eixos permet que qualsevol objecte muntat al cardà sigui independent del moviment del que el sosté. El cardà dicta el moviment de l'objecte, no el que el porta.

Consta de 3 servomotors MG996R per al control de 3 eixos i una base sobre la qual es col·locaran el sensor MPU6050, l’Arduino i la bateria. S’utilitza per mantenir la càmera estabilitzada sense vibracions. Un cardà de 3 eixos garanteix que el moviment de la càmera s’estabilitzi fins i tot si el que la sosté puja i baixa, esquerra i dreta, davant i darrere. Això és el que anomenem estabilització de desviació, alçada i rotació.

Pas 1: llista de components

La llista de components són:

1) Arduino Uno

2) Bateria de 8 V, 1,5 A per alimentar Arduino Uno

3) 7805 Regulador de voltatge Ic o podeu fer servir el convertidor de buck

4) MPU 6050

5) 3 * (MG995 SERVO Motors)

6) cables de pont

Altres equipaments:

1) Soldador

2) Pistola de cola

3) Màquina de trepar

4) Llauna alimentària

En lloc d'utilitzar breadborad, he utilitzat una petita placa de perfeccionament per a la connexió positiva i negativa del bus

Pas 2: Muntatge

El Foamcore, el tauler d’escuma o el tauler d’escuma amb cara de paper és un material lleuger i fàcil de tallar que s’utilitza per muntar servomotors i per fabricar maquetes.

En primer lloc, vaig fabricar uns suports DIY en forma de L per muntar el servomotor amb l'ajut d'un tauler d'escuma.

Pas 3:

Muntar el cardà va ser molt fàcil. Vaig començar instal·lant el servo Yaw, el sensor MPU 6050 i l’interruptor ON-OFF. Amb cargols i femelles el vaig fixar a la base

Pas 4: A continuació, fent servir el mateix mètode, vaig assegurar el roll Servo. les peces estan dissenyades específicament per adaptar-se fàcilment als servidors MG995

Pas 5: A continuació, usant el mateix mètode, vaig assegurar el Servo Roll. les peces estan dissenyades específicament per adaptar-se fàcilment als servidors MG995

Pas 6: connexions

Al diagrama de circuits podeu utilitzar un convertidor de buck o un regulador de voltatge IC 7805 per convertir 8V a 5 V. El microcontrolador al qual es dóna el diagrama de circuits és Arduino Nano. També podeu utilitzar Arduino Uno, Arduino Mega.

Els pins SCL i SDA de MPU 6050 estan connectats als pins A5 i A4 analògics Arduino (els pins SCL i SDA poden variar, així que consulteu el full de dades dels pins SCl i SDA per a altres microcontroladors)

Pas 7: connexió amb el regulador de voltatge IC 7805

Aquest diagrama de circuit és per a la connexió del regulador de voltatge ic 7805, connecteu la bateria de 8v a Vin i obtindreu un voltatge de sortida de 5v.

Pas 8: Codificació

Heu d'incloure les biblioteques següents:

1) #includeClick Aquí per descarregar el fitxer zip

2) #include Feu clic aquí per descarregar el fitxer zip

Després de descarregar el fitxer zip, afegiu la biblioteca zip a l'esbós arduino

Per a Codi

/*

DIY Gimbal - Codi tutorial MPU6050 Arduino basat en l'exemple MPU6050_DMP6 de la biblioteca i2cdevlib de Jeff Rowberg: https://github.com/jrowberg/i2cdevlib * / // I2Cdev i MPU6050 s'han d'instal·lar com a biblioteques, o bé, el.cpp / Els fitxers.h // per a les dues classes han d’estar al camí d’inclusió del vostre projecte #include "I2Cdev.h" #include "MPU6050_6Axis_MotionApps20.h" // # include "MPU6050.h" // no és necessari si feu servir MotionApps include file / / La biblioteca Arduino Wire és necessària si la implementació I2Cdev I2CDEV_ARDUINO_WIRE // s’utilitza a I2Cdev.h #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE #include "Wire.h" #endif #include // L'adreça I2C per defecte de la classe és 0x68 // adreces I2C específiques passat com a paràmetre aquí // AD0 baixa = 0x68 (per defecte per SparkFun breakout i la placa d’avaluació d’InvenSense) // AD0 alta = 0x69 MPU6050 mpu; // MPU6050 mpu (0x69); // <- utilitzar per AD0 alta // Definiu els 3 servomotors Servo servo0; Servo servo1; Servo servo2; flotador correcte; int j = 0; #define OUTPUT_READABLE_YAWPITCHROLL #define INTERRUPT_PIN 2 // utilitzeu el pin 2 a Arduino Uno i la majoria de taules bool blinkState = false; // MPU control / status vars bool dmpReady = false; // defineix true si DMP init va tenir èxit uint8_t mpuIntStatus; // manté el byte d'estat de la interrupció real de la MPU uint8_t devStatus; // torna l'estat després de cada operació del dispositiu (0 = èxit,! 0 = error) uint16_t paquetSize; // mida prevista del paquet DMP (per defecte és de 42 bytes) uint16_t fifoCount; // recompte de tots els bytes actualment a FIFO uint8_t fifoBuffer [64]; // Buffer d’emmagatzematge FIFO // orientació / moviment vars Quaternion q; // [w, x, y, z] contenidor de quaternió VectorInt16 aa; // [x, y, z] accel sensor mesures VectorInt16 aaReal; // [x, y, z] mesures de sensor d'accel sense gravetat VectorInt16 aaWorld; // [x, y, z] mesures del sensor d’acceleració de fotograma mundial gravetat VectorFloat; // [x, y, z] vector de gravetat float euler [3]; // [psi, theta, phi] Euler angle container float ypr [3]; // [yaw, pitch, roll] yaw / pitch / roll container i gravity vector // estructura de paquets per a la demostració de tetera InvenSense uint8_t teapotPacket [14] = {'$', 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0x00, 0x00, '\ r', '\ n'}; // ================================================= ================ // === RUTINA DE DETECCIÓ DE LA INTERRUPCIÓ === // ===================== ========================================== bool volàtil mpuInterrupt = false; // indica si el pin d'interrupció de la MPU s'ha anotat alt void dmpDataReady () {mpuInterrupt = true; } // ================================================ ================= // === CONFIGURACIÓ INICIAL === // ====================== =========================================== void setup () {// uniu-vos al bus I2C (la biblioteca I2Cdev no ho fa automàticament) #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE Wire.begin (); Wire.setClock (400000); // Rellotge I2C de 400 kHz. Comenteu aquesta línia si teniu dificultats de compilació #elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE Fastwire:: setup (400, true); #endif // inicialitza la comunicació en sèrie // (escollit 115200 perquè és necessari per a la sortida de demostració de Teapot, però // depèn del vostre projecte) Serial.begin (38400); mentre que (! sèrie); // espera l'enumeració de Leonardo, altres continuen immediatament // inicialitza el dispositiu //Serial.println(F("Inicialitzar els dispositius I2C … ")); mpu.initialize (); pinMode (INTERRUPT_PIN, INPUT); devStatus = mpu.dmpInitialize (); // proporcioneu aquí les vostres pròpies compensacions giroscòpiques, ajustades per a la sensibilitat mínima mpu.setXGyroOffset (17); mpu.setYGyroOffset (-69); mpu.setZGyroOffset (27); mpu.setZAccelOffset (1551); // 1688 per defecte de fàbrica per al meu xip de prova // assegureu-vos que funcionés (retorna 0 si és així) si (devStatus == 0) {// activeu el DMP, ara que està llest // Serial.println (F ("Activació DMP … ")); mpu.setDMPEnabled (cert); attachInterrupt (digitalPinToInterrupt (INTERRUPT_PIN), dmpDataReady, RISING); mpuIntStatus = mpu.getIntStatus (); // configureu el nostre indicador DMP Ready perquè la funció loop principal () sàpiga que està bé utilitzar-la //Serial.println(F("DMP ready! Esperant la primera interrupció … ")); dmpReady = cert; // obtenir la mida esperada del paquet DMP per a una comparació posterior packetSize = mpu.dmpGetFIFOPacketSize (); } else {// ERROR! // 1 = ha fallat la càrrega inicial de la memòria // 2 = ha fallat l'actualització de la configuració de DMP // (si es trencarà, normalment el codi serà 1) // Serial.print (F ("La inicialització de DMP ha fallat (codi")); //Serial.print(devStatus); //Serial.println (F (")")); } // Definiu els pins als quals estan connectats els 3 servomotors servo0.attach (10); servo1.attach (9); servo2.attach (8); } // ================================================ ================= // === LOOP DEL PROGRAMA PRINCIPAL === // ==================== ============================================ bucle buit () {/ / si la programació ha fallat, no intenteu fer res si (! dmpReady) torna; // espereu la interrupció de la MPU o els paquets addicionals disponibles mentre (! mpuInterrupt && fifoCount <packetSize) {if (mpuInterrupt && fifoCount

= 1024) {

// restableix perquè puguem continuar netament mpu.resetFIFO (); fifoCount = mpu.getFIFOCount (); Serial.println (F ("FIFO overflow!")); // en cas contrari, comproveu si hi ha una interrupció a punt de dades DMP (això hauria de passar amb freqüència)} else if (mpuIntStatus & _BV (MPU6050_INTERRUPT_DMP_INT_BIT)) {// espereu la durada correcta de les dades disponibles, hauria de ser MOLT curta espera mentre (fifoCount 1 paquet disponible / / (això ens permet llegir més immediatament sense esperar una interrupció) fifoCount - = packetSize; // Obtenir valors Yaw, Pitch and Roll #ifdef OUTPUT_READABLE_YAWPITCHROLL mpu.dmpGetQuaternion (& q, fifoBuffer); mpu.dmpGetGravity (& gravity, & q); mpu.dmpGetYawPitchRoll (ypr, & q, & gravity); // Valors Yaw, Pitch, Roll - Radians a graus ypr [0] = ypr [0] * 180 / M_PI; ypr [1] = ypr [1] * 180 / M_PI; ypr [2] = ypr [2] * 180 / M_PI; // Omet 300 lectures (procés d’autocalibratge) si (j <= 300) {correcte = ypr [0]; // Yaw comença al valor aleatori, de manera que captura el darrer valor després de 300 lectures j ++;} // Després de 300 lectures else {ypr [0] = ypr [0] - correcte; // Estableix el Yaw a 0 ° - resta l’últim valor de Yaw aleatori del valor actual per fer el Yaw 0 graus es // Assigneu els valors del sensor MPU6050 de -90 a 90 a valors adequats per al control de servo de 0 a 180 int servo0Value = map (ypr [0], -90, 90, 0, 180); int servo1Value = map (ypr [1], -90, 90, 0, 180); int servo2Value = mapa (ypr [2], -90, 90, 180, 0); // Controleu els servos segons l'orientació MPU6050 servo0.write (servo0Value); servo1.write (servo1Value); servo2.write (servo2Value); } #endif}}

Finalment, mitjançant la funció d’escriptura, enviem aquests valors als servos com a senyals de control. Per descomptat, podeu desactivar el servo Yaw si voleu només estabilitzar els eixos X i Y i utilitzar aquesta plataforma com a cardan de la càmera

Pas 9: quan tots els components estiguin connectats, té un aspecte similar a aquesta imatge

Pas 10: ara introduïu totes les coses bàsiques dins de la llauna d'aliments

Pas 11: Quan es col·loquen tots els cables i components dins d'un aliment, es pot aplicar una pistola de cola a la base del tauler d'escuma

Pas 12: Conclusió

Tingueu en compte que no és un bon cardanal de la càmera. Els moviments no són suaus perquè aquests servos no estan pensats per a tal propòsit. Els cardans de càmera reals utilitzen un tipus especial de motor BLDC per aconseguir moviments suaus. Per tant, tingueu en compte aquest projecte només amb finalitats educatives.

Això seria tot per a aquest tutorial, espero que us hagi agradat i hàgiu après alguna cosa nova. No dubteu a fer qualsevol pregunta a la secció de comentaris que hi ha a continuació i no oblideu consultar les meves col·leccions de projectes