Einem Strukt Attribut, mehrere andere Strukte anhängen. Geht das?

[C. H. (hedie)]

Guten Abend zusammen

Folgende Ausgangslage:

Ich habe eine Strukt a, ein Strukt b, und ein Strukt c

Hier der Aufbau von Strukt

a:

unsigned char Attribut_1a[20];
unsigned char Attribut_2a[1];

b:

unsigned char Attribut_1b[5];
unsigned char Attribut_2b[5];

c:

unsigned char Attribut_1c[5];
unsigned char Attribut_2c[5];

Nun die Frage:

Ist es möglich, dem Attribut_1a von Strukt a die Werte des Gesamten 
Stuktes b und c anzuhängen?

Speichermässig sollte es dann so aussehen

--- Attribut_1a ----
Inhalt von Strukt a
Inhalt von Strukt b
--- Attribut_2a ----
Irgend einen zugewiesenen Wert.


Ich hoffe ich versteht was ich fragen möchte :)

Danke

[Fabian O. (xfr)]

Vielleicht suchst Du ein Union?

struct a {
  union {
    unsigned char Attribut_1a[20];
    struct {
      struct b Attribut_b;
      struct c Attribut_c;
    } Attribut_bc;
  } Attribut_1a_bc;
  unsigned char Attribut_2a[1];
};

Oder vielleicht auch einfach nur:

struct a {
  struct b Attribut_b;
  struct c Attribut_b;
  unsigned char Attribut_2a[1];
};

[C. H. (hedie)]

Fabian O. schrieb:
> Vielleicht suchst Du ein Union?
> struct a {
>   union a1bc {
>     unsigned char Attribut_1a[20];
>     struct bc {
>       struct b;
>       struct c;
>     };
>   };
>   unsigned char Attribut_2a[1];
> };
> Oder vielleicht auch einfach nur:struct a {
>   struct b;
>   struct c;
>   unsigned char Attribut_2a[1];
> };

Hmmm ich bin mir nicht ganz sicher ob wir uns richtig verstanden haben 
:)

Ich habe nun also im Code diese beiden Strukte initialisiert:

struct myStruct_a *StructA;
struct myStruct_b *StructB;
struct myStruct_c *StructC;

nun möchte ich so etwas machen:

myStruct_a->Attribut_1a = myStruct_b+myStruct_c;

Das die so direkt wohl nicht geht ist mir klar.

Es soll quasi der Speicherbereich von myStruct_b und myStruct_c in
das Attribut_1a eingefüllt werden.

[Hmm (Gast)]

Es scheint das kein Unterschied zwischen Deiner Absicht und der 
Verwendung von memcpy, strcpy, strcat etc. beteht. Wie siehst Du das?

[Fabian O. (xfr)]

Das geht, wenn Du den Zeiger auf Attribut_1a in einen Zeiger auf eine 
Hilfsstruktur castest:

struct bc {
  struct myStruct_b Attribut_b;
  struct myStruct_c Attribut_c;
};

struct bc* temp = (struct bc*) &(myStruct_a->Attribut_1a);
temp->Attribut_b = *StructB;
temp->Attribut_c = *StructC;

Schön ist das allerdings nicht und außerdem gefährlich, wenn Attribut_1a 
nicht groß genug ist ...

Wenn Du die Struktur gleich als Union bzw. so definierst, dass sie 
Attribute von Typ myStruct_b und myStruct_c aufnehmen kann, geht es ohne 
gefährlichen Cast:

myStruct_a->Attribut_bc.Attribut_b = *StructB;
myStruct_a->Attribut_bc.Attribut_c = *StructC;

bzw.

myStruct_a->Attribut_b = *StructB;
myStruct_a->Attribut_c = *StructC;

Dir ist übrigens hoffentlich klar, dass Du in dem Beispiel nur Zeiger 
auf die Strukturen definiert hast und nicht den Speicher für die 
Strukturen selbst?

[C. H. (hedie)]

Fabian O. schrieb:
> Das geht, wenn Du den Zeiger auf Attribut_1a in einen Zeiger auf eine
> Hilfsstruktur castest:

Danke für die Lösung. Aber wenn ich ein hilfsstruct brauche, dann kann 
ich auch gleich wie du gesagt hast

Fabian O. schrieb:
> Wenn Du die Struktur gleich als Union bzw. so definierst, dass sie
> Attribute von Typ myStruct_b und myStruct_c aufnehmen kann, geht es ohne
> gefährlichen Cast:

