Electronic – Adding High Byte and Low Byte of LSM303DLHC Accelerometer Output

accelerometeri2cmicrocontrollerpic

Interpreting LSM303DLHC Accelerometer Output

Hi all,
This is my first StackExchange question ever, so I will do my best to be specific and offer as much reference as possible. I'm currently working on a navigation module which uses a PIC16F873A microcontroller to read data from a GPS via the USART module and from a LSM303DLHC Magnetometer/Accelerometer using I2C. At this stage of the project, I'm only trying to use accelerometer data, which I currently do by running the PIC in master mode and reading from the appropriate registers. The way the accelerometer works is the X,Y and Z acceleration data are stored in six different consecutive registers inside of the linear accelerometer register area (i.e. 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)). My I2C_Accelrometer_Data(unsigned char reg_address, unsigned char ack) function reads in one byte of data at a time so my code will read the low byte and then the high byte from the next register, store them in an array of unsigned chars and add them together. According to the datasheet: LSM303DLHC these bytes are expressed in two's complement form.

A section of my C code (XC8 compiler), which I've partly adapted from here on page #6 handles it as follows:

    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);

My question is: because the numbers are in two's complement binary, won't that mess up the way they are added especially since the bytes are being stored as unsigned chars? Or can I do simply what I have done above to convert these two bytes to an int? Basically, the goal to get these numbers onto an LCD screen by then converting this integer into the appropriate string, I'm just not sure if I'm using the data correctly here. Thanks in advance for any insight.

Best Answer

You are sticking the bytes together in the wrong order. since ACC_Data[0] is the low byte, and ACC_Data[1] is the high byte, you need to shift ACC_Data[1] left by 8, and add it to ACC_Data[0] (unshifted) to get the correct int value.

Related Solutions

Electronic – arduino – Accelerometer and Transistor

You are not using the reading variable in the if statement. Your if statement is checking volts, and this never gets changed, it will always be at 170 (it will change to 77 for a few clock cycles, then back to 170.)

Also you shouldn't declare your variables in the loop. And your delay is set to one second not 5. You should add a delay after analogWrite(outputPin1, volts); so the Accelerometer has time to power up.

int outputPin1 = 3; // Pin D3
int outputPin2 = 5; // Pin D5
int analogPin = 0; // Input Pin A0
int volts = 170;
int reading = 0;    

void setup()
{
    pinMode (outputPin1, OUTPUT);
    pinMode (outputPin2, OUTPUT);
    Serial.begin(9600);
}

void loop()    
{   
    analogWrite(outputPin1, volts);  // send signals of 3.3v to Accelerometer   
    delay(200);    // delay .2 sec

    reading = analogRead(analogPin);  //  receive signal
    delay(1000);    // delay 1sec.

    if (reading >= 100)    // Input voltage is more than 2.0V
    {
        volts = 77; // send signals of 1.5V
        analogWrite(outputPin2, volts);  // to Transistor
    }
    else
    {
        volts = 0;
        analogWrite(outputPin2, volts);  // to Transistor
    }
}

Here is what the code is doing now (assuming your voltage math is correct):

outputPin1 powers to ~3.3v
reading gets the value of analogPin
1 second pause
if reading >= 100 power outputPin2 to ~1.5v else 0v
repeat

To be more efficient, you don't need the variable volts and reading. outputPin1 doesn't need to be in the loop. I also put the delay before you analogRead(analogPin), so your if statement executes immediately after the reading, and on power up it allows your accelerometer time to power up. I also removed the Serial.begin(9600); since you weren't using it. Your entire code could look like this:

int outputPin1 = 3; // Pin D3
int outputPin2 = 5; // Pin D5
int analogPin = 0; // Input Pin A0

void setup()
{
    pinMode (outputPin1, OUTPUT);
    pinMode (outputPin2, OUTPUT);
    analogWrite(outputPin1, 170);  // send signals of 3.3v to Accelerometer
}

void loop()    
{
    delay(1000);    // delay 1sec.

    if (analogRead(analogPin) >= 100)    // Input voltage is more than 2.0V
    {
        analogWrite(outputPin2, 77);  // send signals of 1.5V to Transistor
    }
    else
    {
        analogWrite(outputPin2, 0);  // 0v to Transistor
    }
}

For future reference, you should use the serial Serial.println("helpfull info"); to help you debug your code. Take a look at this example. Every time it takes a reading it transmits the reading back to the computer so you can see what is going on.

Edit

Upload this and use a serial terminal to see what happens when you move the accelerometer.

int analogPin = 0;
int value = 0;

void setup()
{
  Serial.begin(9600);          //  setup serial
}

void loop()
{
  value = analogRead(analogPin);    // read the input pin
  Serial.println(value);             // debug value
  delay(1000);
}

Electronic – How to lower output impedance of an accelerometer

One suggestion is to utilize a low input offset rail to rail op amp to act as a buffer to lower the output impedance, but I am not exactly sure how this works.

I would suggest...

...using a low input offset rail to rail op amp to act as a buffer to lower the output impedance. ;-)

At the most basic level an amplifier is more of something out than that something goes in, but depending on semantics, you can get the opposite if so desired.

The operational amplifier (OA) lets very little current flow in (ideally zero). To do this, it must appear to the source as a very large resistor between the input and the reference (typ. "ground") and isolate everything else down the line.

On the output side, the amplifier provides an output voltage equal to the input voltage multiplied by its internal gain (feedback can modify the gain) independent of whatever else is connected to the output (ideal case, but practical OA's get fairly close).

Therefore to the load, looking back at the output of the amplifier, the OA appears like a very small resistor (ideally 0) in series with a very powerful voltage source.

So there!

Consequently the input has high resistance (impedance in the complex case), the output has low resistance, and you have your impedance transformation function.

Pragmatically, the amplifier has simply separated the ADC from the accelerometer by showing the accelerometer its input side (high impedance so the accelerometer output is happy) and the ADC its output side (low impedance so the ADC input is happy).

Hopefully, that helps you intuit through the terminology. Cheers!