Bits spiegeln / C

[Frosch1502 (Gast)]

Hallo zusammen,

ich shifte meine Bits hiermit an die richtige Stelle, allerdings ist das 
Bild bei meiner 8x8 Matrix dann Spiegel verkehrt. Kann mir jemand 
helfen?



 seg_schieb[zaehler] = ((segment[zaehler]&0x01)<<6)
                           + ((segment[zaehler]&0x02)<<4)
                           + ((segment[zaehler]&0x04)<<2)
                           + ((segment[zaehler]&0x08)>>3)
                           + ((segment[zaehler]&0x10)>>1)
                           + ((segment[zaehler]&0x20)>>4)
                           + ((segment[zaehler]&0x40)>>4)
                           + ((~segment[zaehler])&0x80);

[Falk B. (falk)]

https://www.mikrocontroller.net/articles/Bitmanipulation#Siehe_auch

[Teo D. (teoderix)]

So vielleicht ;)

;(08x0&([ɹǝ1ɥǝɐz]ʇuǝɯbǝs~)) +
(4>>(04x0&[ɹǝ1ɥǝɐz]ʇuǝɯbǝs)) +
(4>>(02x0&[ɹǝ1ɥǝɐz]ʇuǝɯbǝs)) +
(1>>(01x0&[ɹǝ1ɥǝɐz]ʇuǝɯbǝs)) +
(3>>(80x0&[ɹǝ1ɥǝɐz]ʇuǝɯbǝs)) +
(2<<(40x0&[ɹǝ1ɥǝɐz]ʇuǝɯbǝs)) +
(4<<(20x0&[ɹǝ1ɥǝɐz]ʇuǝɯbǝs)) +
(6<<(10x0&[ɹǝ1ɥǝɐz]ʇuǝɯbǝs)) = [ɹǝ1ɥǝɐz]qǝıɥɔs_bǝs


