Discussion :

[athomas]

Bonjour,

Je vous expose mon problème; je dispose de données stockées en binaire complément à 2 sur 17 bits avec le MSB à gauche. La donnée est stockée en mémoire sur 3 octets (Considérant que l'indice 0 est le MSB et qu'il est à gauche, les bits de 17 à 24 sont donc inutilisés).

La donnée représente un roulis de navire, le MSB utile représente 45°.
le bit suivant 22.5° ...

Je souhaite récupérer cette valeur sous une forme dirons nous plus "standard" : décimale.

Mon programme est en c++ et je développe sous Borland C++.

Quelle est la méthode la plus astucieuse pour réaliser cette convertion ?

Merci beaucoup pour votre aide.

[Invité(e)]

Bonsoir,

je dispose de données stockées en binaire complément à 2 sur 17 bits avec le MSB à gauche.
La donnée représente un roulis de navire, le MSB utile représente 45°.
le bit suivant 22.5° ...

On est d'accord, +45° sera codé 0 1000 0000 0000 0000, (le premier zéro étant le bit de signe) ?
Peux tu donner un exemple ?

Quelle est la méthode la plus astucieuse pour réaliser cette conversion ?

Vu la présence du complément à deux, j'aurai tendance à stocker les bits dans une structure capable de les accueillir (un singed long int) et d'appliquer une bête multiplication.

C'est qu'on va faire, c'est donc utiliser un long int, en laissant les 15 derniers bits à 0.
Pourquoi les 15 dernier et les les 15 premier ? à cause du complément à deux.

La partie difficile du problème est de bien mettre les données de roulis dans l'entier : de placer les bits aux bons endroits.

Une fois que cette étape sera effectuée, tu te retrouvera avec un type plus facile à manipuler.

En pratique, ça donne ça :

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
int main(void) 
{    
    /* données bord ... un exemple plize */
    char data[3] = ...;
    long long int conv = 0;
    /* bits utiles */
    long long int mask = 0xffff8000;
    long long int roulis_max = 0x7fff8000;
    double roulis;
 
    /* copie des données bors dans conv */
    ...
 
    /* limitation aux 17 premiers bits */
    conv &= mask;
 
    /* conversion du roulis en angle */
    roulis = (double)conv / (double roulis_max) * 45.;
 
 
    return 0;
}

Sinon, une fonction bien utile pour voir où sont tes bits dans tes entiers.

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
void display(long int number)
{
    int i;
    unsigned long int bit = 0x80000000;
    unsigned long int tmp;
    memcpy(&tmp, &number, sizeof number);
 
    printf("%16d = 0x", number);
    for(i = 0; i < 32; ++i)
    {
        if(i%8 == 0){
            putchar(' '); 
        }
        putchar(tmp & bit ? '1' : '0');
        bit /= 2;
    }
    puts("");
 
}

[athomas]

On est d'accord, +45° sera codé 0 1000 0000 0000 0000, (le premier zéro étant le bit de signe) ?
Peux tu donner un exemple ?

Je n'ai pas un exemple très intéressant à te donner ...

Voici par contre un classeur de calcul excel que j'ai créé et qui permet de réaliser le calcul en question : (disponible jusqu'au 10/02/2011)
http://dl.free.fr/pIPpW39AR



Comment placer les données de base dans un entier ?

[Invité(e)]

Comment placer les données de base dans un entier ?

C'est pour ça que je te demandais un exemple, ma boule de cristal n'est pas réparée.

Pour copier un octet complet, utilise simplement = avec les casts qui vont bien :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
/* données bord */
unsigned char data[4];
 
/* l'entier de stockage (cf exemple du post précédent)*/
int conv;
 
/* pointeur sur conv*/
unsigned char * p = &conv;
 
/* après, on utilise simplement : */
p[x] = data[y];

