Discussion :

[netpit]

une petite question toute bête : comment réduire le nombre de bits d'une variable ?

Je m'explique : j'ai un signal stocké par exemple dans une variable A codée sur 32 bits que je veux transmettre à la variable B qui elle n'a que 12 bits. Quelle traitement faire subir à A afin de diminuer sa dynamique de 32 à 12 bits en "dégradant" le moins possible mon signal ?

Merci pour vos lumières..

[Caine]

Bonjour,
heu ce que tu cherches à faire est dangereux, à moins que tu ne soit sur de quelle partis des bits de A tu peux abandonné.

Je m'explique, soit donc A sur 4 bits :

10XX

On est sur que les bits sig,ificatifs sont dans le poids fort, on utilise une opération booléenne pour les récupérés :

Code :

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

1
2
 
 Result = 10XX &  1100;

Result vaut alor:

1000

Maintenant, on effectue un décalage à droite de 2 bits:

Code :

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

1
2
 
Result >>= 2;

ET ainsi, Result vaut 10.

[ggnore]

Il est clair que ça dépend de la gestion de la donnée.
On peut faire dire ce qu'on veut à une séquence de bits.

Mais il est clair que dans ton cas détérioration il y aura.
Si ta variable sur 32 bits est interprétée comme un nombre pur et simple
32 bits => de 0 à (2^32)-1
12 bits => de 0 à (2^12)-1

pour avoir quelquechose de plus causant
disons qu'on a une donnée en 8 bits et une autre en 3 bits
8 bits => de 0 à 255
3 bits => de 0 à 7

Ce qui fait que tu vas obligatoirement perdre de l'information.
ça dépend de la façon dont tu sers de la donnée.

Peut être un peu plus de concret dans ton problème aiderait à t'aider. ( )

[netpit]

heu ce que tu cherches à faire est dangereux

..mais je n'ai pas le choix: j'ai un convertisseur N/A qui ne travaille que sur 12 bits alors que la variable numérique à convertir est sur 32 bits.

à moins que tu ne soit sur de quelle partis des bits de A tu peux abandonné.

justement non: dans mon cas, tous les bits ont le même poids, d'où ma question.

[netpit]

Mais il est clair que dans ton cas détérioration il y aura.
Si ta variable sur 32 bits est interprétée comme un nombre pur et simple
32 bits => de 0 à (2^32)-1
12 bits => de 0 à (2^12)-1

Je suis tout à fait d'accord avec toi et je ne cherche pas à l'éviter mais à avoir une bonne conversion.

Pour être plus précis: je prends le cas où je veux passer de A qui contient un signal sur 4 bits (pouvant prendre 16 valeurs toutes de même poids) à B qui est sur 2 bits (4 valeurs possibles). Là, "intuitivement" je regrouperais par paquet de 4: à savoir:
pour A= 0 à 3==> B=0
pour A= 4 à 7==> B=1

etc..

mais pour passer de 32 à 12 je vois pas surtout que 32 ne se divise pas par 12 donc ce n'est pas la bonne méthode et là je coince...

[ggnore]

32 se divise mal par 12

mais 2^32 se divise très bien par 2^12

[gege2061]

..mais je n'ai pas le choix: j'ai un convertisseur N/A qui ne travaille que sur 12 bits

la je comprend que tu n'aille pas le choix!

alors que la variable numérique à convertir est sur 32 bits.

mais là tu ne peut pas changer?

[netpit]

mais là tu ne peut pas changer?

c'est justement ma question! Comment faire pour la faire "rentrer" dans 12 bits de la bonne manière (en admettant la dégradation, ça c'est pas un problème, 12 bits étant satisfaisant en fait)

[ggnore]

2^32 / 2^20 = 2^12

[gege2061]

mais là tu ne peut pas changer?

c'est justement ma question! Comment faire pour la faire "rentrer" dans 12 bits de la bonne manière (en admettant la dégradation, ça c'est pas un problème, 12 bits étant satisfaisant en fait)

Je pense que l'a il nous faudrait le contenue de ta variable de 32 bits et sa création...
Et si tu transforme ta variable de 32 bits en une de 8 bits, ce sont des multiples et 8bits rentrent dans 12

[gege2061]

2^32 / 2^20 = 2^12

Trés construction tu ça

[netpit]

2^32 / 2^20 = 2^12

.... conclusion ? Je sais que je perd 20 bits dans l'affaire mais ça ne m'avance pas...

[ggnore]

Je sais que c'est laid.
Je sais pas si ça marche, mais ...

je me disais bêtement que tu pouvais convertir ta donnée sur 32 bits en décimal, diviser cette valeur par 2^20 et ainsi tu aurais une donnée tenant dans 12 bits.

C'est marrant, ça tient en une phrase, mais au niveau code, je pense que c'est autre chose ...

[netpit]

je me disais bêtement que tu pouvais convertir ta donnée sur 32 bits en décimal, diviser cette valeur par 2^20 et ...

... et j'arrondi le résultat au nombre entier le plus proche: oui, c'est ça!!

Ex: pour passer de 3 bits à 2 bits: je divise par 2^1=2 d'où:
A=7 ==> B=7/2 soit B=3
et encore:
A= 3 ==> B= 3/2 soit B=1

J'utiliserai le modulo.

Merci ggnore

[ggnore]

en faisant quelques tests bêta sur le papier ça me paraît marcher, mais ...
Je suis sûr qu'il y a une meilleure méthode.

Peut être que la bonne fée Emmanuel Delahaye se penchera sur ton berceau.

Sinon tu peux aussi aller faire un tour dans le forum algorithme

[Trap D]

Salut

Il faut prendre les 12 bits de poids faible.

Code :

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

1
2
int longval; // valeur à convertir sur 12 bits
short int val = (short int) (longval & 0x000007FF)

Mais évidemment, tu perds de l'information.

[netpit]

Salut

Il faut prendre les 12 bits de poids faible.

Code :

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

1
2
int longval; // valeur à convertir sur 12 bits
short int val = (short int) (longval & 0x000007FF)

et les 20 autres bits je les passe en pertes et profits ?

[gege2061]

Il faut prendre les 12 bits de poids faible.

En plus le Monsieur à dit que ses bits avaient tous le même poid!

[Trap D]

Désolé dans un octet, un nombre, on a les bits de poids faibles et les bits de poids forts, je n'y peut rien
Maintenant, pour récupérer lesautres bits tu fais

Code :

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

1
2
3
4
5
6
7
int longval; // valeur à convertir sur 12 bits
// recupération des 12 "premiers" bits
short int val1 = (short int) (longval & 0x000007FF)
// recupération des 12  bits suivant
short int val2 = (short int)((longval & 0x00FF7000) >> 12);
// recupétration des 8 derniers bits
short int val3 = (short int)(((longval & 0xFF000000) >> 24) & 0x000000FF);

[2Eurocents]

Moi, je ferai plutôt un décalage à droite de 20 positions (ou une division par 2^20), suivi d'un masquage (inutile, normalement, mais prudent) pour ne garder que les 12 bits de poids faible (qui étaient les 12 de poids fort sur le codage 32 bits).

Code :

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

1
2
3
4
5
 
unsigned int val12, val32;
 
val32 = 65535 ; /* Pour l'exemple ! */
val12 = (val12 >> 20) & 0x00000FFF ;

Je n'ai pas testé, mais on doit y être, non ?

Après, la gestion éventuelle des valeurs signées est un autre problème ...