[debutant] question en C : réduction du nbre de bits

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..

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 :

Citation:

---

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:

---

1 2	Result = 10XX & 1100;

---

Result vaut alor:

Citation:

---

1000

---

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

Code:

---

1 2	Result >>= 2;

---

ET ainsi, Result vaut 10.

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. ( :!: )

Citation:

---

Envoyé par Caine

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.

Citation:

---

Envoyé par Caine

à 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. :cry:

Citation:

---

Envoyé par ggnore

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 :cry: surtout que 32 ne se divise pas par 12 donc ce n'est pas la bonne méthode et là je coince...

32 se divise mal par 12

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

Citation:

---

Envoyé par netpit

..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!

Citation:

---

Envoyé par netpit

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

---

mais là tu ne peut pas changer?

Citation:

---

Envoyé par 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)

2^32 / 2^20 = 2^12
:roll:

Citation:

---

Envoyé par netpit

Citation:

---

Envoyé par 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 :wink:

Citation:

---

Envoyé par ggnore

2^32 / 2^20 = 2^12
:roll:

---

Trés construction tu ça :(

Citation:

---

Envoyé par ggnore

2^32 / 2^20 = 2^12

---

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

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 ...

Citation:

---

Envoyé par ggnore

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 :D :D

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

Salut

Il faut prendre les 12 bits de poids faible.

Code:

---

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

---

Mais évidemment, tu perds de l'information.

Citation:

---

Envoyé par Trap D

Salut

Il faut prendre les 12 bits de poids faible.

Code:

---

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 ?

Citation:

---

Envoyé par Trap D

Il faut prendre les 12 bits de poids faible.

---

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

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 :evil:
Maintenant, pour récupérer lesautres bits tu fais

Code:

---

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);

---

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:

---

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 ...

Citation:

---

Envoyé par Trap D

Maintenant, pour récupérer lesautres bits tu fais

Code:

---

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);

---

---

:fou: Mais là tu ne fais que divisé la variable en 3 autres variables? ce n'est pas la question posée (en tout pas pas celle j'ai comprie!)

heu effectivement, là je ne comprends plus :?: .

Je vais suivre les conseils de ggnore. C'est vrai qu'il y a surement mieux, mais c'est quand même une bonne piste...

merci en tout cas à tous pour votre aide et à bientôt.. :)

Effectivement 2Eurocents, y'a plus simple pour le dernier :fou:
gege2061 >> Comment veux-tu transporter autant d'informations sur 12 bits que sur 32. Ou alors je ne comprends pas son problème (que fait le convertisseur 12 bits ? )

Citation:

---

Envoyé par Trap D

Comment veux-tu transporter autant d'informations sur 12 bits que sur 32.

---

Bah c'est la question! netpit cherche un moyen de faire rentrée 32 dans 12 avec le moins de perte possible.

Citation:

---

Envoyé par Trap D

Ou alors je ne comprends pas son problème

---

:P

Citation:

---

Envoyé par Trap D

Comment veux-tu transporter autant d'informations sur 12 bits que sur 32. Ou alors je ne comprends pas son problème (que fait le convertisseur 12 bits ? )

---

Oubli mon convertisseur, ça pourrait être n'importe quoi d'autre !

effectivement je perd forcément en "qualité" mais ça n'est pas un problème (12 bits c'est bien pour mon application) . L'important dans l'affaire est de correctement convertir...

bon je sors, à demain :arrow:

Citation:

---

Envoyé par netpit

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

---

En compressant.

Citation:

---

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 ?

---

Rien à voir avec le langage C...

Il faut une table de compression, comme les tables 'Loi A / Loi µ' utilisées en téléphonie (12 bits -> 8 bits).

Citation:

---

Envoyé par Emmanuel Delahaye

Il faut une table de compression, comme les tables 'Loi A / Loi µ' utilisées en téléphonie (12 bits -> 8 bits).

---

Comment est-ce réalisé ?
Comment fonctionne la table de compression ? J'ai cherché sur Internet "Loi A/Loi µ'", et je n'ai rien trouvé pour ce qui est d'un codage informatique :cry:

par ici

Merci :P
J'étudie cà !

Bonjour,

Je prend ce fil en cours, mais je pense qu'il manque une information essentielle pour traiter le problème : que signifie la valeur sur 32 bits, et que signifie la valeur sur 12 bits ?

Si, comme j'en ai l'impression, ce sont tous les 2 des échantillonages linéaires sur des valeurs entières, alors la première réponse donnée est la bonne : effectuer un décalage à droite de 20 bits (équivallent à une division par 2^20).

Sinon il faut donner l'info, la solution devrait être simple de toute façon.

Amicalement.

Citation:

---

Envoyé par sovitec

Bonjour,

