C Logikproblem

[Michael M. (mj09)]

Hallo Zusammen,
ich betreibe meine Jalousinsteuerung mit dem Raspberry PI.
Läuft super.

Nun möchte ich meine Steuerung erweitern und habe ein Logikproblem.
Ich habe mal eine Tabelle erstellt um das Problem zu erläutern.

4  3  2  1        8  4  2  1  8  4  2  1  
0  0  0  0  0x00  0  0  0  0  0  0  0  0  0x00
0  0  0  1  0x01  0  0  0  0  0  0  1  1  0x03
0  0  1  0  0x02  0  0  0  0  1  1  0  0  0x0C
0  0  1  1  0x03  0  0  0  0  1  1  1  1  0x0F
0  1  0  0  0x04  0  0  1  1  0  0  0  0  0x30
0  1  0  1  0x05  0  0  1  1  0  0  1  1  0x33
0  1  1  0  0x06  0  0  1  1  1  1  0  0  0x3C
0  1  1  1  0x07  0  0  1  1  1  1  1  1  0x3F
1  0  0  0  0x08  1  1  0  0  0  0  0  0  0xC0
1  0  0  1  0x09  1  1  0  0  0  0  1  1  0xC3
1  0  1  0  0x0A  1  1  0  0  1  1  0  0  0xCC
1  0  1  1  0x0B  1  1  0  0  1  1  1  1  0xCF
1  1  0  0  0x0C  1  1  1  1  0  0  0  0  0xF0
1  1  0  1  0x0D  1  1  1  1  0  0  1  1  0xF3
1  1  1  0  0x0E  1  1  1  1  1  1  0  0  0xFC
1  1  1  1  0x0F  1  1  1  1  1  1  1  1  0xFF

Auf der linken Seite habe ich 4 Eingangswerte. Die rechte Seite zeigt 
den Ausgangswert.
Ich könnte nun diverse If-Abfragen schreiben und das Problem wäre 
gelöst.
Finde ich aber nicht so gut.
Ich komme auf keine Logik, die mir diese Werte liefert.
Eventuell hat jemand von euch eine Lösung für mich.

Viele Grüße

Michael

[Bastler (Gast)]

Array aus 16 Byte-Werten?

[N. G. (newgeneration)]

ich weiß nicht, ob es dir hilft, aber schau dir mal die Bits an.

8  4  2  1  8  4  2  1
0  0  0  0  0  0  0  0  0x00
0  0  0  0  0  0  1  1  0x03
0  0  0  0  1  1  0  0  0x0C
0  0  0  0  1  1  1  1  0x0F
0  0  1  1  0  0  0  0  0x30
0  0  1  1  0  0  1  1  0x33
0  0  1  1  1  1  0  0  0x3C
0  0  1  1  1  1  1  1  0x3F
1  1  0  0  0  0  0  0  0xC0
1  1  0  0  0  0  1  1  0xC3
1  1  0  0  1  1  0  0  0xCC
1  1  0  0  1  1  1  1  0xCF
1  1  1  1  0  0  0  0  0xF0
1  1  1  1  0  0  1  1  0xF3
1  1  1  1  1  1  0  0  0xFC
1  1  1  1  1  1  1  1  0xFF
----------------------------
^  ^  ^  ^  ^  ^  ^  ^
|  |  |  |  |  |  |  |
+--+  +--+  +--+  +--+  
die werden konstant invertiert
und immer 2 gleiche

[Peter II (Gast)]

sind doch nur 4 IFs

out = 0;
if ( in & 1 ) 
   out |= 3

if ( in & 2 ) 
   out |= (3<<2)

if ( in & 4 ) 
   out |= (3<<4)

if ( in & 8 ) 
   out |= (3<<6)

[lulu (Gast)]

Keine If, nur viel Rechnen

out = (in&0x08)*0xC0 + (in&0x04)*0x30 + (in&0x02)*0x0C + (in&0x01)*0x03

[lulu (Gast)]

optimiert:

out = (in&0x08)*0xC0 | (in&0x04)*0x30 | (in&0x02)*0x0C | (in&0x01)*0x03

[lulu (Gast)]

sorry Fehler:

out = (in&0x08)*0x18 | (in&0x04)*0x0C | (in&0x02)*0x06 | (in&0x01)*0x03

[Dirk B. (dirkb2)]

Bastler schrieb:
> Array aus 16 Byte-Werten?

Ohne Fragezeichen!

[Amateur (Gast)]

