3 Bit shiften

Hans schrieb:
> Wie zerlege ich das wieder richtig?

b = c>>3;
a = c & 7;.

Durch eine UND-Verknüpfung. Auch Ausmaskieren genannt.
Ansonsten würde ich vorzeichenlose Datentypen für solche Zwecke nutzen.

1

uint8_t a;

2

uint8_t b;

3

uint8_t c;

4

c = 58;

5

a = c & 7;

6

b = (c >> 3) & 7;

Weitere Erklärungen unter Boolesche Algebra.

Danke!
Wo ist denn da der Unterschied bei euren Vorschlägen?
b = (c >> 3) & 7;
vs.
a = c & 7;

Beide scheinen zu funktionieren bei einem ersten Test

b = (c >> 3) & 7;
vs
c>>3;

meine ich

Wenn die Bits richtig gefüllt sind, keiner. Wenn Müll drinn steht hat 
das Ergebnis zumindest nur 3 Bit (0..7)

Hallo nochmal,

gerade habe ich das ganze mit 2 anstatt 3 bits probiert und da kommt nur 
Mist raus. Kann man nicht oben einfach die "3" durch"2" ersetzen, wenn 
man 2 bit und 6 bit haben möchte?

der 2 bit Wert wäre dann ja von 0-3
und die restlichen 6 bit von 0-63

Hans schrieb:

> gerade habe ich das ganze mit 2 anstatt 3 bits probiert und da kommt nur
> Mist raus.

Gewöhn Dir mal brauchbare Fehlerbeschreibungen an.

> Kann man nicht oben einfach die "3" durch"2" ersetzen, wenn
> man 2 bit und 6 bit haben möchte?

Die 3 steckt auch implizit in der 7 drin, weil das drei gesetzte Bits 
sind.

Ich fürchte, da hilft Alles nix, Du musst Dir mal die Grundlagen 
erarbeiten. Wie wir von 3 Bit auf die (Dezimal-)Zahl 7 kommen. Was eine 
bitweise Und-Verknüpfung macht. Und vor allem wie das mit diesen 
Dualzahlen geht.

Und dann kommt es ganz von selbst für 2 Bits die 3 zu verwenden.

Ja ich muss gestehen ich habe die UND Verknüpfung nicht verstanden.
Auf einem Zettel habe ich mir es gerade eben nochmal verdeutlicht und da 
ist mir klar geworden, dass bei 2 bit dann dezimal 3 benutzt wird..aber 
mit der Verknüpfung werde ich nicht schlau..

Hans schrieb:
> dass bei 2 bit dann dezimal 3 benutzt wird..aber
> mit der Verknüpfung werde ich nicht schlau..

Ist nicht so schwierig.. das UND (&) ist die bitmaske

sagen wir Du hast ein byte (acht bit)
00111010 (deine 58)

jetzt kommt die bitmaske da'rüber'

&7 (00000111)

die lässt sich so lesen: "gib mir nur die als '1' maskierten bits"
in dem Fall die letzten drei bit

das Ergebniss wär also 00000010 (2)

00111010 // Ursprungswert
00000111 // 0= ignorieren, 1= zurückgeben
--------
00000010 // Resultat

Mit einer bitmaske kannst Du auch die ersten fünf bit lesen,
das funktioniert genauso
00111010 // Ursprungswert
11111000 // 0= ignorieren, 1= zurückgeben
--------
00111000 // Resultat
die bitmaske wär dann &248 (11111000)

oder eben nur die drei bits 3, 4 und 5
00111010 // Ursprungswert
00111000 // 0= ignorieren, 1= zurückgeben
--------
00111000 // Resultat
die bitmaske wär dann &56 (00111000)


MaWins Antwort ist also schon korrekt
und bei fester bitbreite von drei bits auch die einfachste Lösung.

Hans schrieb:
> Wo ist denn da der Unterschied bei euren Vorschlägen?
> b = (c >> 3) & 7;
> vs.
> a = c & 7;

der Unterschied ist das vorhergehende shiften des Werts

00111010 wird um drei Stellen nach rechts verschoben
wird also zu
00000111 (vorne 000 dran, die 010 am Ende gehen verloren)
die nachfolgende Makse wird also auf
00000111 angewendet. (genau wie oben)

und ja das ist im Ergebniss dasselbe wie
b = (c & 56) >> 3; (erst maskieren mit 56, dann um drei bit verschieben)
aber das ist glaub ich grad noch verwirrender ;)

'sid

Oder nehmen wir erstmal einzelne Bits. So ein UND-Gatter hat in seiner 
einfachsten Form 2 Eingänge und einen Ausgang. Der Ausgang ist dann 1 
wenn der eine und der andere Eingang 1 sind, ansonsten ist der Ausgang 
0.
Das kann man auch in eine hübsche Tabelle packen :

1

 A B | Z

2

-----+---

3

 0 0 | 0

4

 0 1 | 0

5

 1 0 | 0

6

 1 1 | 1

Die Spalten A und B stehen für die Werte am Eingang und die Spalte Z für 
den Wert am Ausgang. Jede Zeile für den Zustand zu einer Zeit (nachdem 
der Ausgang genug Zeit hatte sich auf die Eingangssignale anzupassen). 
Damit dass vollständig wird, muss mann alle möglichen Kombinationen der 
Eingänge auflisten.
Jetzt sieht man doch auch schon, wo Eingang A 0 ist, kann sich B auf den 
Kopf stellen, das Ergebnis wird 0 sein. Ist A 1, dann ist der Ausgang 
gleich B.
So, wenn das so weit klar ist, verknüpfen wir jetzt 2 Byte.
Also 8 Mal das Ganze. Das unwichtigste Bit vom einen Byte mit dem 
unwichtigsten Bit vom anderen Byte ergibt das unwichtigste Bit vom 
Ergebnis. Und so weiter zu den wichtigsten Bits.

Hans schrieb:
> zwei max. 3 bit Werte sollen mit einem byte übertragen werden.
>
> Als Test habe ich das im Arduino versucht.
>     int wert1=2;
>     int wert2=7;
>
>     int a = wert1;       //2
>     int b = wert2 << 3;  //56
>
>     int c = a+b;         //58


int-Datentyp ist aber größer als 1 Byte.