Zeiger Umwandlung

[Felix (Gast)]

Hallo,

ich muss relativ zeitkritisch 240Bit hintereinander einlesen. So mache
ich es zurzeit:
Mit malloc 240Bit vom Type bool reservieren. Die Bit's hintereinander
in den Speicher schreiben. Danach habe ich etwas Zeit zum verarbeiten.

Ich habe jetzt 240 einzelne Bits, nur brauche ich eigentlich Word und
Byte lange Datenwörter.

Kann ich einen Byte-Pointer z.B. gleich der Startadresse des
Datenfeldes setzen und dann auf die ersten 8Bit per Byte zugreifen?

Wie gruppiere ich meine Bit's ohne sie z.B. per while() in ein Byte zu
schreiben?

Gibt es vielleicht eine viel schönere Lösung?

cu, Felix

(WinAVR Atmel16)

[Nico S. (Gast)]

Öhm.. Jetzt mal nur ne Idee:

bool *Daten = malloc(240*sizeof(bool));
char *Bytedings;
Bytedings = (char*) Daten;

Zugriff dann mit Bytedings[0], Bytedings[1], Bytedings[2] usw.

[Nico S. (Gast)]

Nachtrag:

mit
  Daten[0]  greifst du auf das erste Bit zu, mit
  Daten[1]  auf das zweite, etc.

Mit
  Bytedings[0]  greifst du auf den ersten 8-bittingen Block zu, mit
  Bytedings[1]  auf den zweiten, etc.

[Felix (Gast)]

genauso wollte ich es machen, aber irgendwie stehten in Bytedings[0]
nicht die ersten 8 Bits.

Meine Syntax ist allerdings etwas anders.

Bytedings[1] wär bei mir *(Bytedings+1)

Aber daran dürfte es doch nicht liegen???

[Nico S. (Gast)]

Was steht denn da? Was soll da stehen? Bitte mal posten.

Die Syntax ist soweit äquivalent.

[Besserwisser (Gast)]

Anstatt
char *Bytedings; könnte es auch
unsigned char *Bytedings; heißen!!

[Rufus Τ. F. (rufus)]

Der Datentyp "bool" ist nicht ein Bit, sondern in der Regel äquivalent
zu int, also je nach Prozessor 16 oder 32 Bit groß.

Daher kann das oben aufgeführte Typecasting nicht funktionieren.

C unterstützt keine Bit-Datentypen, zwar gibt es Bitfelder, auf die
aber kann nicht mit Arrayoperatoren zugegriffen werden.

Beispiel:

  union
  {
    struct
    {
      unsigned char bit0 : 1;
      unsigned char bit1 : 1;
      unsigned char bit2 : 1;
      unsigned char bit3 : 1;
      unsigned char bit4 : 1;
      unsigned char bit5 : 1;
      unsigned char bit6 : 1;
      unsigned char bit7 : 1;
    } bitfeld;
    unsigned char zeichen;
  } bla;

Hier kann mit

  bla.bitfeld.bit0 = 0;

ein einzelnes Bit manipuliert werden, und mit

  bla.zeichen = 0;

auf -in diesem Falle- alle 8 Bits simultan zugegriffen werden.

Es gibt aber keinen Arrayoperator für Bitfelder, so daß die von Felix
erwähnte Einleseroutine die einzelnen Bits nicht einfach in ein Array
eintragen kann.

Stattdessen müsste entweder mit solchen Bitfeldern wie in meinem
Beispiel gearbeitet werden, was reichlich umständlich ist, oder aber
die Bits werden von vornherein mit entsprechenden Bitoperationen in
ganze Bytes eingetragen:


  unsigned char Wert;
  int i;

  Wert = 0;

  for (i = 0; i < 8; i++)
    Wert |= LeseEingang() << i;

Hier wird vorausgesetzt, daß die Funktion LeseEingang 0 oder 1
liefert.

Das muss bei größeren Bitanzahlen entsprechend adaptiert werden.

[Felix (Gast)]

@Nico: Ich deute "Was steht da" mal so :)
Die ersten 8Bit 0b11000000(steht auch wirklich im Speicher) -> 0xC0
bekommen habe ich aber 0xD9 was ich als Zeiger ins Nirgendwo gedeutet
habe.


@Besserwisser: bei mir heißt es uint8_t

[Felix (Gast)]

for (i = 0; i < 8; i++)
    Wert |= LeseEingang() << i;

ist das nicht relativ langsam? Ich müsste dann ja noch die Wert'e
hochzählen.

[Felix (Gast)]

äh, also wenn bool=int ist, dann würde das nicht in den Speicher
passen.

240x8Bit = 1920Bit der Atmel hat aber nur 1k RAM, den Speicher bekomme
ich aber.

Oder verpeile ich das jetzt?

[Besserwisser (Gast)]

printf("%i",strlen(bool));

[Peter D. (peda)]

"ich muss relativ zeitkritisch 240Bit hintereinander einlesen."


Bitstrukturen sind in der Regel sehr ineffizient programmiert.


Wenns wirklich schnell sein soll, dann je 8 Bit seriell in ein Byte
reinschieben, das Byte in einem Byte-Array abspeichern und den Zeiger
aufs Array um 1 hochzählen usw. Also quasi SPI in Software.


Peter

[Karsten Brandt (Gast)]

@Besserwisser:

Du meinst sicherlich

printf("%i", *sizeof*(bool)); ;-)

Mit strlen kannst Du nur die Länge eines NULL-terminierten Strings
ermitteln.

Karsten

[Besserwisser (Gast)]

Klar, die Hitze ließ mein Hirn verdunsten.

[Ulrich (Gast)]

Ein paar Poster wissen es bereits, aber der Rückgabetyp von sizeof ist
eine Ganzzahl in Bytes.... ;-)