AVR C ein Byte aus einer langen Konstante lesen

[Klaus (Gast)]

Lässt sich in C eine 70Bit lange Konstante so ablegen,
dass man per Shift-Operationen an beliebiger Stelle ein Byte auslesen 
kann?

z.B.

Bit 66-59 soll als Byte "00010101" gelesen werden:

1010001010111010111010000010101000101110101000101011101011101000001010
   ^^^^^^^^
oder

Bit 2-0 (MSBs) und Bit 69-65 (LSBs) soll als Byte "01010100" gelesen 
werden:

1010001010111010111010000010101000101110101000101011101011101000001010
^^^^^                                                              ^^^

[Oliver S. (oliverso)]

Mit Shift-Operationen ja, mit nur einer Shiftoperation nein.

Hilfreich sind dabei natürlich Integertypen mit 70 oder mehr Bit, die 
nicht jeder Compiler kennt. Wenn nicht, musst du die 70 Bit halt auf 
mehr als eine Variable aufteilen. Das ist dann aber auch kein 
allzugroßer Akt.

Oliver

[Cube_S (Gast)]

Vom Ansatz her vielleicht so (ohne Gewähr weil nicht getestet):

int p = pos/8, r=pos%8;
byte b = (a[p]>>r)|(a[p+1]<<(8-r))

wenn a das byte-Array mit der Bit-Konstante ist.

[S.Siebenhaar (Gast)]

Da bei den meisten Compilern bei 64 Bit Schluss ist, wirst Du wohl oder 
übel mit einem Array ( unsigned char XXX [ 9 ], für 70 Büdd ) arbeiten 
müssen.

Manche Compiler machen sogar schon vorher (16-32 Büdd) schlapp.

Ein Zugriff auf Bit 7 - 15 ist so oder so nicht ohne Schubsen machbar.

Mit ein bisschen Grips aber, ohne allzu große Verrenkungen, machbar.

[Falk B. (falk)]

@ Klaus (Gast)

>dass man per Shift-Operationen an beliebiger Stelle ein Byte auslesen
>kann?

Das macht man anders.

Bitmanipulation

Beitrag "Re: Bits aus einem unsigned char array extrahieren"

[RC (Gast)]

Auch sehr interessant bei Shift Operationen >32 bit.

http://m.heise.de/developer/artikel/Wider-die-Intuition-3179490.html

[Klaus (Gast)]

@ Cube_S:  danke für den Modulo Tipp.

wenn ich die Konstante als eindimensionales 9Byte Array ablege und
z.B. von Bitposition 11 an lesen will:

10100010 10111010 11101000 00101010 001......
            ^^^^^ ^^^

dann Teile ich 11/8 = 1 und übernehme folglich Byte 1 und 2 von links in 
eine unsigned int Variable:

10111010 11101000
   ^^^^^ ^^^
anschliesend bestimme ich durch 11%8 = 3
dass ich 3mal linksschieben muss
und habe dann linksbündig mein Ergebnis

so müsste es gehen

[Klaus (Gast)]

Klaus schrieb:
> so müsste es gehen

hat funktioniert. Inzwischen ist es eine 80Bit Konstante bestehend aus 
8Byte.

Über (Bitposition / 8) bekomme ich das Hbyte und
mit ((Bitposition / 8) + 1) das Lbyte

Diese 16Bit schiebe ich per (Bitposition % 8) um die nötige Anzahl nach 
links und habe dann linksbündig das 8Bit Ergebnis

[Markus W. (Firma: guloshop.de) (m-w)]

Klaus schrieb:
> hat funktioniert. Inzwischen ist es eine 80Bit Konstante bestehend aus
> 8Byte.

Aber wenn es doch eine Konstante ist, braucht man gar keine 
Bitmanipulation. Man kann die ca. 80 möglichen verschiedenen 
auszugebenden Bitmuster fest in einer Tabelle vorhalten und dann 
indirekt darauf zugreifen.

Klar, belegt in diesem Fall ca. 80 Bytes Platz in den Daten, läuft aber 
sehr schnell und braucht nur ein paar wenige Bytes Programmcode.