Giroscopos - UAV's

[PCCM]

Cuanto más muestras obtienes para obtener el offset menor es la variación en cada cálculo del offset, ya que se obtiene más datos del ruido involucrado. Yo hago algo parecido como tu pero en vez de calcular 50 veces el offset con 600 muestras, calculo el offset solo una vez con 3000 muestras.

Como analizaste en las graficas el calculo en el offset nunca va a ser constante, parece que es por la variación de la temperatura ya que es un factor importante en la suma del ruido.

Viendo en el datasheet del sensor que uso mpu6050, un dato nos da esta variación: "Sensitivity change vs Temperature" = +-0.02%/grados centigrados
lo cual nos dice que por cada variación de 1 grados centigrado tenemos una variación de +-2% de lo sensado.
En el sensor que uso en promedio en cada lectura la temperatura varia 0.19 miligrados. el cual parte de casi 26 grados hasta 32 grados después de varios segundos en el cual se estabiliza, pero siempre variando.

Puede ser que el mayor ruido que viste en el ejex, sea aleatorio, en mi caso cada vez que hago pruebas. a veces el ejex, ejey o ejez son más ruidosos.
Y las pruebas que estas haciendo es para movimientos lentos, podrías hacer pruebas para movimientos bruscos, ya que en el comportamiento real será asi. En las pruebas que hice cuando hago movimientos bruscos, el sensor se desvia demasiado en pocos segundos. por ejemplo de 0,0,0 a 66,4,88. o a otros valores pero el desvió es demasiado.

[elgarbe]

Cuanto más muestras obtienes para obtener el offset menor es la variación en cada cálculo del offset, ya que se obtiene más datos del ruido involucrado. Yo hago algo parecido como tu pero en vez de calcular 50 veces el offset con 600 muestras, calculo el offset solo una vez con 3000 muestras.

Es cierto, no sé si tiene mucho sentido hacer promedio de medias...

Como analizaste en las graficas el calculo en el offset nunca va a ser constante, parece que es por la variación de la temperatura ya que es un factor importante en la suma del ruido.

Viendo en el datasheet del sensor que uso mpu6050, un dato nos da esta variación: "Sensitivity change vs Temperature" = +-0.02%/grados centigrados
lo cual nos dice que por cada variación de 1 grados centigrado tenemos una variación de +-2% de lo sensado.
En el sensor que uso en promedio en cada lectura la temperatura varia 0.19 miligrados. el cual parte de casi 26 grados hasta 32 grados después de varios segundos en el cual se estabiliza, pero siempre variando.

Puede ser que el mayor ruido que viste en el ejex, sea aleatorio, en mi caso cada vez que hago pruebas. a veces el ejex, ejey o ejez son más ruidosos.
Y las pruebas que estas haciendo es para movimientos lentos, podrías hacer pruebas para movimientos bruscos, ya que en el comportamiento real será asi. En las pruebas que hice cuando hago movimientos bruscos, el sensor se desvia demasiado en pocos segundos. por ejemplo de 0,0,0 a 66,4,88. o a otros valores pero el desvió es demasiado.

Voy a ver el tema de la temperatura. Quizá podría loguear un dia entero RAW data vs Temperatura y ver que obtengo.

Lo de los ejes es cierto, a veces esa deriva se ve en el eje X, a veces en el Y.

La deriva con el movimiento no sé bien a que responde, fijate en mis ejemplos que al finalizar y dejar el sensor en reposo aparecen unos grados de deriva, que no son por el offset ya que si ves cuanto se deriva cuando esta quieto en ese tiempo no da tanta driva....

Por cierto, tenes algo de filtro complementario para combinar los datos del gyro y del accel? en matlab?

Saludos!

[PCCM]

No se puede ver bien la deriva que tienes cuando esta quieto al inicio. Pero se ve que son solo por 18 segundos.
pero cuando lo mueves y dejas de mover analizas la desviación después de 60 segundos.

El filtro complementario es en una sola linea:
Angulo_estimado=alpha*(Angulo_debido_gyro) + (1-alpha)*(Angulo_debido_acel)

donde alpha generalmente es un valor alto(0.98, 0.99, ..), este se comporta como filtro pasa bajos para el acelerometro y filtro pasa altos para el giroscopo.
ya que para tiempos pequeños es bueno el gyro, pero para largos tiempos se aprovecha el acelerometro para que lo corrija.

