How to convert a byte array of size 64 to a list of double values in Arduino C++?

Question

void Manager::byteArrayToDoubleArray(byte ch[]) {
  int counter = 0;
  // temp array to break the byte array into size of 8 and read it
  byte temp[64];
  // double result values
  double res[8];
  int index = 0;
  int size = (sizeof(ch) / sizeof(*ch));
  for (int i = 0; i < size; i++) {
    counter++;
    temp[i] = ch[i];
    if (counter % 8 == 0) {
      res[index] = *reinterpret_cast<double * const>(temp);
      index++;
      counter = 0;
    }
  }
}

Here result would be a list of double values with count = 8.

Answer 1

Your problem is two things. You have some typos and misunderstanding. And the C++ standard is somewhat broken in this area.

I'll try to fix both.

First, a helper function called laundry_pods. It takes raw memory and "launders" it into an array of a type of your choice, so long as you pick a pod type:

template<class T, std::size_t N>
T* laundry_pods( void* ptr ) {
  static_assert( std::is_pod<std::remove_cv_t<T>>{} );
  char optimized_away[sizeof(T)*N];
  std::memcpy( optimized_away, ptr , sizeof(T)*N );
  T* r = ::new( ptr ) T[N];
  assert( r == ptr );
  std::memcpy( r, optimized_away, sizeof(T)*N );
  return r;
}

now simply do

void Manager::byteArrayToDoubleArray(byte ch[]) {
  double* pdouble = laundry_pods<double, 8>(ch);
}

and pdouble is a pointer to memory of ch interpreted as an array of 8 doubles. (It is not a copy of it, it interprets those bytes in-place).

While laundry_pods appears to copy the bytes around, both g++ and clang optimize it down into a binary noop. The seeming copying of bytes around is a way to get around aliasing restrictions and object lifetime rules in the C++ standard.

It relies on arrays of pod not having extra bookkeeping overhead (which C++ implementations are free to do; none do that I know of. That is what the non-static assert double-checks), but it returns a pointer to a real honest to goodness array of double. If you want to avoid that assumption, you could instead create each doulbe as a separate object. However, then they aren't an array, and pointer arithmetic over non-arrays is fraught as far as the standard is concerned.

The use of the term "launder" has to do with getting around aliasing and object lifetime requirements. The function does nothing at runtime, but in the C++ abstract machine it takes the memory and converts it into binary identical memory that is now a bunch of doubles.

Answer 2

The trick of doing this kind of "conversion" is to always cast the double* to a char* (or unsigned char or std::byte). Never the other way round.

You should be able to do something like this:

void byteArrayToDoubleArray(byte* in, std::size_t n, double* out)
{
    for(auto out_bytes = (byte*) out; n--;)
        *out_bytes++ = *in++;
}

// ...

byte ch[64];

// .. fill ch with double data somehow

double res[8];

byteArrayToDoubleArray(ch, 64, res);

Assuming that type byte is an alias of char or unsigned char or std::byte.

Answer 3

I am not completly sure what you are trying to achieve here because of the code (sizeof(ch) / sizeof(*ch)) which does not make sense for an array of undefined size.

If you have a byte-Array (POD data type; something like a typedef char byte;) then this most simple solution would be a reinterpret_cast:

double *result = reinterpret_cast<double*>(ch);

This allows you to use result[0]..result[7] as long as ch[] is valid and contains at least 64 bytes. Be aware that this construct does not generate code. It tells the compiler that result[0] corresponds to ch[0..7] and so on. An access to result[] will result in an access to ch[].

But you have to know the number of elements in ch[] to calculate the number of valid double elements in result.

If you need a copy (because - for example - the ch[] is a temporary array) you could use

std::vector<double> result(reinterpret_cast<double*>(ch), reinterpret_cast<double*>(ch) + itemsInCh * sizeof(*ch) / sizeof(double));

So if ch[] is an array with 64 items and a byte is really an 8-bit value, then

std::vector<double> result(reinterpret_cast<double*>(ch), reinterpet_cast<double*>(ch) + 8);

will provide a std::vector containing 8 double values.

There is another possible method using a union:

union ByteToDouble
{
  byte b[64];
  double d[8];
} byteToDouble;

the 8 double values will occupie the same memory as the 64 byte values. So you can write the byte values to byteToDouble.b[] and read the resultingdouble values from byteToDouble.d[].