Eine Union definieren.

Fabian O. schrieb:
> Dir ist übrigens hoffentlich klar, dass Du in dem Beispiel nur Zeiger
> auf die Strukturen definiert hast und nicht den Speicher für die
> Strukturen selbst?

Vielen Dank für den Hinweis.

Nein so wirklich bewusst war mir dies nicht.
Ich bin noch ein wenig Lernbedürftig was Zeiger im Zusammenhang mit 
Strukten und Unions angeht.

Eigentlich ist diese methode jedoch vorteilhaft, da diese Speicher 
spart.
Andererseits gefählrich, wenn zb. ein Interrupt auf das Strukt in der 
Selben Art und weise zugreiffen würde.

Wie sähe es denn aus, wenn ich neuen Speicher mit der Struct Struktur 
anlegen würde?

Danke dir.

[Fabian O. (xfr)]

Claudio Hediger schrieb:
> Eigentlich ist diese methode jedoch vorteilhaft, da diese Speicher
> spart.

Im Gegenteil, die Zeiger brauchen zusätzlichen Speicher (je Zeiger z.B. 
16 Bit = 2 Byte). Um den Speicher, in dem die Struktur selbst liegt, 
kommst Du ja nicht rum.

Mal ein ganz allgemeines Beispiel. Zuerst sagst Du dem Compiler, wie die 
Strukturen aufgebaut sind. Das braucht noch keinen Speicher, sondern ist 
nur eine Information für den Compiler. Ich finde es mit typedef 
leserlicher, ist aber Geschmackssache:

typedef struct {
  uint8_t b1[5];
  uint8_t b2[5];
} b_t;

typedef struct {
  uint8_t c1[5];
  uint8_t c2[5];
} c_t;

typedef struct {
  b_t     b;
  c_t     c;
  uint8_t a2;
} a_t;

Als nächstes legst Du die Variablen an. Dabei wird der Speicher für die 
Strukturen reserviert. Das hängt jetzt von Deiner Anwendung ab, welche 
sie wie oft braucht:

a_t mein_a; // belegt 21 Byte
b_t mein_b; // belegt 10 Byte
c_t mein_c; // belegt 10 Byte

Jetzt kannst Du damit arbeiten:

mein_b.b1[0] = 23;
mein_c.c2[2] = 42;
[...]

Wenn Du nun den Inhalt von mein_b in mein_a.b kopieren willst, geht das 
mit:

mein_a.b = mein_b;

Ich vermute mal, dass das schon das ist, was Du eigentlich brauchst. 
Aber der Vollständigkeit halber auch noch die Version mit der Union:

Die Deklaration des Typs:

typedef struct {
  union {
    uint8_t a1[20];
    struct {
      b_t b;
      c_t c;
    } bc;
  } a1_bc;
  uint8_t a2;
} a_t;

Die Definition der Variable ist wie gehabt:

a_t mein_a; // belegt ebenfalls 21 Byte

Den Inhalt von mein_b und mein_c an die gewünschten Stellen kopieren:

mein_a.a1_bc.bc.b = mein_b;
mein_a.a1_bc.bc.c = mein_c;

Der Unterschied zu vorher ist, dass Du in die Struktur a_t statt einem 
b_t und einem c_t auch 20 Bytes (uint8_t) am Stück ablegen kannst, auf 
die Du per mein_a.a1_bc.a1[x] zugreifst.

[C. H. (hedie)]

Vielen Dank für deinen Beitrag.

Ich denke damit sollte es klappen :)

Ansonsten melde ich mich nochmal :)

//////////////// Edit //////////

Ja da hätte ich noch eine Frage.

Ich habe nun alle structs zu Typedefs gemacht und eine entsprechende 
Variable gezogen.

Zuvor hatte ich ein Strukt wie folgt befüllt:

myHeader = (struct Header*)&ETH_buffer[UDP_DATA];

doch nun klappt das nicht mehr.

error: incompatible types in assignment

Wie würde das befüllen einer typedef Variable aussehen?


Danke

[Fabian O. (xfr)]

Claudio Hediger schrieb:
> myHeader = (struct Header*)&ETH_buffer[UDP_DATA];