Como se ve el analisis solo es en frecuencia, y como sabrás el filtro complementario es un filtro kalman "reducido", en el filtro complementario no se considera el análisis estadístico del ruido en la salida y en el proceso. Lo problemático de kalman es hallar estos datos estadísticos(covarianza) y datos iniciales, ya que por ejemplo se puede hallar la covarianza del ruido a la salida, midiendo la diferencia entre el angulo calculado entre el giroscopo y acelerometro, pero la covarianza del ruido en el proceso generalmente se estima con las pruebas y error que se realizan.

Además si se quiere usar el filtro kalman eficientemente, no es suficiente usar tal filtro sino su variación: el filtro kalman extendido, ya que este ultimo se basa en la estimación del angulo para sistemas no lineales, los cuales son realmente como se comporta el gyro y acelerometro.

Pero no son los unicos , hay varios algoritmos , como el de Mahony, Madgwick, etc

En un post mio sobre "ayuda de acelerómetro" tenía el problema sobre estos estimadores. cuando implementes tu estimador de actitud(sea por filtro complementario o cualquier otro) prueba dejandolo quieto en la mesa y moviendolo de un lado a otro, supuestamente en cabeceo y banqueo debe permanecer en 0 grados pero aumenta debido a la acelereración provocada.

Saludos.

[jonathanPIC888]

Hola como están. Siguiendo sus consejos he implementado una librería para CCS del L3G4200D, con los siguientes resultados:

Eso es en reposo...

Código: [Seleccionar]

GYRO SCALED x:0.06,y:-0.10,z:0.02

GYRO RAW x:-010,y:0003,z:0005

GYRO SCALED x:0.00,y:-0.03,z:-0.04

GYRO RAW x:-010,y:0003,z:0005

GYRO SCALED x:0.06,y:-0.03,z:0.02

GYRO RAW x:-010,y:0003,z:0006

GYRO SCALED x:0.06,y:-0.03,z:-0.04

GYRO RAW x:-011,y:0002,z:0004

GYRO SCALED x:0.13,y:-0.10,z:-0.18

GYRO RAW x:-010,y:0003,z:0004

GYRO SCALED x:0.06,y:-0.10,z:-0.04

Giro completo en el eje Z....

Código: [Seleccionar]

GYRO SCALED x:0.20,y:0.10,z:-2.35

GYRO RAW x:-039,y:-437,z:-571

GYRO SCALED x:-11.97,y:-6.26,z:-363.62

GYRO RAW x:0005,y:0427,z:-921

GYRO SCALED x:-5.32,y:-9.20,z:-272.97

GYRO RAW x:-007,y:-008,z:0329

GYRO SCALED x:0.00,y:0.10,z:18.01

GYRO RAW x:-010,y:0005,z:0192

GYRO SCALED x:0.06,y:0.03,z:15.21

Los datos no me coinciden mucho con los de sus ejemplos...quizá sea por los tipos de datos...pero sinceramente no estoy muy seguro si las lecturas son correctas al 100%.

igual les dejo mi código de ejemplo y la librería:

Código: C

