Vous êtes intéressés par la programmation de votre TI-83 ? Vous voulez vous aussi créer des programmes divers, des logiciels ou des jeux sur votre TI-83, TI-82 ou même sur votre TI-89 ? (le langage utilisé est généralement le même : le TI-basic) Cette page est faite pour vous ! A travers plusieurs exemples détaillées et des photos d'écran de ma TI (images crées à l'aide du TI-graph link), vous pourrez facilement et rapidement apprendre à programmer votre calculatrice en TI-basic ! Nous analyserons chaque instruction, du If, au GetKey, en passant par le Input, le Disp ou les instructions graphiques !
Ce sont les commandes les plus simples à utiliser. Elles sont elles
aussi nécessaires à l'élaboration d'un programme. Bien
que l'on ne puisse rien faire de visuel simplement avec des instructions de
type CTL, on peut arriver à faire un petit programme avec juste des commandes
de type I/O (mais il ne servira pas à grand chose, et sera "désordonné").
On pourra par exemple demander au tester d'écrire un texte, puis l'écran
s'efface et le texte réapparaît. C'est un petit programme mais
il est désordonné (pas de pause, impossible de le modifier, dans
le sens où il donne toujours la même chose (pas de conditions par
exemple) : demande, effacage, réecriture).
Quand vous saurez parfaitement manier toutes les commandes du menu "prgm",
vous serez alors apte à créer un bon programme en langage TI-basic
(il ne manquera plus que les instructions draw, très simples). Mais venons-en
maintenant aux instructions elles-mêmes :
Input est la commande par défaut qui permet d'entrer une valeur dans
la calculatrice (Input signifiant Entrée, comme dans Input/Output). Input
a deux fonctions.
Seule, elle place un curseur à l'écran qui enregistre à
chaque variation les valeurs de l'abscisse X et de l'ordonnée Y. Quand
on appuie sur "ENTER", ces valeurs ne changent plus, jusqu'à
ce que l'on refasse "Input" ou qu'on les change intentionnellement.
Suivie d'un texte, puis d'une variable (avec juste une variable, ça revient
à faire Prompt), elle enregistre une valeur dans la variable placée
après e texte. Input "Nombre d'ennemis",N enregistrera
le nombre d'ennemis choisis par le joueur dans la variable N.
Mais regardons plutôt les exemples :
ex1 : (Il s'agira ici de tracer un rectangle à partir de deux points (comme sous paint), puis d'analyser les variables.
|
:AxesOff On enlève les axes :CoordOff et les coordonnées. :0-->Xmin:0-->Ymin Le point en bas à gauche est l'origine :1-->(delta)X:1-->(delta)Y Et 1 pixel fera une unité (94 pixels sur 62) :ClrDraw Puis on efface le dessin :Input On met Input ici pour avoir le curseur :X-->A:Y-->B On stock les coordonnées du point dans {A,B} :Pt-On(A,B) Et on met ce point pour qu'il reste (qu'on s'en souvienne) :Input On refait la même opération pour le second point :X-->D:Y-->E Et ces coordonnées sont {D,E} :Pt-On(D,E) On trace encore une fois le point. :Line(A,B,D,B) Ensuite, on trace le segment [AD] (en haut si le premier point est plus haut que le 2nd) 
:Line(A,E,D,E) Le segment parallèle à [A,D]:Line(A,B,A,E) Le segment [B,E] (à gauche si le premier point est à gauche du second) :Line(D,B,D,E) Le segment parallèle à [B,E] :abs(D-A)-->C La différence entre les abscisses des deux points est la "largeur" du rectangle :abs(E-B)-->F La différence entre les ordonnées des deux points est la "hauteur" du rectangle :C*F-->G Hauteur * Largeur = Aire, sockée dans G :Pause On met une pause pour admirer le rectangle ainsi tracé. :If C=F:Then Si la hauteur est égale à la largeur (c'est un carré) :ClrHome On efface l'écran :Disp "Vous avez" :Disp "dessiné un carré" Et on dit qu'on a tracé un carré 
:Disp "de":Output(3,4,C) :Output(3,11,"pixels") En spécifiant sa taille :Output(4,1,"de largeur.") :Pause :End On met une pause, et End pour terminer "Then" :ClrHome Puis, quel que soit le cas, on réefface l'écran  :Disp "Largeur : ",C On écrit la largeur :Disp "Hauteur : ",F Et la hauteur du rectangle :Disp "Aire : ",G Ainsi que son aire :Pause On met une pause :ClrHome Et on réefface l'écran. |
Et voilà, le programme fonctionne parfaitement, et ce n'était
pas très dur. La première fonction de Input est donc démontrée.
Note : pour forcer le curseur de Input de se placer autre part qu'au entre de
l'écran, vous pouvez utiliser la fonction text() en mettant les coordonnées
de la place que vous voulez donner au curseur mais en n'écrivant rien
("") : votre curseur sera donc placé à l'endroit où
votre "texte" aura été écrit.
Regardons maintenant
la seconde fonction, qui permet de demander une valeur au joueur, précédé
d'un "invité". Il s'agira dans cet exemple d'écrire
un texte à un certain endroit (le point 0,0 est, dans le cas de la fonction
text(, en haut à gauche). Venons-en au code source et au
programme sur l'écran :
ex2 :
|
:ClrHome D'abord, c'est l'effacage de l'écran :ClrDraw Et des dessins :Disp "Coordonnées du" On ecrit coordonnées du (début de la demande)  :Input "texte :",L1 Et sur la ligne suivante, on met la fonction Input (la ligne d'avant est optionnelle mais elle aide à savoir ce qu'il faut mettre). Les coordonnées devront se présenter sous la forme {ordonnée,abscisse}, ou {0,0} est en haut à gauche. Ces coordonnées seront enregistrées dans la liste L1. :Disp "" Ensuite on saute une ligne en n'écrivant rien avec Disp :Input "Texte : ",Str1 Et on demande le texte à écrire, stocké dans la Chaîne 1 (Vars, 7, 1). Les chaînes n'existent que sur les TI-83 et plus (S-E, Ti-82, Ti-89 etc.), vous ne les trouverez pas sur une TI-82. 
:Text(L1(1),L1(2),Str1) C'est à ce moment-là que l'on écrira le texte aux coordonnées choisies.
|
Prompt se rapproche beaucoup de Input, dans le sens où il "demande"
une valeur (instruction d'entrée). Sa syntaxe est très simple : Prompt
variable, où variable peut être un paramètre de fenêtre, un nombre
réel, une liste, une chaîne, une fonction etc.
Exemple :
|
:ZoomSto On enregistre d'abord les paramètres de zoom (dans zoom, droite) :AxesOff Puis en enlève les axes :ClrHome Puis on efface l'écran 
:Prompt Xmin,Xmax,Xscl,Ymin,Ymax,Yscl Maintenant, on demande (dans l'ordre) : Quelle est l'abscisse minimale, l'abscisse maximale, le nombre d'unités entre chaque graduation de l'abscisse, puis la même chose pour l'ordonnée. On aurait aussi pu prendre une ligne de code par variable (Prompt Xmin, puis Prompt Xmax etc):Horizontal Ymin On trace deux ligne horizontales, une en haut, :Horizontal Ymax L'autre en bas :Vertical Xmin On continue à tracer le cadre en traçant la verticale de gauche :Vertical Xmax Et celle de droite. :Text(25,25,"FENETRE PRETE") Et on écrit que les paramètres Window sont prêts. :For(A,0,400) Et on fait une pause "artisanale" :End le temps de lire ce qu'il y avait d'écrit. 
:ClrDraw On réefface les dessins (celui que l'on vient de faire en l'occurence):AxesOn On remet les axes :Pause Et on fait une pause pour avoir le temps de voir ses nouveaux paramètres :ClrHome On réefface l'écran :Disp "Voulez-vous" 
:Disp "enregistrer":Disp "votre configura-" Là, on demande si le testeur est satisfait. :Disp "tion ?" :Pause Et on lui fait une pause pour lire le message. 
:Menu("ENREGISTRER ?","OUI",1,"NON",2) Ensuite, on lui demande s'il veut garder sa configuration sous forme de menu.:Lbl 1 Si oui, :ZoomSto On enregistre les nouveaux paramètres :Stop Et on s'arrête là. 
:Lbl 2 Sinon,:ZoomRcl On rappelle les anciens paramètres (enregistrés au début du programme) :Stop et on s'arrête (instruction optionnelle ici) |
Disp est certainement l'instruction la plus simple utiliser ; votre premier
programme devrait certainement l'utiliser. La syntaxe de Disp est la suivante
: Disp "Message à écrire" pour écrire
un texte ; Disp Variable pour afficher une variable ; Disp
"Message",Variable pour rajouter la valeur d'une variable au
texte. En fait, on écrit toujours Disp suivit des variables à afficher
séparées par des virgules. Si on veut afficher un texte, la
variable est une chaîne de caractères et on doit la mettre entre
guillements. Voici une exemple de programme utilisant Disp :
|
:ClrHome On efface l'écran :Disp "Disp est l'in-" :Disp "struction la" Et on écrit un petit texte 
:Disp "plus simple à":Disp "utiliser." :Pause On met ensuite une pause (inutile ici) :3.14-->A On affecte une valeur à la variable A :Disp "Ex : A=",A Et on la réécrit avec Disp (après un petit texte). |
Sur les TI, on peut presque dire que l'on a deux écrans : celui où l'on fait les calculs et où on execute les instructions telles que Disp ou Input, et celui où l'on trace les graphes et où l'on peut faire les applications graphiques. On peut passer de l'un à l'autre en appuyant sur "Graph" puis sur "CLEAR" sans les effacer. L'instruction qui permet de passer du mode "normal" au mode "graphique" est "DispGraph". Il n'y a pas de syntaxe à retenir ; l'instruction s'insère telle quelle dans le code source.
Exemple :
:ClrDraw Comme d'habitude, on efface les dessins:ClrHome et les textes pour que rien ne vienne troubler l'experience :Circle(16,14,5) On commence alors à dessiner un cercle :Text(5,20,"UN DESSIN" et à écrire (en un petit message en mode texte) 
:Pause pour avoir quelque chose à montrer sur "l'écran graphique":Disp "DU TEXTE" Du côté de "l'écran normal", on écrit aussi un petit message simple
:Pause Et on met une pause pour commencer la démo : :DispGraph C'est ici qu'on utilise l'instruction à expliquer : elle montre le dessin avec le cercle :Pause Puis on met une pause :ClrHome On efface le texte (qui était : "DU TEXTE") :Disp ":-P" Et on met un petit smiley :-Þ 
|
Output ressemble beaucoup à Disp dans la mesure où il n'e sert
qu'à afficher du texte et des valeurs de variable. Son seul avantage
est que l'on peut placer le texte à n'importe quel endroit de l'écran
(sans toutefois le dépasser bien sûr). La syntaxe de Ouput est
Output(ordonnée,abscisse,"Texte") (ou bien sûr
Variable sans guillemets à la place de Texte, comme dans Disp). Ordonnée
est un entier situé entre 1 et 8, ou 1 est le haut de l'écran
et 8 le bas ; abscisse est un entier entre 1 et 16 ou 1 est la gauche de l'écran
et 16 la droite. Mais venons-en tout de suite à l'exemple :
ex :
:ClrHome :Output(8,8,"Output" :Pause :Output(2,1,"est plus" Ce programme consiste simplement à Ecrire un texte à n'importe quel :Pause :Output(5,9,"Elaboré" endroit de l'écran comme le montre l'animation de droite :Pause :Output(6,3,"Que Disp." :Stop |
etKey est certainement l'instruction la plus utile et utilisée dans un jeu puisque son rôle et de savoir sur quelle touche le joueur appuie. Si on place GetKey tel quel dans un programme, son efficacité ne pourra pas être démontrée car cette n'instruction n'opère que pendant une fraction de seconde ; c'est pourquoi on est obligé d'utiliser GetKey dans une instruction de boucle (Repeat pour ma part). On fera sortir le programme de la boucle lorsque GetKey sera différent de 0, autrement dit, dès que l'on aura appuyé sur une touche quelconque. Encore une chose, GetKey est un nombre mais il est plus pratique de tout de suite lui attribuer un autre nom de variable (K pour ma part). L'exemple de programme ci-dessous rejoint un peu le principe de "Réflèxes", programme téléchargeable sur ce site (bien évidemment puisque c'est moi qui l'ai cré :-þ) :
Exemple :
:ClrHome On efface l'écran, comme d'habitude:O-->Z Z (qui sera le nombre de boucles plus tard) est mis à 0 :Disp "APPUYEZ SUR [+]" :Disp "AU TOP..." On explique les règles du jeu basiques :For(A,1,16) :Output(8,A,"+" Et on met une petite animation avant de passer à la suite :For(B,1,50) Cette boucle sert à ralentir la première :End:End :ClrHome Ici, on efface à nouveau l'écran :randInt(0,250)-->A et on crée un nombre A situé entre 0 et 250 :For(F,1,A) Cette boucle sert d'attente (suspense), sa durée est aléatoire entre 0 et 250) :getKey-->K On rearde si le joueur appuie sur une touche (il ne doit pas le faire) :If K:Goto 0 S'il le fait... :End :Lbl 0 ... :If K:Then :Disp "PERDU !" Il a perdu parcequ'il aura appuyé trop tôt :Disp "TROP TOT..." :Pause:Stop:End On met une pause, on arrête le programme et on marque la fin de la condition :Output(4,6,"TOP !") Donc, après la boucle entre 0 et 250, on met le TOP ! :Repeat K Et là, on regarde si on n'appuie pas sur une touche (on répète jusque K ait une valeur) :Z+1-->Z A chaque nouvelle boucle, Z s'inscrémente d'une unité :getKey-->K Ici, on stoque le numéro de la touche dans K :End Et voilà la fin de la boucle 
:If K=95:Then Si on appuie sur la touche "plus":Disp "VOTRE SCORE : ",Z Le nombre de boucles effectuées avant réflèxe est affiché :Pause On met une pause :Stop:End Et le programme se termine :Disp PERDU ! Si on sort de la boucle (on a appuyé sur une touche) et que K est différent de 95 (on n'a pas appuyé sur "+") :Disp Mauvaise touche. Alors le joueur a perdu, on le lui dit :Stop Et le programme s'arrête ! |
ClrHome (EffEcr sur les versions françaises) sert simplement à effacer l'écran de manière propre, rapidement. Cette instruction n'a pas de syntaxe particulière, elle s'insère telle quelle dans le code source. On l'utilise généralement après une pause dans une série d'instruction Disp ou Output, et surtout à la fin d'un programme. Attention, ClrHome ne permet d'effacer les dessins et les graphiques. Voyons un exemple simple de l'utilisation de cette instruction :
Ex :
:ClrHome On efface d'abord l'écran pour commencer le programme (pour éviter qu'il y ait le nom du programme qui s'affiche par exemple):Disp "E" :Disp "F" :Disp "F" :Disp "A" Ensuite on écrit un texte qui utilise les 8 lignes de l'écran :Disp "C" :Disp "A"  :Disp "G" :Output(8,1,"E") (on utilise Output ici pour que la pause ne saute pas de ligne ; utilisez Disp pour voir) :Pause On met une pause pour avoir le temps de lire :ClrHome Et en une fraction de seconde, l'écran est à nouveau effacé ! |
Si vous trouvez que cet effaçage d'écran est trop rapide, pas assez "stylé", vous pouvez en faire un vous même. Celui que je vais faire ici fait descendre des "+" de haut en bas, et efface ainsi l'écran (mais de façon originale et moins rapide) :
Ex2 :
|
:ClrHome :Disp "E" :Disp "F" :Disp "F" :Disp "A" Tout d'abord, on remplit de nouveau un peu l'écran, comme avant. :Disp "C" :Disp "A" :Disp "G" :Output(8,1,"E") :Pause  :For(A,1,8) Ici, on commence une boucle For faisant varier la variable A (ordonnée de Output) de 1 à 8 (nombre de lignes) :Output(A,1,"++++++++++++++++" On insère 16 caractètres (nombre de "colonnes") :For(B,1,20):End On fait une boucle qui ralentit la première :Output(A,1," " On efface la ligne de caractères (16 blancs) :End Et la boucle se termine |
Et voilà ! La partie "commande" des instructions de type Entrée/Sortie est terminée ! Il ne manque plus que la partie "instruction graphiques" pour compléter la liste des instructions à connaître pour bien programmer !