使用位域运算符时的位填充

Question

My goal is to implement functions to write the signals of a standard CAN frame. A Standard CAN frame contains the following signals:

• ID: 11 bits
• rtr: 1bit
• reserved_0: 1bit
• reserved_1: 1bit
• dlc:4bit
• data: 8 bytes

This is my representation to the CAN frame

typedef union
{
unsigned char tab[10];
struct
{
    unsigned char id_8_10:3; //ID: bit 8==>10
    unsigned char id_4_7:4; //ID: bit 4==>7
    unsigned char id_0_3:4; //ID: bit 0==>3
    unsigned char rtr:1;
    unsigned char reserved0:1;
    unsigned char reserved1:1;
    unsigned char dlc:4;
    unsigned char tabData[8];
 }bBit;
}tCanFrame;

And the Write functions are the following:

void IL_Wr_id_8_10(unsigned char ubVal)
{
 ((tCanFrame*)(&tabFrame))->bBit.id_8_10 = (unsigned int)(ubVal);
}

void IL_Wr_id_4_7(unsigned char ubVal)
{
 ((tCanFrame*)(&tabFrame))->bBit.id_4_7 = (unsigned int)(ubVal);
}

void IL_Wr_id_0_3(unsigned char ubVal)
{
((tCanFrame*)(&tabFrame))->bBit.id_0_3 = (unsigned int)(ubVal);
}

void IL_Wr_rtr(unsigned char ubVal)
{
 ((tCanFrame*)(&tabFrame))->bBit.rtr =(ubVal);
}

void IL_Wr_reserved1(unsigned char ubVal)
{

 ((tCanFrame*)(&tabFrame))->bBit.reserved1 =(ubVal);

}

void IL_Wr_dlc(unsigned char ubVal)
{

 ((tCanFrame*)(&tabFrame))->bBit.dlc =(ubVal);

}

void IL_Wr_data(unsigned char* ubVal)
{

 memcpy(((tCanFrame*)(&tabFrame))->bBit.tabData,ubVal,8);

}

In the main i tried to give values to the signals and to print them, but unfortunately it seems that stuff bits are inserted.

This is the main:

int main()
{
 int i;
 IL_Wr_id_8_10(0x7);
 IL_Wr_id_4_7(0x00);
 IL_Wr_id_0_3(0x0F);
 IL_Wr_rtr(0x00);
 IL_Wr_reserved0(0x0);
 IL_Wr_reserved1(0xFF);
 IL_Wr_dlc(0x0F);
 IL_Wr_data(tableauDonnee);

 for (i=0;i<18;i++)
 {
    printf("Byte %i : %s \n",i,byte_to_binary(tabFrame[i]));
 }
 return 0;
}

The result is the following:

Byte 0 : 0000.0111 // the result should be Byte 0 : 1000.0111 
Byte 1 : 0100.1111 // the result should be Byte 1 : 1110.0111
....

What is the problem in your opinion and do you have any idea to solve this problem?

Answer 1

Your solution is not portable.

You cannot reliably use bitfields for your purpose: the actual layout for the fields in memory is implementation defined and typically depends on the target architecture byte ordering.

If the layout happens to be correct with your compiler/architecture combination, are you sure about the actuel bit layout? You define 18 bits before the tabData array: at least 6 padding bits will be inserted in order to align tabData on byte boundaries, yielding an 11 byte structure where you seem to assume it is only 10 bytes long.

Answer 2

Your total size of bit field data is 18 bits hence, using 'int' or 'unsigned int' will work correctly to represent your header data.

typedef union
{
unsigned char tab[10];
struct
{
    int id_8_10:3; //ID: bit 8==>10
    int id_4_7:4; //ID: bit 4==>7
    int id_0_3:4; //ID: bit 0==>3
    int rtr:1;
    int reserved0:1;
    int reserved1:1;
    int char dlc:4;
    unsigned char tabData[8];
 }bBit;
}tCanFrame;

In case of bit fields,

struct
{
    data_type [member_name] : width;
};  

the size of the 'data_type' specified with bit field data member is used as boundary consideration.

In your case, id_8_10 (3 bits), id_4_7 (4 bits) and id_0_3 (4 bits) add up to 11 bits which exceeds 8 bits. Hence, id_0_3 (4 bits) are allocated in second byte. The first byte only contains id_8_10 (3 bits) and id_4_7 (4 bits) = 7 bits + 1 bit unused.

Using 'int' or 'unsigned int' will help.

NOTE::Based on your main(), Byte 1 is expected to be 1110.0111, not
Byte 1 : ..... // the result should be Byte 1 : 0010.0111 <-- as indicated by you.

Answer 3

I have opted to implement my own function:

/*function: copy_bits
 description: copy nbBitsToCopy bits from srcAdress to destAdress starting from a specific bit start_bit
 destAdress: destination address
 start_bit:the bit in the destination where to paste data
 srcAdress:source address
 nbBitsToCopy: Number of bit to copy from source
*/
void copy_bits(unsigned char* destAdress , unsigned char start_bit, unsigned char *srcAdress, unsigned char nbBitsToCopy)
{
unsigned int dest_Cursor_Byte;
unsigned int dest_Cursor_Bit;
unsigned int src_Cursor_Byte;
unsigned int src_Cursor_Bit;
unsigned int nbCopiedBits=0;

//Initialisation of cursors
dest_Cursor_Byte=start_bit/8;
dest_Cursor_Bit =start_bit%8;

src_Cursor_Byte=0;
src_Cursor_Bit=0;

while (nbCopiedBits<nbBitsToCopy)
{
    if (CHECK_BIT(srcAdress[src_Cursor_Byte],src_Cursor_Bit,1))
    {
        SET_BIT_VALUE(destAdress[dest_Cursor_Byte],dest_Cursor_Bit,1);
    }

    else
    {
        SET_BIT_VALUE(destAdress[dest_Cursor_Byte],dest_Cursor_Bit,0);
    }
    nbCopiedBits++;
    start_bit++;

    //Update cursors
    dest_Cursor_Byte=start_bit/8;
    dest_Cursor_Bit =start_bit%8;

    src_Cursor_Bit=nbCopiedBits%8;
    src_Cursor_Byte=nbCopiedBits/8;
 }
}

Your Remarks are welcome