1. // CCS library compilation [2014]
2. // Driver para el giroscopio L3G4200D.
3. // Programador: Moyano Jonathan
4. // Compilador: CCS v4.140
5. // Versión de la librería: v1.0 Revisión: 0.1
6. // Fecha de modificación: Enero de 2014.
7.  
8. // Definición de macros y funciones
9. #include <L3G4200D.h>  
10.  
11. // Desarrollo de las funciones de usuario.
12.  
13. void L3G4200D_write(int8 reg_address, int8 value){
14.  
15.    i2c_start();                       // Inicializa comunicación I2C, condición de start.
16.    i2c_write(L3G4200D_WRITE_DEV_ADD); // Envíamos la dirección del dispositivo + comando para escritura.
17.    i2c_write(reg_address);            // Indicamos que registro será escrito.
18.    i2c_write(value);                  // Enviamos el nuevo valor al registro.
19.    i2c_stop();                        // Condición de stop.
20.  
21. }
22.  
23. unsigned char L3G4200D_read(unsigned char reg){
24.  
25. unsigned char val = 0x00;  // Variable auxiliar.
26.    
27.    i2c_start();                       // Inicializa comunicación I2C, condición de start.
28.    i2c_write(L3G4200D_WRITE_DEV_ADD); // Envíamos la dirección del dispositivo + comando para escritura.
29.    i2c_write(reg);                    // Indicamos que registro será leído.
30.    i2c_start();                       // Reiniciamos la comunicación.
31.    i2c_write(L3G4200D_READ_DEV_ADD);  // Envíamos la dirección del dispositivo + comando para lectura.
32.    val = i2c_read(0);                 // Leemos el registro.        
33.    i2c_stop();                        // Condición de stop.
34.    return(val);                       // Retornamos con el valor leído.
35. }
36.  
37.  
38. void L3G4200D_GetRawAxis(signed int16 *rx, signed int16 *ry, signed int16 *rz){
39.  
40. // Variables auxiliares.
41. signed int16 ax=0x00;
42. signed int16 ay=0x00;
43. signed int16 az=0x00;
44. int8  lsb,msb;
45.  
46.  msb=L3G4200D_read(L3G4200D_OUT_X_H);
47.  lsb=L3G4200D_read(L3G4200D_OUT_X_L);
48.    ax=make16(msb,lsb);
49.  msb=L3G4200D_read(L3G4200D_OUT_Y_H);
50.  lsb=L3G4200D_read(L3G4200D_OUT_Y_L);
51.    ay=make16(msb,lsb);
52.  msb=L3G4200D_read(L3G4200D_OUT_Z_H);
53.  lsb=L3G4200D_read(L3G4200D_OUT_Z_L);
54.    az=make16(msb,lsb);
55.  
56.   *rx=ax;
57.   *ry=ay;
58.   *rz=az;
59. }
60.  
61. void L3G4200D_init(int16 rango){
62.  
63.   // Habilitamos los ejes X,Y,Z y encendemos el dispositivo.
64.   L3G4200D_write(L3G4200D_CTRL_REG1,0b00001111);
65.   // Configuración del registro CTRL_REG2.
66.   L3G4200D_write(L3G4200D_CTRL_REG2,0b00011001);
67.   // Configuramos el registro CTRL_REG3.
68.   L3G4200D_write(L3G4200D_CTRL_REG3,0x00);
69.   // Configuramos el registro CTRL_REG5.
70.   L3G4200D_write(L3G4200D_CTRL_REG5,0b00010011);
71.  
72.   // Configuramos el rango.
73.  
74.   if(rango == 250){
75.     L3G4200D_write(L3G4200D_CTRL_REG4,0x00); // 250  º/seg
76.   }else if(rango == 500){
77.     L3G4200D_write(L3G4200D_CTRL_REG4,0x10); // 500  º/seg
78.   }else{
79.     L3G4200D_write(L3G4200D_CTRL_REG4,0x20); // 2000 º/seg
80.   }
81.  
82. }
83.  
84. int8 ReadWhoAmI(void){
85.  
86. // Variable auxiliar.
87.  int8 value=0x00;
88.   value=L3G4200D_read(L3G4200D_WHO_AM_I); // Leemos el registro.
89.     return(value);                        // Retornamos con el valor.
90. }
91.  
92. void L3G4200D_GetBiass(float *_bx, float *_by, float *_bz){
93.  
94. // Variable auxiliar.
95. int16 i=0x00;
96. signed int16 _x,_y,_z;
97. float biass_X;
98. float biass_Y;
99. float biass_Z;
100.  
101.    // Obtenemos 600 muestras cada 1ms.
102.    for (i =0; i<600; i += 1) {
103.       L3G4200D_GetRawAxis(&_x,&_y,&_z);
104.       biass_X += _x;
105.       biass_Y += _y;
106.       biass_Z += _z;
107.       delay_ms(1);
108.    }
109.    
110.    // Promediamos..
111.    biass_X /= 600;
112.    biass_Y /= 600;
113.    biass_Z /= 600;
114.    
115.    // Retornamos los valores.
116.    *_bx = biass_X;
117.    *_by = biass_Y;
118.    *_bz = biass_Z;
119. }
120.  
121. void L3G4200D_GetScaledAxis(float *_sx, float *_sy, float *_sz, float biassX, float biassY, float biassZ, int16 rango){
122.  
123. signed int16 _x,_y,_z;
124. float gx,gy,gz;
125. float escala;
126.  
127.   // Adquirimos los datos crudos..
128.   L3G4200D_GetRawAxis(&_x,&_y,&_z);
129.   // A los datos crudos le resto el biass.
130.    gx=((float)_x - biassX);
131.    gy=((float)_y - biassY);
132.    gz=((float)_z - biassZ);
133.    
134.  // La sensibilidad va a estar determinada por el rango...
135.  
136.    if(rango == 250){ escala = 0.00875;      // 250  º/seg
137.   }else if(rango == 500){escala = 0.0175;   // 500  º/seg
138.   }else{escala = 0.07;                      // 2000 º/seg
139.   }
140.  
141.   // Determino los datos correctos, utilizando la fórmula: (RAW - Offset) * Sensibilidad
142.    gx *= escala;
143.    gy *= escala;
144.    gz *= escala;
145.    
146.     // Retornamos con los datos.
147.     *_sx = gx;
148.     *_sy = gy;
149.     *_sz = gz;
150. }

