Jelectronique.com

Bonjour a tous,
J’aimerais concevoir un codeur (arithmétique) en VHDL. Ce codeur me fourni (après codage) un nombre compris entre 0 et 1 et pouvant très bien avoir 25 chiffres après la virgule.
Donc j’aimerai savoir comment représenter ce chiffre en langage binaire…
Merci pour votre aide

Hello,

En nombre à virgule flottante ou norme IEEE-754.

En simple précision tu peux coder un nombre compris entre 2^-126 et ~2^128 sur 32bit, il y a aussi la double précision 2^-1022 à ~2^1024 soit beaucoup plus de 25 chiffres après la virgule

Pour l'utilisation en VHDL, il y a une piste ici :
http://forums.jelectronique.com/ftopic232-0-asc-8.php

a+
JP

C'est simple les bits à droite de la virgule ont les poids 1/2^1, 1/2^2, 1/2^3 etc...

vincevg a écrit :C'est simple les bits à droite de la virgule ont les poids 1/2^1, 1/2^2, 1/2^3 etc...

Simple simple.... ben heu je veux bien que tu me codes 0,00001285984716... (mais la il n'y a que 14 chiffres après la virgule..)

Parce que moi j'aimerais aussi que cela soit implémentable sur la carte....

2 réponses que j'ai reçu :
1ère réponse :

Si c'est uniquement pour de la simulation, le type real est prévu pour. Sinon, il existe deux types de représentation : virgule fixe ou virgule flottante.
Le choix dépend largement de l'utilisation et du type de composant dans
lequel sera implanté la fonction.
La manipulation de flottants consomme beaucoup de resources, c'est à
exclure avec un petit composant.
Le format virgule fixe se manipule comme des entiers (il faut juste
faire attention à la position de la virgule).
Le nombres de bits nécessaires dépend de la précision voulue.
25 chiffres après la virgule en décimal demande 84 bits donc 84 bascules
pour stocker une telle valeur.

La 2ème réponse :

De manière feignante, je représenterai ce nombre par un nombre entier
binaire de 84 bits compris donc entre 0 et 2^84 - 1 soit un peu plus de
10^25. Le résultat étant donc à diviser par 10^25, un peu comme les
nombre décimaux codés bianires mais sans être des flottants.
84 bascules D, ca doit bien se trouver dans un gros FPGA.

Tu prend ton nombre :
et tu le multiples par 2. A chaque étape tu gardes ce qui est à gauche de la virgule (0 ou 1)

(Je prend un exemple simple 0,3)

0,3
x2
___
0,6 Je garde 0
x2
___
1,2 Je garde 1

Je supprime le 1 ce qui me fait 0,2
0,2
x2
____
0,4 Je garde 0
x2
___
0,8 Je garde 0
x2
___
1,6 Je garde 1

Ce qui me donne en binaire 0,01001

Les poids sont les suivants : 0,5/0,25/0,125/0,0625/0,03125

0/ 1 / 0 / 0 / 1
Donc mon nombre décimal correspondant est 0,25 + 0,03125 = 0,28125

9a ne tombe pas juste. Ben oui c'est du binaire alors pour avoir mieux il faut continuer.

Merci Vince !!!
Mais comment savoir s'il faut continuer ou pas? il faux "lire" le nombre et donc se n'est pas synthétisable en VHDL....
Tout comme l'utilisation de virgule flottante...
Parce que le problème que j'ai, c'est que le système donc être synthétisable a 100%

Je pense qu'utiliser un coefficient de 10^X m'aiderais mais le nombre de bits monte vite.. Et mon tuteur de stage ne veut pas cette méthode... Lui veux utiliser la "norme" du codeur avec les 2^-X...

Et mon tuteur de stage ne veut pas cette méthode... Lui veux utiliser la "norme" du codeur avec les 2^-X...

C'est le même principe :
2^-1=0.5
2^-2=0.25
2^-3=0.125

Ce qui est le codage en virgule fixe, c'est vrai c'est la norme

C'est plus simple mais il a des contraintes comme le fait que ça ne soit pas adapté à la multiplication.

Mais comment savoir s'il faut continuer ou pas? il faux "lire" le nombre et donc se n'est pas synthétisable en VHDL....

C'est toi qui te fixes la précision.
25 chiffres après la virgule donc une précision de
2^-x=1*10^-25 x=>84

J'ai pas cherché très loin mais j'ai trouvé quelques réponses en tapant "fixed point vhdl" sous google donc ça doit être synthétisable.

Alors pour le fin mot de l'histoire...
Apres plusieurs test, j'ai choisi pour representer un nombre à virgule allant de 0 et 1 a été pour moi de me fixer une "limite" 1.000.000.000 representant 1 donc 500.000.000 0,5 etc...
C'est limiter a 9 chiffre apres la virgule mais c'est bien car ça utilise un "integer" que je convertis en binaire

Voici comment on représente un nombre à virgule flottante IEEE-754 de longueur 32 bits.

Code : Tout sélectionner

 Format d'un float IEEE-754
 --------------------------------
 | 1 bit |  8 bits  |  23 bits  |
 --------------------------------
     /        /           /
 signe   exposant     mantisse

 Exemple de valeur
      1    10000010     10101000111000010100011
     /        /           /
 signe   exposant     mantisse

 -13.2775
 0xC15470A3

Pour faire quelques tests :
http://babbage.cs.qc.edu/courses/cs341/IEEE-754.html

Jelectronique.com

nombre a virgule en binaire (VHDL)

nombre a virgule en binaire (VHDL)