void Pointer auf struct

[Jan K. (jan_k)]

Hallo Leute,

folgendes Problem habe ich momentan :

Ich baue ein kleines Programm auf einem uC, das über die serielle 
Schnittstelle Befehle bekommt. So soll bspw. ein bestimmter Modus 
eingestellt werden (z.B. Logging Modus 1). Das geht mit einem Befehl. 
Dieser wird dann durch eine Zeichenfolge bestätigt. Dann kann ein 
zweiter Befehl empfangen werden, der z.B. einen anderen Parameter setzt. 
Dieser Befehl wird ebenfalls bestätigt. Und so weiter.

Es soll aber gewartet werden, bis alle Parameter gesetzt worden sind, 
bevor der Modus umschaltet.

Ich habe momentan zwei Modi, die ich beeinflussen möchte :

typedef struct usartMode
{
  uint16_t mode; // aktueller Modus
  uint8_t  confirmed;
} usartModeStruct;

typedef struct pidMode
{
  uint16_t mode;    // aktueller Modus : Tabelle / Funktion
  uint8_t function;  // welche Funktion bzw Tabelle?
  uint16_t amplitude; // Amplitude in steps
  float   frequenz;    // Frequenz in Herz
  uint8_t  confirmed;   // aktiviert?
} pidModeStruct;

volatile typedef struct activateMode
{
  void *newMode;
  void *activeMode;
} activateModeStruct;


...
usartModeStruct usartLogMode = {USART_LOG_OFF_READ,1};  
usartModeStruct newUsartLogMode = {USART_LOG_OFF_READ,1};

pidModeStruct pidMode = {PID_OFF_READ,0,0,0,1};      // aktueller Modus
pidModeStruct newPidMode = {PID_OFF_READ,0,0,0,1};   // nächste Modus  
  
activateModeStruct activateMode = {NULL, NULL};  // Beinhaltet die Modestructs..

Je nachdem, was von außen kommt, steht in 'mode' etwas anderes drin. In 
einer switch/case Anweisung wird dann geprüft, um welchen Befehl es sich 
handelt.

Ausschnitt:

switch(action)    // action
      {
        case USART_LOG_COUNTER:         // Stelle ein : log Mode 1 - counter
            newUsartLogMode.mode = USART_LOG_COUNTER; // noch nicht freigegeben -> usartLogMode.confirmed = 0;
            newUsartLogMode.confirmed = 0;
            activateMode.newMode = (usartModeStruct*) &newUsartLogMode;
            activateMode.activeMode = (usartModeStruct*) &usartLogMode;
          break;

        case USART_LOG_COUNTER_ABS:    // Stelle ein : log Mode 2 - counter + abs
            newUsartLogMode.mode = USART_LOG_COUNTER_ABS; // noch nicht freigegeben -> usartLogMode.confirmed = 0;
            newUsartLogMode.confirmed = 0;
            activateMode.newMode = (usartModeStruct*) &newUsartLogMode;
            activateMode.activeMode = (usartModeStruct*) &usartLogMode;
          break;
...
        case PID_SET_FREQ:  // Frequenz einstellen            
            newPidMode.frequenz = freq;
            newPidMode.confirmed = 0;   
            activateMode.newMode = (pidModeStruct*) &newPidMode;
            activateMode.activeMode = (pidModeStruct*) &pidMode;  
...
        case CONFIRM:          // Führe aus.  C
          if(activateMode.newMode != NULL && (uint16_t)data == lastAction)
          {            
            activateMode.activeMode = activateMode.newMode;  
            activateMode.activeMode -> confirmed = 1;  // neuen Modus setzen        
          }          
          break;

action ist dabei die von außen kommende Variable.

Vermutlich geht die Zuweisung unten nicht, im Notfall kopiere ich halt 
die Inhalte Elementweise. Das ist aber jetzt erst einmal nicht das 
Hauptproblem.

Ich habe gedacht, dass ich dem Problem, dass ich eben nicht weiß, um 
welche struct es handelt, aus dem Weg gehen kann, indem ich den void 
Pointer nehme und dann jeweils caste.

Nun habe ich gelesen, dass nicht bei der Zuweisung, sondern bei der 
Dereferenzierung gecastet werden muss. Damit bin ich wieder beim alten 
Problem. Ich weiß nicht, ob es eine usartModeStruct oder eine 
pidModeStruct ist. Eventuell werden es noch mehr als diese beiden Typen.

Ich hoffe ihr konntet das Problem nachvollziehen, ich wäre euch sehr 
dankbar, wenn einige Tips/Anregungen kämen. Danke :)

[Peter II (Gast)]

Jan K. schrieb:
> Ich weiß nicht, ob es eine usartModeStruct oder eine
> pidModeStruct ist. Eventuell werden es noch mehr als diese beiden Typen.