Ein Array würde das Problem am schnellsten und übersichtlichsten lösen.
Ansätze wie die von Peter sind wohl eleganter, aber wenn Du Dir den Code 
in 3 Jahren mal wieder ansiehst...

Außerdem sind die Werte in einem Array schneller da (Rechenzeit) und 
lassen sich, eine vernünftige Dokumentation vorausgesetzt, schneller 
ändern.

[wendelsberg (Gast)]

Amateur schrieb:
> und
> lassen sich, eine vernünftige Dokumentation vorausgesetzt, schneller
> ändern.

spricht meines Erachtens genau dafuer!

wendelsberg

[Michael M. (mj09)]

Hallo Zusammen,
danke für die Antworten.

Ich habe mich für die Lösung von lulu entschieden.
Ich finde diese Lösung am elegantesten.
Mit der nötigen Dokumentation ist der Weg für mich auch noch später 
nachvollziehbar.


Viele Grüße

Michael

[Hans (Gast)]

Am klarsten finde ich immer noch die vier ifs. Kann man ja recht kompakt 
schreiben:

out = 0;
if (in & 1) out |= 0x03;
if (in & 2) out |= 0x0C;
if (in & 4) out |= 0x30;
if (in & 8) out |= 0xC0;

Oder:

out = 0;
out |= (in & 1) ? 0x03 : 0;
out |= (in & 2) ? 0x0C : 0;
out |= (in & 4) ? 0x30 : 0;
out |= (in & 8) ? 0xC0 : 0;

Oder wenn man es mehr als Zuordnungstabelle erkennen soll:

out = 0;
out |= (!!(in & 1) << 0);
out |= (!!(in & 1) << 1);
out |= (!!(in & 2) << 2);
out |= (!!(in & 2) << 3);
out |= (!!(in & 4) << 4);
out |= (!!(in & 4) << 5);
out |= (!!(in & 8) << 6);
out |= (!!(in & 8) << 7);

[Hans (Gast)]

Oder etwas weniger intuitiv, aber auch hübsch:

out = 0;
out |= ((in & 1) << 0) | ((in & 1) << 1);
out |= ((in & 2) << 1) | ((in & 2) << 2);
out |= ((in & 4) << 2) | ((in & 4) << 3);
out |= ((in & 8) << 3) | ((in & 8) << 4);

Gibt unbegrenzt viele Möglichkeiten ... :-)

[Hans (Gast)]

So, jetzt aber ... die Klammern kann man ja weglassen :-)

out = 0;
out |= !!(in & 1) << 0;
out |= !!(in & 1) << 1;
out |= !!(in & 2) << 2;
out |= !!(in & 2) << 3;
out |= !!(in & 4) << 4;
out |= !!(in & 4) << 5;
out |= !!(in & 8) << 6;
out |= !!(in & 8) << 7;

Oder so?

out = 0;
//                  in    out
out |= !!(in & (1 << 0)) << 0;
out |= !!(in & (1 << 0)) << 1;
out |= !!(in & (1 << 1)) << 2;
out |= !!(in & (1 << 1)) << 3;
out |= !!(in & (1 << 2)) << 4;
out |= !!(in & (1 << 2)) << 5;
out |= !!(in & (1 << 3)) << 6;
out |= !!(in & (1 << 3)) << 7;

[Hans (Gast)]

Oder stehst Du vielleicht auf Makros? :-D

#define MAP_OUT_IN(bit_out, bit_in) out |= !!(in & (bit_in)) << (bit_out)
out = 0;
MAP_OUT_IN(0, 0);
MAP_OUT_IN(1, 0);
MAP_OUT_IN(2, 1);
MAP_OUT_IN(3, 1);
MAP_OUT_IN(4, 2);
MAP_OUT_IN(5, 2);
MAP_OUT_IN(6, 3);
MAP_OUT_IN(7, 3);

[Bastler (Gast)]

Dirk B. schrieb:
> Bastler schrieb:
>> Array aus 16 Byte-Werten?
>
> Ohne Fragezeichen!

Mit!
Bewährtes Verfahren. Wer was lernen will, braucht nicht die Lösung, 
sondern die Richtung in die er/sie weitergehen soll. Dazu benutze ich 
gern eine (provozierende) FRAGE.

[Peter D. (peda)]

out = in & 1;
out += (in & 2) << 1;
out += (in & 4) << 2;
out += (in & 8) << 3;
out += out << 1;

[Michael R. (Firma: Brainit GmbH) (fisa)]

auf dem AVR wäre auch noch ein Einzeiler möglich:

out = __builtin_avr_insert_bits (0x33221100, in, 0);