дополнительные элементы данных в объединенной структуре

Question

дополнительные элементы данных в объединенной структуре

0

Я пытаюсь кодировать относительно сложное сообщение в структуру объединения, так что я могу создать массив uint8_t, который я могу передать в протокол последовательной связи.

Однако, глядя на массив, сгенерированный, когда мой союз заполнен данными, после элемента моего типа команды появляется дополнительный элемент uint8_t. См. Структуру Союза ниже:

union myint16_t{
        uint16_t ui16;
        int16_t i16;
        uint8_t data[2];
    };

union {
    struct {
        uint8_t commandtype;
        myint16_t UpperLimits[4];
        myint16_t LowerLimits[4];
        myint16_t JointZeros[4];
        int8_t JointPolarity[4];
        myint16_t P[4];
        myint16_t I[4];
        myint16_t D[4];

    };
    uint8_t data[53];
};

как вы можете видеть, есть второй анонимный союз, ссылающийся на союз myint16_t. Поэтому, если я заполняю все значения анонимного объединения, а затем распечатываю базовый массив данных [53], мое второе значение (данные [1]) равно 0, а не часть первого элемента UpperLimits [4]. См. Код, в котором я заполняю объединение, а затем распечатываю элементы.

char q = 'c';



    hmmv4_configmsg msg;

msg.commandtype =(uint8_t) q;
msg.UpperLimits[0].ui16 = 784;
msg.UpperLimits[1].ui16  = 784;
msg.UpperLimits[2].ui16  = 784;
msg.UpperLimits[3].ui16  = 784;
msg.LowerLimits[0].ui16  = 223;
msg.LowerLimits[1].ui16  = 223;
msg.LowerLimits[2].ui16  = 223;
msg.LowerLimits[3].ui16  = 223;
msg.JointZeros[0].ui16  = 512;
msg.JointZeros[1].ui16  = 512;
msg.JointZeros[2].ui16  = 512;
msg.JointZeros[3].ui16  = 512;
msg.JointPolarity[0] = -1;
msg.JointPolarity[1] =-1;
msg.JointPolarity[2] =-1;
msg.JointPolarity[3] =-1;
msg.P[0].i16=4000;
msg.P[1].i16=4000;
msg.P[2].i16=4000;
msg.P[3].i16=4000;
msg.I[0].i16=1;
msg.I[1].i16=1;
msg.I[2].i16=1;
msg.I[3].i16=1;
msg.D[0].i16=24;
msg.D[1].i16=24;
msg.D[2].i16=24;
msg.D[3].i16=24;

//msg.change_endian();

while(1)
{
        for(int i =0; i<54; i++)
        {
            writebuf[i]=msg.data[i];

            printf("D: %d,  %d \n", i, msg.data[i]);
        }

        printf("L0: %d, %d, %d", msg.P[0].i16, msg.P[0].data[0], msg.P[0].data[1]);

        int r =jointencoder.xfer1(writebuf, readbuf, 54);
}

вывод printf (оскорбительный элемент D: 1 - его не должно быть):

D: 0,  99 
D: 1,  0 
D: 2,  16 
D: 3,  3 
D: 4,  16 
D: 5,  3 
D: 6,  16 
D: 7,  3 
D: 8,  16 
D: 9,  3 
D: 10,  223 
D: 11,  0 
D: 12,  223 
D: 13,  0 
D: 14,  223 
D: 15,  0 
D: 16,  223 
D: 17,  0 
D: 18,  0 
D: 19,  2 
D: 20,  0 
D: 21,  2 
D: 22,  0 
D: 23,  2 
D: 24,  0 
D: 25,  2 
D: 26,  255 
D: 27,  255 
D: 28,  255 
D: 29,  255 
D: 30,  160 
D: 31,  15 
D: 32,  160 
D: 33,  15 
D: 34,  160 
D: 35,  15 
D: 36,  160 
D: 37,  15 
D: 38,  1 
D: 39,  0 
D: 40,  1 
D: 41,  0 
D: 42,  1 
D: 43,  0 
D: 44,  1 
D: 45,  0 
D: 46,  24 
D: 47,  0 
D: 48,  24 
D: 49,  0 
D: 50,  24 
D: 51,  0 
D: 52,  24 
D: 53,  0 
L0: 4000, 160, 15joint encoder transferred

Мой вопрос: почему там D: 1? Мое понимание профсоюзов и структур заключается в том, что поскольку тип команды - uint8_t, тогда он должен занимать только одно пространство данных, и поэтому UpperLimits [0] должен начинаться с D: 1, но кажется, что command_type действует как uint16_t и отправляет другой бит, Почему это так?

Примечание: вы можете увидеть, что индекс увеличивается, чтобы подсчитать данные [53], которые должны быть за пределами границ, но мне нужно прочитать это и отправить его, чтобы иметь возможность деконструировать данные на другом конце.

rocklegend 07 окт. 2013, в 06:06

Источник

Теги:

c++

arrays

structure

unions

2 ответа

Ещё вопросы

Steger · Answer 1 · 2013-10-07T01-30-00.000Z

Вы должны сообщить компилятору, как выровнять элементы в вашем союзе или структуре. Просто добавьте #pragma pack (push, 1) перед определениями, чтобы дать команду компилятору выровнять соседние элементы на однобайтовых границах, а затем использовать #pragma pack (pop), чтобы вернуться к выравниванию по умолчанию компилятора. По соображениям производительности вы не захотите использовать однобайтное выравнивание для всех структур/союзов/классов, поэтому неплохо было бы обернуть определение соединения в паре прагмы.

Пример:

#pragma pack(push,1)
union
{
uint_8 first;
uint_8 second;
} two_bytes;
#pragma pack(pop)

assert(sizeof two_bytes == 2);

Jonathan Leffler · Answer 2 · 2013-10-07T01-20-00.000Z

Существует почти наверняка байт заполнения между commandtype и UpperLimits; 2-байтовый myint16_t данных myint16_t выровнен по границе четного байта.

struct {
    uint8_t commandtype;
    myint16_t UpperLimits[4];
    ...

Если вы можете напечатать размер анонимной структуры и объединения, вы, скорее всего, обнаружите, что это не менее 54 байт (где вы думаете, что это должно быть 53). Один из недостатков немаркированных типов структур, встроенных в анонимные члены профсоюза, заключается в том, что нет простого способа распечатать размер структуры. Дайте структуре тег (struct tag { uint8_t commandtype;...), чтобы вы могли распечатать свой размер.

Это нелегкое решение для использования текущей структуры.