Remplir un tableau à l'indice n avec m fois des données sans champs de bits

Question

J'essaie d'envoyer un maximum de 8 octets de données. Les 4 premiers octets sont toujours les mêmes et comportent des commandes définies et une adresse. Les 4 derniers octets doivent être variables.

Pour l'instant, j'utilise cette approche. Malheureusement, on m'a dit de ne pas utiliser de boucles for dans ce cas.

// Construct data
local_transmit_buffer[0] = EEPROM_CMD_WREN;
local_transmit_buffer[1] = EEPROM_CMD_WRITE;
local_transmit_buffer[2] = High(MSQ_Buffer.address);
local_transmit_buffer[3] = Low(MSQ_Buffer.address);

uint_fast8_t i = 0;
for(i = 0; i < MSQ_Buffer.byte_lenght || i < 4; i++){ // assign data
    local_transmit_buffer[i + 4] = MSQ_Buffer.dataPointer[i];
} 

Voici un code de test que j'essaie de mettre en place pour résoudre mon problème :

#include <stdio.h>

__UINT_FAST8_TYPE__ local_transmit_buffer[8];
__UINT_FAST8_TYPE__ MSQ_Buffer_data[8];

void print_local(){
for (int i = 0; i < 8; i++)
    {
        printf("%d ", local_transmit_buffer[i]);
    }
    printf("\n");
}

void print_msg(){
for (int i = 0; i < 8; i++)
    {
        printf("%d ", MSQ_Buffer_data[i]);
    }
    printf("\n");
}

int main(){
    // assign all local values to 0
    for (int i = 0; i < 8; i++)
    {
        local_transmit_buffer[i] = 0;
    } print_local();

    // assign all msg values to 1
    for (int i = 0; i < 8; i++)
    {
        MSQ_Buffer_data[i] = i + 1;
    } print_msg();

    *(local_transmit_buffer + 3) = (__UINT_FAST32_TYPE__)MSQ_Buffer_data;

    printf("\n");
    print_local();

    return 0;
}

La première boucle remplit le local_transmit_buffer avec des 0 et le MSQ_Buffer avec 0,1,2,.... local_transmit_buffer -> 0 0 0 0 0 0 0 0 0 MSQ_Buffer_data -> 1 2 3 4 5 6 7 8

Maintenant je veux assigner les 4 premières valeurs de MSQ_Buffer_data à local_transmit_buffer comme ceci : local_transmit_buffer -> 0 0 0 0 1 2 3 4

Existe-t-il un autre moyen de résoudre ce problème sans utiliser des boucles for ou un champ de bits ?

Résolu : J'ai utilisé la fonction memcpy pour résoudre mon problème.

// uint_fast8_t i = 0;
// for(i = 0; i < MSQ_Buffer.byte_lenght || i < 4; i++){ // assign data
//     local_transmit_buffer[i + 4] = MSQ_Buffer.dataPointer[i];
// } 

// copy a defined number data from the message to the local buffer to send
memcpy(&local_transmit_buffer[4], &MSQ_Buffer.dataPointer, local_save_data_length);

Answer 1

• Soit vous déroulez la boucle manuellement en tapant chaque ligne, soit vous utilisez simplement la fonction memcpy . Dans ce cas, il n'y a aucune raison pour que vous ayez besoin de couches d'abstraction, donc j'écrirais le code le plus sain possible, c'est-à-dire un simple déroulage manuel (et je me débarrasserais des macros désagréables) :

  uint8_t local_transmit_buffer [8];
  ...
  local_transmit_buffer[0] = EEPROM_CMD_WREN;
  local_transmit_buffer[1] = EEPROM_CMD_WRITE;
  local_transmit_buffer[2] = (uint8_t) ((MSQ_Buffer.address >> 8) & 0xFFu);
  local_transmit_buffer[3] = (uint8_t) (MSQ_Buffer.address & 0xFFu);
  local_transmit_buffer[4] = MSQ_Buffer.dataPointer[0];
  local_transmit_buffer[5] = MSQ_Buffer.dataPointer[1];
  local_transmit_buffer[6] = MSQ_Buffer.dataPointer[2];
  local_transmit_buffer[7] = MSQ_Buffer.dataPointer[3];

• La raison pour laquelle vous ne pouvez pas utiliser une boucle n'est pas évidente, cela ne ressemble pas à la programmation réelle de l'EEPROM (où le code surchargé pourrait causer des problèmes), mais il suffit de s'y préparer. Commencez à remettre en question de telles exigences.

• Notez également que vous devez no utiliser __UINT_FAST8_TYPE__ mais uint8_t . Je n'utilise jamais les types de produits maison, mais toujours stdint.h . Mais vous ne devriez pas utiliser fast pour un tampon RAM utilisé pour la programmation EEPROM, car il ne peut jamais contenir de remplissage. Il s'agit d'un bogue.