Bits in einem Byte vertauschen

**KingTobi** · 07.12.2008, 17:19

Hi

Ich habe ein Byte, in dem ich Bit 2 und 4 miteinander austauschen möchte.
Wie kann ich das am "elegantesten" tun?

gruß

**error41** · 07.12.2008, 18:12

Hi!
Ich habs mal ausm Ärmel geschüttelt. (Also nicht getestet)
So müsste es gehen:

Code:

bla = (bla & 0xF5) | ((bla & 0x02)<<2) | ((bla & 0x08)>>2);

Ich ging mal davon aus dass du mit Bit 2 das Bit an zweiter stelle von rechts meintest. (LSB ist Bit1)
Wenn nicht, dann probiers damit: (LSB ist Bit0)

Code:

bla = (bla & 0xE6) | ((bla & 0x04)<<2) | ((bla & 0x10)>>2);

Ob das nun eine "elegante" Methode ist, darüber lässt sich sicher streiten.
Ich würds so machen...

Gruß

**fhs** · 07.12.2008, 18:15

Hi,

ganz stur so (Bitzählung von 0 bis 7!):

Code:

void inline bitswp2_4(uint8_t b) {
    asm volatile ( 
       "bst %0,2"   "\n\t"
       "sbr %0,4"   "\n\t"
       "sbrs %0,4"  "\n\t"
       "cbr %0,4"   "\n\t"
       "bld %0,4"   "\n\t"
      : 
      : "d" (b) 
    ); 
}

Schnell hingeschrieben und ungetestet. Mal sehen, ob jemand eine kürzere Lösung findet! Anmerkung: "inttypes.h" muss eingebunden sein. Aufruf mit
"bitswp2_4(byte_argument)".

Gruß

Fred

**fhs** · 07.12.2008, 18:24

Hier noch eine Zeile kürzer:

Code:

void inline bitswp2_4_new(uint8_t b) {
    asm volatile ( 
       "mov __tmp_reg__, %0"   "\n\t"
       "bst %0,2"   "\n\t"
       "bld %0,4"   "\n\t"
       "bst __tmp_reg__,4" "\n\t"
       "bld %0,2"  "\n\t"
       : 
       : "d" (b) 
    ); 
}

**thewulf00** · 07.12.2008, 18:43

Also fhs. Deine Posts begeistern mich immer wieder. Starkes Stück Code!

**fhs** · 07.12.2008, 18:48

Danke für die Blumen ... ich hoffe, der Code stimmt! Eigentlich stehe ich mit dem Inline-Assembler auf Kriegsfuß (bin sonst ein sehr friedlicher Typ), aber ab und zu ist der dann doch hilfreich. Überlege gerade, ob man's nicht noch kürzer machen könnte.

**fhs** · 07.12.2008, 19:18

Und hier noch mal in C:

Code:

uint8_t bitswp2_4_in_c(uint8_t byte) {
    uint8_t anded=byte&&#40;uint8_t)0x14;
    if (anded==(uint8_t)0x14 || !anded) return byte; // bits identisch, nix ändern! 
    return byte^0x14; // bits invertieren
}

Mit Optimierung "-O1" sieht das so kurz aus:

Code:

47:       uint8_t bitswp2_4_in_c(uint8_t byte) {
+000000DD:   2F98        MOV     R25,R24          Copy register
48:           uint8_t anded=byte&0x14;
+000000DE:   7184        ANDI    R24,0x14         Logical AND with immediate
49:           if (anded==(uint8_t)0x14 || !anded) return byte;
+000000DF:   3184        CPI     R24,0x14         Compare with immediate
+000000E0:   F021        BREQ    PC+0x05          Branch if equal
+000000E1:   2388        TST     R24              Test for Zero or Minus
+000000E2:   F011        BREQ    PC+0x03          Branch if equal
50:           return byte^0x14;
+000000E3:   E184        LDI     R24,0x14         Load immediate
+000000E4:   2798        EOR     R25,R24          Exclusive OR
51:       }
+000000E5:   2F89        MOV     R24,R25          Copy register
+000000E6:   9508        RET

Eleganter kann ich's nicht.

**sternst** · 07.12.2008, 22:02

Zitat von thewulf00

Also fhs. Deine Posts begeistern mich immer wieder. Starkes Stück Code!

Ja, guter Ansatz. Nur schade, dass das mühsam errechnete Ergebnis so achtlos weggeworfen wird.

Besser:

Code:

static inline void bitswp2_4(uint8_t *b) {
    asm volatile (
       "mov __tmp_reg__, %0"   "\n\t"
       "bst %0,2"   "\n\t"
       "bld %0,4"   "\n\t"
       "bst __tmp_reg__,4" "\n\t"
       "bld %0,2"  "\n\t"
       : "=d" (*b)
       : "0" (*b)
    );
}