Si tu as un décalage entre le début des données bord et ton entier, utilise simplement (tu as vu, c'est toujours simple ;) l'opérateur <<= ou >>= selon le besoin.

[jeroman]

Le problème, c'est que cette solution n'est pas portable à cause de l'endianness et de la taille du "int" (qui ne fait pas toujours 4 octets).

La solution à base de décalages de bits me semble plus appropriée.

[apesle]

Bonsoir,

Je n'ai pas bien compris, tu dis dans ton premier post que les bits de 17 à 24 sont inutilisés, mais dans ton testeur de trame tu leur donnes des valeurs...

D'après ce que j'ai compris, tu as un nombre codé en complément à 2, MSB à gauche.
Prenons par exemple : 10001000010000000000000000000000
Le bit de gauche (MSB) est le bit de signe, ensuite viennent les 17 bits qui t'interessent.

Si on enlève le complément à gauche, on a : 01110111110000000000000000000000.
Lebit de gauche ets toujours le bit de signe. Ensuite, on a :
1*45° + 1*22.5 + 1*11.25° + 0*5.625 + 1*2.8125 + 1* 1.40625 + ...

C'est bien ça ?

J'ai fait rapidement le code suivant qui implémente l'exemple donnée au dessus. Evidemment, il faudra modifier les accès aux bits si j'ai compris de travers, et il faudrait aussi le modifier pour que le code marche sur une architecture autre que 32 bits.

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
 
#include <stdio.h>
#include <stdlib.h>
 
#define NB_BITS 17
#define VAL_BIT(i_nb, i_indice_bit)  ((i_nb>>i_indice_bit)&1)
 
 
/**récuperer dans une chaine de caractere la representation 
binaire i_N-bits d'un nombre passé en param. 
ch doit avoir au moins i_N+1 caracteres**/
void int_to_bin(const int i_N, char *c_ch, const int i_nb){
	int i,j=0;
	for (i=i_N-1; i>=0; i--) c_ch[j++]= ( ((i_nb>>i)&1 )==0 ) ? '0' : '1' ;
	c_ch[j]='\0';
}
 
 
 
int main (void) {
	int i_cpt;
	int i_acces;
	char c_aff[33]; /* 32 bits + fin de chaine*/
 
	float f_tab_conversion[NB_BITS];
	float f_res=0;
 
	/*init tableau de conversion*/
	f_tab_conversion[0]=45.0;
	for (i_cpt=1; i_cpt<NB_BITS; i_cpt++)
		f_tab_conversion[i_cpt]=f_tab_conversion[i_cpt-1]/2.0;
 
	/* i_conv est l'entier à convertir */
	int i_conv= (1<<31)|(1<<27)|(1<<22);
 
	/* affichage de la representation binaire */
	int_to_bin(32, c_aff, i_conv);
	printf("A convertir : %d = \"%s\"\n",i_conv, c_aff);
 
	/* on enleve le complément à deux */
	char c_inv=0;
	/* complément à deux : on parcourt de droite à gauche. 
	On garde le 1er bit à 1 inchangé, et on inverse tous les bits qui suivent */
	for (i_cpt=0; i_cpt<32; i_cpt++)
	{
		if ( c_inv==0 && VAL_BIT(i_conv,i_cpt)==1 )
		{
			c_inv=1;
			continue;
		}
		if (c_inv == 1)
		{
			if ( VAL_BIT(i_conv,i_cpt)==1 )
				/* forcage du bit i_cpt à 0 */
				i_conv &= ~(1<<i_cpt);
			else
				/* forcage du bit i_cpt à 1 */
				i_conv |= (1<<i_cpt);
		}
	}
 
	/* affichage de la representation binaire */
	int_to_bin(32, c_aff, i_conv);
	printf("Apres avoir enlever complement a deux : %d = \"%s\"\n",i_conv, c_aff);
 
	/* On calcule la valeur : */
	for (i_cpt=1; i_cpt<NB_BITS+1; i_cpt++)
	{
		i_acces = 32-i_cpt-1;
		if ( VAL_BIT(i_conv,i_acces)==1 )
		{
			f_res += f_tab_conversion[i_cpt-1];
		}
	}
 
 
	printf("Angle trouvé : %f\n",f_res );
 
	return EXIT_SUCCESS;
}

Exemple d'execution :

Code :

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

1
2
3
A convertir : -2009071616 = "10001000010000000000000000000000"
Apres avoir enlever complement a deux : 2009071616 = "01110111110000000000000000000000"
Angle trouvé : 84.199219

Bonne soirée