[TI83] assembleur additionner 2 registres

Bonjour
toujours dans mon apprentissage..

j'essaie d'additionner 2 registres et de les récupérer en Basic dans la variable X
cela fonctionne bien ça m'affiche bien 5

Code:

.nolist
#define TI83

#include "ti83.inc"
 .list
 .org $9327

start:
 call _clrlcdfull
 call _homeup
 ;call _newline
 ld a,2
 ld b,3
 add a,b
 call _SETXXOP1
 call _Stox
 ret
.end

et en basic

Code:

:0→X
:Send(9prgmTEST
:Disp X

mais je n'arrive pas avec des registres 16bits (hl par exemple)
je suppose que setxxop1 récupère la valeur de a ?

Code:

ld hl,1234
ld bc,4567
add hl,bc
call _SETXXOP1
call _Stox

merci de votre aide

Salut

Oui, setxxop1 charge le registre OP1 à partir de la valeur de a.

Pourquoi as-tu besoin de faire une telle chose? Si tu veux faire des maths, fais le directement en ti basic, ou bien passe par les OP plutôt : http://wikiti.brandonw.net/index.php?title=Category:83Plus:BCALLs:By_Name:FP_Math
http://z80-heaven.wikidot.com/floating-point-stuff

EDIT : au passage, dans le code en basic, l'initialisation de X ne sert à rien

Merci m@thieu41

je fais cela pour apprendre l'assembleur...

en fait je voudrais passer des paramètres à l'assembleur par  _Rclx _Rcly (on peut faire ça je pense)

lui faire faire des calculs et des boucles (plus rapide qu'en basic) et les récupérer en Basic. call _Stox par exemple

J'initialise X à 0 pour être sûr que la valeur qui s'affiche au final a bien été changée et est bien le résultat attendu de l'assembleur.. (sinon ça me gardait l'ancienne valeur éventuelle)

le lien que tu me donnes (un grand merci)
est pour la 83+ et il faut sans doute que j'adapte les adresses.
exemple : 83Plus:BCALLs:4072 serait  TI83Regular call _FPadd 4092h

mais je ne comprends pas du tout comment on utilise ces (b)call sur les op1 (je n'en suis pas là..)

pour l'instant je reprends tout à zéro et lis de la doc par ci par là..
pour l'instant je sais effacer un écran, écrire à l'écran

j'essaie de comprendre les registres 8 bits 16 bits

et mes prochaines étapes seront le cp et jp ... (ça me parait moins difficile mais bon je ne m'y suis pas encore attaqué...)

voila...

c'est pas quand même pas facile l'assembleur...

Le fait que ce soit pour 83+ c'est parce que la 83 est moins documentée
Mais normalement avec l'include tu n'as pas à gérer les adresses.

Le truc si tu veux c'est que les registres sont en 8 ou 16 bits, comme tu le sais. Donc ils contiennent des nombres entre 0 et 2^8-1 ou 2^16-1. Or les variables en basic contiennent des nombres dits flottants, avec une mantisse de 14 chiffres, et un exposant allant de -99 à 99. Pour plus d'info c'est ici : http://z80-heaven.wikidot.com/floating-point-stuff
Donc pour comprendre les registres 8 et 16 bits... Il ne faut pas passer par des calculs de flottants

Les variables en basic sont donc codées comme les OP. Donc tu peux passer la valeur de X dans OP1, celle de Y dans OP2, faire tes calculs avec les rom call, puis mettre OP1 (qui contient le résultat) dans X.

Par contre, les maths ne sont pas le meilleur moyen d'apprendre l'asm

Si tu as compris que les registres 8 bits contiennent des nombres entier entre 0 et 255, ceux de 16 bits allant jusqu'à 65535, et que le bit tout à gauche peut signifier qu'ils sont négatifs ou non (dans le cas de registres signés, c'est toi qui décide selon l'utilisation), tu as tout compris

Bonjour et merci pour ta réponse.
c'est vrai ce n'est peut-être pas la bonne méthode de commencer par les maths..
Je n'ai pas bien compris comment on utilisait les OP1, OP2 dans le cas de mon exemple.
J'ai essayé plusieurs choses mais ça ne fonctionne pas.
Donc tu n'aurais pas un bout de code ? comme ça je pourrais passer à autre chose en assembleur.
Merci d'avance

Je te propose sérieusement de consulter les SDK de TI, en particulier celui des routines, malgré les différences entre TI83 et TI83plus.
Il suffit souvent de vérifier l'existence d'une routine en consultant un include de TI83.

Les OP servent de paramètres et de résultats aux romcalls de TI. Ils contiennent des variables (telles que les nombres) ou des entêtes de variables de types longs telles que les listes.
La manipulation pour tes maths via romcall sera
1-copier les variables ou entêtes dans les OP
2-appeler la romcall
3-copier les OP dans les variables
Bien sûr on préfère copier et créer en utilisant les OP qu'en copiant soi-même les champs de données.

J'improvise ça que tu peux toujours tester.

Code:

.nolist
#define TI83

#include "ti83.inc"
 .list
 .org $9327

start:
 call _RclY ; OP1:=Y
 call _op1toop2 ; OP2:=OP1 (==Y)
 call _RclX ; OP1:=X
 call _FPadd ; add OP1:=OP1+OP2 (==X+Y)
 call _StoX ; X:=OP1 (==X+Y)
 ret
.end

Code:

Prompt X,Y // saisie des nombres flottants
Send(9prgmADDXY  // input X,Y output X
X // affiche le résultat X:=X+Y

Merci Linkakro

oui je vais un peu potasser la doc que tu me donnes

Ton code marche du premier coup - qui en aurait douté ?
(j'ai juste du adapter les majuscules, minuscules des noms)
alors merci !

Code:

.nolist
#define TI83

#include "ti83.inc"
 .list
 .org $9327

start:
 call _Rcly ; OP1:=Y
 call _Op1tooP2 ; OP2:=OP1 (==Y)
 call _Rclx ; OP1:=X
 call _FPadd ; add OP1:=OP1+OP2 (==X+Y)
 call _Stox ; X:=OP1 (==X+Y)
 ret
.end

bon je vais continuer à avancer avec vos conseils

tiens j'ai vu que tu utilisais la syntaxe du pascal pour tes commentaires. Pratique, je vais faire ça aussi
(je rajoute juste le ; à la fin pour ne pas perdre l'habitude)

Code:

OP1:=Y;
 OP2:=OP1;
 OP1:=X;
 OP1:=OP1+OP2;
 X:=OP1;


On n'a pas le droit d'affecter  directement à OP2 ?
de faire ça ?

Code:

OP1:=X;
OP2:=Y;
OP1:=OP1+OP2;
X:=OP1;

Les SDK officiels sont bien, mais souvent incomplets, voire même parfois incorrects...
Vérifie leurs infos sur des sites comme wikiti, ou sinon pose une question si tu cherches une rom call faisant quelque chose de particulier (ici ou sur un autre site).

Bon courage, n'hésite pas à nous demander de l'aide

Merci pour tous ces conseils.
je n'hésiterais pas à vous solliciter.

à bientôt

m@thieu41 a écrit:Les SDK officiels sont bien, mais souvent incomplets, voire même parfois incorrects...
Vérifie leurs infos sur des sites comme wikiti, ou sinon pose une question

Oui m@thieu41 a bien raison... il faut toujours recouper avec d'autres sources, même les documentations officielles, et HELAS je crois bien surtout celles de TI.

jo2geek a écrit:On n'a pas le droit d'affecter  directement à OP2 ?

je n'ai simplement ni cherché ni trouvé de romcall qui soit en évidence pour copier n'importe quelle variable vers n'importe quel OP. Soit tu trouves une telle romcall, soit tu le codes toi-même (facile mais pas vraiment dans la philosophie de la compatibilité), soit tu te débrouilles avec plusieurs romcalls. J'ai donc simplement donné un exemple de manière d'appeler des romcalls successives faute d'avoir plus direct dans l'immédiat.

jo2geek a écrit:Ton code marche du premier coup - qui en aurait douté ?
(j'ai juste du adapter les majuscules, minuscules des noms)
alors merci !

De rien ; mais héhé sâche que je suis le premier à me tromper en improvisant la plupart du temps.