anders geht es nicht. Dann musst du irgendwie dafür sorgen das du es 
weißt.

[Karl H. (kbuchegg)]

Mit etwas Bauchweh kann man tricksen.

Die Zuweisung
  activateMode.activeMode = activateMode.newMode;
geht sowieso nicht, weil da ein paar Dereferenziersterne fehlen.

Allerdings: Du musst ja nicht mit einer direkten Zuweisung operieren. 
memcpy kopiert Bytefelder und alles was es dazu braucht ist die Länge 
des zu kopierenden Bytefeldes. Und die kann man sich ja zusätzlich zu 
den Pointern merken.

Das Problem, dass das confirmed Feld irgendwo in der Struktur steckt, 
kann man damit umgehen, indem man ihn als ersten Member in die Struktur 
packt. Dann weiß man immer, egal bei welcher STruktur, wo dieser Member 
liegt.

Allerdings: Damit ist jegliche Sicherheit dahin! Wenn auf deiner 
Schnittstelle Kommandos reinkommen, die so nicht erlaubt sind, dann geht 
das enorm in die Hose!

[Ralf R. (rrascher)]

Peter II schrieb:
> Jan K. schrieb:
>> Ich weiß nicht, ob es eine usartModeStruct oder eine
>> pidModeStruct ist. Eventuell werden es noch mehr als diese beiden Typen.
>
> anders geht es nicht. Dann musst du irgendwie dafür sorgen das du es
> weißt.

ufuer so etwas gibt es in C den Datentyp UNION.

[c}
typedef struct usartMode
{
  uint16_t mode; // aktueller Modus
  uint8_t  confirmed;
} usartModeStruct;

typedef struct pidMode
{
  uint16_t mode;    // aktueller Modus : Tabelle / Funktion
  uint8_t function;  // welche Funktion bzw Tabelle?
  uint16_t amplitude; // Amplitude in steps
  float   frequenz;    // Frequenz in Herz
  uint8_t  confirmed;   // aktiviert?
} pidModeStruct;

volatile typedef struct activateMode
{
  void *newMode;
  void *activeMode;
} activateModeStruct;

[/c]

pidModeStruct enthaelt ja praktisch die gleichen
Variablen die auch in usartModeStruct drin sind.
Dann definier dir doch noch eine zusaetzliche
Variable im pidModeStruct, z. B. mode, die dir
die verwendeten Variablen defieniret, bzw. welche
Art von Struktur gerade gueltig ist.

Ralf

[Jan K. (jan_k)]

Danke für die Antworten :)

Ich habe mir sowas in der Art auch überlegt, Peter. Aber das fühlte sich 
dann auch nach zu sehr Gefrickel an.

Die Eingaben werden gefiltert, viel mehr Möglichkeiten gibt es momentan 
auch noch nicht. Ist ein kleines Programm, aber schadet ja nicht, das 
vernünftig zu designen.

Ich denke ich werde eine zusätzliche Variable nehmen, die sich merkt, 
was zuletzt gesetzt werden sollte..

Ist denn so eine Aufgabe so ungewöhnlich? Ging jetzt davon aus, dass 
häufiger in der Art auf Benutzereingaben reagiert wird?

Danke + viele Grüße!

edit: Deinen Beitrag hab' ich zu spät gesehen, Ralf :) Mit Unions habe 
ich noch nie gearbeitet, werde mir die aber auch angucken, danke.

[Pako (Gast)]

Jan K. schrieb:

activateMode.activeMode -> confirmed = 1;  // neuen Modus setzen

Das kann nicht gehen.
Du hast einen void* und versuchst auf das Element "confirmed" 
zuzugreifen. Der C-Compiler kann nicht wissen, was der Inhalt des void* 
bedeuten soll, daher kann er auch keinen Zusammenhang zu usartModeStruct 
oder pidModeStruct herstellen.

Durch das Zuweisen der Adresse einer Struktur auf einen void* ändert 
sich am Typ des void* nichts, es ist nach wie vor ein void*.

[Gebhard R. (Firma: Raich Gerätebau & Entwicklung) (geb)]

Die Struktur:
typedef struct pidMode
{
  uint16_t mode;    // aktueller Modus : Tabelle / Funktion
  uint8_t function;  // welche Funktion bzw Tabelle?
  uint16_t amplitude; // Amplitude in steps
  float   frequenz;    // Frequenz in Herz
  uint8_t  confirmed;   // aktiviert?
} pidModeStruct;

würd ich so umformen;

typedef struct pidMode
{
  uint8_t  confirmed;   // aktiviert?
  uint8_t function;  // welche Funktion bzw Tabelle?
  uint16_t mode;    // aktueller Modus : Tabelle / Funktion
  float   frequenz;    // Frequenz in Herz
  uint16_t amplitude; // Amplitude in steps
} pidModeStruct;

