Comment calculer en assembleur avec des chiffres à virgule ?

[invite9e020ebb]

Salut tout le monde,

alors voilà je dois réaliser un programme en assembleur ou je fais différents calculs. Je m'expliqe, je recois une valeur en hexa et à partir de là je dois en sortir un temps en minute, seconde et centième. Lors de mes calculs je fais des multiplications, des divisions, ect......je sais que lorsqu'on fait une division par exemple, le micro place le quotient dans un registre et le reste dans un autre registre. Mais à partir de là je suis bloqué Comment puis-je faire pour utiliser ce reste dans mes caluls étant donné que le micro travail avec des valeurs entières

Merci pour toute l'aide que vous pourrez me fournir
A+
-----

[Garion]

Il te faut utiliser les instructions du coprocesseur arithmétique qui ne sont pas les même et qui utilisent d'autres registres (qui se traitent sous forme de pile).

[yat]

On peut aussi travailler en virgule fixe. Par exemple, si tu multiplies toutes tes valeurs par 100 dès le départ, c'est comme si toutes tes valeurs avaient deux chiffres après la virgule. Après il faut juste penser à rediviser par 100 après une multiplication et remultiplier par 100 après une division.
Dans la pratique, évidemment, on préfèrera des multiplications par une puissance de 2 qui n'est qu'un décalage de bits. L'avantage c'est qu'une fois qu'on a pigé le truc c'est tout simple. Bien sur c'est souvent beaucoup moins efficace que d'utiliser le coprocesseur.

[invite9e020ebb]

Il te faut utiliser les instructions du coprocesseur arithmétique qui ne sont pas les même et qui utilisent d'autres registres (qui se traitent sous forme de pile).

Dsl de faire mon inculte, mais suis pas très bon en prog, que veux tu dire par les instructions du coprocesseur? Tu veux dire qu'il y a d'autre instructions qui font aussi des division, ect?

Merci d'avance de ta réponse
A+

[A voir en vidéo sur Futura]

[Jack]

salut,

pas besoin d'un coprocesseur pour faire du calcul en virgule flottante. On peut trouver des librairies pour pratiquement tous les microprocesseurs et microcontrôleurs.

Mais pour ton cas, comme le signale yat, il vaut mieux travailler en virgule fixe. Je ne vois pas où est ton problème avec le reste puisque celui-ci est forcément entier.

Le problème risque cependant d'être un peu compliqué si le dividande excède la taille de la donnée traitée par la division. Par exemple, avec un registre de 16 bits, cela devient compliqué de diviser un nombre supérieur à 65536.

Mais admettons que tu aies 3761 secondes à convertir et H:M:S.

3761/60 = 62 avec un reste de 41 ==> 41 secondes
62/60 = 1 avec un reste de 2 ==> 1 heure et 2 minutes.

ce n'est pas si compliqué en fait.

A+

[invite9e020ebb]

Salut Jack,

en effet vu comme ca c'est facile, mais le problème est que je recois une valeur en hexa et à partir de là je dois en sortir un temps en heure, minute, seconde.
Voici un exemple: je recois 3A7C ce qui donne 14972 en base 10.
Les calculs que je dois faire sont les suivant:

Pour les heures : 14972 * 2 = 29944
29944 / 3600 = 8.3178 => 8h

Pour les minutes : 8.3178 – 8 = 0.3178
0.3178 * 60 = 19.067 => 19 min

Pour les secondes : 19.067 – 19 = 0.067
0.067 * 60 = 4 => 4 sec

Donc le temps est : 8h 19min 4sec

Alors là tu peux voir que j'ai beaucoup de chiffre à virgule dans mes calculs. Et quand je fais 29944/3600 le 8 est mis dans un registre (donc c bon pas de prob là), mais le "reste" de la division va dans un autre registre et il est égal dans notre cas à 1144. Et si je veux obtenir ces 0.3178 je dois faire 1144/3600, mais à nouveau comme le micro travail qu' avec des entiers je ne vois pas comment continuer mes calculs et être précis acr il me faudra au moin 4 chiffre après la virgule.

Aurai tu une idée à me proposer?

Merci d'avance
A+

[Jack]

je n'ai pas trop compris pourquoi tu multiplie par 2 mais je trouve que tu te compliques la vie:
un ordinateur est fait pour calculer en binaire, alors pourquoi passer par le décimal?

tu reçois $3A7C. Je multiplie par 2 (je ne sais pas pourquoi, mais bon, c'est ton choix), ce qui donne $74F8. Tu divises par $3C (60 en décimal), ce qui donne $1F3, reste $4 secondes.

tu divises $1F3 par $3C, ce qui donne $8, reste $13 (19 en décimal).

On trouve bien 8h 19mn 4s.

Et tout ça sans virgule !!!!

A+

[yat]

Tu dois mal t'y prendre... quand tu fais une division, le processeur place le résultat dans un registre et le reste dans un autre.

D'ou, pour ton exemple, apparemment 29944 secondes =>
tu divises 29944 par 60, le quotient te donne le nombre total de minutes (499) et le reste le nombre de secondes restantes (4).
Tu divises 499 par 60, le quotient te donne le nombre d'heures (8) et le reste le nombre de minutes (19).

D'ou, 29944 secondes = 8h19m4s, et il n'y a absolument pas la moindre virgule là-dedans...

Pour généraliser, de mémoire (j'ai pas touché à l'assembleur depuis 5 ans) :

mov eax,nbsecondes
mov edx,0
mov ebx,60
div ebx
mov secondes,edx
mov edx,0
div ebx
mov minutes,edx
mov heures,eax.

EDIT : croisement avec Jack

[invite9e020ebb]

Ok merci les gars, j'ai essayé votre méthode et ca marche super bien. J'avais pas pensé à faire comme ca car c'est le client qui m'avait donné une feuille avec les calcul à faire, donc j'ai simplement suivi cette feuille.

Encore merci c'est sympa
A+