Gimbal de control de movimiento: 12 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:40

Hola a todos, Mi nombre es Harji Nagi. Actualmente soy un estudiante de segundo año de ingeniería en electrónica y comunicaciones del Instituto de Tecnología Pranveer Singh, Kanpur (UP). Tengo un gran interés en robótica, arduino, inteligencia artificial y electrónica analógica.

La palabra "cardán" se define como un soporte pivotante que permite la rotación de cualquier objeto en un solo eje. Por lo tanto, un cardán de tres ejes permite que cualquier objeto montado en el cardán sea independiente del movimiento del que sostiene el cardán. El cardán dicta el movimiento del objeto, no el que lo lleva.

Consta de 3 servomotores MG996R para el control de 3 ejes, y una base sobre la que se colocará el sensor MPU6050, el Arduino y la batería, se utiliza para mantener la cámara estabilizada sin vibraciones. Un cardán de 3 ejes asegura que el movimiento de la cámara se estabilice incluso si el que la sostiene está subiendo y bajando, hacia la izquierda y hacia la derecha, hacia adelante y hacia atrás. Esto es lo que llamamos estabilización de guiñada, cabeceo y balanceo.

Paso 1: Lista de componentes

La lista de componentes son:

1) Arduino Uno

2) Batería de 8 V, 1,5 amperios para alimentar Arduino Uno

3) Regulador de voltaje 7805 Ic o puede usar convector buck

4) MPU 6050

5) 3 * (Motores SERVO MG995)

6) cables de puente

Otros equipos:

1) soldador

2) pistola de pegamento

3) Taladro

4) Lata de comida

En lugar de usar breadborad, he usado una pequeña placa de perforación personalizada para una conexión de bus positiva y negativa

Paso 2: Montaje

Foamcore, tablero de espuma o tablero de espuma con cara de papel es un material liviano y fácil de cortar que se usa para montar el servomotor y para hacer modelos a escala.

En primer lugar, hice unos soportes en forma de L de bricolaje para montar el servomotor con la ayuda de una placa de espuma.

Paso 3:

Montar el cardán fue bastante fácil. Comencé con la instalación del servo Yaw, el sensor MPU 6050 y el interruptor de encendido y apagado. Usando pernos y tuercas lo aseguré a la base

Paso 4: A continuación, utilizando el mismo método, aseguré el servo de rollo. las piezas están diseñadas específicamente para adaptarse fácilmente a los servos MG995

Paso 5: A continuación, utilizando el mismo método, aseguré el servo de rollo. las piezas están diseñadas específicamente para adaptarse fácilmente a los servos MG995

Paso 6: Conexiones

En el diagrama del circuito, puede usar un convertidor buck o un regulador de voltaje IC 7805 para convertir 8V a 5 V. El microcontrolador que se muestra en el diagrama del circuito es Arduino Nano, también puede usar Arduino Uno, Arduino Mega.

Los pines SCL y SDA de MPU 6050 están conectados a los pines analógicos A5 y A4 de Arduino (los pines SCL y SDA pueden variar, así que consulte la hoja de datos para los pines SCl y SDA para otros microcontroladores)

Paso 7: Conexión con el regulador de voltaje 7805 IC

Este diagrama de circuito es para la conexión del regulador de voltaje 7805 ic, conecte la batería de 8v en Vin y obtendrá un voltaje de salida de 5v.

Paso 8: codificación

Debe incluir las siguientes bibliotecas:

1) #includeHaga clic aquí para descargar el archivo zip

2) #includeHaga clic aquí para descargar el archivo zip

Después de descargar el archivo zip, agregue la biblioteca zip en arduino sketch

Para el código