kostet dich nix, bringt 5 Bytes mehr Speicher.

Grüsse

[Jan K. (jan_k)]

@ Pako: Ja, ich dachte halt, es würde bei der Zuweisung reichen, zu 
casten. Tatsächlich muss aber beim Auslesen gecastet werden. Habe jetzt 
in der struct "activateMode" ein weiteres Feld angelegt, das den letzten 
Modus gespeichert hält..

@ Gebhard, danke für den Tip, gehe davon aus, es liegt am alignment. Der 
Compiler selbst packt die Reihenfolgen nicht an?

[Klaus W. (mfgkw)]

Und warum nicht eine struct, die den Typ enthält (als enum) sowie eine 
union mit dem einen oder dem anderen mode?
Für sowas ist eine union doch da.

Den Typ außerhalb der Daten (also in activateMode) zu speichern, geht 
zwar, ist aber weniger elegant. Je näher bei den Daten, desto klarer und 
zuverlässiger.

Wenn man void* verwendet, hat man meistens etwas falsch gemacht - so 
auch hier.

Oder: wie du es schon hast in activateMode den Typ merken, und darin 
dann eine union mit einem Zeiger auf den einen oder den anderen mode.

[Stefan W. (dl6dx)]

Karl Heinz Buchegger schrieb:
> Das Problem, dass das confirmed Feld irgendwo in der Struktur steckt,
> kann man damit umgehen, indem man ihn als ersten Member in die Struktur
> packt. Dann weiß man immer, egal bei welcher Struktur, wo dieser Member
> liegt.

Ich verwende in solchen Fällen gern ein Konstrukt aus einer Struktur, 
die als erstes Element einen Typdeskriptor (kleiner uint-Typ) und ggf. 
weitere immer vorhandene Werte enthält, gefolgt von einer Union aus 
mehreren, zu den  einzelnen funktionalen Typen gehörenden Structs. Für 
den Einsatzzweck des OP könnte ich mir das so vorstellen:

// Message-Typen
#define MSGT_UNDEF 0
#define MSGT_USART 1
#define MSGT_PID   2
// etc...

// Die typabhängigen Teilstrukturen
typedef struct
  {
  uint16_t mode;       // aktueller Modus
  } usartModeStruct;

typedef struct
  {
  uint16_t mode;       // aktueller Modus : Tabelle / Funktion
  uint8_t function;    // welche Funktion bzw Tabelle?
  uint16_t amplitude;  // Amplitude in steps
  float   frequenz;    // Frequenz in Hertz
  } pidModeStruct;

// Jetzt die "Superstruktur"
// Für alle gemeinsame Elemente zuerst
// und in der Union die typabhängigen Elemente

typedef struct {
  uint8_t  type;              // Typ der Message
  uint8_t  confirmed;         // confirmed?
  union
    {
    usartModeStruct usartmode; // Daten, falls USART-MSG
    pidModeStruct   pidmode;   // Daten, falls PID-MSG
    } daten;
  } messageStruct;


void beispielfunktion(messageStruct InMsg)
  {
  uint8_t  confirmed;

  uint16_t usartmode;

  uint16_t pidmode;
  uint8_t  pidfunction;
  uint16_t pidamplitude;
  float    pidfrequenz;

  switch(InMsg.type)
    {
    case MSGT_USART:
      if(InMsg.confirmed)
        {
        usartmode = InMsg.daten.usartmode.mode;
        }
      // weiteres...
      break;

    case MSGT_PID:
      if(InMsg.confirmed)
        {
        pidmode      = InMsg.daten.pidmode.mode;
        pidfunction  = InMsg.daten.pidmode.function;
        pidamplitude = InMsg.daten.pidmode.amplitude;
        pidfrequenz  = InMsg.daten.pidmode.frequenz;
        }
      // weiteres...
      break;

    default: // unbekannter Typ
      // panic();
      break;
  }

Durch die Schachtelung ist es natürlich etwas mehr "Schreibarbeit", bis 
man am gewünschten Element ist. Und man muss darauf achten, je nach Typ 
die richtige Union anzusprechen, dafür gibt es in C natürlich keine 
Automatik.

Grüße

Stefan

PS: Ich hab den Beispielcode nur "auf die Schnelle" in die Eingabemaske 
des Forums gehackt. Tippfehler möchte ich daher nicht restlos 
ausschließen.

[Jan K. (jan_k)]

Danke für die zusätzlichen Antworten!

In etwa so, wie im letzten Beitrag habe ich das jetzt, nur ohne union. 
Werde die union aber auch ausprobieren, dankeschön!