Le manuel est souvent pour de nombreuses personnes, obscure, c'est pourquoi je vous propose ce petit aperçu de la programmation sur casio de façon moins austère afin, pourquoi pas, de vous lancer vous aussi dans le monde des (petits) programmeurs. Cette introduction à la programmation ce veut explicite et j'espère qu'elle vous sera utile et agréable à lire !

Pour essayer les exemples dans la suite de ce document, il vous faudra appuyer sur la touche EXE à chaque fin de ligne !

1. Les variables :

Tout les programmes fonctionnent à l'aide de variables représentées par les lettres de l'alphabet : A, B,C… Celles-ci servent à garder en mémoire des nombres stockés dans ces variables et utiliser des nombres rentrés au préalable.

Exemples :

L'utilisation de la flèche : "Ü " se révèle indispensable à l'utilisation des variables.

Vous voulez attribuer la valeur "9,81" à la variable "B", vous tapez :

9,81Ü B

Maintenant, vous voulez multiplier la variable "B" par 9,81 et attribuer cette valeur à la variable "A" :

B*9,81Ü A

Δ Si vous utilisez les variables X ou Y, leurs valeurs peuvent être modifiées lors de l'utilisation d'un graphique et des coordonnées.

2. L'entrée des données :

Pour utiliser les variables à partir de l'entrée de données, afin de les réutiliser dans des calculs, il faut employer le point d'interrogation.

Exemple :

Ce programme va demander l'entrée de 2 nombres qu'il va stocker dans la variable A et B puis les multiplier pour créer la variable C.

? Ü A

? Ü B

A*BÜ C

3. L'affichage simple d'un nombre :

Pour afficher le résultat d'un calcul ou la valeur d'une variable il faut utiliser le "triangle noir". Ce symbole interrompt le programme.

Exemples :

Vous voulez afficher la valeur de la variable A, vous écrivez :

A◢

Ou

A*5+B◢

4. L'affichage simple d'un texte :

Pour afficher un texte sur l'écran de votre calculatrice, c'est très simple, il suffit de placer votre texte entre deux guillemets.

Exemple :

Programme : "TEXTE"

Si vous voulez que le programme s'arrête sur ce texte il faut insérer le triangle :

Programme : "TEXTE"◢

5. Résumé :

Afin de comprendre l'utilité de ces fonctions je vais associer le tout dans un programme calculant automatiquement le poids d'un solide à partir de l'entrée de sa masse.

Programme :

Au première abord, la notion de boucle paraît vague. Celle-ci est une fonction permettant de répéter un nombre de fois l'opération voulue. Etudions les 3 types de boucles que possède votre casio.

1. For, To, Step et Next :

Cette boucle permet d'effectuer une opération ou une partie de programme un certain nombre de fois et incrémente (augmente la valeur numérique d'une variable) ou décrémente la variable définie auparavant tant que celle-ci n'a pas atteint la valeur inscrite après To. Ces fonctions permettent notamment de raccourcir un programme. Lorsque la variable augmente de 1 en 1, l'entrée de Step est facultative ! Vous pouvez également introduire des variables pour la valeur butoir (après To), ce qui complexifie un peu. Vous ne devez pas oubliez que la variable située après For peut être utilisée dans les calculs, sachant que la valeur est à chaque passage modifiée.

A savoir :

For signifie de

To signifie à

Next retourne l'exécution du programme à For

Step incrémente ou décrémente la variable

Exemples :

Vous voulez additionner l'entrée de 10 nombres :

0Ü B

For 1Ü F To 10 ' F va augmenter de 1 en 1 jusqu'à la valeur 10 puis va passer à la suite du programme (après Next)

? Ü A

A+BÜ B

Next

B◢

Vous désirez afficher une suite de nombre allant de -3 à 5 en allant de 0,5 en 0,5 :

For -3Ü A To 5 Step 0,5

A◢

Next

