C: Bit in einer Variable eigenen Namen geben?

[Tio T. (misterten)]

Hallo,

ich sehe grad den Wald vor lauter Bäumen nicht:

ich habe einen zwei Strukturen, eine mit Byte-Variablen und eine mit 
Bit-Variablen:

struct
{   unsigned char fix;
    unsigend char foxy;
}
X;


struct
{   unsigned a:1;
    unsigned b:1;
    unsigned c:1;
}
Y;


Wie mache ich das nun, dass Y.a das erste Bit von X.fix, Y.b das zweite 
Bit von X.fix ist, usw.? Ich blick das grad nicht.

danke schonmal!
tio

[Werner B. (werner-b)]

Die Strukturen in eine Union packen.

[Tio T. (misterten)]

Ach, d.h. ich würde es so schreiben:


union fix
{   unsigned a:1;
    unsigned b:1;
    unsigned c:1;
};


?

[Daniel C. (cagara)]

Naja einfacher wäre es doch einfach den Inhalt von

unsigned char fix;

per memcpy in das struct Y zu kopieren.

Mehr brauchst du nicht zu tun!

[Benutzer N. (benutzername)]

versuch mal

union muh
{
  struct
  {   
    unsigned char fix;
  }X;

  struct
  {   
    unsigned b0:1;
    unsigned b1:1;
    unsigned b2:1;
    unsigned b3:1;
    unsigned b4:1;
    unsigned b5:1;
    unsigned b6:1;
    unsigned b7:1;
  }Y;
};



void main()
{
  muh test;

  test.X.fix = 193;

  printf("%d\n",test.X.fix);
  printf("%d %d %d %d %d %d %d %d \n",test.Y.b7, test.Y.b6, test.Y.b5, test.Y.b4, test.Y.b3, test.Y.b2, test.Y.b1, test.Y.b0);
}

und die Ausgabe auf der Konsole sieht wie folgt aus

193
1 1 0 0 0 0 0 1

Viel Spaß damit ;)

[Matthias D. (marvin42)]

Da hilft ein Blick in den Urvater aller C-Anleitungen, 
Kerningham-Rithice bei Prentice-Hall.

Eine "union" hat den Zweck an nur einer Speicherstelle verschiedene 
Inhakte unterbringen zu können. Die folgende union

union u_1 {
  int ivalue;
  float fvalue;
  char* svalue;
} u;

kann entweder einen integer, einen float oder einen char* aufnehmen, der 
Compiler macht sich aber automatisch groß genug, damit auch die grösste 
Variable hineinpasst (vorsicht mit "int", das ist nicht bei jedem 
Prozessor gleich gross, dass kan 8,16 oder 32 bit sein).

Deine union "fix" ist demnach nur 1 Bit groß und kann enteder aus a, 
oder b, oder c bestehen. Wenn du aber zwei Bytes bitweise ansprechen 
willst, dann würde ich folgendes vorschlagen:

union myUnion
{
  struct
  {
    char fix;
    char foxi;
  } uByte;

  struct
  {
    unsigned a:1;
    unsigned b:1;
    // usw und so fort
  } uBit;
} uutype;

wenn du nun folgende Variable erzeugst:

uutype uvar;

dann sollte folgender Code möglich sein:

uvar.uByte.fix = 0x55;
uvar.uByte.foxi = 0xAA;
uvar.uBit.a = 1;
uvar.uBit.b = 0;

Nicht alle C-Compiler sehen das mit dem "uByte" und "uBit" gleich, es 
gibt ältere, bei denen muss man das weglassen.


matthias

[Benutzer N. (benutzername)]

oder wie folgt :)

union uBYTE
{
  struct
  {   
    unsigned char byte;
  };

  struct
  {   
    unsigned b0:1;
    unsigned b1:1;
    unsigned b2:1;
    unsigned b3:1;
    unsigned b4:1;
    unsigned b5:1;
    unsigned b6:1;
    unsigned b7:1;
  };
};



struct Stuff
{
  uBYTE  fix;
  uBYTE  fox;
}myStuff;


void main()
{

  myStuff.fix.byte = 193;

  myStuff.fox.b4 = 1;

  printf("%d\n",myStuff.fix.byte);
  printf("%d %d %d %d %d %d %d %d \n",myStuff.fix.b7, myStuff.fix.b6, myStuff.fix.b5, myStuff.fix.b4, myStuff.fix.b3, myStuff.fix.b2, myStuff.fix.b1, myStuff.fix.b0);

}

das wäre dann genau gleich

193
1 1 0 0 0 0 0 1

[Werner B. (werner-b)]

Nur als Hinweis:
Die Umsetzung einer Union ist aber Compiler- und Architekturspezifisch. 
Also nicht Sourcecode-Portabel.

[Tio T. (misterten)]

Was soll

muh test;

bewirken? Was ist test? Also, der erste Beitrag des anonymen Freunds 
sieht schon so inetwa danach aus, was ich mir vorstelle. Ich erklär mal, 
was ich genau bezwecken wollte:

Bei Abschalten des uC sollen Werte ins EEPROM geschrieben werden. Da ich 
nun mehrere Variablen habe, die nur zwei Zustände haben können, macht es 
halt Sinn, diese als Bit zu deklarieren (in einer union macht auch 
Sinn).

