Bonjour a tous !  
 
Une petite question pour un jour de glande nationale.  
 
Voila j ai un mot ( qui se trouve Fifo-->u8payload[3] ) de 8 bits , donc de 1 octet.
 
qui se lit comme ca:
bit      Description
0        Char size    
1        Char size 1                                                                                      
2        Char size 2                                                                                      
3        Stop bit                                                                                          
4        Paritiy mode
5        Parity mode 1
6        Flow control
7        Reserved.
 
 
Et j aurais aime lire les trois premiers bits pour avoir  mon char size, puis lire mon bit 3, lire mon bit 4 et 5 ensemble et enfin le bit 6.
 
Voici  le tableau du Char size par exemble
 
  | Value  |  Char size
      000          5-bit
      001          6-bit
      010          7-bit
      111          9-bit
 
 
Voila je vous remercie par avance

si ton mot est w,

c'est (w & 0x07) puisque 0x07 c'est le masque binaire 00000111

c'est ((w & 0x08)?1:0) ce qui peut aussi se faire comme ((w & 0x08)>>3)

c'est ((w & 0x30)/0x10) ce qui peut aussi se faire comme ((w & 0x30)>>4)

c'est ((w & 0x40)?1:0) ce qui peut aussi se faire comme ((w & 0x40)>>6)
A+,

Bonjour Gilou,  
 
Merci pour ta reponse en premier lieu !
 
J y ai pense hier soir, mais j avais plutot eu l idee de faire simplement comme ca
 
size[0=w&0x07;   //char size
size[1]=w&0x08;  // stop bits
size[2]=w&0x30;  // parity mode
size[3]=w&0x40;  // flow control
 
Mais je viens de me rendre compte que j avais faux, si je n utilise pas les "shift left" ?  
 
Merci encore une fois !

Rajoutons que le décalage est plus rapide que la division...

 
Mais que les compilateurs modernes savent transformer une division en décalage

 
À condition que le diviseur soit une puissance de 2
 
moto-proof

nonon , une division entiére ca suffira.
Dans le cas non puissance de 2 y a des algo pour.