Tutorial 14
Entrée d'informations avec le clavier
(Touches directionnelles et Clear)

 

Survol
    Pour ceux qui connaissent un peu en programmation Asm de TI-83, le programme ci-dessous vous paraîtra familier. C'est normal, c'est exactement le même programme que dans le tutorial 7 de ASMguru, le tutorial de James Matthew! Ça prouve que les programmes Asm de TI-83 tourneront sur TI-83 Plus avec seulement quelques changements mineurs. C'est pourquoi je n'assume aucune responsabilité pour l'écriture de ce programme, juste pour le portage. Ce programme analyse les touches sur lesquelles vous appuyez pour déplacer un point à l'écran. Comme une sorte de petit sprite! Ce programme utilise le call Getkey (Tutorial 8). Seulement cette fois, on se rend un peu mieux compte que getkey scanne le clavier au niveau des flèches et de la touche clear.


Programmation
    Nous y voilà...


#define B_CALL(xxxx)           rst 28h \ .dw xxxx
#define B_JUMP(xxxx)           call 50h \ .dw xxxx

_RunIndicOff   = 4570h
_IPoint             = 47E3h
_getkey                        = 4972h
_clrlcdfull                      = 4540h
_homeup                      = 4558h

#DEFINE kLeft        02h
#DEFINE kRight       01h
#DEFINE kUp          03h
#DEFINE kDown       04h                   ;Voilà les codes hex
#DEFINE kEnter      05h                    ;pour les touches du clavier TI.
#DEFINE kClear       09h

.org 9D95h
           
            B_CALL(_clrLCDFull)           ;Efface l'écran.

            ld b,47
            ld c,47
            ld d,1                           ;Met D à 1.
            B_CALL(_IPoint)                   

B_CALL(_runIndicOff)                             ;Éteint l'indicateur d'exécution.
GetKey:
            B_CALL(_getKey)                       ;Demande si une touche est pressée.
            cp kLeft                                   ;Compare la touche avec le code pour la flèche gauche
            jp z,Left                                   ;Si la valeur est 0, aller à left.
            cp kRight                                
            jp z,Right
            cp kUp
            jp z,Up
            cp kDown
            jp z,Down
            cp kClear
            jp z,Quit
            jp GetKey
Left:
            ld d,0                           ;Met D à 0.
            B_CALL(_IPoint)
            dec b                           ;Décrémente B
            jp Draw
Right:
            ld d,0
            B_CALL(_IPoint)
            inc b
            jp Draw
Up:
            ld d,0
            B_CALL(_IPoint)
            inc c
            jp Draw
Down:
            ld d,0
            B_CALL(_IPoint)
            dec c
            jp Draw
Draw:
 
ld d,1
            B_CALL(_IPoint)
            jp GetKey                                  ;Répéter
Quit:
            ret                                           ;Retourne à l'OS.
.end
END

 
    Note: Peut-être que vous devrez régler l'écran graphique de la calculatrice à ZInteger au lieu de ZStandard, car ce dernier peut causer des interférences avec l'axe.

 

Nouvelles Commandes
    cp - Compare avec l'accumulateur.
    jr - L'équivalent ASM de If xx then jump to xxxxxx
    jp - Same as above, except very different
    _ipoint - Allume/éteint/permute/teste un pixel.

    Quelle est la différence entre Call et jp/jr? Call est une instruction z80 qui saute à une sous-routine, un label avec des calls et instructions spécifiques. Et à propos de jp/jr? Eh bien je vais laisser James Matthews expliquer ça.

    "Quelle est la différence entre jr et jp? Il y a une importante différence. JR est un jump relatif - ce qui signifie que, lorsque TASM le compile, l'instruction pour le processeur Z80 lui indique simplement combien d'octets en avant ou en arrière il faut sauter. simply tells it how many bytes forward or backward to jump.   Il n'a donc qu'une portée limitée. JP est un jump absolu - il indique au Z80 l'adresse où aller. L'avantage de JR par rapport à JP est la taille et la rapidité d'exécution du fichier une fois compilé: en effet, il est plus petit et plus rapide.  (Merci à Mindless Productions pour cette information.)   Harper m'a dit que jr était un petit jump (jusqu'à 128 octets), et jp un grand jump (jusqu'à 23Ko - toute la RAM en fait!)."

- James Matthews

Conclusion
    Pas encore familier avec l'utilisation des registres ? Allez jeter un oeil au tutorial Asm 83 d'Andy S dans le tutorial 4. Ou regardez dans le tutorial 17 de ce fichier d'aide. Maintenant continuons !

 

 

Tutorial 15

    Cliquez pour revenir au menu du site... ou ici pour retourner au menu du tutorial.