使用memcpy将数据复制到数据结构

Question

I'm trying to read data from EEPROM, and I have three structs.

typedef struct
{
    fract32 MechCoilPhiBase;    // Mech Angle Table
    fract32 MechCoilPhi3rd;    // Mech Angle Table
    fract32 PhiSaltwater;       // Saltwater Table
    UINT16  d;
    UINT16  crc;
} ChannelData_T;

typedef struct
{

    UINT32 reHarmonic;
    UINT32 reFundamental;
    UINT32 imgHarmonic;
    UINT32 imgFundamental;

    UINT16 crc;
} CoilBoard_T;

// mechanic angles and salt water angles of coil stored in coil-eeprom
typedef struct
{
    ChannelData_T channel[NUM_CHANNELS];
    CoilBoard_T   coilboard;
//  UINT32    gCoilSerialNumber;
//  UINT32    gInversSerialNumber;
} Coil_Eeprom_Data_T;

I'm trying to read the data, but the size is not a power of 2, I tried to padding the data, but the struct is not filled correctly.

I'm using the following code to read the data from the buffer, and fill it with the struct. For example the crc variable is 0, and its not read correctly from the buffer.

here is how I copy the data to the buffer

 memcpy( (void*) &CoilEepromData, (const void*) &EepromCoil.aRxData[0], sizeof(Coil_Eeprom_Data_T) );



extern volatile Coil_Eeprom_Data_T  CoilEepromData; 
extern volatile Eeprom_Coil_T       EepromCoil;                         // control struct for the coil-eeprom  


typedef struct
{   
    UINT8   crcValueOut;
    UINT8   crcValueIn; 

    UINT8   pageAddress; 
    UINT8   dataLength;

    UINT8   bytesToTransmit;
    UINT8   bytesWritten;

    UINT8   bytesToReceive;    
    UINT8   bytesRead;    

    UINT8   errorCount;     
    bool    bWriteSucceed:1;
    bool    bStartup:1;  
    bool    bReadingStarted:1;
    UINT8   aTxData[COIL_SPI_BUFFER_SIZE];
    UINT8   aRxData[COIL_SPI_BUFFER_SIZE];
} Eeprom_Coil_T;

Answer 1

No idea what your comment about powers of two means, if that's a requirement you have to make it clearer.

Also, most casts to/from void * in C are not necessary, you shouldn't do them "just to be safe". It's hard to understand from your posted code why the casts are needed.

Finally, remember that structures are values too, you can use plain old assignment:

CoilEepromData.channel[0] = EepromCoil.aRxData[0];
CoilEepromData.channel[1] = EepromCoil.aRxData[1];
CoilEepromData.channel[2] = EepromCoil.aRxData[2];

The compiler might well optimize that into a single memcpy() call, but this is much better since it's more readable and easie to get right. You might want to put it in a loop to lessen the risk for indexing typos.

If you really want to use memcpy() , here's how:

memcpy(&CoilEepromData.channel[0], &EepromCoil.aRxData[0], sizeof CoilEepromData.channel[0]);

This uses sizeof on the destination variable, not on a type. This is a bit safer. Again, this would do well in a loop:

for(size_t i = 0; i < sizeof CoilEepromData.channel / sizeof CoilEepromData.channel[0]; ++i)
  memcpy(&CoilEepromData.channel[i], &EepromCoil.aRxData[i], sizeof CoilEepromData.channel[i]);

The sizeof in the second part of the for header is to avoid hard-coding the array length. This is a bit scary since it requires that the length of both source and destination arrays be the same, of course.