Discussion :

[ludo894]

Bonjour,
Je cherche un algo me permettant de décaler tous les bits d'un tableau (de bytes) à la fois. Probleme : les octets sont inversés deux par deux (contenu du tableau : {MSB0, LSB0, MSB1, LSB1, LSB2, MSB2}).
Le moins prise de tête serait de :
- ré-inverser chaque LSB avec son MSB correspondant
- décaler le tableau du nombre de bits désiré
- ré-inverser de nouveau MSB/LSB

Si quelqu'un sait déjà comment décaler ces bits, je ferais cette methode (un peu crade...).
Pour info, c'est pour une fonction Modbus de lecture/ecriture de bits.

Merci a vous

Ludo.

[Emmanuel Delahaye]

Je cherche un algo me permettant de décaler tous les bits d'un tableau (de bytes) à la fois. Probleme : les octets sont inversés deux par deux (contenu du tableau : {MSB0, LSB0, MSB1, LSB1, LSB2, MSB2}).
Le moins prise de tête serait de :
- ré-inverser chaque LSB avec son MSB correspondant
- décaler le tableau du nombre de bits désiré
- ré-inverser de nouveau MSB/LSB

Si quelqu'un sait déjà comment décaler ces bits, je ferais cette methode (un peu crade...).
Pour info, c'est pour une fonction Modbus de lecture/ecriture de bits.

L'algo est simple, si les données sont bien organisées, ce qui n'est pas le cas.

Met tes données dans un tableau de unsigned short ou unsigned int, ça facilitera le traitement avec >> ou << en pensant à conserver le bit qui 'sort' du groupe de 16 bits avant de décaler, bien sûr. Un masquage & 0xFFFF permet de garantir l'intégrité des données.

Un tableau de unsigned long (32 bits) peut aussi être adapté si tu as un nombre pair de mots de 16-bit...

Bref, essaye d'agrandir tes mots de stockage. C'est comme ça qu'on fait des 'tableaux de bits' performants. D'ailleurs je me demande... non. Je croyais avoir ça dans ma bibliothèque... J'ai utilisé ça un jour, mais c'est resté dans le projet, je n'ai pas pris le temps de le mettre dans ma CLIB, dommage...

[JMLLB]

Tu peux traiter la particularité de ton mappage de bit dans une fonction à part.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
/* fonction de formatage MSB_LSB */
short inverse_MSB_LSB(short val_in){
return ((short) (((val_in&0xFF)<<8) & ((val_in&0xFF00)>>8)));
}

De cette manière ton algo de décalage reste général.
De plus, si tu change de cible avec un autre mappage de bit (comme ça peut arriver), tu n'as que ta fonction de formattage à changer.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
/* fonction de decalage de n bits vers la gauche */
int decaler(
           int decalageAGauche_in, //nb de bits a decaler (positif a gauche)
           short * tab_in,         //tableau d'octets en entree
           int nbElement_in,       //nb d'elements du tableau en entree
           short * tab_out,        //tableau d'octets en sortie
           int * p_nbElement_out)    //nb d'elements du tableau en sortie
{
  int result=-1;                   //resultat de la fonction
  long tmpLong=0;                  //variable de calcul
  elementEnCours=0;                //indice de parcours
 
  /* TODO!: generaliser pour les cas decalageAGauche_in negatif et superieur à 16 */
  if((decalageAGauche_in>0)&&(decalageAGauche_in<16)){
    /* calcul du nombre d'elements en sortie */
    *p_nbElement_out=nbElement_in+1;
    /* allocation memoire du tableau en sortie */
    tab_out=malloc((*p_nbElement_out)*sizeof(short));
 
    for(elementEnCours=0;elementEnCours<nbElement_in;elementEnCours++){
      /* copie de l'element en entree decale dans la variable de calcul */
      tmpLong&=inverse_MSB_LSB(tab_in[elementEnCours])<<decalageAGauche_in;
      /* copie du resultat intermediaire */
      tab_out[elementEnCours]=inverse_MSB_LSB((short) (tmpLong&0xFF));
      /* shift de la variable de calcul */
      tmpLong>>=16;
    }
    /* copie du dernier resultat intermediaire */
    tab_out[elementEnCours]=inverse_MSB_LSB((short) (tmpLong&0xFF));    
    /* calcul termine, affectation du code retour a OK */
    result=0;
  }

Les algos sont donnés à titre indicatif. Je viens de les faire sur un bloc note, ce n'est pas dit qu'ils passent à la compil.

[ludo894]

Un grand merci a vous !
Je n'ai pas suivi scrupuleusement vos algos, mais vous m'avez orienté :
Finalement, je traite mes registres (inversés LSB/MSB) avec un buffer temporaire 32bits, que je décale (du nombre de bits d'offset), puis masque, avant de l'écrire dans le tableau de destination. Le fait de traiter le tableau avec un buffer temporaire de 32 bits me permet de m'affranchir de moult cas particuliers (nb de bit à ecrire < 16 notamment).
Et ça marche à merveille ! Encore merci a vous !

Ludo

PS : dites-moi si le code vous interresse...