Sorry aber bei zu viel Bit-Schieberei krieg ich Kopfschmerzen :(
Bei der Ausgabe den Index Rückwerts laufen lassen?

[Dirk B. (dirkb2)]

Frosch1502 schrieb:
> ich shifte meine Bits hiermit an die richtige Stelle,

passt nicht zu

Frosch1502 schrieb:
> allerdings ist das
> Bild bei meiner 8x8 Matrix dann Spiegel verkehrt

Tipp: die Zahlen hinter den << haben eine Bedeutung.

[Frosch1502 (Gast)]

Das die Zahlen eine Bedeutung haben ist mir bewusst..

Ich schiebe sie allerdings spiegel verkehrt :D

[Dirk B. (dirkb2)]

Du schiebst Bit
00000001 << 6 = 01000000
00000010 << 4 = 00100000
00000100 << 2 = 00010000
00001000 << 3 = 01000000  // soll da wirklich so sein?

Wenn die Bits rechts falsch sind, dann musst du die Wert nach dem << 
anpassen, bzw auch noch  << durch >> ersetzen

[Walter (Gast)]

Frosch1502 schrieb:
> Ich schiebe sie allerdings spiegel verkehrt :D

dann schieb sie doch an die richtigen Stellen

[Teo D. (teoderix)]

Walter schrieb:
> dann schieb sie doch an die richtigen Stellen

Hätte Er das wirklich selbst verbrochen, wüste Er auch wies ging.


+ ((~segment[zaehler])&0x80)
+ ((segment[zaehler]&0x40)<<4)
+ ((segment[zaehler]&0x20)<<4)
+ ((segment[zaehler]&0x10)<<7)
+ ((segment[zaehler]&0x08)<<5)
+ ((segment[zaehler]&0x04)>>6)
+ ((segment[zaehler]&0x02)>>4)
+ ((segment[zaehler]&0x01)>>2);

Ohne Gewehr, Pistole und sonstigen Schweinkram.
(Hab keinen Plan was ich da gemacht habe :)

[Thomas K. (muetze1)]

Mir stellen sich immer die Nackenhaare auf wenn ich Quellcode sehe 
welcher Bits zusammenbastelt und dann + verwendet. Ein Programmierfehler 
und das Byte ist im Hintern, warum also nicht die dafür logisch richtige 
Funktion | nutzen? Dann haben Programmierfehler in den o.g. Beispiel 
keine Auswirkung, weil man dann gezielt die gewünschten Bits beeinflußt 
und eben nicht mit der Schrotflinte zusammenprügelt...

[Walter (Gast)]

Thomas K. schrieb:
> Dann haben Programmierfehler in den o.g. Beispiel
> keine Auswirkung,

wie das? Bits an der falschen Stelle sind mit | genauso falsch wie mit +

[Ralf G. (ralg)]

Walter schrieb:
> wie das? Bits an der falschen Stelle sind mit | genauso falsch wie mit +

Mit '+' ist es sozusagen 'noch falscher'. Der Fehler verschiebt sich an 
eine Stelle, die mit der Ursache möglicherweise gar nichts zu tun hat.

[Frank M. (ukw) (Moderator)]

Thomas K. schrieb:
> Mir stellen sich immer die Nackenhaare auf wenn ich Quellcode sehe
> welcher Bits zusammenbastelt und dann + verwendet.

avr-gcc macht merkwürdigerweise bei '+' meist besseren Code als bei '|'. 
Scheint eine (vernachlässigbare) Macke zu sein.

[Ralf G. (ralg)]

Frank M. schrieb:
> Scheint eine (vernachlässigbare) Macke zu sein.

Aber nur, wenn der Quellcode stimmt! Und wenn an der Art der 
Bitmanipulation in einem bestimmten Programmteil sich niemals was ändern 
wird. (Bit setzen, wo vorher schon eins war) Solange man sich noch nicht 
100% sicher ist, was man tut, sollte man das '+' und die paar vielleicht 
eingesparten µs ganz schnell vergessen.

[Dennis X. (Gast)]

Teo D. schrieb:
> ;(08x0&([ɹǝ1ɥǝɐz]ʇuǝɯbǝs~)) +
> (4>>(04x0&[ɹǝ1ɥǝɐz]ʇuǝɯbǝs)) +
> (4>>(02x0&[ɹǝ1ɥǝɐz]ʇuǝɯbǝs)) +
> (1>>(01x0&[ɹǝ1ɥǝɐz]ʇuǝɯbǝs)) +
> (3>>(80x0&[ɹǝ1ɥǝɐz]ʇuǝɯbǝs)) +
> (2<<(40x0&[ɹǝ1ɥǝɐz]ʇuǝɯbǝs)) +
> (4<<(20x0&[ɹǝ1ɥǝɐz]ʇuǝɯbǝs)) +
> (6<<(10x0&[ɹǝ1ɥǝɐz]ʇuǝɯbǝs)) = [ɹǝ1ɥǝɐz]qǝıɥɔs_bǝs

HAHA sehr geil Teo! ;-)

[Thomas E. (picalic)]

Warum sind die Zahlen nicht gespiegelt?

[Teo D. (teoderix)]

Kein Plan, frag da:
http://www.24gb.de/flip.php

[Martin Kan (Gast)]

hi,
anstatt Bits zu shiften, benutzt lieber enums und structs.
Mach dir lieber Gedanken über das Speichermodell dann erübrigt sich das 
shiften.

[Solder (Gast)]

Gib's da nichts Schönes in C? In Assembler kann man die Bits rechts 
rausschieben (ins Carry) und links wieder rein. Nach 8 Schiebungen ist 
man fertig. Ein Stück Assembler in den C-Code einbauen? Wäre dann aber 
CPU-abhängier Code.
Weil es eine Matrix ist, müsste man mit dem niedrigsten Index beim 
Auslesen anfangen und mit dem höchsten Index anfangen reinzuschreiben.

Solder

[Ralf G. (ralg)]

Solder schrieb:
> Gib's da nichts Schönes in C?
Sicher! Man kann sich sogar das schönste aus den anderen 108 Threads zu 
diesem Thema hier auf µc-net raussuchen!

[Dirk B. (dirkb2)]

Ein Shift with Carry gibt es in c nicht.

Eine Tabelle mit den Werten wäre sicher eine schnelle Variante.

[Teo D. (teoderix)]

Dirk B. schrieb:
> Eine Tabelle mit den Werten wäre sicher eine schnelle Variante.

Wer weiß woher der Mist kommt!?