Je prend ce fil en cours, mais je pense qu'il manque une information essentielle pour traiter le problème : que signifie la valeur sur 32 bits, et que signifie la valeur sur 12 bits ?

---

La variable sur 32 bits (que j'ai appelé A) contient un signal numérique en temps réel. Par exemple une sinusoide. Je dois le convertir en analogique avec un CNA qui n'est que sur 12 bits.

Je m'oriente pour l'instant vers un décalage vers la droite de 20 bits, permettant une division par 2^20.

J'espère avoir répondu à ta question.

Citation:

---

Envoyé par netpit

La variable sur 32 bits (que j'ai appelé A) contient un signal numérique en temps réel. Par exemple une sinusoide. Je dois le convertir en analogique avec un CNA qui n'est que sur 12 bits.

J'espère avoir répondu à ta question.

---

En fait ma question était : quels sont les formats des variables ?

Pour la variable 32 bits : est ce un entier signé ? un entier non signé ? un flottant ? Représente t-il un échantillonage linéaire ? logarithmique ?

De même pour la variable 12 bits : est-ce une vraie variable 12 bits ? une variable 16/32 bits dont on ne prend en compte que les 12 bits de poid faible ? les 12 bits de poid fort ? Quel type d'échantillonage ? ...

On ne pourrait faire une simple règle de trois ?
la valeur divisée par le max sur 32 bits, multipliée par le max sur 12 bits ?

Citation:

---

Envoyé par Trap D

On ne pourrait faire une simple règle de trois ?
la valeur divisée par le max sur 32 bits, multipliée par le max sur 12 bits ?

---

Ouh la ... si on est en entiers, on fait un "underflow" avec la première division et tout est à 0.

Si l'on accepte un passage en entiers très longs (64 bits), il vaut mieux commencer par la multiplication, suivie par la division.

Mais cela revient au même que de diviser par 2^20 (pour les entiers signés) ou faire >> 20 (pour les entiers non-signés)

Citation:

---

Envoyé par sovitec

En fait ma question était : quels sont les formats des variables ?

Quel type d'échantillonage ? ...

---

variable A (en C) : non signé sur 32 bits flottant
variable B (autre langage: VHDL) : 12 bits réels (permet de travailler bit par bit)

CNA: on lui rentre "0...000" (12 bits) : il sort 2 volts (min) et pour "1..111" (12 bits) il sort 3 volts (le max)

Citation:

---

Envoyé par netpit

variable A (en C) : non signé sur 32 bits flottant

---

Euh ? flottant non signé ça n'existe pas en C.

Citation:

---

Envoyé par netpit

variable B (autre langage: VHDL) : 12 bits réels (permet de travailler bit par bit)

---

Comment s'effectue la conversion C -> VHDL ?

Citation:

---

Envoyé par netpit

CNA: on lui rentre "0...000" (12 bits) : il sort 2 volts (min) et pour "1..111" (12 bits) il sort 3 volts (le max)

---

Je suppose donc que c'est un échantillonage linéaire.

Citation:

---

Envoyé par sovitec

Comment s'effectue la conversion C -> VHDL ?

---

là, je préfère ne pas rentrer trop dans les détails ! Pour rester clair, je programme une carte FPGA (Xilinx) avec 2 programmes :l'un proche du C (pour le micro-controlleur), l'autre en VHDL (pour le design). J'ai un "compilateur" qui se charge du téléchargement dans la carte des 2 programmes.

Citation:

---

Envoyé par sovitec

Euh ? flottant non signé ça n'existe pas en C.

---

oui excuse-moi c'est parceque le type de ma variable est spécifique au langage proche du C. Il faut lire que c'est un int non signé.

Citation:

---

Envoyé par sovitec

Je suppose donc que c'est un échantillonage linéaire.

---

oui

Alors le décalage à droite de 20 bits (j'espère que ça existe dans ton pseudo C) fera parfaitement l'affaire : c'est rapide, et tu ne pourras pas faire mieux au niveau qualité de conversion.

Cordialement.

Citation:

---

Envoyé par 2Eurocents

Citation:

---

Envoyé par Trap D

On ne pourrait faire une simple règle de trois ?
la valeur divisée par le max sur 32 bits, multipliée par le max sur 12 bits ?

---

Ouh la ... si on est en entiers, on fait un "underflow" avec la première division et tout est à 0.

---

Tu as entendu parler des cast ? :evil:

Code:

---

val = (short int) ((((double) (unsigned long)val) * (double) 0x000007FF) / (double)(unsigned long)0xFFFFFFFF) ;

---

Citation:

---

Envoyé par Trap D

Tu as entendu parler des cast ? :evil:

---

Oui, c'était le sens de ma remarque ... Pour attirer la vigilance sur le fait qu'il ne faut pas rester bêtement en entier pour ce genre d'opération.

Désolé de t'avoir froissé, Trap D, ce n'était pas le but.