/*

DIY Gimbal - MPU6050 Código de tutorial de Arduino basado en el ejemplo MPU6050_DMP6 de la biblioteca i2cdevlib de Jeff Rowberg: https://github.com/jrowberg/i2cdevlib * / // I2Cdev y MPU6050 deben instalarse como bibliotecas, o de lo contrario el.cpp / Los archivos.h // para ambas clases deben estar en la ruta de inclusión de su proyecto / La biblioteca Arduino Wire es necesaria si la implementación I2Cdev I2CDEV_ARDUINO_WIRE // se utiliza en I2Cdev.h #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE #include "Wire.h" #endif #include // La dirección I2C predeterminada de la clase es 0x68 // puede ser específica pasado como parámetro aquí // AD0 low = 0x68 (predeterminado para la placa de evaluación SparkFun breakout y InvenSense) // AD0 high = 0x69 MPU6050 mpu; // MPU6050 mpu (0x69); // <- utilizar para AD0 alto // Definir los 3 servomotores Servo servo0; Servo servo1; Servo servo2; flotar correctamente; int j = 0; #define OUTPUT_READABLE_YAWPITCHROLL #define INTERRUPT_PIN 2 // use el pin 2 en Arduino Uno y la mayoría de las placas bool blinkState = false; // Control de MPU / estado vars bool dmpReady = false; // establecer verdadero si DMP init fue exitoso uint8_t mpuIntStatus; // contiene el byte de estado de interrupción actual de MPU uint8_t devStatus; // devuelve el estado después de cada operación del dispositivo (0 = éxito,! 0 = error) uint16_t packetSize; // tamaño esperado del paquete DMP (el valor predeterminado es 42 bytes) uint16_t FIFoCount; // recuento de todos los bytes actualmente en FIFO uint8_t fifoBuffer [64]; // Búfer de almacenamiento FIFO // orientación / movimiento vars Quaternion q; // [w, x, y, z] contenedor de cuaterniones VectorInt16 aa; // [x, y, z] medidas del sensor de aceleración VectorInt16 aaReal; // [x, y, z] mediciones del sensor de aceleración sin gravedad VectorInt16 aaWorld; // [x, y, z] mediciones del sensor de aceleración de marco mundial VectorFloat gravity; // [x, y, z] vector de gravedad float euler [3]; // [psi, theta, phi] Contenedor de ángulo de Euler float ypr [3]; // [guiñada, cabeceo, balanceo] guiñada / cabeceo / balanceo contenedor y vector de gravedad // estructura del paquete para la demostración de tetera InvenSense uint8_t teapotPacket [14] = {'$', 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0x00, 0x00, '\ r', '\ n'}; // ============================================== ================ // === RUTINA DE DETECCIÓN DE INTERRUPCIONES === // ===================== ========================================= volatile bool mpuInterrupt = false; // indica si el pin de interrupción de MPU se ha elevado void dmpDataReady () {mpuInterrupt = true; } // ============================================= ================= // === CONFIGURACIÓN INICIAL === // ===================== =========================================== Void setup () {// unirse al bus I2C (la biblioteca I2Cdev no hace esto automáticamente) #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE Wire.begin (); Wire.setClock (400000); // Reloj I2C de 400 kHz. Comente esta línea si tiene dificultades de compilación #elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE Fastwire:: setup (400, true); #endif // inicializar la comunicación en serie // (se eligió 115200 porque es necesario para la salida de demostración de Teapot, pero depende // de usted según su proyecto) Serial.begin (38400); mientras (! Serial); // esperar la enumeración de Leonardo, otros continúan inmediatamente // inicializar el dispositivo //Serial.println(F("Initializing I2C devices… ")); mpu.initialize (); pinMode (INTERRUPT_PIN, ENTRADA); devStatus = mpu.dmpInitialize (); // proporcione aquí sus propias compensaciones giroscópicas, escaladas para sensibilidad mínima mpu.setXGyroOffset (17); mpu.setYGyroOffset (-69); mpu.setZGyroOffset (27); mpu.setZAccelOffset (1551); // 1688 predeterminado de fábrica para mi chip de prueba // asegúrese de que funcionó (devuelve 0 si es así) si (devStatus == 0) {// enciende el DMP, ahora que está listo // Serial.println (F ("Habilitando DMP… ")); mpu.setDMPEnabled (verdadero); attachInterrupt (digitalPinToInterrupt (INTERRUPT_PIN), dmpDataReady, RISING); mpuIntStatus = mpu.getIntStatus (); // establece nuestro indicador DMP Ready para que la función main loop () sepa que está bien usarlo //Serial.println(F("DMP ready! Waiting for first interrupt… ")); dmpReady = verdadero; // obtener el tamaño de paquete DMP esperado para una comparación posterior packetSize = mpu.dmpGetFIFOPacketSize (); } else {// ¡ERROR! // 1 = falló la carga de memoria inicial // 2 = fallaron las actualizaciones de la configuración DMP // (si se va a romper, normalmente el código será 1) // Serial.print (F ("DMP Initialization failed (code")); //Serial.print(devStatus); //Serial.println (F (")")); } // Define los pines a los que están conectados los 3 servomotores servo0.attach (10); servo1.attach (9); servo2.attach (8); } // ============================================= ================= // === BUCLE PRINCIPAL DEL PROGRAMA === // ==================== ========================================== bucle vacío () {/ / si la programación falló, no intente hacer nada si (! dmpReady) return; // espere la interrupción de MPU o paquetes adicionales disponibles mientras (! mpuInterrupt && FIFoCount <packetSize) {if (mpuInterrupt && FIFoCount

= 1024) {

// reiniciar para que podamos continuar limpiamente mpu.resetFIFO (); FifoCount = mpu.getFIFOCount (); Serial.println (F ("¡Desbordamiento FIFO!")); // de lo contrario, compruebe si hay interrupción de datos DMP listos (esto debería suceder con frecuencia)} else if (mpuIntStatus & _BV (MPU6050_INTERRUPT_DMP_INT_BIT)) {// espere la longitud correcta de los datos disponibles, debería ser una espera MUY corta mientras (FIFoCount 1 paquete disponible / / (esto nos permite leer más inmediatamente sin esperar una interrupción) FIFoCount - = packetSize; // Obtener valores de Yaw, Pitch y Roll #ifdef OUTPUT_READABLE_YAWPITCHROLL mpu.dmpGetQuaternion (& q, FIFoBuffer); mpu.dmpGetGravity (& gravity, & q); mpu.dmpGetYawPitchRoll (ypr, & q, & gravity); // Valores de Yaw, Pitch, Roll - Radianes a grados ypr [0] = ypr [0] * 180 / M_PI; ypr [1] = ypr [1] * 180 / M_PI; ypr [2] = ypr [2] * 180 / M_PI; // Omitir 300 lecturas (proceso de autocalibración) if (j <= 300) {correct = ypr [0]; // La guiñada comienza en un valor aleatorio, por lo que capturar el último valor después de 300 lecturas j ++;} // Después de 300 lecturas else {ypr [0] = ypr [0] - correcto; // Establecer el Yaw en 0 grados - restar el último valor de Yaw aleatorio del valor actual para hacer el Guiñada 0 grados es // Mapea los valores del sensor MPU6050 de -90 a 90 a valores aceptables para el servocontrol de 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); // Controla los servos según la orientación del MPU6050 servo0.write (servo0Value); servo1.write (servo1Value); servo2.write (servo2Value); } #terminara si } }

Finalmente, usando la función de escritura, enviamos estos valores a los servos como señales de control. Por supuesto, puede deshabilitar el servo Yaw si solo desea estabilizar los ejes X e Y, y usar esta plataforma como cardán de la cámara

Paso 9: cuando todos los componentes están conectados, se ve similar a esta imagen

Paso 10: Ahora inserte todo el material base dentro de la lata de comida

Paso 11: Cuando todos los cables y componentes se colocan dentro de una lata de comida, se aplica una pistola de pegamento en la base de la tabla de espuma

Paso 12: Conclusión

Tenga en cuenta que esto está lejos de ser un buen cardán de cámara. Los movimientos no son suaves porque estos servos no están diseñados para tal propósito. Los cardanes de cámara reales utilizan un tipo especial de motor BLDC para obtener movimientos suaves. Por lo tanto, considere este proyecto solo con fines educativos.

Eso sería todo por este tutorial, espero que lo hayas disfrutado y hayas aprendido algo nuevo. No dude en hacer cualquier pregunta en la sección de comentarios a continuación y no olvide revisar mis colecciones de proyectos.