www.mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik C: Bit in einer Variable eigenen Namen geben?


Autor: Tio T. (misterten)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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

Autor: Werner B. (werner-b)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Die Strukturen in eine Union packen.

Autor: Tio T. (misterten)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ach, d.h. ich würde es so schreiben:


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


?

Autor: Daniel Cagara (cagara)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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!

Autor: Benutzer Name (benutzername)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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 ;)

Autor: Matthias D. (marvin42)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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

Autor: Benutzer Name (benutzername)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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

Autor: Werner B. (werner-b)
Datum:

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

Autor: Tio T. (misterten)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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?

Autor: Johann L. (gjlayde) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

Autor: Tobias Plüss (hubertus)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

Autor: Johann L. (gjlayde) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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...

Autor: Tio T. (misterten)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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?

Autor: Johann L. (gjlayde) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
#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;

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.