Pour calculer la moyenne d'un certain nombre de chiffres (façon, vous le constaterez par la suite, un peu barbare mais utilisant uniquement les notions déjà appréhendées) :

"NOMBRE DE CHIFFRES"

0Ü D

? Ü A

For 1Ü B To A

? Ü C

C+DÜ D

Next

"MOYENNE="

D / A◢

2. Do et Lpwhile, While et Whileend

Ces 2 fonctions permettent d'exécuter une opération tant que la condition fixée est vraie.

La différence entre Do… et While… est que pour la première, la condition est vérifiée à la fin alors que pour la seconde elle est au début. Par conséquent si vous utilisez Do… la partie postérieure à cette commande sera exécutée au moins une fois.

A savoir :

Do signifie faire

LpWhile signifie tant que et retourne à Do

While signifie faire si

Whileend signifie fin de While et retourne à While

Exemples :

Pour créer un programme qui demande d'entrer des nombres tant que ceux-ci sont supérieurs à 0 :

Do

? Ü A

LpWhile A>0

Ou bien :

1Ü A

While A>0

? Ü A

Whileend

A première vue, cette commande semble être de peu d'utilité, mais elle s'avère indispensable dans des programmes plus complexes ! Il ne faut pas oublié qu'entre Do… et While…, vous êtes libre de mettre ce que vous voulez.

3. Les sauts :

Ces fonctions : Lbl et Goto sont sans doutes les plus usitées. Elles permettent de se déplacer dans l'exécution du programme. Pour nommer ces Lbl (par conséquent aussi les Goto) vous disposez des lettres de l'alphabet ainsi que tous les chiffres allant de 0 à 9. Même si ces fonctions sont très pratiques, elles sont déconseillées notamment pour l'apprentissage d'un autre langage qui n'en possède pas comme le Maple. Dans le programme, chaque Goto ramène au Lbl qui porte la même marque que lui.

Vous voulez créer un programme qui après avoir fini ces opérations retourne au début :

Ainsi après l'affichage du nombre, le programme ne s'arrête pas mais reviens sur l'entrée du nombre "?".

Les programmes sont régis par des conditions qui exécutent en fonction de ces tests certaines partie du programme. Il n'existe pas beaucoup de commandes différentes pour créer ces tests.

Structure principale :

If + condition(s) :

Then + programme

Else (événement contraire à la condition exposée par If) + programme

Ifend : ' signifie que la suite du programme ne dépend plus de cette condition

Il n'y a pas besoin d'introduire Else si l'événement contraire n'est pas pris en compte ! N'oublions pas que cette structure peut-être complexifiée à volonté en imbriquant les conditions les unes dans les autres.

Après avoir entré un nombre, la calculatrice détermine si celui-ci est positif, nul ou négatif :

Afin d'éviter une accumulation de "If" si plusieurs conditions sont requises ou bien plusieurs sont possibles alors il existe des structures très simples :