encabezado...

Código: C

1. // CCS library compilation [2014]
2. // Driver para el giroscopio L3G4200D.
3. // Programador: Moyano Jonathan
4. // Compilador: CCS v4.140
5. // Versión de la librería: v1.0 Revisión: 0.1
6. // Fecha de modificación: Enero de 2014.
7.  
8. // Macros y definición de registros internos.
9.  
10. #define L3G4200D_WRITE_DEV_ADD  0xD0
11. #define L3G4200D_READ_DEV_ADD   0xD1
12.  
13. #define L3G4200D_WHO_AM_I       0x0F
14.  
15. #define L3G4200D_CTRL_REG1      0x20
16. #define L3G4200D_CTRL_REG2      0x21
17. #define L3G4200D_CTRL_REG3      0x22
18. #define L3G4200D_CTRL_REG4      0x23
19. #define L3G4200D_CTRL_REG5      0x24
20. #define L3G4200D_REFERENCE      0x25
21. #define L3G4200D_OUT_TEMP       0x26
22. #define L3G4200D_STATUS_REG     0x27
23.  
24. #define L3G4200D_OUT_X_L        0x28
25. #define L3G4200D_OUT_X_H        0x29
26. #define L3G4200D_OUT_Y_L        0x2A
27. #define L3G4200D_OUT_Y_H        0x2B
28. #define L3G4200D_OUT_Z_L        0x2C
29. #define L3G4200D_OUT_Z_H        0x2D
30.  
31. #define L3G4200D_FIFO_CTRL_REG  0x2E
32. #define L3G4200D_FIFO_SRC_REG   0x2F
33.  
34. #define L3G4200D_INT1_CFG       0x30
35. #define L3G4200D_INT1_SRC       0x31
36. #define L3G4200D_INT1_THS_XH    0x32
37. #define L3G4200D_INT1_THS_XL    0x33
38. #define L3G4200D_INT1_THS_YH    0x34
39. #define L3G4200D_INT1_THS_YL    0x35
40. #define L3G4200D_INT1_THS_ZH    0x36
41. #define L3G4200D_INT1_THS_ZL    0x37
42. #define L3G4200D_INT1_DURATION  0x38
43.  
44. // Definimos los pines utilizados para la comunicación (POR DEFECTO).
45. #define _SDA PIN_B0
46. #define _SCL PIN_B1
47.  
48. // Configuramos el puerto utilizado para la comunicación I2C a 400Khz.
49. #use i2c(Master,Fast, SDA=_SDA, SCL=_SCL)  
50.  
51. // Escribe un registro del L3G4200D.
52. void L3G4200D_write(int8 reg_address, int8 value);
53. // Lee un registro del L3G4200D.
54. unsigned char L3G4200D_read(unsigned char reg);
55. // Lee los 3 ejes del giroscopio.
56. void L3G4200D_GetRawAxis(signed int16 *rx, signed int16 *ry, signed int16 *rz);
57. // Inicializa el L3G4200D y selecciona la escala de medida en º/seg.
58. void L3G4200D_init(int16 rango);
59. // Lee el registro Who i am ?
60. int8 ReadWhoAmI(void);
61. // Obtiene el offset del sensor.
62. void L3G4200D_GetBiass(float *_bx, float *_by, float *_bz);
63. // Obtiene los datos en grados/segundos.
64. void L3G4200D_GetScaledAxis(float *_sx, float *_sy, float *_sz, float biassX, float biassY, float biassZ, int16 rango);

Otra consulta que tengo, para poder visualizar el ángulo en el que se encuentra el giróscopo, tengo que multiplicar por el tiempo de muestreo verdad ?

[elgarbe]

