Adición de alto byte y byte bajo de la salida del acelerómetro LSM303DLHC

2

Interpretación de la salida del acelerómetro LSM303DLHC

Hola a todos,      Esta es mi primera pregunta de StackExchange, por lo que haré todo lo posible para ser específica y ofrecerle la mayor referencia posible. Actualmente estoy trabajando en un módulo de navegación que utiliza un microcontrolador PIC16F873A para leer los datos de un GPS a través del módulo USART y de un magnetómetro / acelerómetro LSM303DLHC utilizando I2C. En esta etapa del proyecto, solo trato de usar los datos del acelerómetro, lo cual hago actualmente ejecutando el PIC en modo maestro y leyendo los registros correspondientes. La forma en que funciona el acelerómetro es que los datos de aceleración X, Y y Z se almacenan en seis registros consecutivos diferentes dentro del área de registro del acelerómetro lineal (es decir, OUT_X_L_A (28h), OUT_X_H_A (29h) ... OUT_Y_L_A (2Ah), OUT_Y_H_A (2Bh ) ... OUT_Z_L_A (2Ch), OUT_Z_H_A (2Dh)). Mi función I2C_Accelrometer_Data (unsigned char reg_address, unsigned char ack) lee en un byte de datos a la vez, por lo que mi código leerá el byte bajo y luego el byte alto del siguiente registro, los almacenará en una matriz de caracteres sin firmar y agregarlos juntos. De acuerdo a la hoja de datos: LSM303DLHC estos bytes se expresan en forma de complemento a dos.

Una sección de mi código C (compilador XC8), que he adaptado en parte de aquí en la página 6 lo maneja de la siguiente manera:

    unsigned char ACC_Data[6];

                                            ACC_Data[0] = I2C_Accelerometer_Data(0x28, 0);//X_Low Byte
                                            ACC_Data[1] = I2C_Accelerometer_Data(0x29, 0);//X_High_Byte

                                            ACC_Data[2] = I2C_Accelerometer_Data(0x2A, 0);//Y_Low_Byte
                                            ACC_Data[3] = I2C_Accelerometer_Data(0x2B, 0);//Y_High_Byte

                                            ACC_Data[4] = I2C_Accelerometer_Data(0x2C, 0);//Z_Low_Byte
                                            ACC_Data[5] = I2C_Accelerometer_Data(0x2D, 1);//Z_High_Byte

                                            int Ax = (int) (ACC_Data[1] << 8) + ACC_Data[0];
                                            int Ay = (int) (ACC_Data[3] << 8) + ACC_Data[2];
                                            int Az = (int) (ACC_Data[5] << 8) + ACC_Data[4];

                                            char Ax_str[];
                                            char Ay_str[];
                                            char Az_str[];
                                            itoa(Ax_str, Ax, 10);
                                            lcdcmd(0x94);//third row, first column position
                                            send_string(Ax_str);

                                            itoa(Ay_str, Ay, 10);
                                            lcdcmd(0x9E);//third row, 10th column position
                                            send_string(Ay_str);

                                            itoa(Az_str, Az, 10);
                                            lcdcmd(0xD4);//4th row, first column position
                                            send_string(Az_str);

Mi pregunta es: debido a que los números están en el binario del complemento de dos, ¿esto no afectará la forma en que se agregan, especialmente porque los bytes se almacenan como caracteres sin signo? ¿O puedo hacer simplemente lo que he hecho anteriormente para convertir estos dos bytes en un int? Básicamente, el objetivo de obtener estos números en una pantalla LCD al convertir este número entero en la cadena adecuada, no estoy seguro de si estoy usando los datos correctamente aquí. Gracias de antemano por cualquier información.

    
pregunta Alexander Villa

2 respuestas

1

Estás pegando los bytes en el orden incorrecto. dado que ACC_Data [0] es el byte bajo, y ACC_Data [1] es el byte alto, debe desplazar ACC_Data [1] hacia la izquierda por 8, y agregarlo a ACC_Data [0] (sin cambios) para obtener el valor int correcto.

    
respondido por el Peter Bennett
0

Otra complicación más allá del orden de bytes mencionado anteriormente del acelerómetro LSM303DLHC es que el acelerómetro solo tiene 12 bits de valor almacenados en dos bytes, contados desde MSB.

Eso significa que los valores que obtiene deben dividirse por 16, esto se hace en el código de demostración STM32F3 pero no se explica en la hoja de datos LSM303DLHC. Si adjunta un depurador y muestra los bytes recibidos en binario, verá que los últimos 4 bits en el LSB siempre son cero.

    
respondido por el Adam.at.Epsilon

Lea otras preguntas en las etiquetas