• And (et, pour les incultes)
• Or (ou, pour les incultes)
• Not (pas, pour les incultes, commande d'aucun intérêt)

Ainsi, vous pourrez les incorporer dans la structure conditionnelle.

Programme servant de code à l'exécution d'un programme (le code étant "555" et "444") :

Il existe une autre commande plus simple du point de vue syntaxique : c'est la double flèche. Elle remplace la fonction du If et Then et même And.

Programme qui affiche "trouvé" si le nombre choisit est 4 et "perdu" si c'est un autre :

Programme du dessus mais avec la double flèche :

Δ Si vous souhaitez comme condition que trois variables soient égales ne surtout pas taper If A=B=C, la machine en lisant va renvoyer la valeur 1 si cette condition est vraie et 0 si la condition est fausse. Donc vous devez écrire toutes les égalités deux à deux, ou bien si vous avez bien suivi créer une boucle, à vous de chercher…

Break : Cette commande doit être placé dans une boucle, et quand elle est sollicitée amène l'exécution du programme après la boucle (par exemple après Next…). Cela évite d'introduire un saut inutile.

Prog : Cette commande permet de relier entre eux différents programmes. Pour revenir au programme initial, vous devez utiliser la commande Return qui renvoi à l'endroit exacte, là ou le programme de départ c'était arrêté. Syntaxe : Prog "NOM DU PROG"

Stop : Cette commande arrête le programme.

Il faut savoir (uniquement pour graph30 et +) que votre écran est partagé en 7 lignes et 21 colonnes. Vous pouvez afficher un texte ou un chiffre à n'importe quel endroit de l'écran grâce à la commande Locate.

Syntaxe : Locate n°colonne, n° ligne, Texte. A la place de texte vous pouvez mettre un chiffre une variable ou une chaîne de caractère si celle-ci est entre guillemets.

Ou

La casio possède une fonction : Clear qui permet soit d'effacer tout le contenu d'une liste ou d'une matrice soit l'écran en mode Texte ou en mode Graphique.

A savoir :

ClrText : efface l'écran en mode Texte

ClrGraph : efface l'écran en mode graphique

ClrList et ClrMatrix : efface les listes et matrices (vous étudierez leur usage ultérieurement). Cette commande doit être disposée seule dans le programme.

Il existe également 2 autres commandes : Isz et Dsz, le premier augmente la valeur placée juste après elle de 1 et l'autre, c'est le contraire, elle diminue la variable de 1.

Dsz B ' diminue la variable B de 1

Votre calculatrice possède une commande : Getkey, qui permet de contrôler toutes les touches de la casio sauf ON. Pour les repérer chaque touche a un numéro. Exemple EXE a pour numéro 31 (se référencer au manuel pour les autres touches). Ainsi vous pouvez insérer cette commande dans une structure conditionnelle. Lorsque vous appuyez sur une touche, le numéro de cette touche est transmis au Getkey qui prend ainsi sa valeur donc cette commande peut être transférée à une variable pour être par la suite étudiée.

La fonction "~" sert à regrouper des variables pour éviter une répétition. Par exemple, pour attribuer la valeur -1 à toutes les variables allant de D jusqu'à K vous écrivez : -1Ü D~K

Résumé :

Programme qui affiche au milieu de l'écran un nombre qui augmente quand on appuie sur plus et inversement :

L'écran de votre calculatrice (graph30 et +) est composé de 128 pixels sur 64. L'affichage graphique se différencie complètement du mode texte par conséquent, il n'est pas possible de mélanger les deux. Heureusement il existe des autres commandes !

1. La fenêtre :

Avant de faire un graphique, vous devez créer une fenêtre adaptée correspondant à un repère orthonormé. Syntaxe : WiewWindow X minimum, X maximum, Fréquences des traits, Y minimum, Y maximum, Fréquences des traits

Exemple :

Pour créer une fenêtre ayant pour abscisse -5 et 5 et en ordonnée -2,5 et 2,5 avec des traits toutes les 2 unités en abscisse et toutes les unités en ordonnée :

WiewWindow -5,5,2,-2.5,2.5,1

2. Les fonctions :

Pour tracer une fonction, c'est simple, il suffit d'utiliser la commande : GraphY= et de mettre juste derrière la fonction. Par exemple : GraphY= 4x^2+36. Pour les inéquations, il faut écrire par exemple : GraphY>, sauf pour la graph100 ou la méthode est plus longue et complexe (voir chapitre 8-6-3 du livre).

3. Commandes complémentaires :

1. les traits :

Pour tracer un trait vous devez utiliser la commande : F-Line abscisse 1, ordonnée 1, abscisse 2, ordonnée 2. Pour que ce trait s'affiche à l'écran, les deux coordonnéees doivent être dans la fenêtre.

2. les points :

Pour afficher un point, il y a plusieurs commandes. Tout d'abord : Plot abscisse, ordonnée.

Il existe également PxlOn n° de pixel en ordonnée, n° de pixel en abscisse (sachant qu'en ordonnée, le pixel en haut de l'écran correspond on n°1). Cette commande ne dépend pas de la fenêtre mais utilise les dimensions de l'écran à travers les pixels. PxlOff (avec la même syntaxe que PxlOn) sert à éteindre un pixel si celui-ci est allumé. PxlChg (avec la même syntaxe) sert à allumer un pixel si celui-ci est éteint et inversement.

3. l' affichage d'un texte :

Vous devez utiliser la fonction Text. Elle a les mêmes caractéristiques que Locate à la différence que celle-ci utilise le repérage par pixel comme pour PxlOn.

Exemple :

Vous voulez afficher du texte sur un graphique sachant que la première lettre correspondra au premier pixel en abscisse et le 20^ième en ordonnée :

Text 20,1,"MOT"

4. tracer un cercle :

Il suffit d'utiliser la fonction : Cercle abscisse du centre, ordonnée du centre, rayon.

Exemple : Cercle 4,5,2. Seulement si vous possédez une graph25 ou une graph20, vous êtes obligé d'utiliser deux fonctions : GraphY= (centre ordonnée) * √ ( Rayon^2 - ( X - (centre abscisse))^2) et GraphY= - (centre ordonnée) * √ ( Rayon^2 - ( X - (centre abscisse))^2).

5. tracer une droite verticale, horizontale :

Utilisez la commande Vertical ou Horizontal en ajoutant juste derrière un chiffre correspondant à l'emplacement.

6. comment savoir si un pixel est allumé ou pas ?

Il faut utiliser la commande PxlTest(n° de pixel en ordonnée, n° de pixel en abscisse), ainsi après avoir exécuté cette ligne, la calculatrice attribue la valeur 1 à la variable Ans et 0 à la variable si celui-ci est éteint. Après il vous reste à utiliser cette variable dans une structure conditionnelle.

7) enregistrer une image :

