Hallo

Ich suche eine Möglichkeit, mit der ich Variablen (>8 Bit) in die
entsprechenden Bytes aufteilen kann und so hinterher einzeln bearbeiten
kann.

Um 16-Bit Variablen in 8-Bit Blöcke zu teilen klappt das einwandfrei:

#define HIGH(Word16) (((uint8_t*) &Word16)[1])
#define LOW(Word16) (((uint8_t*) &Word16)[0])

uint16_t foo;
LOW(foo)=0x12;

Soweit so gut. Jetzt möchte ich nach diesem Prinzip eine 32-Bit Variable
aufteilen, aber nicht in Bytes, sondern in 16-Bit Worte:

#define HIGH(Word32) (((uint16_t*) &Word32)[1])
#define LOW(Word32) (((uint16_t*) &Word32)[0])

uint32_t foo;
HIGH(foo)=0x1234;

Diese Variante funktioniert ersteinmal auch. Allerdings gibt mir der
Compiler folgende Warnmeldung:

>"dereferencing type-punned pointer will break strict-aliasing rules"


In den beiden Beiträgen, die ich hier im Forum zu diesem Thema gefunden
habe, werden Workarounds vorgeschlagen. Beispielsweise soll eine Union
verwendet werden. Das möchte ich aber nicht, da ich dann ja zukünftig
alle Variablen als u_Union16, Union16, u_Union32, ... deklarieren
müsste. Sehr unschön.

Was kann ich tun?

Grüße
Steffen

Steffen Hausinger wrote:
> Beispielsweise soll eine Union
> verwendet werden. Das möchte ich aber nicht, da ich dann ja zukünftig
> alle Variablen als u_Union16, Union16, u_Union32, ... deklarieren
> müsste. Sehr unschön.

Du musst sie ja nicht als Union deklarieren, du kannst sie ja auch im
Makro zur Union casten.

Ich würde das nicht mit Pointer-Casting machen, sondern mit Shift-
Operationen. Diese setzt der Compiler zwar nicht immer optimal um,
aber auch die Pointermethode ist oft nicht effizient, weil der
Compiler wegen der Verwendung des Adressoperators die Variable ins RAM
legt, statt sie in Registern zu halten.

Oder eben -fno-strict-aliasing verwenden. Dann geht aber die Effizienz
möglicherweise woanders verloren.

Den Beitrag von Stefan Ernst habe ich zu spät gelesen. Das, was er
beschrieben hat, ist natürlich die beste Methode, auch
taktzyklenmäßig.

Die Idee mit dem Typecast als Union gefällt mir gut! Sie ergibt auch den
gleichen kompakten Code wie die von mir im Eingangsposting beschriebene
Variante. Ich habe es wie folgt implementiert:

// Union zum Konvertieren
typedef union
{
 uint32_t u32;
 uint16_t u16[2];
 uint8_t u8[4];
} Word32;

// High-Wort der 32-Bit Variable "foo" den Wert 0x1234 zuweisen
uint32_t foo;
Word32 *__Converter;
__Converter=(Word32*) &(foo);
__Converter->u16[1]=0x1234;

Nur leider klappt der Code nicht mehr, wenn ich daraus ein Makro forme!
Wenn ich der Variable "foo" im High-Wort den Wert 0x1234 wie folgt
zuweisen will

uint32_t foo;
HIGH16(foo)=0x1234;

dann sagt er mir

>"expected expression before '=' token".

Und wenn ich umgekehrt einer 16-Bit Variablen den High-Teil von foo
zuweisen will:

>"expected expression before 'typecast'"

Das ist mir soweit auch verständlich, weil er bei der Variable ja einen
Wert erwartet und keine weiteren Befehle, mit denen am Ende irgendwann
ein Wert berechnet wird.

Gibt es eine Abhilfe? Ohne, die Union etc. an anderer Stelle "global" zu
deklarieren?

Steffen Hausinger wrote:

> Nur leider klappt der Code nicht mehr, wenn ich daraus ein Makro forme!

Wie sehen denn die Makros aktuell aus?

Sowas in der Art sollte funktionieren:

#define HIGH16(Var) (((uint8_t*) &Var)[1])
#define LOW16(Var) (((uint8_t)*) &Var)[0])

Kann aber sein, dass es da noch ganz böse Fallstricke geben kann.

EDIT: Ups hab nur den Titel gelesen und nicht gesehen, dass der Thread
schon eine Zeit lang läuft. Im ersten Post befinden sich ja sogar
"meine" defines. hehe :-)

>Wie sehen denn die Makros aktuell aus?

Naja, im Prinzip so wie oben im C-Code, also:

#define HIGH16(Word) (typedef union{uint32_t u32;uint16_t u16[2];} Word32; \
                     Word32 *__Converter;\
                     __Converter=(Word32*) &(Word);\
                     __Converter->u16[1])

Der Ausdruck steht in runden Klammern. Ich hatte ihn ursprünglich in
geschweiften Klammern stehen, damit der typedef ausserhalb des Makros
seine Gültigkeit verliert. Aber das funktionierte genausowenig.

Fällt Dir da ein Fehler auf?

@Simon: Mit der Umwandlung 16Bit -> 2x 8Bit funktioniert es auch
einwandfrei. Nur bei 32Bit -> 2x 16Bit meckert der Compiler. Das wundert
mich.

Steffen Hausinger wrote:

> Naja, im Prinzip so wie oben im C-Code, also:
>

#define HIGH16(Word) (typedef union{uint32_t u32;uint16_t u16[2];} Word32; \
                     Word32 *__Converter;\
                     __Converter=(Word32*) &(Word);\
                     __Converter->u16[1])

Igitt, so wird das natürlich nichts.
Nimm folgendes:

typedef union
{
 uint32_t u32;
 uint16_t u16[2];
 uint8_t  u8[4];
} Word32;

#define HIGH16(X) (((Word32*)&(X))->u16[1])
#define LOW16(X)  (((Word32*)&(X))->u16[0])

Ach, ich sehe erst jetzt deinen Satz oben:
> Ohne, die Union etc. an anderer Stelle "global" zu deklarieren?

Was spricht denn gegen ein globales Union-Typedef?
Du kannst es doch einfach in die selbe Datei packen, wie die Defines.

Hallo Stefan,

ich mache es jetzt so, wie Du vorschlägst. Das typedef sieht für mein
Empfinden zwar nicht besonders elegant aus, aber dafür ist der Code sehr
kompakt und der Compiler meckert nicht.

Danke für Deine und Eure Hilfe!
Steffen