Pero que buena codificacion!!!! Ojalá yo fuses tan prolijo con el código!!!!

En principio, si solo lees los datos raw y luego le sacas el offset y lo escalas lo que obtienes es la velocidad angular. Entonces, por más que des un giro completo los datos que mostrás pueden estar bien o no... depende de con que velocidad lo estés girando....

Para obtener el ángulo de giro debes hacer la integracion discreta, es mas o menos como vos dijiste, al angulo actual le sumas la velocidad leída x el tiempo de muestreo. Yo uso estas líneas:

      L3G4200D_read_data();

      gx += (((float)gyro_X - biass_X) * GYRO_X_SCALE) * timeStep/1000;
      gy += (((float)gyro_Y - biass_Y) * GYRO_Y_SCALE) * timeStep/1000;
      gz += (((float)gyro_Z - biass_Z) * GYRO_Z_SCALE) * timeStep/1000;

De alguna forma debes asegurar que el tiempo del bucle principal (si es que ahí haces la integracion) dure un tiempo conocido, en mi caso timeStep.

Si fueses tan amable, te pediría el main con el que obtuviste los datos que mostraste. La librería que pusiste va a mis favoritos y en caso de usar pic la usaré.

Seré curioso, que aplicacion estás trantado de desarrollar?

Saludos!!!

[jonathanPIC888]

Pero que buena codificacion!!!! Ojalá yo fuses tan prolijo con el código!!!!

Muchas gracias, igual me falta pulir algunas cosas de la programación.

En principio, si solo lees los datos raw y luego le sacas el offset y lo escalas lo que obtienes es la velocidad angular. Entonces, por más que des un giro completo los datos que mostrás pueden estar bien o no... depende de con que velocidad lo estés girando....

En mi caso lo estoy girando con la mano, tendría que utilizar algún sistema mecánico más estable para hacerlo girar a velocidades angulares constantes.

Para obtener el ángulo de giro debes hacer la integracion discreta, es mas o menos como vos dijiste, al angulo actual le sumas la velocidad leída x el tiempo de muestreo.

Voy a implementar una tarea con RTOS de CCS para que cada 50ms haga una lectura de los 3 ejes....ahora no entiendo lo siguiente:


* timeStep/1000; ----> por que es el tiempo de muestreo dividido 1000 ? Si uso el RTOS...el timeStep serian los 50ms que le indico para que realice la adquisición ?

El main que utilizo es el siguiente:

Código: C

1. // Programa: Prueba del giroscopio L3G4200D.
2. // Programador: Moyano Jonathan.
3. // Fecha: Enero de 2014.
4. // Versión: v1.0
5. // Revisión: r0.1
6. /////////////////////////////////////////////
7.  
8. // Incluimos plantilla.
9. #include <Plantilla_UconnectME28.h>  // Drivers de periféricos.
10.  
11. // Variables globales.
12. float _sx,_sy,_sz;
13. float bx,by,bz;
14. int8 data=0x00;
15. signed int16 _rx,_ry,_rz;
16.  
17. void main ()
18. {
19.     // Inicializamos el sensor.
20.     L3G4200D_init(2000);
21.    
22.     // Verificamos el funcionamiento de la comunicación.
23.      data=ReadWhoAmI();
24.       fprintf(DEBUG,"who am I:%u\r\n",data);
25.        delay_ms(2000);
26.        
27.        // Determinamos el offset del sensor.
28.        L3G4200D_GetBiass(&bx,&by,&bz);
29.        fprintf(DEBUG,"Offset x:%f\r\n",bx);
30.        fprintf(DEBUG,"Offset y:%f\r\n",by);
31.        fprintf(DEBUG,"Offset z:%f\r\n",bz);
32.        delay_ms(2000);
33.  
34.    
35.     while(true){
36.    
37.          // Imprime los datos crudos del giróscopo.
38.          L3G4200D_GetRawAxis(&_rx,&_ry,&_rz);
39.          fprintf(DEBUG,"GYRO RAW x:%04ld,y:%04ld,z:%04ld\r\n\r\n",_rx,_ry,_rz);
40.          
41.          // Imprimimos la velocidad angular cada 50ms aprox.
42.          L3G4200D_GetScaledAxis(&_sx,&_sy,&_sz,bx,by,bz,2000);
43.          fprintf(DEBUG,"GYRO SCALED x:%f,y:%f,z:%f\r\n\r\n",_sx,_sy,_sz);
44.          delay_ms(50);
45.       }    
46.                      
47.    }

