Arduino read 20 bit number from 3 registers

Question

I have an ADXL355 (EVAL-ADXL355-PMDZ) that I am trying to test against a very expensive industrial grade sensor. I am using I2C and I am able to read the device properties and settings as described in the datasheet.

The issue I'm having is how to read the 3 ZDATA (or XDATA, YDATA) registers as a single value. I have tried two approaches. Here is the first:

double values[3];
Wire.beginTransmission(addr);
  Wire.write(0x08); // ACCEL_XAXIS
  Wire.endTransmission();
  Wire.requestFrom(addr, 9, true); // Read 9, 3 for each axis
  byte x1, x2, x3;
  for (int i = 0; i < 3; ++i){
    x3 = Wire.read();
    x2 = Wire.read();
    x1 = Wire.read();
    unsigned long tempV = 0;
    unsigned long value = 0;
    value = x3;
    value <<= 12;
    tempV = x2;
    tempV <<= 4;
    value |= tempV;
    tempV = x1;
    tempV >>= 4;
    value |= tempV;
    values[i] = SCALEFACTOR * value;
  }

This will produce values that approach 1g for negative gravity and 3g for positive gravity. Also the unloaded axes will sometimes show offscale high instead of -0.0g. They bounce from 0.0 to 4.0 g's. This tells me I have a sign problem which I'm sure comes from using unsigned long. So I attempted to read it as a 16 bit value and retain the sign.

double values[3];
  Wire.beginTransmission(addr);
  Wire.write(0x08); // ACCEL_XAXIS
  Wire.endTransmission();
  Wire.requestFrom(addr, 9, true); // Read 9, 3 for each axis
  byte x1, x2, x3;
  for (int i = 0; i < 3; ++i){
    x3 = Wire.read();
    x2 = Wire.read();
    x1 = Wire.read();
    long tempV = 0;
    long value = 0;
    value = x3;
    value <<= 8;
    tempV = x2;
    value |= tempV;
    values[i] = SCALEFACTOR * value;
  }

This produced values are good in terms of sign but they are (as expected) much lower in magnitude than they are supposed to be. I tried to create a 20 bit number like this long value:20; but I received

expected initializer before ':' token

same error for int.

How do I properly read from 3 registers to obtain a correct 20 bit value?

I'm trying to do the same thing: test this acceleremoeter against expensive ones. I'm having a very bad time because of output values stucked to the selected range, as described also [here](https://ez.analog.com/mems/f/q-a/109925/adxl355-latch-up-condition) by other users. Did you have the same problems with this accelerometer or all went good? — user11696358, Nov 13 '20 at 12:45

score 2 · Accepted Answer · answered Aug 17 '17 at 14:23

First of all, you really want to use unsigned types when using the left and right shift operators (see this question).

Taking a look to the avr-gcc type layout we learn that long are represented on 4 bytes (i.e. 32 bits) so they are long enough (no pun intended) to "hold" your 20 bits numbers (XDATA, YDATA, and ZDATA). On the other hand, int are represented on 2 bytes (i.e. 16 bits) and thus should not be used in your case.

According to the datasheet you linked page 33, the numbers are formatted as two's complement. Your first example correctly set the last 20 bits of your unsigned, 32 bits long value (in particular the left justification handling — right-shifting x1 by four — already looks correct) but the "new" 12 most significants bits are always set to 0.

To perform sign extension, you need to set the "new" 12 most significant bits to 0 if the number is a positive value, 1 if the number is a negative value (adaptation of your first example):

...
value |= tempV;
if (x3 & 0x80) /* msb is 1 so the number is a negative value */
    value |= 0xFFF00000;

From there, what you should observe is about the same behaviour as previously: high positive values instead of small negative ones (but even higher than previously). This is caused by the fact that while your value is correct bitwise speaking, it is still intepreted as unsigned. This can be worked around by forcing the compiler to use value as signed:

values[i] = SCALEFACTOR * (long)value;

And now it should be working.

Note that this answer use the fact that your C/C++ implementation use two's complement to represent negative integers. While very rare in practice, the standard allow other representations (see this question for examples).

score 0 · Answer 2 · answered Aug 17 '17 at 16:26

0

Here is one way to make it work. It does use bitshifting on a signed value. Various sources have said that this is a potential bug as it is implementation defined. It worked on my platform.

typedef union {
  byte bytes[3];
  long value:24;
} accelData;

double values[3];
Wire.beginTransmission(addr);
Wire.write(0x08); // ACCEL_XAXIS
Wire.endTransmission();
Wire.requestFrom(addr, 9, true); // Read 9, 3 for each axis
accelData raw;
for (int i = 0; i < 3; ++i){
  raw.bytes[2] = Wire.read();
  raw.bytes[1] = Wire.read();
  raw.bytes[0] = Wire.read();
  long temp = raw.value >> 4;
  values[i] = SCALEFACTOR * (double)temp;
}

I prefer the solution presented by Alexandre Perrin.

answered Aug 17 '17 at 16:26

Matt

2,554
2
24
45

Also note that this implementation rely on endianess. – Alexandre Perrin Aug 17 '17 at 21:00
@Alexandre Perrin Your one as well. It is unnecessary bad comment – 0___________ Aug 18 '17 at 08:06
@PeterJ As far as I understand, my solution use only bitwise operations which work the same regardless of the endianess (unlike union type-punning). see [this question](https://stackoverflow.com/questions/1041554/bitwise-operators-and-endianness). – Alexandre Perrin Aug 18 '17 at 12:45

score 0 · Answer 3 · answered Aug 18 '17 at 08:26

union
{
    struct
    {
        unsigned : 4;
        unsigned long uvalue : 20;
    };
    struct
    {
        unsigned : 4;
        signed long ivalue : 20;
    };
    unsigned char rawdata[3];
}raw;

for (int i = 0; i < 3; ++i){
  raw.bytes[2] = Wire.read();  //if most significant part is transfered first
  raw.bytes[1] = Wire.read();
  raw.bytes[0] = Wire.read();

  values[i] = SCALEFACTOR * (double)raw.ivalue;
}

Arduino read 20 bit number from 3 registers

3 Answers3