CODEWITHSUNDEEP
c++arduinotype-conversion
speedy-MACHO
speedy-MACHO

Reputation: 103

Convert 4 bytes to long on Arduino error

I'm having a really strange inconsistancy.
I'm preparing for reading from binary files on Arduino (for a midi player, in case you were interested). If I try to combine 4 bytes on Arduino to a long, it gives me a wrong result.
However, if I use the equivalent code on PC, I get the correct value.

Input is: 0x12481248 (0x12, 0x48, 0x12, 0x48) (really a random number).

Arduino gives: 4680.

Code::Blocks gives: 306713160.

4680 is the same as 0x1248, and the result you get when you use an int instead of long on Arduino (2 bytes omitted).

Arduino code:

void setup(){
    Serial.begin(57600);
    char read1 = 0x12;
    char read2 = 0x48;
    char read3 = 0x12;
    char read4 = 0x48;
    unsigned long testint = read1<<24|read2<<16|read3<<8|read4;
    unsigned long testint2 = 306713160;
    Serial.println(testint);
    Serial.println(testint2);
}

void loop(){}

testint2 is to show that it isn't caused by Serial.println(). Serial Monitor output is indeed:

4680

306713160

C++ code:

#include <iostream>

using namespace std;

int main(){
    char read1 = 0x12;
    char read2 = 0x48;
    char read3 = 0x12;
    char read4 = 0x48;
    unsigned long testint = read1<<24|read2<<16|read3<<8|read4;
    cout << testint;
}

Any idea what's going on?

Also, does anyone know a better/prettier way of converting bytes with Arduino/SD library?

Upvotes: 7

Views: 4888

Answers (4)

Norm Helman
Norm Helman

Reputation: 1

Here is another way to create 4 bytes to Long value and the reverse. Includes a simple test for these functions.

byte dataj[4];  //4 byte array output
unsigned long testint;
unsigned long testnum, temp;
unsigned long prev_time, cur_time = 0;

void setup() {
  Serial.begin(115200);

  Serial.println(F("********** Initalized +++++++"));
  //   -----4294967295  Max value
  testnum = 4294967295L;  //Start at maximum value

  for (int i = 0; i < 999; i++)
  {
    Serial.print(F("Test #"));
    Serial.print( i + 1);

    Serial.print(F("  Initial value = "));
    Serial.println(testnum);

    prev_time = micros();
    Long_2_Four_Bytes(testnum);


    testint = Four_Bytes_2_Long(dataj[3], dataj[2], dataj[1], dataj[0]);
    cur_time = micros();

    Serial.print(F("         final value   = "));
    Serial.print(testint);
    Serial.print("  time (microsec) = ");  Serial.print(prev_time - cur_time);

    if (testint == testnum)
      Serial.println();
    else
      Serial.println(F("  ERROR  <-----"));

    testnum--;

    delay(50);
  }
}

void loop() {}

//---- Long_2_Four_Bytes ---------------------------
// Fills an array 'dataj[]' with 4 bytes representing
// the 'unsigned long val'.
// Input : unsigned long number - range 0 - 4294967295
// Output : dataj[] where dataj[0] = LSB  & dataj[3] = MSB
//---------------------------------------------------
void Long_2_Four_Bytes(unsigned long val )
{
  unsigned long temp;
  byte data1[] = { 0, 0, 0, 0}; //4 byte array

  temp = val;

  for (byte bytegroup = 0; bytegroup  < 4; bytegroup ++)
  {
    int offset = bytegroup * 8;

    for (byte bit_pntr = 0; bit_pntr < 8; bit_pntr++)
    {
      if ( bitRead(temp, (7 - bit_pntr) + offset) == 1)
        bitSet(data1[bytegroup], (7 - bit_pntr));
    }
  }

  for (byte i = 0; i < 4; i++)
    dataj[i] = data1[i];

}


//-- Four_Bytes_2_Long -------------------------------------
// Creates an unsigned long from  4 bytes where A = MSB and
// D = LSB.  Based upon code by Mehrdad Nazmdar.
// Called by :
// Calls : N/A
// Returns :  unsigned long number - range 0 - 4294967295
//------------------------------------------------------------
unsigned long Four_Bytes_2_Long(byte A, byte B, byte C, byte D)
{
  uint8_t data[4];
  unsigned long testBigint;

  data[0] = D;  //LSB
  data[1] = C;
  data[2] = B;
  data[3] = A; //MSB

  testBigint = *(unsigned long*)(&data);

  return testBigint;
}

Upvotes: 0

Mehrdad Nazmdar
Mehrdad Nazmdar

Reputation: 192

You can also use the following code:

uint8_t data[4];
data[0]=read4;
data[1]=read3;
data[2]=read2;
data[3]=read1;
unsigned long testint =*(unsigned long*)(&data);

Upvotes: 0

nnn
nnn

Reputation: 4230

On Arduino, int size is 16 bits.

In this line: 

unsigned long testint = read1<<24|read2<<16|read3<<8|read4;

even if the result is stored in a unsigned long (32 bits), the bitwise operations are done on ints.

Change this line to:

unsigned long testint = (unsigned long)read1 << 24 
                      | (unsigned long)read2 << 16
                      | (unsigned long)read3 << 8
                      | (unsigned long)read4;

Upvotes: 11

marom
marom

Reputation: 5230

I would expect the result 4680 (=0x1248) on any platform where sizeof(int)=2, and I think this is the case for arduino.

That's because (read1 << 24) gets implicitly converted to int (not long), so the upper two bytes get lost. Yout should convert read* to unsigned long first

Upvotes: 4

Related Questions