Bit-Felder per structs verschachteln

[Jörg (Gast)]

Hallo,

ich möchte mehrere TLC5948A LED Treiber ansprechen. Diese benutzen ein 
257Bit Shiftregister.

Bevor ich mir nun Funktionen schreibe, welche ein byte/bit an eine 
gewünschte Position in einem byte-Array schreiben, dachte ich kann man 
das evtl. auch mit bit-Feldern lösen.

Das folgende Beispiel, auf einem STM32F070 mit Atollic Studio erzeugt 
laut sizeof eine Größe von 2 Byte. Kann ich dem Compiler sagen, dass es 
das trotzdem in einem Byte packen darf/soll?

typedef struct{
  uint8_t MSB :  6;
} s_component;

typedef struct {
  uint8_t MSB1 :  1;
  s_component oTest;
  uint8_t MSB2 :  1;
} s_shiftregister;

Im weiteren Verlauf dachte ich dann an folgendes, doch auch diese Lösung 
erzeugt wesentlich mehr Bytes, als erwartet.

typedef struct{
  uint8_t MSB :  1;
  uint8_t u8Data[32];
} s_component;

typedef struct {
  s_component aoData[7];
} s_shiftregister;

Dass diese Lösung dann stark Compiler abhängig wäre, ist mir bewusst.

[Niklas G. (erlkoenig)]

Meine in Serialisierung vorgestellte Library µSer kann genau das 
portabel.

https://github.com/Erlkoenig90/uSer

[Jörg (Gast)]

Danke, aber ich benutze kein C++ und zusätzlich möchte ich für dieses 
Problem nicht unbedinkt eine fette Library einbinden.

[bssst (Gast)]

Das was du evtl sucht ist:

__attribute__((packed))

 Aber pass auf, da gibt es noch so tolle Geschichten wie memory 
alignment

[Irgendwer (Gast)]

Dir dürfte das padding und alignment der struct hier einen strich durch 
deinen Denkfehler machen.

https://en.wikipedia.org/wiki/Data_structure_alignment

Beim unteren Beispiel würde ich mindestens 33 x 7 Bytes erwarten...

In der vorhergehenden struct wird nach deinem einen Bit 7 Patting-Bits 
eingefügt weil sich der darauffolgende Typ ändert. Insgesamt sind es am 
ende immer ganze Bytes bzw. ein vielfaches davon die eine struct groß 
ist (C/C++ kennt eigentlich keine echten Bits als Datentyp).

Das aligment (wenn es denn größer als eine Byte ist) kannst du teilweise 
mit "packed" überschreiben.

[Niklas G. (erlkoenig)]

bssst schrieb:
> Das was du evtl sucht ist:

Das funktioniert nicht mit Bitfeldern.

Jörg schrieb:
> zusätzlich möchte ich für dieses
> Problem nicht unbedinkt eine fette Library einbinden.

Die Bibliothek ist sehr kompakt (1 Datei) und generiert nur das absolute 
Minimum an nötigem Code. Hier wäre ein Beispiel für deinen Fall:

#include <iostream>
#include <uSer.hh>

struct s_component {
  USER_STRUCT (s_component, uSer::AttrNone)
  
  USER_MEM(std::uint8_t, MSB, uSer::Width<6>)

  USER_ENUM_MEM (MSB)
};

struct s_shiftregister {
  USER_STRUCT (s_shiftregister, uSer::AttrNone)
  
  USER_MEM(std::uint8_t, MSB1, uSer::Width<1>)
  s_component oTest;
  USER_MEM(std::uint8_t, MSB2, uSer::Width<1>)
  
  USER_ENUM_MEM (MSB1, oTest, MSB2)
};

int main () {
  s_shiftregister sr;
  sr.MSB1 = 1;
  sr.MSB2 = 1;
  sr.oTest.MSB = 0xC;
  
  std::uint8_t raw [1];
  
  uSer::serialize (raw, sr);
  
  std::cout << std::hex << int { raw [0] } << std::endl;
}

Das Kompilat dieses Codes ist exakt identisch zu "std::cout << std::hex 
<< 0x99 << std::endl;" - also Null Overhead. Die Bibliothek ist auch 
C-Kompatibel, es muss nur 1 Datei mit C++ übersetzt werden.

[Jörg (Gast)]

Irgendwer schrieb:
> Beim unteren Beispiel würde ich mindestens 33 x 7 Bytes erwarten...

Genau das passiert auch.

Irgendwer schrieb:
> Das aligment (wenn es denn größer als eine Byte ist) kannst du teilweise
> mit "packed" überschreiben.

Pakced bringt keine Veränderung.

[Mutluit M. (mutluit)]

Weiss jetzt nicht auf Anhieb ob für dieses Problem relevant sein könnte, 
aber ich habe vor einigen Wochen C-Code für sizeof() und offsetof() für 
Bitfelder (insb. in structs) entwickelt (dabei heisst es ja man kann die 
C-Operatoren sizeof und offsetof nicht bei Bitfeldern benutzen, was ja 
auch stimmt; meine Lösung ist ein Workaround mit C-macros).
Falls Interesse besteht kann ich es hier posten.