Il est possible de mettre en mémoire des images inscrites à l'écran. Pour cela il faut déjà la faire apparaître l'image à l'écran puis introduire la commande StoPict suivie d'un numéro allant de 1 à 20, servant à les rappeler. Pour faire réapparaître cette image (car cette fonction est utile pour faire apparaître rapidement une image) vous devez utiliser la commande RclPict suivie du numéro. Maintenant, si vous désirez qu'une image reste tout le temps en mémoire (qui ne s'efface même pas avec CLS) il faut utiliser la fonction BG-Pict suivie du numéro correspondant à la mémoire d'image. Pour annuler cette fonction, tapez : BG-None

Les listes sont des instruments indispensable par exemple pour programmer le Master Mind de façon rapide et logique. Elles servent à stocker des chiffres dans une colonne numérotée. Dans le livre vous pourrez voir les multiples atouts de ces listes comme calculer une somme de termes, une moyenne, ses dimensions (nb de chiffres dans la liste)… Cela ne servirait à rien que je fasse une description exhaustive de ces commandes car elles sont très bien expliquées dans le bouquin. Ces listes peuvent servir de variables, utilisables en très grande quantité !

Pour mettre le chiffre 4 dans la liste 3 de la première ligne (attention : vous ne pouvez mettre un nombre dans la ligne n+1 d'une colonne si il n'y a rien dans ligne n) : 4Ü List3[1]

Pour insérer une suite de chiffres dans la liste 2 : {4,5,3,2,25,47,-36,-21,1,4}Ü List2

Pour créer une liste composée de 8 "0" dans la liste 4 : 8Ü Dim List4

Pour lire une valeur (au hasard) : List 1 [5]

Même description que pour les listes sauf que les matrices sont en 2 dimensions et que les noms des matrices sont des lettres comme les variables. Il existe également de nombreuses commandes permettant de les exploiter mais beaucoup sont sans intérêt pour la programmation.

Pour mettre le chiffre 4 dans la matrice A dans la troisième lignes et 5^ème colonnes : 4Ü Mat A[3,5]