Nun bin ich aber faul: Ich möchte jetzt nicht x Mal den Befehl 
__EEPROM_WRITE ausführen, sondern möchte nur eine als char deklarierte 
Variable ins EEPROM schicken. Und diese Variable soll dann die Werte in 
der union deklarierten Bits enthalten.

Warum dann nicht gleich nur die char Variable nehmen, und die 
entsprechenden Bits manipulieren!? Nun ja, es liest sich nicht gut. Das 
Programm ist ein wenig größer, und die Bits werden an den 
verschiedensten Stellen geändert. Und wenn ich an einer Stelle des 
Programms vertieft bin, weiß ich dann nicht mehr, an welchem Bit ich 
manipulieren muss.

Daher will ich den Bits jeweils einen Namen vergeben, so dass ich 
letztenendes nur benamten Bits manipuliere, und schlussendlich nur das 
Char (das diese Bits enthält) ins EEPROM schreibe.

Ich hoffe, ich denke da nicht zu umständlich?

[Johann L. (gjlayde)]

Er meinte

union muh test;

Das ist eine Variablendefinition, wobei die Lösung von benutzername zwar 
nicht standardkonform, aber hübscher ist beim Hintexten des Zugriffs.

[Tobias P. (hubertus)]

Du könntest auch für jedes Bit folgendes machen:

#define BIT0 0x01
#define BIT1 0x02
...
#define BIT7 0x80


und dann in deinem Code Dinge wie

var = BIT0 | BIT1 | BIT7;


schreiben um Bits zu setzen, oder

var ^= BIT0 | BIT 1;

um Bits umzukehren, oder

if(var & (BIT0 | BIT3 | BIT6))
...

um Bits zu prüfen und so weiter und so fort.
Bei der Windows-Programmierung wird das ähnlich gemacht. Der Befehl 
MessageBox z.B. kennt verschiedene Flags: MB_ICONEXCLAMATION (Dialogbox 
mit Ausrufezeichen-Symbol), MB_ICONINFORMATION (Dialogbox mit 
Info-Symbol), MB_OK (Dialogbox nur mit OK-Button) MB_YESNO (Dialogbox 
mit Ja und Nein Button). Im Code könnte man dann z.B. schreiben

MessageBox("Hallo Welt", MB_OK | MB_ICONINFORMATION);

Das würde eine Dialogbox mit dem Text "Hallo Welt", einem OK-Button und 
einem Info-Symbol anzeigen.
Mit diesen

#define BIT0 0x01

am Codeanfang kannst du für jedes Bit Namen vergeben und seine Position 
festlegen.
Der Vorteil ist klar:

1. Du hast die volle Kontrolle darüber, wo welches Bit steht.
2. Das funktioniert mit jedem Variablentyp (egal ob int, char, long, 
wasweissich).
3. Das funktioniert mit jedem Compiler.

Es wurde ja von meinen Vorgängern schon gesagt, dass nicht bei jedem 
Compiler int = 32 Bit ist und auch nicht jeder Compiler seine structs 
und unions gleich macht.

[Johann L. (gjlayde)]

Tobias Plüss wrote:

> Es wurde ja von meinen Vorgängern schon gesagt, dass nicht bei jedem
> Compiler int = 32 Bit ist und auch nicht jeder Compiler seine structs
> und unions gleich macht.

Was aber nur dann berücksichtigt werden muss, wenn man die Daten binär 
zwischen unterschiedlichen Systemen überträgt.

Wenn man einen char mit 8 bit überlager, ist einem recht egal, wo diese 
stehen.

Ausserdem ist es dann wesentlich einfacher, ein Bit zu setzen:

foo.bit3 = 1;
foo.bit4 = 0;

Das rumbasteln mit Masken und und und oder und not und weil das nervt 
und noch ein set makro und noch ein clear und weil wir gerade dabei sind 
noch ein toggle und damits komplett ist ein test makro und...

[Tio T. (misterten)]

Naja, ich will ja nicht zwischen Plattformen wandeln. Ich bin und bleibe 
beim 8-Bit uC, und ich weiß ja, was mein Compiler mit Unions anstellt.

Johann, das sieht prima aus. Und wenn ich nun einen bit 'uta' deklariert 
habe, wie definiere ich, dass bit 'uta' das bit 'foo.bit3' ist?

Ich denke

#define uta foo.bit3

alleine wird nicht funtionieren, da nicht definiert wurde, was 'uta' 
ist. Oder kann ich diese Deklaration einfach vorab setzen?

[Johann L. (gjlayde)]

#define mach nur Textersatz.

IMHO sollte man die sparsam verwenden. Man kann zwar Tipparbeit sparen, 
aber spätestens bei 3-fach verschachtelten Makros verfluchst du den 
Erschaffer...

In C gibt es keine Bits in Sinne wie Bytes (char) oder Worte (short). Es 
gibt nur Bitfelder, die sich aber von normalen Variablen unterscheiden: 
Man kann keine Arrays davon anlegen, keine Adressen bilden, etc.

In deinem Fall muss eben ein Objekt foo angelegt werden. Wie das geht 
steht oben

#ifndef FLAGS_H_
#define FLAGS_H_
#include <stdint.h>

typedef union
{
   struct
   {
       ...
       uint8_t uta:1;
   };
   ...
} flags_t;

extern flags_t foo;
#endif // FLAGS_H

~~~~~~~~~~~~~~~~~

#include "flags.h"
flags_t foo;

... foo.uta = 0;
... foo.orang = !foo.uta;