C pointer in Struct-Array übergeben

[RH (Gast)]

Hallo,

ich habe folgendes Problem:

Ich möchte uint32_t integer Variablen in ein uint8_t Array schreiben. 
Die Variablen werden einem struct zugeordnet und bekommen dort einen 
Namen. Der Variablenwert wird als Zeiger auf die jeweilige Variable in 
der structur hinterlegt.

Das Füllen des uint8_t Arrays möchte ich nun über den in dem struct 
hinterlegten pointer machen (siehe Code).

struct uint32_t_variable
{
  char* name[10];
  uint32_t* ptr;
};

struct uint32_t_variable uint32_t_variablen[] =
{
    {"Zähler 1", &cnt},
    {"Zähler 2", &cnt2}
};
uint8_t nmbr_of_uint32_t_variables = sizeof(uint32_t_variablen)/sizeof(*uint32_t_variablen);

mit der Funktion void MP_update_array(void) möchte ich nun das Array 
tx_value_buffer updaten. wie folgt:

void MP_update_array(void){
  uint8_t *pos = tx_value_buffer;
  for(int i = 0; i < nmbr_of_uint32_t_variables; i++){
    uint32_t* value = uint32_t_variablen[i].ptr;
    *pos = *value >> 24;
    pos++;
    *pos = *value >> 16;
    pos++;
    *pos = *value >> 8;
    pos++;
    *pos = *value;
    pos++;
  }
}

Leider wird mir hier in das Array eine sehr hohe Zahl (vermutlich die 
Speicheradressen?) geschrieben. Wenn ich *pos = &cnt; anstelle von *pos 
= *value; schreibe wird mir der richtige Wert ins Array geschrieben. Das 
riecht stark nach einem Fehler in meinem struct aber was mache ich 
falsch? Ich verzweifle.

Das ganze läuft in der STM32CubeIDE auf einem STM32G0 Kern.

[Jim M. (turboj)]

STM32 ist little endian.

[z.B. (Gast)]

RH schrieb:
> struct uint32_t_variable
> {
>   char* name[10];
>   uint32_t* ptr;
> };
>
> struct uint32_t_variable uint32_t_variablen[] =
> {
>     {"Zähler 1", &cnt},
>     {"Zähler 2", &cnt2}
> };

in der struct ist char* ein Array von Zeigern (und kein Stringarray - 
was die Zuweisung wohl annimmt).

[C++ ist doof (Gast)]

in C

   uint32_t x = 0x10203040;
   printf("als int32-Wert: %#x\n", x);

   uint8_t* p = (uint8_t*)&x;

   uint8_t arr[4];

   for (int i = 0; i < 4; i++)
      arr[i] = *p++;

   uint32_t* p32 = (uint32_t*)arr;

   printf("als Array: %#x\n", *p32);

[Andreas J. (ajbln)]

RH schrieb:
> uint32_t* value = uint32_t_variablen[i].ptr;
>     *pos = *value >> 24;
>     pos++;
>     *pos = *value >> 16;
>     pos++;
>     *pos = *value >> 8;
>     pos++;
>     *pos = *value;
>     pos++;

Stattdessen kannst Du auch folgendes machen:

    *reinterpret_cast<uint32_t*>(pos) = *value;
    pos += sizeof(uint32_t);

So bleibt die Endianess aber gleich! Wenn Du aber Little Endian bist und 
Big Endian rausschreiben willst wie in Deinem Code (Highbyte first), 
musst Du die Endianess vorher drehen.

Das geht z.B. so (kann aber von der Plattform abhängen):

    *reinterpret_cast<uint32_t*>(pos) = htobe32(*value);

Versuche nicht von Hand zu drehen, viele Prozessoren haben dafür 
spezielle Maschinenbefehle, daher sind solche Endianessconverter immer 
sinnvoller.
Wie gesagt, je nach Plattform können sie auch anders heißen.
Meistens irgendwas mit h(ost) to 32 bits oder unsigned integer...