La librería la hice siguiendo tus consejos del acelerómetro y leyendo la hoja de datos del sensor. Vos podrías adaptarla perfectamente para trabajar con el LCP1769.

Con respecto a la aplicación, es para un sistema de navegación en un robot móvil. En estos momentos estoy tratando de entender la física y demás parámetros para poder
implementarlo con un PIC trabajando a 12mips a 48Mhz....o 16Mips a 64Mhz.
Ya tengo librerías desarrolladas para HCM5883L (magnetómetro), BMP085 (barómetro - falta función para determinar la altura con respecto a nivel del mar), ADXL345 (acelerómetro - falta función para escalar los datos y obtener la aceleración en Gs)..y algunas otras funciones más y dispositivos como el GPS que se irán integrando con el tiempo.

[elgarbe]

* timeStep/1000; ----> por que es el tiempo de muestreo dividido 1000 ? Si uso el RTOS...el timeStep serian los 50ms que le indico para que realice la adquisición ?

En mi caso timeStep vale 20 (mseg). Lo divido por 1000 para que quede en segundos, ya que el sensor nos etrega rad/seg debemos multiplicar por el tiempo en segundos. Me explico?

Con respecto a la aplicación, es para un sistema de navegación en un robot móvil. En estos momentos estoy tratando de entender la física y demás parámetros para poder
implementarlo con un PIC trabajando a 12mips a 48Mhz....o 16Mips a 64Mhz.
Ya tengo librerías desarrolladas para HCM5883L (magnetómetro), BMP085 (barómetro - falta función para determinar la altura con respecto a nivel del mar), ADXL345 (acelerómetro - falta función para escalar los datos y obtener la aceleración en Gs)..y algunas otras funciones más y dispositivos como el GPS que se irán integrando con el tiempo.

Por los sesnores que tienes imagino que usas la GY-80. Yo estoy usando la misma. Tengo el barometro funcionando, pero aún no hice tiempo de postearlo. Fijate en este subforo que he escrito sobre el acelerómetro también.
Ahora estoy con el magnetómetro. Si quieres compartir tu código será bienvenido!

No me imagino la navegacion de un robot con acelerómetros, gyros y demás. Me gustaría saber más de tu desarrollo...

Saludos y estamos en contacto!

[PCCM]

Hola Jonathan, dices que tienes librerías desarrolladas para el HMC5883L. Has hecho pruebas de como te da el azimut para ángulos de cabeceo o banqueo superiores a +-40 grados?, se que se puede solucionar con el giroscopo, pero con el magnetómetro solo?

Saludos, y excelente trabajo.

[jonathanPIC888]

En mi caso timeStep vale 20 (mseg). Lo divido por 1000 para que quede en segundos, ya que el sensor nos etrega rad/seg debemos multiplicar por el tiempo en segundos. Me explico?

Ok, ahora entiendo. Entonces si genero una tarea que se ejecute cada 50ms, mi timeStep sería 50ms/1000.

Tengo el barometro funcionando, pero aún no hice tiempo de postearlo. Fijate en este subforo que he escrito sobre el acelerómetro también.

Voy a postear la librería que tengo del acelerómetro, barómetro y magnetómetro dentro del foro de UAV.

No me imagino la navegacion de un robot con acelerómetros, gyros y demás. Me gustaría saber más de tu desarrollo...

Quiero darle a un robot, una posición X,Y dentro de una zona a campo abierto y que se guíe por IMU+GPS. Luego quiero darle la misma dirección X,Y dentro de una zona cerrada y que se guíe por radar + cámara + odometría. Es un proyecto ambicioso, pero por ahora estoy aprendiendo...no se nada sobre navegación ni tampoco mucho sobre sistemas
de control de lazo cerrado complejos...

Has hecho pruebas de como te da el azimut para ángulos de cabeceo o banqueo superiores a +-40 grados?, se que se puede solucionar con el giroscopo, pero con el magnetómetro solo?

Disculpá mi ignorancia, pero no entiendo tu pregunta 

[elgarbe]

Quiero darle a un robot, una posición X,Y dentro de una zona a campo abierto y que se guíe por IMU+GPS. Luego quiero darle la misma dirección X,Y dentro de una zona cerrada y que se guíe por radar + cámara + odometría. Es un proyecto ambicioso, pero por ahora estoy aprendiendo...no se nada sobre navegación ni tampoco mucho sobre sistemas
de control de lazo cerrado complejos...

