Configurar el MPU6050.

2 marzo, 20188 junio, 2022 Vicente García

INTRODUCCIÓN.

Este tutorial, es una extensión del artículo sensormpu6050. EL módulo MPU6050 contiene un giroscopio de tres ejes con el que podemos medir velocidad angular y un acelerómetro también de 3 ejes con el que medimos los componentes X, Y y Z de la aceleración, el acelerómetro trabaja sobre el principio piezo eléctrico, posee además de un sensor de temperatura.

Los acelerómetros internamente tienen un MEMS (MicroElectroMechanical Systems) que de forma similar a un sistema masa-resorte permite medir la aceleración. Los giroscopios utilizan un MEMS (MicroElectroMechanical Systems) para medir la velocidad angular usando el efecto Coriolis.

En esta ocasión presento un ejemplo simple de cómo interconectar el MPU-6050 con una placa Arduino. El MPU6050 es un sensor de movimiento, que tiene un conversor ADC de 16 bits que convierte los datos a un valor digital, el módulo de giroscopio se comunica con el Arduino a través de la comunicación serie I2C a través del reloj serial (SCL) y datos (SDA), el chip MPU6050 necesita 3.3V pero un regulador de voltaje en la tarjeta GY-521 le permite alimentarlo hasta 5V, en nuestro caso en un Arduino con el que haremos unos ejercicios.

El procesador interno del IMU (Inertial Measurment Units) es capaz de realizar cálculos precisos de los valores que miden sus sensores internos que son, aceleraciones lineales y angulares, para informarnos de valores útiles como los ángulos de inclinación con respecto a los 3 ejes principales. Un dato importante es que ni la aceleración ni la velocidad lineal afectan la medición de giro.

La dirección de los ejes está indicado en el módulo el cual hay que tener en cuenta para no equivocarnos en el signo de las aceleraciones. Como la comunicación del módulo es vía I2C, esto le permite trabajar con la mayoría de microcontroladores. En el módulo los pines SCL y SDA tienen una resistencia pull-up en placa para una conexión directa al microcontrolador que estemos utilizando.

Fig. 1

Alguien como Jeff Rowberg ya ha hecho el trabajo duro por nosotros, escribió algunas bibliotecas de Arduino para obtener los datos del acelerómetro/giroscopio y manejar todos los cálculos. Las librerías están disponibles como un archivo zip desde aquí.

Y también las puede descargar de:
https://github.com/jrowberg/i2cdevlib/tree/master/Arduino/MPU6050
y la encargada de I2Cdev de:
https://github.com/jrowberg/i2cdevlib/tree/master/Arduino/I2Cdev

Instalar las librerías en el IDE Arduino, con ellas podremos trabajar los siguientes ejercicios. Una vez descomprimido, copie las dos carpetas “I2Cdev” y “MPU6050” en su carpeta Arduino “libraries” en el siguiente directorio: C: \ Archivos de programa (x86) \ Arduino \ libraries

EL CIRCUITO.

Fig. 2 Circuito.

Abra su Arduino si no lo tiene abierto ya, vaya al menú Archivos/Ejemplos… y navegue hasta MPU6050> y encontrará el archivo MPU6050_DMP6, ábralo y seleccione el puerto COM adecuado, suba el boceto. En el monitor Serial elija la velocidad de 115200 Baudios.

Fig. 3 Archivo MPU6050_DMP6.

Le aparecerá una indicación, pruebe a escribir algún dato y pulse Enter, en ese momento deberían aparecer los datos, lo que indica que todo está saliendo bien.

Fig. 4 Monitor Serial.

CALIBRANDO EL MPU6050

Muchos de los ejemplos que podemos encontrar, tienen un problema y es que presentan muchas vibraciones y ruido en las medidas, además cuando tengamos instalado el módulo MPU6050 en el proyecto, siempre puede haber un desnivel en sus componentes, motivo por el cual debemos calibrar el módulo, asegurándonos de que no haya un error de desnivel agregado en cada componente.

Fig. 5 Ejes Tait-Brayan o Euler

Podemos solucionar estos problemas al configurar el módulo MPU6050 OFFSETS, para compensar dichos errores.

// calibrar_mpu6050.ino
// Librerias I2C para controlar el mpu6050 con Arduino,
// la libreria MPU6050.h necesita I2Cdev.h, la libreria I2Cdev.h necesita Wire.h
 
#include "I2Cdev.h"
#include "MPU6050.h"
#include "Wire.h"
 
// La dirección del MPU6050 puede ser 0x68 o 0x69, dependiendo 
// del estado de AD0. Si no se especifica, 0x68 estarÃ¡ implicito
MPU6050 sensor;
 
// Valores RAW (sin procesar) del acelerometro y giroscopio en los ejes x,y,z
int ax, ay, az;
int gx, gy, gz;
 
//Variables usadas por el filtro pasa bajos
long f_ax,f_ay, f_az;
int p_ax, p_ay, p_az;
long f_gx,f_gy, f_gz;
int p_gx, p_gy, p_gz;
int counter=0;
 
//Valor de los offsets
int ax_o,ay_o,az_o;
int gx_o,gy_o,gz_o;
 
void setup() {
  Serial.begin(57600);   //Iniciando puerto serial
  Wire.begin();           //Iniciando I2C  
  sensor.initialize();    //Iniciando el sensor
 
  if (sensor.testConnection()) Serial.println("Sensor iniciado correctamente");
 
  // Leer los offset los offsets anteriores
  ax_o=sensor.getXAccelOffset();
  ay_o=sensor.getYAccelOffset();
  az_o=sensor.getZAccelOffset();
  gx_o=sensor.getXGyroOffset();
  gy_o=sensor.getYGyroOffset();
  gz_o=sensor.getZGyroOffset();
  
  Serial.println("Offsets:");
  Serial.print(ax_o); Serial.print("\t"); 
  Serial.print(ay_o); Serial.print("\t"); 
  Serial.print(az_o); Serial.print("\t"); 
  Serial.print(gx_o); Serial.print("\t"); 
  Serial.print(gy_o); Serial.print("\t");
  Serial.print(gz_o); Serial.println("\t");
 
  Serial.println("nnEnvie cualquier caracter para empezar la calibracionnn");  
  // Espera un caracter para empezar a calibrar
  while (true){if (Serial.available()) break;}  
  Serial.println("Calibrando, no mover IMU");    
}
 