Damit hast Du nicht die Struktur gefüllt, sondern nur einen Zeiger 
verändert! Das muss nicht falsch sein, aber es macht 
höchstwahrscheinlich nicht das, was Du eigentlich dachtest. Poste also 
am besten mal den ganzen (relevanten) Code, sonst ist das Stochern im 
Nebel ...

[Tom M. (Gast)]

Fabian O. schrieb:
> Mal ein ganz allgemeines Beispiel...

Super ausgeführt, danke dafür. :)

[Claudio hediger (Gast)]

Fabian O. schrieb:
> Claudio Hediger schrieb:
>> myHeader = (struct Header*)&ETH_buffer[UDP_DATA];
>
> Damit hast Du nicht die Struktur gefüllt, sondern nur einen Zeiger
> verändert! Das muss nicht falsch sein, aber es macht
> höchstwahrscheinlich nicht das, was Du eigentlich dachtest. Poste also
> am besten mal den ganzen (relevanten) Code, sonst ist das Stochern im
> Nebel ...

Ja da hast du recht :) ich poste morgen den gesamten relevanten code.
Ich danke dir für deine bisherige unterstützung

[Carlo (Gast)]

entschuldigt, eine etwas unorthodoxe Frage:

Luna unterstützt wie C ja auch Strukturen, wäre rein zum Verständnis 
diese Strukturdeklaration hier dasselbe aus obigem Beispiel?:

struct b_t
  byte b1(5)
  byte b2(5)
endstruct

struct c_t
  byte c1(5)
  byte c2(5)
endstruct

struct a_t
  b_t b
  c_t c
  byte a2
endstruct

dim mein_a as a_t

mein_a.b.b1(1) = 123
...

dasselbe?

Gruß, Carlo

[Fabian O. (xfr)]

> myHeader = (struct Header*)&ETH_buffer[UDP_DATA];

Da man ja ein bisschen erahnen kann, warum es geht, vielleicht doch noch 
ein paar Worte dazu:

Du möchtest wahrscheinlich auf die einzelnen Elemente des UDP-Headers 
zugreifen, der Teil des empfangenen Ethernet-Frames in ETH_buffer ist. 
Dazu musst Du den Header nicht extra in eine eigene Variable kopieren, 
wie ich es oben beschrieben habe. Es reicht, die bereits im Speicher 
liegenden Daten anders zu interpretieren.

ETH_buffer ist wohl ein Byte-Array, also z.B. so definiert:

uint8_t ETH_buffer[1500];

Dort liegen die empfangenen Daten. ETH_buffer{UDP_DATA] dürfte das erste 
Byte des UDP-Headers sein. Mit &ETH_buffer[UDP_DATA] bekommst Du einen 
Zeiger auf dieses Byte, also dessen Speicheradresse.

Man kann diese Speicheradresse aber nicht nur so interpretieren, dass 
sie auf das erste Byte zeigt, sondern auch so, dass sie auf den 
UDP-Header zeigt. Diese "uminterpretieren" geht in C mit einem Cast.

Dazu muss man C zuerst sagen, wie so ein UDP-Header aussieht:

typedef struct {
  uint16_t port_source;
  uint16_t port_destination;
  uint16_t length;
  uint16_t checksum;
} udp_header_t;

Danach erstellt man sich eine Variable, die einen Zeiger auf einen 
UDP-Header enthält:

udp_header_t* udp_header_zeiger;

In dieser Variable ist nur Platz für eine Adresse (je nach Plattform 
z.B. 16 Bit = 2 Byte), nicht für die eigentlichen Daten des UDP-Headers!

Jetzt lassen wir diese Variable auf die Stelle zeigen, an der der 
UDP-Header wirklich im Speicher liegt. Dazu müssen wir den Zeiger 
&ETH_buffer[UDP_DATA], der auf das erste Byte zeigt, in einen Zeiger auf 
einen UDP-Header casten:

udp_header_zeiger = (udp_header_t*) &ETH_buffer[UDP_DATA];

Und nun kann man über diesen Zeiger auf die einzelnen Elemente des 
UDP-Headers zugreifen:

udp_header_zeiger->port_source

Hier muss man den Pfeiloperator statt dem Punkt benutzen, weil 
udp_header_zeiger eben nicht die Daten selbst enthält, sondern die 
Speicheradresse, an der sie stehen.

[Fabian O. (xfr)]

Und um den Bogen zu vorher noch zu schließen:

Wenn Du nicht die Daten in ETH_buffer uminterpretieren willst, sondern 
tatsächlich eine Kopie des UDP-Headers erstellen willst, geht das 
natürlich auch.