Ok, si queres te comento algo, no lo tomes 100% seguro ya que es mi conclusion de lo que vengo leyendo hace unos meses. Creo que no se puede o es muy dificil conocer la posicion de un objeto midiendo con acelerómetros, giróscopos y magnetómetros. Tengo entendido que podes obtener con cierta presicion la orientacion (léase, rotación) del objeto. Para obtener la posicion deberías integrar 2 veces la medicion del acelerómetro por ejemplo (verdad?) y tengo entendido que la primera integra aporta deriva y una segunda integral hace ilegible la medicion. Fijate en este video si no entendí mal:

El proyecto es muy, pero muy interesante! todo lo que quieras y puedas compartir será bienvenido ya que será de utilidad para el resto de los proyectos que pueden aparecer en este foro y sin duda me será de utilidad para mi controladora de vuelo.

Has hecho pruebas de como te da el azimut para ángulos de cabeceo o banqueo superiores a +-40 grados?, se que se puede solucionar con el giroscopo, pero con el magnetómetro solo?

Disculpá mi ignorancia, pero no entiendo tu pregunta 

Lo que pregunta es si has probado la medicion del ángulo (respecto del norte) pero inclinando tu magnetómetro. En la pràctica cuando inclinas el magnetómetro la lectura deja de ser correcta y el límite esta en los 40º aproximadamente. Para evitar ese error se suele compensar con acelerómetros. Compensar con magnetometro solo no sé si se podrá... imagino que conociendo el vector flujo magnetíco terrestre con presicion en el lugar de operacion (es un vector que no es paralelo a la tierra) y combinand la lectura de los tres ejes del magnetómetro se podría estimar... pero no sé... estoy lejos de eso por ahora!!!

Saludos!

[jonathanPIC888]

Tengo entendido que podes obtener con cierta presicion la orientacion (léase, rotación) del objeto. Para obtener la posicion deberías integrar 2 veces la medicion del acelerómetro por ejemplo (verdad?) y tengo entendido que la primera integra aporta deriva y una segunda integral hace ilegible la medicion.

Esto me lo comentaron tal cuál unos estudiantes de doctorado, que están preparando unos sistemas de guía de vuelo en el grupo de investigación de robótica de la UTN de Mendoza. Me dijeron que era complejo resolver la matemática necesaria para obtener un sistema que me entregara una posición confiable utilizando una unidad de medición inercial. Ellos tenían un proyecto similar al mio, pero no encontraron los sensores adecuados y solo resolvieron que el robot móvil se moviera dentro de un ambiente cerrado a una posición X,Y determinada por el usuario...no pudieron utilizar el GPS + IMU para orientarse..

El proyecto es muy, pero muy interesante! todo lo que quieras y puedas compartir será bienvenido ya que será de utilidad para el resto de los proyectos que pueden aparecer en este foro y sin duda me será de utilidad para mi controladora de vuelo.

Todavía estoy muy verder, me falta estudiar más conceptos...por ahora estoy resolviendo las librerías para los sensores y realizando pruebas básicas.

Lo que pregunta es si has probado la medicion del ángulo (respecto del norte) pero inclinando tu magnetómetro.

No, la lectura se volvía errática cuando lo inclinaba...me medía cualquier cosa...luego cuando lo coloco sobre la mesa y comienzo a girar se estabiliza por completo. En mi librería utilizo el ángulo de declinación terrestre para mejorar la lectura, según un tutorial de internet, pero nada más. Con respecto a la compensación por inclinación, en este post hay un enlace donde se explica como resolverlo con un acelerómetro ADXL345.

http://www.todopic.com.ar/foros/index.php?topic=41981.0

[PCCM]

Para obtener su recorrido del sistema solo con los sensores inerciales es posible pero muy errático con el tiempo, he leido temas donde calculan el recorrido solo el acelerómetro  pero obtienen mucho error con el tiempo. es como si fuera el giroscopo solo intentando calcular angulos.

En las pruebas que hice solo de laboratorio, para recorridos moviendo en diagonal (50cm veritcal y 50cm horizontal) tuve recorrido del acelerometro de 45cm vertical y 40 horizontal., pero esas pruebas duraron solo unos segundos. ya me imagino para mas tiempo el error incrementará.