the solution is fairly classical:

solution 1:

1. unsigned char brev0(unsigned char x) {
   
2.     x = (((x & 0xaa) >> 1) | ((x & 0x55) << 1));
   
3.     x = (((x & 0xcc) >> 2) | ((x & 0x33) << 2));
   
4.     x = (((x & 0xf0) >> 4) | ((x & 0x0f) << 4));
   
5.         return x;
   
6. }

复制代码solution 2:

1. //map 4 bits
   
2. const unsigned char code b2b[]={
   
3.         0x00,                                                //0x00
   
4.         0x08,                                                //0x01
   
5.         0x04,                                                //0x02
   
6.         0x0c,                                                //0x03
   
7.         0x02,                                                //0x04
   
8.         0x0a,                                                //0x05
   
9.         0x06,                                                //0x06
   
10.         0x0e,                                                //0x07
    
11.         0x01,                                                //0x08
    
12.         0x09,                                                //0x09
    
13.         0x05,                                                //0x0a
    
14.         0x0d,                                                //0x0b
    
15.         0x03,                                                //0x0c
    
16.         0x0b,                                                //0x0d
    
17.         0x07,                                                //0x0e
    
18.         0x0f                                                //0x0f
    
19. };
    
20. 
    
21. 
    
22. unsigned char brev1(unsigned char x) {
    
23.         return b2b[x>>4] | (b2b[x&0x0f]<<4);
    
24. }

复制代码so rather than "Pn=dat;", you say "Pn=brevx[dat];" to bit reverse the data.

if you need speed, you can inline brev1().