void loop() {
  // Leer las aceleraciones y velocidades angulares
  sensor.getAcceleration(&amp;ax, &amp;ay, &amp;az);
  sensor.getRotation(&amp;gx, &amp;gy, &amp;gz);
 
  // Filtrar las lecturas
  f_ax = f_ax-(f_ax&gt;&gt;5)+ax;
  p_ax = f_ax&gt;&gt;5;
 
  f_ay = f_ay-(f_ay&gt;&gt;5)+ay;
  p_ay = f_ay&gt;&gt;5;
 
  f_az = f_az-(f_az&gt;&gt;5)+az;
  p_az = f_az&gt;&gt;5;
 
  f_gx = f_gx-(f_gx&gt;&gt;3)+gx;
  p_gx = f_gx&gt;&gt;3;
 
  f_gy = f_gy-(f_gy&gt;&gt;3)+gy;
  p_gy = f_gy&gt;&gt;3;
 
  f_gz = f_gz-(f_gz&gt;&gt;3)+gz;
  p_gz = f_gz&gt;&gt;3;
 
  //Cada 100 lecturas corregir el offset
  if (counter==100){
    //Mostrar las lecturas separadas por un [tab]
    Serial.print("promedio:"); Serial.print("\t");
    Serial.print(p_ax); Serial.print("\t");
    Serial.print(p_ay); Serial.print("\t");
    Serial.print(p_az); Serial.print("\t");
    Serial.print(p_gx); Serial.print("\t");
    Serial.print(p_gy); Serial.print("\t");
    Serial.println(p_gz);
 
    //Calibrar el acelerometro a 1g en el eje z (ajustar el offset)
    if (p_ax&gt;0) ax_o--;
    else {ax_o++;}
    if (p_ay&gt;0) ay_o--;
    else {ay_o++;}
    if (p_az-16384&gt;0) az_o--;
    else {az_o++;}
    
    sensor.setXAccelOffset(ax_o);
    sensor.setYAccelOffset(ay_o);
    sensor.setZAccelOffset(az_o);
 
    //Calibrar el giroscopio a 0º/s en todos los ejes (ajustar el offset)
    if (p_gx&gt;0) gx_o--;
    else {gx_o++;}
    if (p_gy&gt;0) gy_o--;
    else {gy_o++;}
    if (p_gz&gt;0) gz_o--;
    else {gz_o++;}
    
    sensor.setXGyroOffset(gx_o);
    sensor.setYGyroOffset(gy_o);
    sensor.setZGyroOffset(gz_o);    
 
    counter=0;
  }
  counter++;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

// calibrar_mpu6050.ino

// Librerias I2C para controlar el mpu6050 con Arduino,

// la libreria MPU6050.h necesita I2Cdev.h, la libreria I2Cdev.h necesita Wire.h

#include "I2Cdev.h"

#include "MPU6050.h"

#include "Wire.h"

// La dirección del MPU6050 puede ser 0x68 o 0x69, dependiendo

// del estado de AD0. Si no se especifica, 0x68 estarÃ¡ implicito

MPU6050 sensor;

// Valores RAW (sin procesar) del acelerometro y giroscopio en los ejes x,y,z

int ax, ay, az;

int gx, gy, gz;

//Variables usadas por el filtro pasa bajos

long f_ax,f_ay, f_az;

int p_ax, p_ay, p_az;

long f_gx,f_gy, f_gz;

int p_gx, p_gy, p_gz;

int counter=0;

//Valor de los offsets

int ax_o,ay_o,az_o;

int gx_o,gy_o,gz_o;

void setup() {

Serial.begin(57600); //Iniciando puerto serial

Wire.begin(); //Iniciando I2C

sensor.initialize(); //Iniciando el sensor

if (sensor.testConnection()) Serial.println("Sensor iniciado correctamente");

// Leer los offset los offsets anteriores

ax_o=sensor.getXAccelOffset();

ay_o=sensor.getYAccelOffset();

az_o=sensor.getZAccelOffset();

gx_o=sensor.getXGyroOffset();

gy_o=sensor.getYGyroOffset();

gz_o=sensor.getZGyroOffset();

Serial.println("Offsets:");

Serial.print(ax_o); Serial.print("\t");

Serial.print(ay_o); Serial.print("\t");

Serial.print(az_o); Serial.print("\t");

Serial.print(gx_o); Serial.print("\t");

Serial.print(gy_o); Serial.print("\t");

Serial.print(gz_o); Serial.println("\t");

Serial.println("nnEnvie cualquier caracter para empezar la calibracionnn");

// Espera un caracter para empezar a calibrar

while (true){if (Serial.available()) break;}

Serial.println("Calibrando, no mover IMU");

}

void loop() {

// Leer las aceleraciones y velocidades angulares

sensor.getAcceleration(&ax, &ay, &az);

sensor.getRotation(&gx, &gy, &gz);

// Filtrar las lecturas

f_ax = f_ax-(f_ax>>5)+ax;

p_ax = f_ax>>5;

f_ay = f_ay-(f_ay>>5)+ay;

p_ay = f_ay>>5;

f_az = f_az-(f_az>>5)+az;

p_az = f_az>>5;

f_gx = f_gx-(f_gx>>3)+gx;

p_gx = f_gx>>3;

f_gy = f_gy-(f_gy>>3)+gy;

p_gy = f_gy>>3;

f_gz = f_gz-(f_gz>>3)+gz;

p_gz = f_gz>>3;

//Cada 100 lecturas corregir el offset

if (counter==100){

//Mostrar las lecturas separadas por un [tab]

Serial.print("promedio:"); Serial.print("\t");

Serial.print(p_ax); Serial.print("\t");

Serial.print(p_ay); Serial.print("\t");

Serial.print(p_az); Serial.print("\t");

Serial.print(p_gx); Serial.print("\t");

Serial.print(p_gy); Serial.print("\t");

Serial.println(p_gz);

//Calibrar el acelerometro a 1g en el eje z (ajustar el offset)

if (p_ax>0) ax_o--;

else {ax_o++;}

if (p_ay>0) ay_o--;

else {ay_o++;}

if (p_az-16384>0) az_o--;

else {az_o++;}

sensor.setXAccelOffset(ax_o);

sensor.setYAccelOffset(ay_o);

sensor.setZAccelOffset(az_o);

//Calibrar el giroscopio a 0º/s en todos los ejes (ajustar el offset)

if (p_gx>0) gx_o--;

else {gx_o++;}

if (p_gy>0) gy_o--;

else {gy_o++;}

if (p_gz>0) gz_o--;

else {gz_o++;}

sensor.setXGyroOffset(gx_o);

sensor.setYGyroOffset(gy_o);

sensor.setZGyroOffset(gz_o);

counter=0;

}

counter++;

}

Durante la calibración deberemos mantener el sensor sin moverlo en la posición de trabajo habitual, entonces el programa empieza por leer los offsets y nos pide que enviemos un carácter por el puerto serie. El programa trata de corregir los errores de las medidas, para ello modifica constantemente el offest, usando un filtro y cada 100 lecturas comprueba los valores si se acercan a los que deseamos leer, aumentando o disminuyendo los offsets. Esto hará que las lecturas filtradas se acerquen a:
-aceleración: p_ax=0 , p_ay=0 , p_az=+16384
-velocidad angular: p_gx=0 , p_gy=0 , p_gz=0

Fig. 6 Calibrado del PMU6050.

Tal como indica en el monitor debemos anotar las compensaciones obtenidas para configurarlas en nuestros proyectos, usando la función mpu.setXAccelOffset(), como se indica a continuación.

Abriremos el archivo MPU6050_PMT y buscaremos la parte de Calibration results como se aprecia en la figura que sigue.

Fig. 7 Configurar el boceto.

La calibración solo es necesario hacerla una vez. EL filtro complemento en si, es para combinar el acelerómetro y el giroscopio. Si solo utilizáramos el acelerómetro para determinar el ángulo, cualquier aceleración generada por un desplazamiento generaría errores en el ángulo. En cambio sí solo usamos el giroscopio vamos a obtener un error acumulativo por causa de la integración de w (velocidad angular). Este filtro se utiliza acunado, queremos sensar el ángulo pero el MPU está en constante movimiento (Drones, robots móviles, etc). En cambio, si el PMU va a estar fijo podemos tomar sólo el vector de la aceleración de la gravedad para determinar los ángulos.

ESCALADO DE LECTURAS

Ahora, vamos a escalar las lecturas a valores con las unidades de aceleración y velocidad angular. Carguemos el siguiente programa que usa una ecuación para convertir el valor leído en un valor de aceleración o velocidad angular.

Este código nos permite escalar valores de aceleración y velocidad angular.

// escalar_valores.ino
// Librerias I2C para controlar el mpu6050 con Arduino,
// la libreria MPU6050.h necesita I2Cdev.h y la libreria I2Cdev.h necesita Wire.h
/* 
 Conociendo los rangos con los que está configurado nuestro MPU6050, 
 dichos rangos pueden ser 2g/4g/8g/16g para el acelerómetro y 
 250/500/1000/2000(°/s) para el giroscopio.
 Los rangos por defecto (2g y 250°/s)
 
 Variable        valor mínimo  valor central  valor máximo
 Lectura MPU6050    -32768        0             +32767 
 Aceleración         -2g          0g            +2g
 Velocidad angular  -250°/s       0°/s          +250°/s
*/
 
#include "I2Cdev.h"
#include "MPU6050.h"
#include "Wire.h"
 
// La dirección del MPU6050 puede ser 0x68 o 0x69, dependiendo 
// del estado de AD0. Si no se especifica, 0x68 estará implicito
MPU6050 sensor;
 
// Valores RAW (sin procesar) del acelerometro y giroscopio en los ejes x,y,z
int ax, ay, az;
int gx, gy, gz;
 
void setup() {
  Serial.begin(57600);    //Iniciando puerto serial
  Wire.begin();           //Iniciando I2C  
  sensor.initialize();    //Iniciando el sensor
 
  if (sensor.testConnection()) Serial.println("Sensor iniciado correctamente");
  else Serial.println("Error al iniciar el sensor");
}
 
void loop() {
  // Leer las aceleraciones y velocidades angulares
  sensor.getAcceleration(&amp;ax, &amp;ay, &amp;az);
  sensor.getRotation(&amp;gx, &amp;gy, &amp;gz);
  float ax_m_s2 = ax * (9.81/16384.0);
  float ay_m_s2 = ay * (9.81/16384.0);
  float az_m_s2 = az * (9.81/16384.0);
  float gx_deg_s = gx * (250.0/32768.0);
  float gy_deg_s = gy * (250.0/32768.0);
  float gz_deg_s = gz * (250.0/32768.0);
 
  //Mostrar las lecturas separadas por un [tab]
  Serial.print("a[x y z](m/s2) g[x y z](deg/s):\t");
  Serial.print(ax_m_s2); Serial.print("\t");
  Serial.print(ay_m_s2); Serial.print("\t");
  Serial.print(az_m_s2); Serial.print("\t");
  Serial.print(gx_deg_s); Serial.print("\t");
  Serial.print(gy_deg_s); Serial.print("\t");
  Serial.println(gz_deg_s);
 
  delay(100);
}

// escalar_valores.ino

// Librerias I2C para controlar el mpu6050 con Arduino,

// la libreria MPU6050.h necesita I2Cdev.h y la libreria I2Cdev.h necesita Wire.h

Conociendo los rangos con los que está configurado nuestro MPU6050,

dichos rangos pueden ser 2g/4g/8g/16g para el acelerómetro y

250/500/1000/2000(°/s) para el giroscopio.

Los rangos por defecto (2g y 250°/s)

Variable valor mínimo valor central valor máximo

Lectura MPU6050 -32768 0 +32767

Aceleración -2g 0g +2g

Velocidad angular -250°/s 0°/s +250°/s

#include "I2Cdev.h"

#include "MPU6050.h"

#include "Wire.h"

// La dirección del MPU6050 puede ser 0x68 o 0x69, dependiendo

// del estado de AD0. Si no se especifica, 0x68 estará implicito

MPU6050 sensor;

// Valores RAW (sin procesar) del acelerometro y giroscopio en los ejes x,y,z

int ax, ay, az;

int gx, gy, gz;

void setup() {

Serial.begin(57600); //Iniciando puerto serial

Wire.begin(); //Iniciando I2C

sensor.initialize(); //Iniciando el sensor

if (sensor.testConnection()) Serial.println("Sensor iniciado correctamente");

else Serial.println("Error al iniciar el sensor");

}

void loop() {

// Leer las aceleraciones y velocidades angulares

sensor.getAcceleration(&ax, &ay, &az);

sensor.getRotation(&gx, &gy, &gz);

float ax_m_s2 = ax * (9.81/16384.0);

float ay_m_s2 = ay * (9.81/16384.0);

float az_m_s2 = az * (9.81/16384.0);

float gx_deg_s = gx * (250.0/32768.0);

float gy_deg_s = gy * (250.0/32768.0);

float gz_deg_s = gz * (250.0/32768.0);

//Mostrar las lecturas separadas por un [tab]

Serial.print("a[x y z](m/s2) g[x y z](deg/s):\t");

Serial.print(ax_m_s2); Serial.print("\t");

Serial.print(ay_m_s2); Serial.print("\t");

Serial.print(az_m_s2); Serial.print("\t");

Serial.print(gx_deg_s); Serial.print("\t");

Serial.print(gy_deg_s); Serial.print("\t");

Serial.println(gz_deg_s);

delay(100);

}

Con el MPU6050, sólo podemos obtener los ángulos X e Y, con el filtro de complemento usamos los ángulos obtenidos del acelerómetro, los cuales se limitan a X e Y, puesto que una rotación en Z del acelerómetro no la detectará ya que usamos la gravedad para determinar el ángulo. Para esto es mejor usar un Magnetómetro similar al HMC5883L.

Fig. 8 Escalar valores de acel/grad.

Los valores obtenidos ya están escalados a unidades de aceleración y velocidad angular, hemos convertido la aceleración a valores en m/s^2 por lo que se reemplazó el valor de g=9.81 si el sensor se mantiene en posición horizontal se deben obtener mediciones cercanas a 9.8 m/s^2 (aceleración de la gravedad terrestre) es la componente z de la aceleración.

SIMULACIÓN 3D.

Para ejecutar la demostración o simulación 3D, vamos a utilizar una sencilla maqueta de un Eurofighter para que se comprenda mejor la evolución de los parámetros Yaw, Roll y Pitch a medida que se generan al cambiar la posición del IMU.

El primer paso es subir el código al IDE Arduino o si lo prefiere al nodeMCU, vamos a probar con Arduino, en ese caso, nos sirve el circuito descrito en la figura 2, en el que la conexión INT del MPU6050 no es necesaria.

En el caso de utilizar el nodeMCU12, el esquema es el siguiente:

Fig. 9 Conexiones nodeMCU e IMU.

EL CÓDIGO.

El código obtener inclinación viene bastante bien descrito y no hará falta muchas aclaraciones.

/*
*   obtener_inclinacion.ino
* Con el código se leen datos de la MPU-6050, este código 
* es modificado de la web: 
* http://robologs.net/2014/10/15/tutorial-de-arduino-y-mpu-6050/
* 
* Descrito muy bien en el vídeo: 
* https://www.youtube.com/watch?v=uN8SYfGwYVw&amp;t=164s
*
*  El factor de conversión: w= Lectura*(250/32768) = lectura*(1/131)
*/
 
#include "Wire.h" // librería Wire.h
 
//Direccion I2C de la IMU
#define MPU 0x68
 
//Ratios de conversion
#define A_R 16384.0    // 32768/2
#define G_R 131.0       // 32768/250
 
//Conversion de radianes a grados 180/PI
#define RAD_A_DEG = 57.295779
 
//MPU-6050 da los valores en enteros de 16 bits
//Valores RAW
int16_t AcX, AcY, AcZ, GyX, GyY, GyZ;
 
//Angulos
float Acc[2];
float Gy[3];
float Angle[3];
 
String valores;
 
long tiempo_prev;
float dt;
 
void setup()
{
 Wire.begin(); // D2(GPIO4)=SDA / D1(GPIO5)=SCL
 Wire.beginTransmission(MPU);
 Wire.write(0x6B);
 Wire.write(0);
 Wire.endTransmission(true);
 Serial.begin(115200);
}
 
void loop()
{
   //Leer los valores del Acelerometro de la IMU
   Wire.beginTransmission(MPU);
   Wire.write(0x3B); //Pedir el registro 0x3B - corresponde al AcX
   Wire.endTransmission(false);
   Wire.requestFrom(MPU,6,true);   //A partir del 0x3B, se piden 6 registros
   AcX=Wire.read()&lt;&lt;8|Wire.read(); //Cada valor ocupa 2 registros
   AcY=Wire.read()&lt;&lt;8|Wire.read();
   AcZ=Wire.read()&lt;&lt;8|Wire.read();
 
   //A partir de los valores del acelerometro, se calculan los angulos Y, X
   //respectivamente, con la formula de la tangente.
   Acc[1] = atan(-1*(AcX/A_R)/sqrt(pow((AcY/A_R),2) + pow((AcZ/A_R),2)))*RAD_TO_DEG;
   Acc[0] = atan((AcY/A_R)/sqrt(pow((AcX/A_R),2) + pow((AcZ/A_R),2)))*RAD_TO_DEG;
 
   //Leer los valores del Giroscopio
   Wire.beginTransmission(MPU);
   Wire.write(0x43);
   Wire.endTransmission(false);
   Wire.requestFrom(MPU,6,true);   //A partir del 0x43, se piden 6 registros
   GyX=Wire.read()&lt;&lt;8|Wire.read(); //Cada valor ocupa 2 registros
   GyY=Wire.read()&lt;&lt;8|Wire.read();
   GyZ=Wire.read()&lt;&lt;8|Wire.read();
 
   //Calculo del angulo del Giroscopio
   Gy[0] = GyX/G_R;
   Gy[1] = GyY/G_R;
   Gy[2] = GyZ/G_R;
 
   dt = (millis() - tiempo_prev) / 1000.0;
   tiempo_prev = millis();
 
   //Aplicar el Filtro Complementario
   Angle[0] = 0.98 *(Angle[0]+Gy[0]*dt) + 0.02*Acc[0];
   Angle[1] = 0.98 *(Angle[1]+Gy[1]*dt) + 0.02*Acc[1];
 
   //Integración respecto del tiempo paras calcular el YAW
   Angle[2] = Angle[2]+Gy[2]*dt;
 
   //Mostrar los valores por consola
   valores = "90, " +String(Angle[0]) + "," + String(Angle[1]) + "," + String(Angle[2]) + ", -90";
   Serial.println(valores);
   
   delay(10);
}

* obtener_inclinacion.ino

* Con el código se leen datos de la MPU-6050, este código

* es modificado de la web:

* http://robologs.net/2014/10/15/tutorial-de-arduino-y-mpu-6050/

* Descrito muy bien en el vídeo:

* https://www.youtube.com/watch?v=uN8SYfGwYVw&t=164s

* El factor de conversión: w= Lectura*(250/32768) = lectura*(1/131)

#include "Wire.h" // librería Wire.h

//Direccion I2C de la IMU

#define MPU 0x68

//Ratios de conversion

#define A_R 16384.0 // 32768/2

#define G_R 131.0 // 32768/250

//Conversion de radianes a grados 180/PI

#define RAD_A_DEG = 57.295779

//MPU-6050 da los valores en enteros de 16 bits

//Valores RAW

int16_t AcX, AcY, AcZ, GyX, GyY, GyZ;

//Angulos

float Acc[2];

float Gy[3];

float Angle[3];

String valores;

long tiempo_prev;

float dt;

void setup()

{

Wire.begin(); // D2(GPIO4)=SDA / D1(GPIO5)=SCL

Wire.beginTransmission(MPU);

Wire.write(0x6B);

Wire.write(0);

Wire.endTransmission(true);

Serial.begin(115200);

}

void loop()

{

//Leer los valores del Acelerometro de la IMU

Wire.beginTransmission(MPU);

Wire.write(0x3B); //Pedir el registro 0x3B - corresponde al AcX

Wire.endTransmission(false);

Wire.requestFrom(MPU,6,true); //A partir del 0x3B, se piden 6 registros

AcX=Wire.read()<<8|Wire.read(); //Cada valor ocupa 2 registros

AcY=Wire.read()<<8|Wire.read();

AcZ=Wire.read()<<8|Wire.read();

//A partir de los valores del acelerometro, se calculan los angulos Y, X

//respectivamente, con la formula de la tangente.

Acc[1] = atan(-1*(AcX/A_R)/sqrt(pow((AcY/A_R),2) + pow((AcZ/A_R),2)))*RAD_TO_DEG;

Acc[0] = atan((AcY/A_R)/sqrt(pow((AcX/A_R),2) + pow((AcZ/A_R),2)))*RAD_TO_DEG;

//Leer los valores del Giroscopio

Wire.beginTransmission(MPU);

Wire.write(0x43);

Wire.endTransmission(false);

Wire.requestFrom(MPU,6,true); //A partir del 0x43, se piden 6 registros

GyX=Wire.read()<<8|Wire.read(); //Cada valor ocupa 2 registros

GyY=Wire.read()<<8|Wire.read();

GyZ=Wire.read()<<8|Wire.read();

//Calculo del angulo del Giroscopio

Gy[0] = GyX/G_R;

Gy[1] = GyY/G_R;

Gy[2] = GyZ/G_R;

dt = (millis() - tiempo_prev) / 1000.0;

tiempo_prev = millis();

//Aplicar el Filtro Complementario

Angle[0] = 0.98 *(Angle[0]+Gy[0]*dt) + 0.02*Acc[0];

Angle[1] = 0.98 *(Angle[1]+Gy[1]*dt) + 0.02*Acc[1];

//Integración respecto del tiempo paras calcular el YAW

Angle[2] = Angle[2]+Gy[2]*dt;

//Mostrar los valores por consola

valores = "90, " +String(Angle[0]) + "," + String(Angle[1]) + "," + String(Angle[2]) + ", -90";

Serial.println(valores);

delay(10);

}

Copie y pegue el anterior código y guárdelo con un nombre por ej. simulador.ino, súbalo al IDE Arduino o al nogeMCU y ejecútelo. Cuando termine, si todo ha ido bien, al abrir el monitor serie podrá ver como surgen los valores que detecta el IMU.

Fig. 10 Monitor Serial.

Para tener una imagen más aproximada de lo que representan estos valores, vamos a poder ver la evolución de estos datos con la ayuda del monitor llamado Serial Plotter, pulse CRTL+Mayús+L o vaya al menú Herramientas/Serial Plotter, se abre una ventana que nos muestra unas líneas de colores que indican el progreso de los parámetros YAW, PITCH y ROLL en la medida que se producen.

Fig. 11 Tres ejes.

En la nueva ventana aparecen unas líneas de colores que corresponden a los ya mencionados YAW, PITCH y ROLL (según se puede ver en la figura 11). Pueden apreciarse las variaciones de cada línea de color en su evolución.

Fig. 12 Serial Plotter.

Estos datos que he intentado describir se aprecian mejor en el vídeo que he realizado y se muestra a continuación.

<span data-mce-type="bookmark" style="display: inline-block; width: 0px; overflow: hidden; line-height: 0;" class="mce_SELRES_start"></span>
Vídeo.

Espero que les sirvan estos artículos para iniciarse en este mundo tan emocionante y con tantos caminos por andar. Esto es todo por este simple tutorial, como parte de una serie de artículos sobre estos nuevos dispositivos que nos permiten utilizar los recursos del Internet de las cosas.

ANEXO: Debido a la demanda de los lectores, y gracias a la web desapaecida Muerde la apple se adjunta el archivo MPU6050_PMT que puede usted descargar de aquí.

Ayúdenos a mantener la comunidad en lo positivo y útil.
Sobre el tema, sea respetuoso con todas las edades y niveles
con la habitual responsabilidad.
Sea amable y no haga Spam – ¡Gracias!

https://www.luisllamas.es/como-usar-un-acelerometro-arduino/
https://www.luisllamas.es/arduino-orientacion-imu-mpu-6050/
https://www.youtube.com/watch?v=uN8SYfGwYVw&t=164s
http://www.naylampmechatronics.com/blog/45_Tutorial-MPU6050-AceleróB3metro-y-Giroscopio.html
https://www.youtube.com/watch?v=ecgSCQDNkcQ&t=12s

42 comentarios sobre «Configurar el MPU6050.»

Jesús Sánchez dice:

7 marzo, 2018 a las 0:23

Gracias Vicente por el tutorial, tan bien explicado.

Saludos.

Accede para responder
1. Vicente García dice:
  
  7 marzo, 2018 a las 10:01
  
  Hola Jesús Sánchez.
  
  Gracias.
  
  Accede para responder
  1. Hernán dice:
    
    27 mayo, 2020 a las 20:01
    
    Hola, una pregu ta estoy haciendo lamparte de la calibración cómo se menciona en el artículo pero no más no converge a ni gún dato, ya lleva más de 12 minutos y nada, que puede ser?
    
    Accede para responder
    1. Vicente García dice:
      
      6 junio, 2020 a las 11:15
      
      Hola Hernán.
      Por lo que me dices cabe la posibilidad de que tengas un problema de cableado, por lo que te aconsejo que revises las conexiones y las soldaduras, suelen desaparecer los problemas en su mayoría.
      Es cierto que es fácil desesperarse con estas cosas pero cuando lo superas te das un baño de satisfacción. No sabría que más aconsejarte con la información que me indicas.
      
      Saludos.
      
      Accede para responder
Jose R. dice:

14 marzo, 2018 a las 23:39

Estimado Sr. Vicente,
Gracias por su ayuda. Es muy útil y buen artículo. Muchas felicidades.
Sin embargo, quisiera hacerle unas preguntas. Una vez cargado en la placa de Arduino el código de calibración, el resultado mostrado en el monitor serie no es igual que la figura 6 que usted muestra en este blog. Es decir, una vez cargado el código en el monitor serie y enviado el carácter, empiezan a salir números que no terminan nunca y que no dan un resultado. Solo cuándo se vuelve a abrir el monitor serie aparecen unos resultados y no tan bien clasificados cómo en la figura 6. Ademas, por alguna otra razón, aunque la calibración la haya realizado en el plano y con un perfecto 0º, los resultados mostrados una vez rectificados los valores SET (según lo que yo interpreto del monitor serie), nunca obtengo en pantalla ni el 0º ni el 90º cuándo lo giro. El error suele ser de +/-3º o más.
Gracias,
Jose

Accede para responder
Vicente García dice:

20 marzo, 2018 a las 18:29

Hola Jose R.
Los resultados de la figura 6, digamos que son los ideales, en realidad, lo que hacemos al ejecutar dicho programa en nuestro MPU6050, lo que hacemos es exactamente eso calibrarlo. Me explico, al ejecutar el programa de calibrado, debemos esperar un tiempo (45 seg. a 1 minuto) y aún así puede que no lleguemos a esos valores ideales, sin embargo, con los valores obtenidos, modificaremos nuestros programa MPU6050_PMT, en las líneas 228 a 231, como se indica en:
Abriremos el archivo MPU6050_PMT y buscaremos la parte de Calibration results como se aprecia en la figura 7 que sigue.
También se dice que se calibrará una sola vez. En cuanto al desvío de las lecturas del orden del ±3 %, se puede deber al propio MPU, personalmente no he tenido ocasión de comprobar estos datos.
Espero haber dado respuesta a su consulta.
Saludos.

Accede para responder
José R. dice:

29 marzo, 2018 a las 22:41

Muchas gracias por la respuesta.
Si, los valores que da el sensor son muy aceptables. Si pudiera conseguir una superficie más plana quizás llegaría al ángulo deseado.

Accede para responder
jose ricardo dice:

24 mayo, 2018 a las 20:50

Buenas tardes, estoy trabajando con un MPU-9250, usted sabe como cambiar el valor de la escala del giroscopio a +-2000 °/S

Accede para responder
Darío dice:

19 diciembre, 2018 a las 17:58

Hola, gracias por la explicación. Estoy intentando entender por qué no es posible medir la velocidad angular en el eje z, siendo que con la función getRotation() supuestamente se obtiene en los tres ejes, luego integrando obtendría el ángulo rotado en z, ¿por qué es así? ¿Necesariamente hay que usar un magnetómetro para ello?

Gracias!

Accede para responder
Michael dice:

25 marzo, 2019 a las 9:31

Buenos días Vicente
Muy bueno tu artículo explicando la calibración del MPU6050.
¿Tendrás información similar para calibrar el sensor LSM9DS1 y para estimar correctamente los ángulos Roll, Pitch y Yaw? Tiene 9 ejes: 3 de acel, 3 de gir y 3 de mag.
Muchas gracias
Michael

Accede para responder
1. Vicente García dice:
  
  2 abril, 2019 a las 20:39
  
  Hola Michael.
  Disculpa pero no tengo experiencias con este dispositivo y por lo tanto no puedo darte una respuesta adecuada.
  
  Saludos.
  
  Accede para responder
Alex dice:

27 julio, 2019 a las 12:39

Buenas, gracias por el tutorial! Todo perfectamente explicado!

Tengo una pequeña duda, puesto que empiezo a meterme en el mundillo de Arduino des de hace muy poquito, no termino de comprender algunas estructuras de programación. He programado en python y entiendo como funciona un codigo y demas, pero cada lenguaje es un mundo.

En las ultimas lineas del codigo, comentas para mostrar los valores por consola, la variable declarada como «valores» contiene toda la información del sensor? Puedo usar esa variable para enviarla, por ejemplo, a traves de un modulo LORA?
No entiendo porque en el print añades esto : «90» ……… «-90». Entiendo que es un texto que añades, pero que funcionalidad tiene??

Gracias una vez mas, disculpa mi ignorancia si las preguntas son un poco basicas y saludos! Gran trabajo! 😀

Accede para responder
1. Vicente García dice:
  
  31 julio, 2019 a las 21:59
  
  Hola Alex.
  
  Gracias por tus palabras.
  
  En efecto:
  //Mostrar los valores por consola valores = "90, " +String(Angle[0]) + "," + String(Angle[1]) + "," + String(Angle[2]) + ", -90"; Serial.println(valores);
  
  La variable ‘valores’, como verás es una cadena de valores que se ha compuesto para el caso. Es decir, se concatenan los
  valores de String(Angle[0]), String(Angle[1]) y String(Angle[2]) en una misma línea para una mejor comprensión. Los límites
  están entre 90 y -90, si relees el artículo verás el porque.
  
  En cuanto a lo que dices de enviar por un módulo LORA, la verdad no tengo experiencia con este tema.
  
  Lo siento.
  
  Accede para responder
Angel dice:

15 diciembre, 2019 a las 21:41

Hola! gracias por el tutorial pero una vez cargado el programa MPU6050_DMP6 y enviar el caracter, me aparece lo siguiente:
Checking hardware revision…
Revision @ user[16][6] = A5
Resetting memory bank selection to 0…
>************************************************
y no dejan de salir los * , ¿alguna solucion?

Accede para responder
1. Vicente García dice:
  
  21 enero, 2020 a las 10:21
  
  Hola Angel.
  El problema que refieres, creo que se produce por una compilación erronea por parte del sistema.
  En alguna ocasión se ha presentado un problema semejante y he tenido que reinicar el PC, para conseguir que se complie bien.
  No se de otra solución.
  
  Saludos.
  
  Accede para responder
Ikar59 dice:

9 enero, 2020 a las 16:39

Buenos dias. Gracias por este artículo. Tengo una pregunta, cual es el archivo MPU6050_PMT al que haces referencia? es un sketch más, necesario para la calibración? O es un proyecto particular en el cual se usa el mpu6050?

Accede para responder
1. Vicente García dice:
  
  21 enero, 2020 a las 10:08
  
  Hola Ikar59.
  
  Ante todo, gracias portus palabras.
  Si te fijas, en el propio artículo se hace referencia a dicho archivo. El código por el que preguntas se muestra a continuación de la figura 5.
  
  Fig. 5 Ejes Tait-Brayan o Euler
  Podemos solucionar estos problemas al configurar el módulo MPU6050 OFFSETS, para compensar dichos errores. Este código nos sirve para calibrar los offset del MPU6050. // calibrar_mpu6050.ino // Librerias I2C para controlar el mpu6050 con Arduino, // la libreria MPU6050.h necesita I2Cdev.h, la libreria I2Cdev.h necesita Wire.h Espero que te haya servido la respuesta.
  Saludos.
  
  Accede para responder
Juan Carlos dice:

24 enero, 2020 a las 16:33

Hola Vicente,
Muchas gracias por este magnífico tutorial. Tengo un par de preguntas. La primera es ¿Dónde puedo encontrar el archivo MPU6050_PMT al que el tutorial hace referencia? Dice que hay que abrirlo pero no especifica dónde se encuentra.
La otra pregunta es que, para el proyecto que estoy creando necesitaría que no imprimiera los datos en el puerto serie varias veces por segundo sino que lo hiciera cada 10 segundos aprox. He intentado esto modificando el delay pero entonces me da grandes errores en la medición de los ángulos.
Gracias por tu atención

Accede para responder
1. Vicente García dice:
  
  25 enero, 2020 a las 12:00
  
  Hola Juan Carlos.
  
  Debido a que no eres el primero que me pide el MPU6050_PMT, he incluido este archivo en el anexo que aparece al final del artículo, de donde puedes descargarlo.
  
  En cuanto al tema de reducir los datos mostrados en el monitor serie, no sabría decirte con seguridad vomo proceder, de todas formas se me ocurre que deberías probar a modificar ~~el valor de dt = (millis() - tiempo_prev) / 1000.0; cambiando el valor del ivisor por 10 en lugar de 1000, ya te digo (que no lo he probado) lo pruebes y ya me dirás que resultado te da.~~ (Lo que había puesto no tiene sentido) He revisado otra vez el código y no se me ocurre que podrías probar. Piensa que se trata de información importante de navegación, si lo que quieres es obtener otra cosa ya no se que decir.
  
  El Delay no lo debes cambiar por el motivo que ya sabes.
  
  Saludos.
  
  Accede para responder
  1. Juan Carlos dice:
    
    26 enero, 2020 a las 19:37
    
    Muchas gracias 🙂
    
    Accede para responder
Juan Carlos dice:

25 enero, 2020 a las 13:32

Hola de nuevo Vicente.
Disculpa, es posible que esté cometiendo algún error ya que soy bastante nuevo en Arduino. He cargado el sketch de calibrado, he abierto el puerto serir, ha empezado a calibrar y lo he dejado correr durante varias horas pero nunca termina y da la impresión que no llega a calibrarse. Debo cerrar el puerto serir y el sketch y continuar con el siguiente paso, el escalado? o debo intentar alguna otra cosa
Gracias por tu atención. Un cordial saludo

Accede para responder
1. Vicente García dice:
  
  29 enero, 2020 a las 11:16
  
  Hola Juan Carlos.
  Para hacer el calibrado en primer lugar debes tener el módulo a calibrar en estado fijo, no moverlo. Cuando está fijo es el momento de ejecutar el boceto de calibrado, puede que le cuesta un tiempo llegar a una salida regular, luego con le trasladas esos parámetros al boceto y a partir de ahí todo te debe funcionar.
  
  Saludos.
  
  Accede para responder
Ronald dice:

4 febrero, 2020 a las 16:04

Hola Vicente.

Se puede configurar el MPU6050 para que dispare una salida por el pin de interrupcion por ejemplo indicando que existe movimiento? Me preguntaba si seria util esta manera para usarlo como alarma?

Accede para responder
1. Vicente García dice:
  
  5 febrero, 2020 a las 20:15
  
  Hola Ronald.
  
  No llego a entender que pretendes realizar, MPU6050 contiene un giroscopio de tres ejes con el que podemos medir velocidad angular y un acelerómetro también de 3 ejes con el que medimos los componentes X, Y y Z de la aceleración.
  
  Desde luego que si quieres detectar si se produce un movimiento bien en un objeto que se mueve delante del detector o bien si es el propio detector el que se mueve.
  
  Para ese caso estaría mejor utilizar un snesor de movimiento como HC-SR501 u otro similar hay muchos detectores especializados para detectar movimiento.
  
  Saludos.
  
  Accede para responder
  1. Ronald dice:
    
    8 febrero, 2020 a las 3:23
    
    Pensaba que se podia usar el acelerometro por ejemplo para detectar si un vehiculo se mueve teniendo el mpu6050 dentro del vehiculo que tendria un estado de reposo y otro de movimiento que generaria una interrupcion para poder enviar alguna alarma que se dispara por medio del Wake-on Motion.
    
    En el documento Register Map and Register Descriptions document del MPU6500 indica
    
    4.10 Register 31 – Wake-on Motion Threshold
    Serial IF: R/W
    Reset value: 0x00
    BIT
    NAME
    FUNCTION
    [7:0]
    
    WOM_THRESHOLD
    This register holds the threshold value for the Wake on Motion Interrupt for accel x/y/z axes. LSB = 4mg. Range is 0mg to 1020mg.
    For more details on how to configure the Wake-on-Motion interrupt, please refer to section 5 in the MPU-6500 Product Specification document.
    
    7.18 Interrupts
    Interrupt functionality is configured via the Interrupt Configuration register. Items that are configurable include the INT pin configuration, the interrupt latching and clearing method, and triggers for the interrupt. Items that can trigger an interrupt are (1) Clock generator locked to new reference oscillator (used when switching clock
    sources); (2) new data is available to be read (from the FIFO and Data registers); (3) accelerometer event interrupts; and (4) the MPU-60X0 did not receive an acknowledge from an auxiliary sensor on the secondary I2C bus. The interrupt status can be read from the Interrupt Status register.
    For further information regarding interrupts, please refer to the MPU-60X0 Register Map and Register Descriptions document.
    For information regarding the MPU-60X0’s accelerometer event interrupts, please refer to Section 8.
    
    8 Programmable Interrupts
    The MPU-60X0 has a programmable interrupt system which can generate an interrupt signal on the INT pin. Status flags indicate the source of an interrupt. Interrupt sources may be enabled and disabled individually.
    Table of Interrupt Sources Interrupt Name Module
    FIFO Overflow
    FIFO
    Data Ready
    Sensor Registers
    I2C Master errors: Lost Arbitration, NACKs
    I2C Master
    I2C Slave 4
    I2C Master
    
    For information regarding the interrupt enable/disable registers and flag registers, please refer to the MPU-6000/MPU-6050 Register Map and Register Descriptions document. Some interrupt sources are explained below.
    
    Accede para responder
    1. Vicente García dice:
      
      11 marzo, 2020 a las 23:59
      
      Hola Ronald.
      
      Lo siento, no he tenido tiempo para revisar tu consulta y por otra parte creo que necesita un estudio más dedicado debido a las interrupciones y sus posibles configuraciones, lo que no domino lo suficiente.
      
      Saludos.
      
      Accede para responder
Pao dice:

11 marzo, 2020 a las 0:20

¿Cómo junto el codigo de calibracion con el de PMT?

Accede para responder
1. Vicente García dice:
  
  12 marzo, 2020 a las 0:05
  
  Hola Pao.
  
  El resultado del calibrado, es decir, los valores obtenidos del calibrado, son los que debes introducir en el código del MPT, fíjate en el texto de la figura 7 (Abriremos el archivo MPU6050_PMT y buscaremos la parte de Calibration results como se aprecia en la figura que sigue.) Supongo que te refieres a eso.
  
  Saludos.
  
  Accede para responder
Thomas dice:

13 mayo, 2020 a las 4:17

El terminal int es mas como un data ready que se puede usar como una interrupcion, para procesar el dato, al menos asi he visto como lo usan en otros SKETCHES
Saludos

Accede para responder
1. Thomas dice:
  
  13 mayo, 2020 a las 4:24
  
  Segun veo esta ligado a otro dispositivo interno del MPU6050 el DMP, acabo de ver un ejemplo
  por lo que lei es un filtro interno, y cuando esta listo a entregar los datos genera una int
  
  Accede para responder
  1. Vicente García dice:
    
    16 mayo, 2020 a las 16:57
    
    Hola Thomas.
    
    Entiendo que has encontrado la respuesta a tu consulta, es bastante complejo el MPU6050, por lo que es muy interesante leer las hojas de especificaciones, las cuales pueden darnos una respuesta en muchas ocasiones.
    
    Saludos.
    
    Accede para responder
Pablo dice:

2 agosto, 2020 a las 13:45

Estimado Vicente quiero consultarle sobre el MPU 9250, Usted ha trabajado con el mismo?
He comprado dos modulos MPU-9250/6500 con diferencia de dos años cada uno y en ambos no obtengo lectura en el eje «Y» de aceleracion.
Por otro lado compre un sensor MPU-92/65 y este funciona correctamente.
Gracias

Saludos
Pablo

Accede para responder
1. Vicente García dice:
  
  3 agosto, 2020 a las 11:19
  
  Hola Pablo.
  Lamento decirte que no he utilizado ese sensor, no obstante, debes leer con atención las hojas del fabricante para entender que y como hacer con el dispositivo. En cuanto a lo de comprar un mismo producto con fechas distintas puede comportar desfases en los resultados en el mejor de los casos, por lo tanto, es de esperar que haya derivas en los resultados, aunque no siempre.
  Todos los dispositivos que me indicas están fuera de mis proyectos y por lo tanto poco o nada te puedo aconsejar salvo que leas las notas del fabricante.
  
  Lo siento. Saludos.
  
  Accede para responder
Aritz dice:

12 mayo, 2021 a las 21:32

Buenas Vicente,

Primero de todo gracias por el trabajo, es un tutorial espectacular.
En el programa «Escalando lecturas», dices que el acelerómetro MPU6050 puede funcionar a 2g/4g/8g/16g y que por defecto viene con 2g. ¿Sabrías explicarme cómo cambiar a 8 o 16g ?

Gracias,
Saludos

Accede para responder
1. Vicente García dice:
  
  14 mayo, 2021 a las 19:46
  
  Hola Aritz.
  Gracias por tus palabras.
  Respecto a tu pregunta sobre el escalado de lecturas según las notas del fabricante del acelerómetro MPU6050 puede funcionar a ±2g/±4g/±8g/±16g, aunque por defecto viene configurado en ±2g.
  Si lees las notas del fabricante en el apartado 4.5 describe la configuración del acelerómetro (ACCEL_CONFIG) en los bit 3 y bit4, AFS_SEL selecciona el rango de escala completa de las salidas del acelerómetro de acuerdo con los siguientes valores
  0/±2g, 1/±4g, 3/±8g, 4/±13g
  Ten en cuenta que el valor AFS_SEL sin signo de 2 bits. Selecciona el rango de escala completa del acelerómetro. Por ejemplo:
  
  //================= Subrutina inicilialización (solo se ejecuta una vez al iniciar el programa) void init_gyro() { Wire.beginTransmission(MPU6050_address); Wire.write(0x6B); // PWR_MGMT_1 registro 6B hex Wire.write(0x00); // 00000000 para activar Wire.endTransmission(); Wire.beginTransmission(MPU6050_address); Wire.write(0x1B); // GYRO_CONFIG registro 1B hex Wire.write(0x08); // 00001000: 500dps Wire.endTransmission(); Wire.beginTransmission(MPU6050_address); Wire.write(0x1C); // ACCEL_CONFIG registro 1C hex Wire.write(0x10); // 00010000: +/- 8g Wire.endTransmission();
  Wire.beginTransmission(MPU6050_address); Wire.write(0x1A); // LPF registro 1A hex Wire.write(0x03); // 256Hz(0ms):0x00 - 188Hz(2ms):0x01 - 98Hz(3ms):0x02 - 42Hz(4.9ms):0x03 - 20Hz(8.5ms):0x04 - 10Hz(13.8ms):0x05 - 5Hz(19ms):0x06 Wire.endTransmission(); }
  
  Espero que te quede claro el tema.
  
  Saludos y cuídate.
  
  Accede para responder
Angel Labombarda dice:

24 julio, 2021 a las 0:51

Hola, ya he probado el MPU6050 con Arduino UNO, seria posible para no usar la PC realizar la visualizacion a traves de una pantalla TFT 3.5″ LCD Shield ?
Muchas gracias.

Accede para responder
Gregory Ch. dice:

11 septiembre, 2021 a las 17:45

Buenas Vicente,
Ante todo, que gran tutorial. Te escribo para consultarte si podrías ayudarme con un error, ya que al iniciar el código el monitor serial se queda en : «Initializing I2C devices…». No he encontrado solución a este error por ningún lado.

Saludos cordiales,

Gregory Ch.

Accede para responder
1. Vicente García dice:
  
  22 septiembre, 2021 a las 12:05
  
  Hola Gregory Ch.
  No he tenido tiempo para investigar tu caso. No obstante, parece un problema de librerías, en principio yo actualizaría todas las librerías involucradas para salir de dudas. Si eso no da solución, ya tendrías que pensar en otros motivos, como por ejemplo probar con un segundo sensor (esto es muy poco probables). Espero que encuentres una solución, en todo caso dime como sigues.
  
  Saludos y cuídate.
  
  Accede para responder
iñigo Martínez Díez dice:

25 abril, 2022 a las 18:12

Buenos días
Estoy haciendo pruebas para la medición de inclinación y en todos los codigos que encuentro incluido este se trata de forma muy especial al eje z. Y esto lleva a problemas y es que he hecho pruebas agitando el giroscopio muy rápido y los valores X e Y vuelven a la posición que le corresponde sin embargo el eje Z igual tiene una inclinación 30 grados mayor o menor a la que debería. ¿Por qué pasa esto y como hago para solucionarlo?

Accede para responder
Leyna dice:

6 junio, 2022 a las 19:46

Hola, buenos días, tengo que realizar un proyecto y necesito utilizar 4 de estos módulos mpu6050, pero no sé cómo programar más de un módulo y la verdad no entiendo mucho de este código. Serías tan amable de decirme o mostrarme cómo puedo programar los 4 mpu6050?

Gracias.

Accede para responder
Edwin dice:

12 septiembre, 2022 a las 18:28

Intento compilar el codigo para corregir los offset, pero, al compilar me sale que no estan declaradas «amp» y «gt». He revisado y encuentro que esas variables estan presentes en todo el codigo. Podría ayudarme con este problema. Muchas gracisas

Accede para responder
1. Vicente García dice:
  
  23 septiembre, 2022 a las 9:35
  
  Hola Edwin.
  Entiendo tu problema, se ha producido un error tipográfico producido por un cambio en el editor del programa. En pocas palabras, donde dice «&» se ha de cambiar por el signo & y donde dice «>» se ha de cambiar por > así que sólo debes cambiar esos signos por los adecuados. Por ejemplo:
  sensor.getAcceleration(&ax, &ay, &az); sensor.getRotation(&gx, &gy, &gz);
  // Filtrar las lecturas f_ax = f_ax-(f_ax>>5)+ax; p_ax = f_ax>>5;
  
  Espero te sirva la explicación.
  Saludos.
  
  Accede para responder