Bits in Variable per #define ansprechen

[Marco S. (sharkman)]

Hallo.

Ich arbeite mit c18 compiler und hänge grad ein bisschen in der Luft.

Es geht um folgendes:
Wenn ich von einem Register ein bestimmtes Bit ansprechen möchte, 
schreibe ich
REGISTERbits.BIT

Das ganze möchte ich jetzt auch für selbstdefinierte 8bit Variablen 
haben. Also das ich mir eine Variable als unsigned char definiere und 
dann schreiben kann
VARIABLEbits.BIT
allerdings soll nun noch BIT über einen #define BIT 0...7 die Bitstelle 
angeben.

Die Frage ist jetzt, wie stelle ich das am besten an, ohne dass ich 
jedesmal das gesamte Bitmuster laden muss. Es soll allerdings auch 
möglich sein, die Variable wie gewohnt mit VARIABLE = 0x00; oder 
ähnlichem zu beschreiben.

besten Dank und schöne Grüße
Marco

[bitte löschen (Gast)]

Probiere mal:
http://publications.gbdirect.co.uk/c_book/chapter6/bitfields.html
Meinst Du so etwas?

Marco Schulze schrieb:
> Es soll allerdings auch
> möglich sein, die Variable wie gewohnt mit VARIABLE = 0x00; oder
> ähnlichem zu beschreiben.

Das müsstest Du dann mit einem cast machen.

[Marco S. (sharkman)]

Ok.

Ich bedanke mich. Dann werd ich das mal so versuchen

€dit:
Also das mit dem cast hat er nicht gefressen. Jemand eine andere Idee 
oder vielleicht ein Programmbeispiel?

[michl (Gast)]

Super Thema, genau das selbe Problem hab ich momentan auch^^ Falls 
jemand zu einer Lösung kommt / gekommen ist bitte hier posten.
Ein Ansatz ist eventuell die jeweilige Header-Datei des µC.

[IsobarX (Gast)]

Hallo Marco,

vielleicht hilft Dir das folgende Codebeispiel etwas weiter. Du kannst 
natürlich auch ein unbenutztes Register, z.B. eines GPIOs, verwenden 
(schneller). Falls man mehrere Bitfelder braucht, dann würde ich das in 
eine Struktur tun.

/* Terminal Out */
#include <stdio.h>

#define Bitfield_0   (Bitfield_init & 0x01)
#define Bitfield_1   (Bitfield_init & 0x02)
#define Bitfield_2   (Bitfield_init & 0x04)
#define Bitfield_3   (Bitfield_init & 0x08)
#define Bitfield_4   (Bitfield_init & 0x10)
#define Bitfield_5   (Bitfield_init & 0x20)
#define Bitfield_6   (Bitfield_init & 0x40)
#define Bitfield_7   (Bitfield_init & 0x80)
#define Bitfield     (*(unsigned int*) &Bitfield_init)

void main(void)
  { 
    unsigned int Bitfield_init = 0x00;                     /* Initialisierung der Bitmaske*/ 
    Bitfield = 0x0F;                                       /* Bitmaske mit etwas füllen */
    printf("Der Wert von Bitfield ist: %i\n", Bitfield); 
    printf("Der Wert von Bitfield ist: %i\n", Bitfield_0); /* Ausgabe des LSB */
    Bitfield_7 = 0xFF; /* MSB mit etwas füllen */ 
  }

MfG
IsobarX

[bitte löschen (Gast)]

typedef struct eBitfeld
{
        unsigned bit0:1;
        unsigned bit1:1;
} EBitfeld;

main()
{
        EBitfeld e;
        // Initialisieren:
        e.bit0 = 0;
        e.bit1 = 0;
        // Beide Bits mit einem mal setzen:
        *(int*)&e = 3; // dreckig, aber geht! Lesbarer: *((int*)&e)
        // Schauen, ob gefunzt:
        printf ("Bit 0: %d und Bit 1: %d\n", e.bit0, e.bit1);
}

[IsobarX (Gast)]

Bevor ich das vergesse, das ist nur ein Ansatz. Die Makros müssen 
natürlich etwas komplizierter ausfallen, UND-Operator zum löschen eines 
Bits, ODER-Operator zum setzen der Bits

Grüße
IsobarX

[Marco S. (sharkman)]

@IsobarX

Also entweder steh ich voll auf dem Schlauch oder du löst ein anderes 
Problem, als das was mich interessiert.


@Phillip

Hmm das könnte gehen, ich brauch das mit dem mehrfachen beschreiben 
eigentlich hauptsächlich zum initialisieren. Wenn der Compiler das so 
frisst, dann seis drum, ob sauber oder nicht.