Pour créer une matrice C de 20 (en longueur) sur 10 (à partir d'une commande il me semble que c'est possible que pour la graph100, sinon il faut le faire dans le menu prévu à cet effet) : {10,20}Ü Dim Mat C

Pour lire une valeur : Mat (nom de matrice) [n°de ligne, n° de colonne)]

Il serait crédule de croire que ces bases suffisent à faire de bons programmes, seulement elles vous permettront de progresser plus rapidement. Maintenant pour vous améliorer il n'y a qu'une solution avoir des idées de programmes, jeux… puis essayer de les créer. C'est le seul secret de la réussite (tout de même avec un peu de talent) ! Cette aide est loin de traiter toutes les commandes mais les plus importantes sont présentes. Il reste bien évidemment de nombreuses fonctions relevant de domaines plus techniques qu'ils vous restent à découvrir. Ainsi vous pourrez profiter pleinement de votre casio.

Nous avons abordé dans la première partie les bases inhérentes à la programmation, maintenant nous allons étudiez de façon plus exhaustive des cas particuliers et des astuces à travers de multiples exemples. Nous verrons également de manière plus approfondie l'utilisation primordiale des listes et des matrices ainsi que certaines commandes permettant de manier habilement les nombres.

1. Commandes pour "manier" les nombres :

2. garder la partie fractionnaire d'un nombre :

Vous devez utiliser la fonction Frac suivie du nombre, plus généralement d'une variable.

Exemple :

Déterminer si est nombre est pair ou impair :

? Ü A

If Frac (A/2) = 0 : Then "PAIR"◢

Else "IMPAIR"◢

Ifend:

3. valeur absolue :

Il vous faut utiliser la commande Abs suivie du nombre ou de la variable, pour avoir toujours un nombre positif.

 

4. Générer un nombre aléatoire :

Votre casio possède une fonction : Randomize, qui permet de générer un nombre aléatoire entre 0 et 0,99999… grâce à un algorithme complexe qui modélise très bien le hasard. Pour insérer cette commande dans un programme il faut écrire : Ran#. A partir de cette commande, vous avez les moyens d'obtenir tout les nombres aléatoirement dans une fourchette choisie.

Exemples :

Vous désirez obtenir aléatoirement un nombre entre 5 et 15 :

10 Ran# +5 ' vous devez écrire "10" : "15-5".

Obtenir un nombre entier aléatoirement dans la fourchette -8 à 22 :

Int 31 Ran# -8

5. les factoriels :

La fonction se nomme : x!, mais s'écrit : !

Exemple :

Avoir le produit : 1*2*3*…*25 :

25!

∆ La calculatrice étant peu puissante, vous ne pourrez pas aller au delà de 69!. Si vous avez les calculs formels, la casio sature à partir de 298!.

6. Les permutations :

Cette commande "nPr" très utile permet de déterminer le nombre de permutations possibles sur n nombres en en prenant r.

Exemple :

Pour estimer le nombre de permutations pour n=3 et r=2. Les solutions sont : 3 3 ; 2 2 ; 1 1 ; 1 2 ; 1 3 ; 2 3. Il y a donc 6 possibilités.

Si vous écrivez : 3P2 vous obtiendrez le résultat 6 !

7. Les combinaisons :

1. Les listes :

Dans la partie précédente, nous avons parlé très lapidairement de ces listes, qui servent à stocker des nombres. Nous allons regardé leurs utilisations à travers plusieurs exemples relativement complexes qui je pense vous éclaireront sur leurs utilités !

Voici quelques exemples de difficulté croissante :

Exemples :

Si il vous faut calculer une moyenne à partir d'une suite de nombres :

Principe : On stocke tout les nombres dans une liste puis on utilise la commande Dim permettant d'obtenir le nombre de termes de la liste et Sum pour calculer la somme des termes. Pour marquer la fin de l'entrée des nombres, on attribuera la valeur pi à la liste.

