copier des données à la structure de données en utilisant memcpy

Question

J'essaye de lire des données de l'EEPROM, et j'ai trois structures.

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; 

Je suis en train de lire les données, mais la taille n'est pas une puissance de 2, j'ai essayé de rembourrage des données, mais le struct n'est pas rempli correctement.

J'utilise le code suivant pour lire les données du tampon et le remplir avec la structure. Par exemple, la variable crc est 0 et n'est pas lue correctement dans le tampon.

voici comment copier les données dans la mémoire tampon

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

Aucune idée de ce que vos commentaires sur les pouvoirs de deux moyens, si c'est une exigence que vous devez le rendre plus clair.

De même, la plupart des conversions de void * en C ne sont pas nécessaires, vous ne devriez pas les faire "juste pour être sûr". Il est difficile de comprendre à partir de votre code affiché pourquoi les moulages sont nécessaires.

Enfin, rappelez-vous que les structures sont des valeurs aussi, vous pouvez utiliser plaine ancienne affectation:

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

Le compilateur pourrait bien optimiser cela en un seul memcpy() appel, mais ce qui est beaucoup mieux car il est plus lisible et easie pour bien faire. Vous pourriez vouloir le mettre dans une boucle pour diminuer le risque d'indexation des fautes de frappe.

Si vous vraiment voulez utiliser memcpy(), voici comment:

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

Il utilise sizeof sur la variable de destination, et non pas sur un type. C'est un peu plus sûr. Là encore, cela ferait bien dans une boucle:

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]); 

Le sizeof dans la deuxième partie de l'en-tête for est d'éviter coder en dur la longueur du tableau. C'est un peu effrayant car cela nécessite que la longueur des deux matrices source et destination soit la même, bien sûr.