Variable für den UDP-Header anlegen:

udp_header_t mein_udp_header;

Die belegt 8 Byte im Speicher für die ganzen Felder des UDP-Headers. In 
diese Variable kann man jetzt die 8 Bytes ab der Stelle 
ETH_buffer[UDP_DATA] kopieren. Dazu gibt es zwei Möglichkeiten.

Die erste ist:

memcpy(&mein_udp_header, &ETH_buffer[UDP_DATA], sizeof(mein_udp_header));

Sprich: Kopiere 8 Bytes (die Größe des UDP-Headers) von der Adresse 
&ETH_buffer[UDP_DATA] an die Adresse &mein_udp_header.

Die andere Möglichkeit geht wieder über einen Cast:

mein_udp_header = *((udp_header_t*) &ETH_buffer[UDP_DATA]);

Sprich: Interpretiere die Adresse &ETH_buffer[UDP_DATA] als Zeiger auf 
einen UDP-Header. Lese die Daten, auf die der Zeiger zeigt 
(Dereferenzieren, mit dem *-Operator), und speichere sie in der Variable 
mein_udp_header.

Auf die einzelnen Elemente greift man dann ganz normal mit dem Punkt zu:

mein_udp_header.port_source

[C. H. (hedie)]

@Fabian.

Du hast es echt drauf!

Danke vielmals. Auch deine Erklärungen sind sehr verständlich.
Du hast wohl alle meine Fragen beantwortet, das was genau dass, was ich 
wissen wollte :)

Tausend Dank!

[Harald (Gast)]

Carlo schrieb:
> Luna unterstützt wie C ja auch Strukturen, wäre rein zum Verständnis
> diese Strukturdeklaration hier dasselbe aus obigem Beispiel?:struct b_t
>   byte b1(5)
>   byte b2(5)
> endstruct
>
> dim mein_a as a_t
>
> mein_a.b.b1(1) = 123
> ...
>
> dasselbe?
>
> Gruß, Carlo

ja, ist dasselbe, mit dem Unterschied, dass bei C mit [..] die 
Elementanzahl und bei Luna mit (..) das maximale, nullbasierte 
Arrayelement angegeben wird. Du musst also z.Bsp. c1(4) schreiben.

H.

[Kutte (Gast)]

Claudio Hediger schrieb:
> @Fabian.
>
> Du hast es echt drauf!

dem möchte ich mich als Mitleser unbedingt anschließen !
danke, Kutte

[Claudio H. (Gast)]

Ich hätte da doch noch eine Frage.

Ich habe folgenden Code:

    if(MRFD_NEW_PACKET_RECEIVED == 1)
    {
      MRFD_NEW_PACKET_RECEIVED = 0;
      myHeader = (DataHeader*)    &rxPACKET_Buffer[0];
      myRGBData = (RGBPaket*)   &xPACKET_Buffer[HeaderOffset];

      //uart_send_var(myHeader->DestinationAddr);

      if((myHeader->DestinationAddr == 255))
      {
        //uart_send_var(myRGBData->RedChannel);
        ucPWMRed   =   myRGBData->RedChannel;
        ucPWMGreen   =   myRGBData->GreenChannel;
        ucPWMBlue   =   myRGBData->BlueChannel;
      }

    }

  }

Wenn ich die Auskommentierten Zeilen für die UART Funktion weg mache, 
(also die Uart funktion ausführe) funktioniert alles so wie es soll.

Wenn ich hingegen die funktion auskommentiere, werden die Werte den 
Variablen nicht zugewiesen!

Der Inhalt im rxPACKET_Buffer ist korrekt.

Woran kann dies liegen?

hier noch die uart funktion:

void uart_send_var(unsigned int ucNumber)
{
  char cBuffer[5];
  ItoA(ucNumber,cBuffer);
  uart_puts(cBuffer);
}

[Claudio H. (Gast)]

Achjaa, natürlich habe ich auch noch eine Variable mit dem Zeiger...

Header* myHeader;
RGBPaket* myRGBData;

[Claudio H. (Gast)]

Claudio H. schrieb:
> Achjaa, natürlich habe ich auch noch eine Variable mit dem Zeiger...
> Header* myHeader;
> RGBPaket* myRGBData;

Problem gelöst.

Es muss so heissen:

volatile Header* myHeader;
volatile RGBPaket* myRGBData;