Programme :

ClrList

0Ü A

Do

Isz A

? Ü List1[A]

LpWhile List1[A] ≠pi

"MOYENNE="

(Sum List1-pi)/(Dim List1-1) ◢

Si on rentre directement les termes dans la suite, on peut avoir la moyenne en écrivant : Mean List1

Maintenant vous voulez savoir combien de jours ce sont écoulés depuis le début de l'année en tenant bien évidemment compte des années bissextiles ! Rappelons tout d'abord la notion d'année bissextile. C'est simple, c'est une année sur 4, donc toutes les années multiples 4 ; SAUF les multiples de 100 qui ne sont pas multiples de 400 !!

Principe : le nombre de jours d'un mois étant variable et non régulier, nous allons stocker une suite de chiffres (correspondant au nb de jours pour chaque mois) dans un liste puis utiliser une boucle permettant de les additionner.

Programme :

"ANNEE"

? Ü A

"MOIS"

?Ü B

"JOUR DU MOIS"

?Ü C

0Ü D~E ' D représente le jour supplémentaire de l'année bissextile et E le nombre de jours comptabilisés par les mois

If A/4=Int(A/4) Then If ((Frac (A/100)=0 And Frac(A/400)=0) Or Frac (A/100) ≠0) And B>2 Then D=1 'conditions pour déterminer si l'année est bissextile ou pas et si le jour choisit se trouve après le mois de février

Ifend : {31,28,31,30,31,30,31,31,30,31,30,31}Ü List1 'Les nombres correspondent aux jours contenus dans un mois

For 1Ü S To C-1 'on additionne le nb de jours ci le mois ce situe après janvier

E+List1[S] Ü E

Next

"NB DE JOURS"

E+C+D◢

