Tabla de contenido:
2025 Autor: John Day | [email protected]. Última modificación: 2025-01-13 06:57
¡Bienvenido a mi primer instructable! Espero que les resulte informativo. No dude en dejar comentarios, ya sean positivos o negativos.
Este proyecto es para hacer un nivel de burbuja digital basado en arduino y MPU6050. Si bien el diseño y el código terminados son míos, el concepto original y gran parte del código con el que he trabajado no lo son. No me gusta el plagio, así que estoy más que feliz de dar crédito a aquellos cuyas ideas he construido. Las 2 personas principales a las que quiero agradecer son Paul McWhorter y DroneBot Workshop de YouTuber. Incluyo enlaces a ellos en mi PDF de enlaces útiles de youtube. Gracias también a EEEnthusiast por su video informativo sobre el uso del MPU6050, incluida la configuración y lectura del módulo sin una biblioteca externa (su enlace está en el mismo PDF).
El proyecto que he producido funciona "tal cual" y es muy preciso, sin duda hasta un 45% en cualquier dirección. Puede usarlo exactamente como lo he diseñado, o puede adaptarlo a sus propios gustos. Los más astutos notarán que mi proyecto luce casi idéntico al producido por el taller de DroneBot, pero tenga la seguridad de que hay diferencias significativas, especialmente en lo que respecta al código para el cálculo de ángulos, además de la facilidad para almacenar valores de calibración en Eeprom!
Algunas funciones para abrir el apetito:
Ángulos de cabeceo y balanceo disponibles dentro de 0,1 grados.
Detección automática de la orientación de la unidad giroscópica (horizontal o vertical)
Calibración completa con resultados almacenados automáticamente en eeprom
Indicación LED de -2 a +2 grados (modificable en código)
Indicación audible adicional de nivel (se puede encender / apagar al vuelo)
Curcuit compacto que requiere componentes mínimos
Empecemos.
Suministros
Este proyecto (como está) utiliza los siguientes elementos:
1 x Arduino nano (el mío es un clon)
1 x módulo de giroscopio / acelerómetro MPU6050
1 x LCD - 16 x 2 + conexión I2C
1 x empujar para hacer el interruptor
1 x zumbador piezoeléctrico
1 x LED verde
2 x LED amarillos
2 x LED rojos
5 resistencias de 220 ohmios
Varios cables de puente
Tablero de circuitos
Fuente de alimentación (la mía usó un banco de energía USB de 5v, cuando no estaba conectado a mi PC, pero podrías usar una batería correctamente conectada)
Paso 1: el circuito
Suponiendo que tiene todos los componentes, necesitará construir su tablero.
Muestro mi configuración como guía, pero las conexiones son las siguientes:
El pin D2 de Arduino se conecta a 1 lado del interruptor de empuje. El otro lado del interruptor de empuje se conecta a tierra
El pin D3 de Arduino se conecta a 1 lado de la resistencia de 220 ohmios. El otro lado de la resistencia se conecta al nodo del LED rojo. El cátodo de LED rojo va a tierra.
El pin D4 de Arduino se conecta a 1 lado de la resistencia de 220 ohmios. El otro lado de la resistencia se conecta al nodo del LED amarillo. El cátodo de LED amarillo va a tierra.
El pin D5 de Arduino se conecta a 1 lado de la resistencia de 220 ohmios. El otro lado de la resistencia se conecta al nodo del LED verde. El cátodo de LED verde se conecta a tierra.
El pin D6 de Arduino se conecta a 1 lado de la resistencia de 220 ohmios. El otro lado de la resistencia se conecta al nodo del LED amarillo. El cátodo de LED amarillo va a tierra.
El pin D7 de Arduino se conecta a 1 lado de la resistencia de 220 ohmios. El otro lado de la resistencia se conecta al nodo del LED rojo. El cátodo de LED rojo va a tierra.
El pin D8 de Arduino se conecta a un lado del zumbador piezoeléctrico. El otro lado del zumbador se conecta a tierra.
El pin A4 de Arduino se conecta a los pines SDA en el MPU6050 Y la pantalla LCD.
El pin A5 de Arduino se conecta a los pines SCL en el MPU6050 Y la pantalla LCD
5v de potencia y Gnd para MPU6050 y LCD provienen de los pines Arduino Nano 5v y GND respectivamente.
Una vez completado, debería ser similar a mi configuración que se muestra. Puse blu tak debajo del MPU6050 para evitar que se mueva y también en la pantalla LCD para mantenerlo en el borde de la placa de pruebas.
Paso 2: el código
El código adjunto es el código que he usado para este proyecto. La única biblioteca con la que puede tener un problema es la
LiquidCrystal_I2C.h, ya que lo importé cuando comencé a trabajar con LCD. Desafortunadamente, hay algunas bibliotecas que usan la misma instrucción #include, pero son ligeramente diferentes. Si tiene problemas con el suyo, busque otro código LCD que funcione para usted y modifique el código en consecuencia. Es probable que sea la configuración la que difiera. Todos los comandos 'imprimir' deberían funcionar igual.
Todo el código ha sido comentado y suponiendo que lo haya hecho bien, también habrá un video que explica todo, pero aquí hay algunos puntos a tener en cuenta:
LiquidCrystal_I2C lcd (0x27, 16, 2);
El código anterior es la configuración de mi LCD. Si su biblioteca es diferente, es posible que deba cambiar no solo su biblioteca, sino también esta línea.
{lcd.setCursor (0, 1); lcd.print ("¡Horizontal!"); orientación = HORIZONTAL; // Lea los datos sin procesar de acc y gyro del MPU-6050 1000 veces para (int cal_int = 0; cal_int <1000; cal_int ++) {read_mpu_6050_data (); // Agrega el desplazamiento gyro x a la variable gyro_x_cal gyro_x_cal + = gyro_x; // Agrega el desplazamiento gyro y a la variable gyro_y_cal gyro_y_cal + = gyro_y; // Agrega el desplazamiento gyro z a la variable gyro_z_cal gyro_z_cal + = gyro_z; // Agregue el desplazamiento acc x a la variable acc_x_cal acc_x_cal + = acc_x; // Agregue el desplazamiento acc y a la variable acc_y_cal acc_y_cal + = acc_y; } // Divida todos los resultados por 1000 para obtener el desplazamiento promedio gyro_x_cal / = 1000.0; gyro_y_cal / = 1000.0; gyro_z_cal / = 1000.0; acc_x_cal / = 1000.0; acc_y_cal / = 1000.0; horizonalCalibration = 255; eeprom_address = 0; EEPROM.put (eeprom_address, horizonalCalibration); eeprom_address + = sizeof (int); EEPROM.put (eeprom_address, gyro_x_cal); eeprom_address + = sizeof (flotante); EEPROM.put (eeprom_address, gyro_y_cal); eeprom_address + = sizeof (flotante); EEPROM.put (eeprom_address, gyro_z_cal); eeprom_address + = sizeof (flotante); EEPROM.put (eeprom_address, acc_x_cal); eeprom_address + = sizeof (flotante); EEPROM.put (eeprom_address, acc_y_cal); eeprom_address + = sizeof (flotante); // ¡Tenga en cuenta que no estamos almacenando un desplazamiento para acc_z, debido a la gravedad! retraso (500); }
El bloque de código anterior se ejecuta en la rutina de calibración. Este código es para la calibración horizontal. Hay un código casi idéntico para la calibración vertical (tenga en cuenta que el código sabe si su MPU6050 está montado horizontal o verticalmente). MPU6050, se lee 1000 veces. los valores apropiados se suman acumulativamente y luego se dividen por 1000 para dar un valor de "compensación" promedio. Estos valores luego se almacenan en la eeprom Nano. Todos los valores de calibración horizontal se almacenan comenzando en la dirección eeprom 0. Todos los valores verticales se almacenan comenzando en la dirección eeprom 24. La calibración DEBE realizarse en una superficie completamente nivelada, de lo contrario no significan nada.
/ * * Las siguientes líneas procesan los datos sin procesar para convertirlos en ángulos que se pueden enviar a la pantalla LCD y los LED. * El valor de 4096, por el que se dividen los datos de aceleración, se toma de la hoja de datos del MPU6050 y se basa en la frecuencia de muestreo. * El valor de 9.8 es la gravedad * La función atan2 es del módulo matemático y se usa para calcular los ángulos a partir de los datos dados * / thetaM = -atan2 ((acc_x / 4096.0) /9.8, (acc_z / 4096.0) /9.8) /2/3.141592656 * 360; // Datos brutos phiM = -atan2 ((acc_y / 4096.0) /9.8, (acc_z / 4096.0) /9.8) /2/3.141592656 * 360; // Datos brutos dt = (millis () - millisOld) / 1000.; millisOld = millis (); / * * Esta sección utiliza los datos del giróscopo para hacer que el sistema responda mejor * el valor de 65.5, por el cual se dividen los datos del giróscopo, se toma de la hoja de datos del MPU6050 y se basa en la frecuencia de muestreo * / theta = (theta + (gyro_y / 65,5) * dt) *. 96 + thetaM *.04; // Filtro de paso bajo phi = (phi + (gyro_x / 65.5) * dt) *. 96 + phiM *.04; //Filtro de paso bajo
El código anterior es lo que calcula los ángulos. Con suerte, los comentarios brindan una pequeña idea de cómo funciona, pero para una explicación más detallada, consulte el video de Paul McWhorters vinculado en el PDF adjunto. Sin embargo, lo que diré es que puede cambiar la frecuencia de muestreo para el giroscopio y el acelerómetro (que se realiza en la subrutina de configuración MPU6050 en la parte inferior de mi código). Si cambia la frecuencia de muestreo, también debe cambiar cuánto se dividen los datos brutos. Para los datos del acelerómetro, el valor actual es 4096. Para el giroscopio, el valor actual es 65,5.
Consulte las hojas de datos adjuntas y el video de EEEntusiast (enlace en el PDF adjunto) para obtener información más detallada sobre cómo se encuentran los valores de muestreo y compensación.
Paso 3: Pasos siguientes
A estas alturas con suerte habrá realizado este proyecto, pero ¿ahora qué?
En primer lugar, ¿por qué no construirlo en un nivel de burbuja que pueda usar? Puedes comprar un nivel de burbuja barato (asegúrate de que sea del tipo de caja) que puedas adaptar, o si tienes el kit, imprime tu propio nivel / caja.
Quizás juegue con las frecuencias de muestreo del giroscopio y el acelerómetro para ver si funcionan mejor a una velocidad que a otra.
Intente refinar aún más el código. Por ejemplo, en la actualidad, más allá de los 45 grados, el ángulo indicado es aproximado por decir lo menos. ¿Hay alguna forma de evitarlo?
Si tiene alguna pregunta, no importa lo simple que parezca, por favor pregunte. Si puedo ayudar, lo haré.
Si te gusta este instructivo, dale un me gusta para que yo sepa.
Si hace esto, por favor enséñemelo (especialmente si es en un caso de trabajo).
GRACIAS