Convert struct with pointer to char array

Question

I am currently trying to find the simplest way to convert a struct which contains a char * to a char array for transmitting a serial data frame.

The struct stores the frame headers, checksum, msg size etc along with the data to be transmit. eg

struct {
    unsigned char header;
    unsigned char msgSizeL;
    unsigned char msgSizeH;
    unsigned char *data;
    unsigned char checksum;
    ....
    ....
    ....
    ....
    unsinged char endFrame;
} Frame;

The data is a pointer as the amount of data can change with each frame transmit in the range from 1 to 16 bytes.

I am trying to find the simplest way to convert the struct to an array of unsigned chars without copying out each entry in the struct to the array but don't seem to be able to find a way.

Alternately I don't have to use a struct, as i am generating the frame contents excluding the data contents from scratch, I just want to avoid a case of -

unsigned char frame[1000];
frame[0] = 0x01; // header
frame[1] = msgSizeL; // msg size low byte
frame[2] = msgSizeH; // msg size high byte
frame[3] = data[0]; // data contents 0    Over simplification
frame[4] = data[1]; // data contents 1    for data copying - 
frame[5] = data[2]; // data contents 2    data length is variable.
frame[6] = data[3]; // data contents 3
frame[7] = data[4]; // data contents 4
frame[8] = data[5]; // data contents 5
frame[9] = data[6]; // data contents 6
frame[10] = data[7]; // data contents 7
frame[3 + msgSize]; = getChecksum(data);
....
....
....
....
frame [3 + msgSize + 20] = 0xFF; // end frame

where i write data to what reads as a random array index rather than something meaningful like frame.checksum = getChecksum(data);.

Open to suggestions and a little bit of flaming for asking a general question rather than a specific one :-)

Answer 1

I am trying to find the simplest way to convert the struct to an array of unsigned chars without copying out each entry in the struct to the array but don't seem to be able to find a way.

If data would contain up to 16 bytes, I would just declare it as 16-char array, like so:

#define MAX_DATA_LEN 16
struct {
    unsigned char header;
    unsigned char msgSizeL;
    unsigned char msgSizeH;
    unsigned char data[MAX_DATA_LEN]; // 16-char array instead of pointer
    unsigned char checksum;
    ....
    ....
    ....
    ....
    unsinged char endFrame;
} Frame;

If this is done, then all your data inside this struct has a pre-defined size (i.e. number of unsigned char * sizeof(unsigned char), and so on with other data types...) and you can use simple memcpy to copy the struct to an array:

size_t struct_len = /* computing the length of the data */ 100;
memcpy(frame, struct Frame, struct_len);

Answer 2

You have two options:

1. dynamic frame length

struct {
    unsigned char header;
    unsigned char msgSizeL; // this will be dynamic from 0x06 (empty) to 0x16 (full)
    unsigned char msgSizeH; // this will be always 0x00
    unsigned char dataSize; // specify the data size here
    unsigned char data[16]; // use a static memory area for the package
    unsigned char checksum;
    unsigned char endFrame;
} Frame;

then you can do this:

Frame xFrame;
unsigned char ucaData[17] = {0}; // your data 
unsigned int uiDataLength = 6; // for example
memset(&xFrame, 0, sizeof(Frame)); // just to be sure
xFrame.header = 0x01;
xFrame.msgSizeL = uiDataLength;
xFrame.msgSizeH = 0;
xFrame.dataSize = uiDataLength;
memcpy(xFrame.data, ucaData, uiDataLength);
xFrame.checksum = CRC8(&xFrame, uiDataLength + 4); // crc for filled area
xFrame.endFrame = 0xFF;

then when building the package:

unsigned char xDataFrame[1000];
memcpy(xDataFrame, xFrame, 4 + uiDataLength);
memcpy(xDataFrame + 4 + uiDataLength, &xFrame + 20, 2);
transmit(xDataFrame, 6 + uiDataLength);

This way, you will discard empty bytes from sending and from calculating checksum for.

2. static frame length

Then you can use a struct like this:

struct {
    unsigned char header;
    unsigned char msgSizeL; // this will be always 0x16 (22)
    unsigned char msgSizeH; // this will be always 0x00
    unsigned char dataSize; // specify the data size here
    unsigned char data[16]; // use a static memory area for the package
    unsigned char checksum;
    unsigned char endFrame;
} Frame;

This way you can calculate the checksum for the first 20 bytes of this structure, but be aware of that this structure may contain padding areas which may move your data around the defined and padded memory area. sizeof(Frame) may be calculated by hand as 22 bytes but the compiler may decide that it should use 32 bytes or 24 bytes of memory related with the pack setting. You may use

#pragma pack(1) // disable padding
[structure code]
#pragma pack()  // back to the original setting

More info about packing:

#pragma pack effect