A présent nous allons compliquer les choses en essayant de programmer le Mastermind (uniquement la partie résultat), vous verrez ainsi une application directe des listes ! (vous pouvez retrouver ce jeu sur http://www.chez.com/calculatricecasio)

Principe : dans la liste 1, on met le code initiale de 4 chiffres et dans la liste 2 la proposition à vérifier, du joueur, puis nous allons comparer ces 2 listes dans deux boucles.

Programme :

0Ü A~B 'A et B représente respectivement les biens placés et les mal placés

For 1Ü M To 4 'cette première boucle détermine les biens placés en vérifiant leurs égalités ligne par ligne

If List1[M]=List2[M]: Then Isz A

10Ü List1[M] 'on attribue de fausses valeurs aux chiffres bien placés pour ne pas qu'ils soient repris dans la 2^ème boucle vérifiant les mal placés

11Ü List2[M]

Ifend : Next

For 1Ü M To 4 'cette 2^ème boucle prend une à une les valeurs de la 1^ère liste et les comparent à toutes les valeurs de la 2^ème liste pour dépister les mal placés.

For 1Ü N To 4

If Lsit 2[M]=List 1[N] : Then Isz B

12Ü List2[M]

13Ü List1[N]

Ifend : Next : Next

Avec ces exemples, je pense que vous aurez saisi l'intérêt qu'il s'en dégage et les manières très variées dont on peut en faire usage.

 

 

 

2. Les matrices :

Les matrices sont des listes mais en deux dimensions. Elles permettent le traitement entier de l'écran de la calculatrice en divisant celui-ci selon les besoins. Par exemple, les matrices peuvent servir lors d'un jeu comme démineur, ou les cases divisant l'écran peuvent être représentées par les différentes cases de la matrice.

Exemple :

Vous voulez dessiner un labyrinthe à l'écran dont les murs sont représentés par des "#" et le personnage par "O". Difficulté : comment empêcher le personnage de pouvoir se déplacer sur les "#" ?

Principe : Toutes les cases de la matrice ou le personnage pourra aller seront égales à 0 et les autres à 1, ainsi il suffira de contrôler la valeur de la case pour valider le déplacement. Les dimensions de la matrice seront celle de l'écran en mode texte : 21*7.

Programme :

ClrText

[[0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0][0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0][0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0][0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,1,1,1,0,0][0,0,0,0,0,0,0,0,1,1,1,0,0,0,1,0,1,0,0,0,0][0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,1,1,0,0][0,0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0]] Ü MatA 'ces chiffres permettent par la suite d'afficher les # à leur places

For 1Ü E To 21

For 1Ü F To 7

MatA[F,E]=1 => Locate E,F,"#"

Next : Next

1Ü A~B : Lbl 0 : Locate A,B,"O" : GetkeyÜ K

K ≠0 => Locate A,B," " 'si il y a un déplacement cette ligne efface la position précédente du personnage

K = 27 => A<21 => MatA[B,A+1]=0 => Isz A ' différents tests pour le déplacement du O

K = 38 => A>1 => MatA[B,A-1]=0 => Dsz A

K = 28 => B>1 => MatA[B-1,A]=0 => Dsz B

K = 37 => B<7 => MatA[B+1,A]=0 => Isz B : Goto 0

Vous avez pu constater l'utilité de ces matrices qui permettent facilement de prendre "contrôle" de l'écran. Le jeu démineur est à la base un fonctionnement de deux matrices, mais il amène à une plus grande réflexion logique et non à des connaissances pointues. Ce qui prouve encore une fois que de simples lettres sur du papier ne feront jamais de miracles, et que c'est à vous à partir de ces bases d'apprendre réellement à programmer.

 

 

3. Astuces et présentations :

1. Pour faire défiler un texte :

Il faut utiliser la commande Locate, puis à la suite du texte rajouter un ou plusieurs espaces correspondant à la vitesse de décalage du texte.

Exemple :

Faire défiler un texte de la droite vers la gauche :

For 21Ü A To 1 Step -1

Locate A,2,"COUCOU " 'l'espace situé après le texte sert à effacer les lettres précédentes, si le nombre situé après Step était -3 alors le nombre d'espaces serait de trois.

Next

2. feux d'artifice :

Idée ingénieuse d'Aurélien Bernard qui consiste à mettre dans une boucle (Lbl et Goto) un grand nombre de PlotChg. Ainsi des pixels s'allument puis s'éteignent indéfiniment les uns après les autres.

3. mot de passe :

Vous pouvez insérer un mot de passe très facilement pour empêcher l'exécution d'un programme : Lbl 0 : ? Ü A : A≠4586=> Goto0. Seulement pour qu'il soit valable, il ne faut pas que la lecture du programme soit possible (donc avec un autre code prévu par casio) et mettre un mot de passe, c'est pas très pratique lorsque le programme est en pleine construction. En voici un qui même avec la lecture du programme en arrêtera plus d'un !

Exemple :

Votre code est 9 89 et 33 :

Lbl 0

? Ü A

? Ü B

? Ü C

A*B+C≠834 => Goto 0

Allez dont trouver 9 89 et 33 à partir de 834, c'est possible mais c'est long ! De toute façon même si le code est introuvable l'indésirable peut encore supprimer cette partie du programme. Sauf ci celui-ci est imbriqué dans le programme et que c'est un vrai imbroglio pour le différencier, et là encore…

4. mettre en mémoire un texte :

Les variables ne peuvent malheureusement contenir une chaîne alphanumérique, seul les nombres peuvent être mis en mémoire. Seulement vous pouvez faire une boucle contenant des Getkey qui envoient leurs valeurs à une liste lors de l'appuie de touches. Ainsi vous pourrez réafficher le mot à partir d'un autre programme qui déchiffrera les nombres en lettres comme s'il s'agissait d'un message codé.

5. ralentir un programme :

Il suffit d'insérer la boucle For… et de mettre après To un nombre plus au moins grand suivant la durée de l'arrêt.

Exemple :

For 1Ü A To 500

Next

6. utilisation de Do et LpWhile :

1. Conclusion :