Enum andersrum verwenden

Hallo Zusammen,

ich bin gerade dabei einen NMEA decoder zu programmieren und will nun folgendes verwirklichen:

Ich habe eine Struktur wie folgt:

Code:

---

typedef struct
        {
                uint16_t UTC_TIME;
                uint8_t STATUS;
                float LAT;
                uint8_t LATIND;
                float LON;
                uint8_t LONIND;
                float SOG;
                float COG;
                uint16_t DATE;
                float MAGVAR;
                uint8_t MVDIR;
        }RMC;

---

und will die einzelnen Variablen nun in einer Schleife ansprechen.

Gedacht habe ich mir das folgendermassen:
Ich bastel mir eine Enumeration mit den entsprechenden Variablennamen und kann dann mittels Schleifenvariable(0..10) die entsprechenden Variablen der Struktur "RMC" ansprechen.
(z.B. über RMC.(enumvar.i))

Geht sowas? Oder wie geht sowas besser bzw. anders?

Vielen Dank!

Marten83

Hallo Marten,

aus anderen Programmiersprachen kenn ich die Möglichkeit ein Array von Pointern zu verwenden.

grüsse,
Hannes

Dann müsste ich ja jedem Pointer nochmal die Adresse der entsprechenden Variable zuordnen.?
Wenn es geht würde ich das gerne eleganter machen.

Nein, was dir da vorschwebt, geht nicht. Nur wenn alle Variablen in der Struktur den gleichen Typ hätten, ließe sich da was machen.

Das ist blöd!
Danke für die Info.
Aber wie wäre es denn möglich wenn alle Variablen vom gleichen Typ wären?

Da die Variablen üblicherweise schön der Reihe nach im Speicher abgelegt sein sollten, könnte man z.B. mit einem Pointer auf das erste Element beginnen und diesen einfach inkrementieren.

Eventuell könnte man auch mal sowas versuchen:

Code:

---

typedef struct
{
        uint16_t UTC_TIME;
        uint8_t STATUS;
        float LAT;
        uint8_t LATIND;
        float LON;
        uint8_t LONIND;
        float SOG;
        float COG;
        uint16_t DATE;
        float MAGVAR;
        uint8_t MVDIR;
}RMC;

typedef union
{
        RMC A;
        char B[28];
}uRMC;

---

Aber auch das würde nur dann wirklich Sinn machen, wenn die Variablen alle den gleichen Typ, bzw. wenigstens die gleiche Größe hätten.

Wenn alle Variablen vom gleichen Typ sind, kann man ein Array definieren.

grüsse, Hannes

Folgendes verbraucht mehr Speicher (44 Bytes statt 28 Bytes für ein struct vom Typ RMC), aber die Variablen sind jeweils immer 4-Byte-Schritte voneinander entfernt. Man kann also einen Pointer auf das Struct hernehmen und immer um 4 inkrementieren, dann zeigt der Pointer nacheinander auf die Variablen.

Code:

---

struct RMC
{
      uint16_t UTC_TIME __attribute__ ((aligned (4)));
      uint8_t STATUS __attribute__ ((aligned (4)));
      float LAT __attribute__ ((aligned (4)));
      uint8_t LATIND __attribute__ ((aligned (4)));
      float LON __attribute__ ((aligned (4)));
      uint8_t LONIND __attribute__ ((aligned (4)));
      float SOG __attribute__ ((aligned (4)));
      float COG __attribute__ ((aligned (4)));
      uint16_t DATE __attribute__ ((aligned (4)));
      float MAGVAR __attribute__ ((aligned (4)));
      uint8_t MVDIR __attribute__ ((aligned (4)));
};

---

Wegen der unterschiedlichen Typen macht das hintereinander ansprechen nicht viel Sinn. Die einzige ausnahme wäre eventuell beim versenden oder das Speicher im Eeprom.
Dazu könnte man eine Union definieren, für einen alternativen zugriff auf die Daten z.B. als array von Char Werten.

... und dann per Software den float erst in 4 char aufspalten um ihn dann in das struct einzufügen wo es wieder als float ansprechbar ist?

Naja, schön ist die Lösung so oder so nicht...

Tja, da habe ich mir die Sache doch einfacher vorgestellt als sie ist.
Die unterschiedlichen Typen wollte ich schon so beibehalten, damit ich nicht unnötig Speicher belege.
Ich werde das jetzt wohl so machen, dass ich das Abspeichern der gefundenen Variablen mit einer switch-Anweisung machen werde.
Ich möchte halt auch der Übersichtlichkeit halber nicht von dem struct abweichen.

Danke an Alle für die Infos.

MfG, Marten83