Problems with structures and unions in c

Question

After many years I started for fun to program in C again. Now I have an issue with the use of structures and unions.

The declaration:

typedef struct {
    unsigned char   SOAKTEMP;
    unsigned char   SOAKTIME;
    unsigned char   REFLOWTEMPERATURE;
    unsigned char   REFLOWTIME;
    unsigned char   BAKETEMP;
    unsigned int    BAKETIME;
    unsigned char   COOLDOWNTEMPERATURE;
    unsigned char   COOLDOWNTIME;
    unsigned char   KP;
    unsigned char   KI;
    unsigned char   KD;
    unsigned char   CYCLETIME;    
}EEPROM_DEFAULTS;

The initialisation:

EEPROM_DEFAULTS EEPD = {
                     170,    // SoakTemp
                      90,    // SoakTime   
                     220,    // ReflowTemperature
                      30,    // ReflowTime
                      80,    // BakeTemp
                    7200,   // BakeTime
                      60,    // CooldownTemperature
                       0,    // CooldownTime
                      11,    // Kp
                       5,    // Ki
                       1,    // Kd
                       5     // cycleTime

};

To write and read this data into the EEPROM of the PIC16F18877 I need to split BAKETIME into a high and a low byte.

I have done this with a Union.

union{ 
        unsigned int Baketime;
        struct
        {
            unsigned char BakeTimeLowbyte;
            unsigned char BaketimeHighbyte;
        };
        } BT;

It works but I do not like the way I have done this. I have tried in many ways to incorporate the union into the EEPROM_DEFAULTS typedef but without succes. So my knowledge runs short after so many years. Assistance would be nice.

Answer 1

In order to integrate the union in the struct typedef, you need to use modern standard C. In the C11 version of the standard, anonymous unions/structs were added as a feature. With a standard C compiler you can do this:

typedef struct {
    unsigned char   SOAKTEMP;
    unsigned char   SOAKTIME;
    unsigned char   REFLOWTEMPERATURE;
    unsigned char   REFLOWTIME;
    unsigned char   BAKETEMP;

    union
    { 
      unsigned int  BAKETIME;
      struct
      {
        unsigned char BakeTimeLowbyte;
        unsigned char BaketimeHighbyte;
      };
    };

    unsigned char   COOLDOWNTEMPERATURE;
    unsigned char   COOLDOWNTIME;
    unsigned char   KP;
    unsigned char   KI;
    unsigned char   KD;
    unsigned char   CYCLETIME;    
}EEPROM_DEFAULTS;

You can now either use BAKETIME, BakeTimeLowbyte or BaketimeHighbyte as if they were 3 different struct members, even though they refer to the same 16 bit word.

---

However, this code is slightly problematic as you enforce the processor endianess upon your struct. If the code is only ever going to run on a Little Endian PIC, this is perhaps acceptable. But suppose you want to do the same thing with a struct that describes a data communication protocol. The sender, the network protocol and the receiver may all differ in endianess.

Therefore it would actually be better to keep the 16 bit integer from the initial code, then access individual bytes like this:

unsigned char hi = (unsigned char) (eeprom.BAKETIME >> 8);
unsigned char lo = (unsigned char) (eeprom.BAKETIME & 0xFF);

This code is endianess-independent and portable.

---

General good advice / code review:

• This struct and the union may have padding bytes inserted anywhere inside. Padding is never an issue on 8 bit MCUs, but on most other systems. You might want to protect against unintended padding by checking that the struct size is correct, using a static_assert.
• Avoid the default types of C, since they are non-portable and sometimes come with various nasty side effects such as implicit type promotion. Instead of unsigned char and unsigned int, use uint8_t and uint16_t from stdint.h
• Remember that the variable instance of the EEPROM_DEFAULTS struct must be declared as volatile, since the EEPROM might be changed at any time.

Answer 2

You don't need to split anything. Just dump the structure to the EEPROM as it is.

Let EEPD be structure of EEPROM_DEFAULTS and assume eepromWrite8(uint8_t data,int index) is the writing function.

Then, it should be something like that:

eepromWrite8(*((uint8_t*)&EEPD)+index),index);

&EEPD is the address of EEPD, a pointer type of EEPD*.

It is casted into pointer type uint8_t*.

"+index" part is the pointer arithmetic which you calculate the offset to point (in the resolution of the type, that is why it is called pointer arithmetic)

Finally, you make an uint8_t from where the pointer points to. (The asterisk on the left)

Answer 3

Unfortunately this is the only way of achieving what you want in C.

You can make the following simplification though.

typedef struct  {
    char lo, hi;
} BytePair;

typedef union {
    int intValue;
    BytePair bytes;
} Word;

// for example purposes / your large structure here
typedef struct {
    u8 a;
    u8 b;
    Word c;
} MyStruct;

I'm assuming an 'int' on your system is 16bits wide ?

Answer 4

I would argue that the method that is most clear is best, I see two ways you can do this. The first is the way you outlined, I would just use sized types such as uint8_t and uint16_t rather than unsigned int and char to explicitly show their sizes. The second way is just to mask off the individual bytes. This may require a little more typing but is also fairly clear in my mind. The idea is to bitwise and your data 8 bits at a time with 8 ones that are right justified (the low byte) then right shift the data 8 bits to move the 8 significant bits to the low position then repeat.

/* Helper Macros */
#define LOW_BYTE(data16)    ((uint8_t)(data & 0xFF))
#define HIGH_BYTE(data16)   ((uint8_t)((data>>8) & 0xFF) 
/* Actual data manipulation */
uint8_t bakeTimeHighByte = HIGH_BYTE(EEPD.BAKETIME)
uint8_t bakeTimeLowByte  = LOW_BYTE(EEPD.BAKETIME)

/* my test code */
void p(void){
    uint16_t data = 0x1234;
    printf("0x%04X\r\n", data);
    printf("Low Byte  : 0x%02X\r\n", LOW_BYTE(data));
    printf("High Byte : 0x%02X\r\n", HIGH_BYTE(data));
}

/* my output */
0x1234
Low Byte  : 0x34
High Byte : 0x12