incrementing union data in c

Question

I am somewhat unfamiliar with unions, have done some reading on them and am having trouble figuring this out.

Someone has defined a union for me:

union CANDATA   // Unionize for easier cooperation amongst types
{
    unsigned long long ull;
    signed long long   sll;
    u32        ui[2];
    u16        us[4];
    u8     uc[8];
    u8     u8[8];
    s32        si[2];
    s16        ss[4];
    s8         sc[8];
};

There is also a struct that has this union as one of its members:

struct CANRCVBUF        // Combine CAN msg ID and data fields
{ //                               offset  name:     verbose desciption
    u32 id;         // 0x00 CAN_TIxR: mailbox receive register ID p 662
    u32 dlc;        // 0x04 CAN_TDTxR: time & length p 660
    union CANDATA cd;   // 0x08,0x0C CAN_TDLxR,CAN_TDLxR: Data payload (low, high)
};

I am creating an instance of CANRCVBUF:

static struct CANRCVBUF increasingMessage = {
    0x44400000,     /* 11 bit id */
    0x00000002,     /* 2 data bytes */
    {
        0x0000
    }
};

What I want to do next, is create a loop that increments the data portion of increasingMessage. This is where I am having trouble. My attempt was:

if(increasingMessage.cd + 1 > 65535) {
    increasingMessage.cd = 0x0000;
} else {
    increasingMessage++;
}

I realize that by using increasingMessage.cd I am accessing the union, not the data in the union. My trouble is, how do I know which member of the union is used when creating increasingMessage?

Any tips are greatly appreciated

For example by: "increasingMessage.cd.ui[0]++" or "increasingMessage.cd.ull++" or whatever else you want to increase inside the union. — Ingo Blackman, Jan 25 '14 at 23:17

score 1 · Accepted Answer · answered Jan 25 '14 at 23:18

1

You need to supply which of the union members you are addressing. The compiler needs to know if you want to test ull (as unsigned long long) or sc[0] (as unsigned char), or any of the other members.

In your case you probably want to use

if(increasingMessage.cd.us[3] + 1 > 65535) {
  ...

-- that is, if this part of the union is the number you are looking for. (It's not entirely clear from your code.)

Union members are accessed the same as struct members, they only difference is that they get stored differently.

Note that the particular field I chose will never be >65535 ... So choose your test member carefully ...

answered Jan 25 '14 at 23:18

Jongware

22,200
8
54
100

So, you knew it would be .us[3] because 0x0000 is an int? and why index 3 (i would have guessed 0). – Troy Cosentino Jan 25 '14 at 23:24
Sorry, just a guess -- not enough information to go on. It depends on what part of the union you should be testing (surely you have *some* documentation on that?), and also, unfortunately, on the endianness of your system. – Jongware Jan 25 '14 at 23:27
Unfortunately, not much documentation was provided. It does note that the union is being used to make it easier cooperation for types. The data held is a 64 bit data string that will be sent over CAN bus. I am just trying to access the part of the union that gets created in my declaration of `increasingMessage`. – Troy Cosentino Jan 25 '14 at 23:31
Yes, but you don't know which *part* of `increasingMessage` holds just your data length. If you are sure the entire member should only hold a single number, you can test `increasingMessage.cd.ull` -- a full 64-bit value. – Jongware Jan 25 '14 at 23:57

Michał · Answer 2 · 2014-01-25T23:47:48.057

0

Usually when you use unions you should know which member has correct data in it. If it is not possible, you will need to add a variable to CANRCVBUF to indicate which member is correct. That's a C way to use inheritance.

edited Jan 25 '14 at 23:47

answered Jan 25 '14 at 23:17

Michał

2,202
2
17
33

@EricPostpischil my bad, sorry for that. I'll edit my answer to comply – Michał Jan 25 '14 at 23:46

barak manos · Answer 3 · 2014-01-25T23:31:03.207

In a union, all the fields are overlapping. Hence, the size of a union is equal to the size of the largest field in it.

As to your question:

You need to specify the name of the field on which you want to apply the operation, by adding a reference to it after increasingMessage.cd. For example, increasingMessage.cd.ull. But please note that all the other fields in your union will also be affected every time you change this field, as they are all overlapping each other.

Usually, in order to indicate the relevant field, the entire union is placed within a struct which contains an additional enum which is used in order to indicate that field. For example:

typedef enum
{
    MSG_1,
    MSG_2,
    MSG_3,
    ...
}
msg_type_e;


typedef struct
{
    msg_type_e type;
    union CANDATA cd; // 0x08,0x0C CAN_TDLxR,CAN_TDLxR: Data payload (low, high)
}
msg_t;

Notlikethat · Answer 4 · 2014-01-26T00:05:42.543

The standard says it is the first named member of a union that receives a static initialiser, thus you are implicitly saying increasingMessage.cd.ull = 0x0000 when you declare it.

In general it is most robust to work on the largest member of a union in cases like this. If you don't know any better, then:

increasingMessage.cd.ull++;
increasingMessage.cd.ull &= 0xFFFF;

is the safest way to do a 16-bit count - if you don't know the endianness then you don't know which of cd.us[0] and cd.us[3] is the least significant 16 bits of a CANDATA so you might as well guarantee it's consistent in local endianness. Of course, if it has to be communicated to another system that's another matter, but documentation should clearly define any requirements there.

score 0 · Answer 5 · answered Jan 26 '14 at 00:08

So, if I got your intention correctly, you want to loop through increasingMessage.cd, from 0 to 65535. As others stated, union's members overlap with each other, i.e. ull, sll, ui[2], ..., all point to the same memory. In other words, these different fields are in the same memory address and store the same value, but you can represent that same value with different types by accessing different fields.

Thus, a simple loop over eg ull can do the trick, like:

for (increasingMessage.cd.ull = 0;increasingMessage.cd.ull<65536;increasingMessage.cd.ull++)
{
}

Now, if you only want to loop through the lease significant bits of your data, you need to make the loop a little bit more complicated:

for (increasingMessage.cd.ull &= 0xFFFFFF00;(increasingMessage.cd.ull & (0x000000FF))<65536; increasingMessage.cd.ull++)
{
...
}

Finally, pay attention that how different fields of increasingMessage.cd is interpreted depends on the endianness of your target machine as well as your programs semantic. For example, if increasingMessage.cd.ull=0x11223344, this might mean that cd.us[0]=0x11 and cd.us[3] = 0x44, or alternatively cd.us[0]=0x44 and cd.us[3]=0x44, depending on the endianness.

incrementing union data in c

5 Answers5