Getting high-low bytes

[venkman]

HI, I'm currently working on a project where I need to split an unsigned 16bit int into bytes the code I have written is:

msg[AXIS_HI]=value>>8;
msg[AXIS_LO]=(uint8)value;

The software I'm working on provides various macros for byte manipulation there is one macro that splits 16 bit ints;

#define HI_UINT16(a) (((a) >> 8) & 0xFF)
#define LO_UINT16(a) ((a) & 0xFF)

I'm a C novice so I'm not sure what the purpose of the and operation is I understand what it does I'm just not sure why it's necessary.

[cas]

For LO_UINT16(), “and”ing with 0xff gives you the bottom byte. It's necessary, I think, for obvious reasons: if you didn't do it, you'd get the whole value you passed in. If you're wondering why to mask instead of cast, I would suggest that the mask gets the intent across, while the cast does not. A cast could be there for a number of reasons, while a mask with 0xff is very clear.

If you always pass an unsigned, 16-bit type to HI_UINT16() (or at the very least a value in that range), the masking with 0xff is not necessary. There are two reasons I can think of why one might use the mask here, though:

1. If a larger value gets passed in, simply right-shifting by 8 won't result in an 8-bit value (0x100000 >> 8 is 0x1000, for example). However, it'd be wrong to pass in a larger value, so there's a bug either way.
2. Semantics. You clearly want the bottom 8 bits after shifting, so the mask makes that explicit. We know that the top 8 bits will be empty, but it might be clearer to a reader to see the mask with 0xff.

I would definitely use a mask over a cast for getting the bottom 8 bits. I don't think one method (masking vs. not) is clearly superior for getting the top 8 bits. Depends on how explicit you want to be.

[venkman]

Thanks for that cas.

Coding in C continues to be an interesting experience....

[CommonTater]

Of course threre's always the "union" method...

union twobytes
   {  unint_16  Word;
       struct  bytes
          { uint_8  HiByte;
             uint_8  LoByte; } }

stuff in a word ... s.Word = myval; ... read the bytes ... mybyte = s.bytes.LoByte;

[venkman]

So the word is accessible via the struct members because its a union?
I'm familiar with structs but not so much with unions.

[CommonTater]

So the word is accessible via the struct members because its a union?
I'm familiar with structs but not so much with unions.

The idea of a union is that two or more variables occupy the same memory address. Since they occupy the same space, they become interchangeable... Two bytes or 1 word same thing.

The union simply describes a Word that occupies the same memory address as 2 Bytes... Therefore you can put in a word and get two bytes out or you can reverse it and put in two bytes and get a word out...

Of course there are other uses for unions, but I've always liked the cleverness of this one.