Question

I have the following struct:

typedef union
{
    struct
    {
        unsigned char       ID;
        unsigned short      Vdd;

        unsigned char       B1State;
        unsigned short      B1FloatV;
        unsigned short      B1ChargeV;
        unsigned short      B1Current;
        unsigned short      B1TempC;
        unsigned short      B1StateTimer;
        unsigned short      B1DutyMod;

        unsigned char       B2State;
        unsigned short      B2FloatV;
        unsigned short      B2ChargeV;
        unsigned short      B2Current;
        unsigned short      B2TempC;
        unsigned short      B2StateTimer;
        unsigned short      B2DutyMod;

    } bat_values;
    unsigned char buf[64];
} BATTERY_CHARGE_STATUS;

and I am stuffing it from an array as follows:

for(unsigned char ii = 0; ii < 64; ii++) usb_debug_data.buf[ii]=inBuffer[ii];

I can see that the array has the following (arbitrary) values:

inBuffer[0] = 80;
inBuffer[1] = 128;
inBuffer[2] = 12;
inBuffer[3] = 0;
inBuffer[4] = 23;
...

now I want display these values by changing the text of a QEditLine:

str=QString::number((int)usb_debug_data.bat_values.ID);
ui->batID->setText(str);
str=QString::number((int)usb_debug_data.bat_values.Vdd)
ui->Vdd->setText(str);
str=QString::number((int)usb_debug_data.bat_values.B1State)
ui->B1State->setText(str);
...

however, the QEditLine text values are not turning up as expected. I see the following:

usb_debug_data.bat_values.ID = 80 (correct)
usb_debug_data.bat_values.Vdd = 12 (incorrect)
usb_debug_data.bat_values.B1State = 23 (incorrect)

seems like ‘usb_debug_data.bat_values.Vdd’, which is a short, is not taking its value from inBuffer[1] and inBuffer[2]. Likewise, ‘usb_debug_data.bat_values.B1State’ should get its value from inBuffer[3] but for some reason is picking up its value from inBuffer[4].

Any idea why this is happening?

Answer 1

C and C++ are free to insert padding between elements of a structure, and beyond the last element, for whatever purposes it desires (usually efficiency but sometimes because the underlying architecture does not allow unaligned access at all).

So you’ll probably find that items of two-bytes length are aligned to two-byte boundaries, so you’ll end up with something like:

unsigned char       ID;          // 1 byte
//                                  1 byte filler, aligns following short
unsigned short      Vdd;         // 2 bytes
unsigned char       B1State;     // 1 byte
//                                  3 bytes filler, aligns following int
unsigned int        myVar;       // 4 bytes

Many compilers will allow you to specific how to pack structures, such as with:

#pragma pack(1)

or the gcc:

__attribute__((packed))

attribute.

If you don’t want to (or can’t) pack your structures, you can revert to field-by-filed copying (probably best in a function):

void copyData (BATTERY_CHARGE_STATUS *bsc, unsigned char *debugData) {

    memcpy (&(bsc->ID), debugData, sizeof (bsc->ID));
    debugData += sizeof (bsc->ID);

    memcpy (&(bsc->Vdd), debugData, sizeof (bsc->Vdd));
    debugData += sizeof (bsc->Vdd);

    : : :

    memcpy (&(bsc->B2DutyMod), debugData, sizeof (bsc->B2DutyMod));
    debugData += sizeof (bsc->B2DutyMod); // Not really needed

}

It’s a pain that you have to keep the structure and function synchronised but hopefully it won’t be changing that much.