16Bit Variable Wertigkeit umdrehen

So habe ich einen 12bit-Wert, der in einer 16bit-Variable gespeichert 
ist, umgedreht. Ist aber quick-and-dirty.

// 0b 0000 0001 0000 0100
// wird zu
// 0b 0000 0010 0000 1000
// die ersten 4 bits sind immer 0b0000
unsigned short ushort_rev(unsigned short x)
{
    unsigned short val = 0, mask;

  for(int i=0; i<12; ++i)
  {
    mask = x & 0x0FFF;
    mask = mask << (i+1);
    val &= ~(1<<i);
    val |= ((mask & 0x1000) >> 12-i);
  }
  return (val);
}

Blackbird

Buchegger:

einen swap meinte er nicht

@Blackbird
Vielen Dank das war genau das was ich gesucht habe.

Würde mich Interessieren ob es noch eine andere Möglichkeit ohne 
Schleife gibt.

Man kann das auch über Tabellen machen,
entweder 1x 64kWorte oder aufteilen in 2 Bytes und eine 256Byte Tabelle

const u8 Tabelle[256] = { 0x00, 0x80, 0x40, 0xc0,
                          0x20, 0xa0, 0x60, 0xe0,
                          ....
                          0x3f, 0xbf, 0x7f, 0xff};

Val_u16 = ((Tabelle[Old_u16 && 0x00ff] << 8)
        +  (Tabelle[(Old_u16 >> 8) && 0x00ff]);

int input;
int a;
int b = 0x0001;
int result = 0;

for(a = 0x8000;a>0;a/=2)
{
 if (input & a) result |= b;
 b *= 2;
}

oder nicht? Sollte so um die 16 Durchläufe brauchen...

wie waere es mit

    val ^ 0b1111111111111111  ( eor 0xffff ) ?

gruss
       horst

>val ^ 0b1111111111111111  ( eor 0xffff ) ?

da kommt das gleiche raus wie bei ~val...

1

/***** Kehr die Reihenfolge der Bits um *****/

2

char turn8bit(char val)

3

{

4

  char i;

5

  char mirr;

6

7

  i = 0;

8

  mirr = 0;

9

  // Bits umtauschen

10

  while(i<8)

11

  {

12

    mirr |= ((val>>i)&0x1)<<(7-i);

13

    ++i;  

14

  }

15

  return mirr;

16

}

Das ist meine Lösung für PIC mit dem HT Compiler. Das lässt sich auch 
auf 16 Bit erweitern. Der Vorteil hier, es gibt nur zwei 
Shiftoperationen.

Viel Spaß dabei