GOWAP - Cours de Basic sur TO7 / TO7-70.

En 1985, j'ai programmé sur un TO7. Cet ordinateur est une sorte de console avec des touches sensitives (comparable à certaines calculatrices), accompagné généralement d'un lecteur de cassettes qui pouvait être qu'un simple lecteur audio (pour la lecture du moins). Dans l'ordinateur on trouvait un crayon optique, l'ancêtre de la souris, permettant de désigner une zone sur le moniteur ou la télévision sur lequel on se branchait en péritel. Pour faire fonctionner cet ordinateur, nous devions y insérer une cartouche (ROM, nommée mémo7) dans laquelle se trouvait le système d'exploitation. Les cartouches les plus utilisées étaient LOGO, ColorPaint et BASIC. Ah, que de bon souvenir. Dans la salle informatique de mon école primaire, il y avait aussi un lecteur de disquette cinq pouces un-quart (soit 180 à 360 Ko). Puis, j'ai eu le plaisir d'utiliser un MO5, installé en réseau avec un serveur IBM, offrant la possibilité d'accéder à ces deux lecteurs de disquettes. Avec le MO5, une touche de fonction permettait d'écrire des mots BASIC en pressant la lettre associée. C'était le début de la fainéantise légendaire des informaticiens digne de se nom.

Je ne me rappelle pas de tout sur ce BASIC, mais je vais faire un effort. - Voyons, il est où ce TO7/70, que je ne raconte pas trop de bêtises - J'ai retrouvé un petit manuel nommé "mémento basic" avec ma cartouche. Je vous écris ce qui s'y trouve avec un peu d'amélioration (enfin ce que j'en pense). Voir mémento BASIC du TO7 / TO7-70.

Le TO7 est un ordinateur : donc il peut calculer. Mais il permet aussi de créer des programmes pour gérer des données. Pour cela, le TO7 propose le langage de programmation BASIC. Avec ce langage, vous pourrez gérer des données numériques et alphanumériques en mémoire vive ou de masse, effectuer des présentations colorisées, et même faire de la musique.

Une fois votre ordinateur allumé, choisissez le menu BASIC. Le TO7 affiche quelques lignes d'information, puis met un curseur (caractère clignotant) sur une ligne vide.

Ce curseur représente la localisation de votre insertion de caractère ; c'est-à-dire, si vous tapez sur une touche, le caractère s'insère à cet endroit sur l'écran. Puis, le curseur se décale d'un caractère vers la droite.

L'écran vous permet d'afficher 40 caractères de large sur 25 de haut. Lorsque vous entrez un caractère et que le curseur se trouve sur la 40^ème colonne, il se déplace sur la première colonne de la ligne suivante.

Les touches de directions gauche, droite, haut, bas, vous permettent de déplacer ce curseur sur l'écran.

Toutes les saisies devront être validées (touche "entrée") pour être interprétées par l'ordinateur. Je vous conseille d'effectuer vos saisies sur une ligne vide. Vous pouvez modifier vos saisies, en vous déplaçant sur celles-ci, puis en validant. Cela est très utile pour modifier un programme.

Pour que l'ordinateur effectue quelques opérations, vous allez devoir apprendre quelques mots-clefs. Les mots-clefs sont des mots que le BASIC reconnaît, et qui ne peuvent pas être redéfinis (Eh, pas à votre niveau, voir reprogrammation du BASIC du TO7).

Si nous voulons afficher le résultat d'un calcul simple comme "2 + 2", nous allons utiliser l'instruction "PRINT", avec la syntaxe suivante (voir le mémento) :

En validant cette ligne, le TO7 vous affiche le résultat (voir les opérateurs dans le mémento). Remarquez, le résultat est indenté d'un espace. Le BASIC marque le signe positif de cette façon. Comparez les deux ligne suivantes :

L'instruction "PRINT" permet d'écrire sur l'écran, à l'emplacement du curseur. Nous pouvons écrire des phrases, des nombres et même les deux. Vous pouvez taper "?" à la place de "PRINT", l'interpréteur BASIC le changera automatiquement.

1
2
3
4
5
6
7
8
9
10
11

PRINT "Le GOWAP est heureux"
PRINT "Le GOWAP" " est heureux"
PRINT "Le GOWAP";" est heureux"
PRINT "Le GOWAP"; : PRINT " est heureux"
PRINT "Le GOWAP","est heureux"
PRINT 1 2*2
PRINT 1;2*2
PRINT 1,2*2
PRINT "Le TO7" ; -70
PRINT 01
PRINT "01"

Les lignes (1), (2), (3) et (4) sont équivalentes, car l'espace et le point-virgule indiquent à l'instruction PRINT de ne pas retourner à la ligne et de ne pas faire d'espacement. Le (5) est donc différent car la virgule effectue un espacement (tabulation). La ligne (6) donne "24" comme résultat. En fait, le basic ne reconnaît pas l'espace dans le nombre 12. Un espace peut donc séparer un nom et une chaîne, mais pas deux nombres. La (7) et (8) affichent les deux nombres espacés d'un caractère (espace de signature du nombre) pour le point-virgule, et d'une tabulation pour la virgule. La ligne (9) vous permet d'écrire "Le TO7-70" en mélangeant une chaîne avec un nombre. Je n'ai pas écrit "PRINT "Le TO" 7;-70" car dans ce cas, nous aurions un espace de signe entre "TO" et "7" dû à la signature positive. Vous avez sûrement remarqué, que les chaînes sont écrites entre deux guillemets. Effectivement, les exemples (11) et (12) permettent de montrer la différence entre une chaîne et un nombre.

L'instruction "CLS" permet d'effacer l'écran. Elle utilise les couleurs actives pour effectuer ce travail. Pour la gestion des couleurs nous avons quelques instructions que nous verrons ultérieurement.

Voici une petite liste de fonction qui travaille sur les nombres : ABS(r), CDBL(r), CINT(r), COS(r), CSNG(r), EXP(r), FIX(r), HEX$(r), INT(r), LOG(r), OCT$(r), SGN(r), SIN(r), SQR(r), TAN(r). Ces fonctions mathématiques, pour la plupart, existent dans presque tous les langages d'aujourd'hui.

Une variable est une zone de mémoire permettant de mémoriser une donnée. Cette variable est désignée par un identifiant. L'identifiant, c'est un nom composé de quelques caractères. Un symbole peut être apposé à l'identifiant pour définir le type (structure) de la variable, et donc déclarer la forme de la donnée qui sera stockée par cette variable.

Afin d'éviter les erreurs probables, nous allons définir notre convention : toutes les variables de chaîne de caractères aussi appelées variables alphanumériques auront le symbole "$", et les autres, donc les nombres, n'auront pas de symbole. Alors "A$" désigne une variable alphanumérique et "A" une variable numérique.

Le BASIC ne nous oblige pas à déclarer nos variables. Il faudra faire attention à bien les initialiser toute de même avant de les utiliser, car sinon, elles peuvent contenir n'importe quelle valeur.

Maintenant que nous savons ce qu'est une variable, il serait sûrement intéressant de travailler avec. Je vous propose un exemple que je commente après :

Le signe "=" permet d'affecter une donnée à une variable. L'instruction primaire "LET" permet d'effectuer la même chose. Cette instruction est maintenant désuète, mais si vous désirez l'utiliser, pourquoi pas (voir le mémento). A$ est une variables alphanumérique et B est une variable numérique. PRINT permet d'afficher sur l'écran le contenu des variables. Si vous écrivez D = "GOWAP" et C$=10, vous obtiendrez une erreur : "Type Mismatch".

Jusque là, nous avons écrit du code en direct : dès que nous validions, le code était exécuté immédiatement. Bien, mais il est plus intéressant de pouvoir exécuter les codes plusieurs fois. Pour cela, nous allons créer un programme. En fait, écrire un programme, c'est juste donner une numérotation d'ordre pour le code. Cela nous donne l'exemple suivant :

L'instruction "RUN" indique au BASIC d'exécuter le programme en mémoire. Cette instruction possède une syntaxe étendue qui ne nous est pas utile pour l'instant (voir le mémento). Nous utilisons une numérotation de dix en dix, pour pouvoir facilement insérer des lignes de correction de notre programme dans le cas où nous oublierions quelques éléments à traiter (des lignes de programme).

Avant d'aller plus loin, je pense qu'il serait utile de savoir comment sauvegarder son programme et le recharger par la suite. Le BASIC nous propose les instructions "SAVE" et "LOAD" respectivement pour sauvegarder et charger un programme.

Lorsque nous créerons des programmes plus évolués, nous insérerons des commentaires avec l'instruction "REM" qui peut être remplacée par le caractère apostrophe ('). Un programme ce n'est pas forcément une instruction par ligne. Avec le caractère deux points (:), nous séparerons deux instructions.

Si vous avez entré le programme du paragraphe précédent, et que vous entrez que la ligne "10" de ce nouveau programme, vous obtiendrez deux écritures de la variable A$. En effet, le programme est en mémoire, et donc les lignes "10" et "20" existent. Comme nous n'avons pas réécrit cette ligne 20, ni effacé, elle est toujours présente. Pour voir le programme qui est en mémoire actuellement, nous utiliserons l'instruction LIST (voir le mémento); cela donne :

Pour effacer une ligne, vous pouvez utiliser l'instruction DELETE (voir le mémento).

10 REM Initialisation de la variable A$
15 A$ = "GOWAP"
20 ' Écrit le texte "Bonjour" et le contenu de A$
25 PRINT "Bonjour", A$

Une chaîne alphanumérique est une concaténation de caractères. De ce fait, le BASIC nous propose des instructions et fonctions pour travailler et nous informer de leur contenu.

10 A$ = "GOWAP"
20 PRINT LEN(A$)
30 PRINT RIGHT$(A$,3)
40 PRINT LEFT$(A$,2)
50 PRINT MID$(A$,2,3)
60 PRINT "Le" + A$
RUN

En ligne 10, nous affectons notre variable A$. En 20, la fonction "LEN" nous retourne la taille de la chaîne contenue dans la variable A$, qui est 5. En 30, la fonction "RIGHT$" retourne les 3 caractères de droite de la chaîne contenue dans la variable A$, qui est "WAP". En 40, nous obtenons les 2 de gauche, qui sont "GO". En 50, la fonction "MID$" retourne les 3 caractères à partir de la 2^ème, ce qui donne "OWA". Avec la ligne 60, nous affichons la concaténation de deux chaînes, ce qui donne "LeGOWAP". L'opérateur "+" permet donc une forme d'addition de chaînes ou de variables alphanumériques. Cette action est appelée concaténation. Et bien entendu, l'instruction "RUN" lance l'exécution du programme.

L'instruction INPUT va nous permettre de saisir des données par le clavier. Nous allons pouvoir entamer le dialogue avec l'ordinateur. Voyons un exemple :

10 INPUT "Nombre : ",N
20 INPUT "Nombre : ";N
30 INPUT "Chaîne : ",A$
40 INPUT "Nb, Nb",N,N
50 INPUT A$
RUN

Les lignes 10 et 20 demande à l'utilisateur d'entrer un nombre qui est mémorisé dans la variable N. Le point virgule derrière la chaîne dans la ligne 20 fait afficher un point d'interrogation suivit d'un espace devant la saisie. Si l'utilisateur tape autre chose qu'un nombre, une erreur (non fatale : "? Redo From start") se produit, et vous incite à ré-entrer une nouvelle saisie. La ligne 30 demande une chaîne de caractère et la mémorise dans la variable A$. Avec la ligne 40, nous demandons deux nombres. La saisie se fait en une fois, en séparant les nombres d'une virgule. En 50, nous demandons dans la saisie d'une chaîne sans émettre de messages.

Nous avons aussi la fonction INPUT$(nb) qui permet de lire un nombre (passé en paramètre) de caractères tapés au clavier. J'utilise souvent cette fonction dans l'attente d'une touche pour continuer mon programme.

En ligne 20, l'ordinateur attend que l'utilisateur appuie sur une touche pour continuer.

Voici quelques exemples de programme. Ils sont simples, mais ils vous permettront de bien comprendre les différentes instructions précédemment expliquées.

10 INPUT "Quel est ton nom ", Nom$
20 INPUT "Quel est ton prénom ", Pre$
30 INPUT "En quel année es-tu né(e) ", AA
40 REM --- saut d'une ligne ---
50 PRINT
60 PRINT "Tu as" 98-AA "ans."

Il est très souvent utile de pouvoir convertir un nombre en chaîne et une chaîne numérique en nombre. Pour cela, nous disposons respectivement de la fonction "VAL" et "STR$"

Avec ces deux lignes, nous affichons le nombre 10 en numérique puis en alphanumérique. Ces deux fonctions sont complémentaires. si la chaîne utilisé avec "VAL" commence par des caractères, alors nous obtiendrons zéro.

Une autre conversion, de type un peu spécial, est la récupération de la valeur ASCII d'un caractère et vis versa.

Dans un programme, nous pouvons être amené à sauter des lignes, pour effectuer un traitement spécifique. Le BASIC nous propose pour cela l'instruction "GOTO" (voir le mémento).

Je vous propose d'utiliser cette instruction avec parcimonie, car elle rend rapidement un programme illisible.

Nous aurons très souvent besoin de comparer des données pour choisir un traitement approprié. Pour cela, le BASIC nous propose la commande "IF" (voir le mémento), et "ON ... GOTO" (voir le mémento). Avec ces instructions, nous pouvons exécuter un bloc d'instruction choisi. L'instruction "IF" exécute un bloc suivant le résultat d'une expression booléenne, et "ON variable GOTO" effectue un branchement sur une ligne suivant la valeur de la variable. Je vous explique les expressions booléenne dans le paragraphe suivant.

10 INPUT "Entrez votre choix [1/2/3] :",a
20 ' --- 1^ère forme ----
21 IF a<1 THEN GOTO 10
22 IF a>3 GOTO 10
30 ' --- 2^ème forme ----
31 IF (a<1) or (a>3) GOTO 10
40 ' --- 3^ème forme ----
41 IF a<1 GOTO 10 ELSE IF a>3 GOTO 10
50 ' --- saut conditionnel ----
51 ON a GOTO 61, 62, 63
61 PRINT "Choix un" : GOTO 70
62 PRINT "Choix deux" : GOTO 70
63 PRINT "Choix trois"
70 ' fin

La ligne 10 vous demande une saisie numérique. Les formes 1, 2 et 3 sont équivalentes. Les lignes 21 et 22 exécutent l'instruction "GOTO 10" respectivement si l'expression "a<1" est vraie et si l'expression "a>3" est vraie. En gros, si la valeur de "a" n'appartient pas à l'intervalle [1..3], la saisie est considérée comme invalide, et nous retournons à la ligne 10. De ce fait, les tests des lignes 31 et 41 sont inutiles, mais elles sont des exemples de codes. Vous remarquerez la différence entre la ligne 21 et 22. L'une contient "THEN GOTO" et l'autre simplement "GOTO". En effet, l'instruction "IF" possède plusieurs syntaxes. Le mot réservé "ELSE" permet d'exécuter un bloc dans le cas ou l'expression ne serait pas vérifiée. Nous pouvons traduire l'instruction "IF" par le texte suivant : si l'expression est vraie, alors l'ordinateur exécute le premier bloc, sinon, il exécute le deuxième (dans le cas où ce deuxième est implémenté).

En 51, nous utilisons l'instruction "ON variable GOTO". Avec ce code, nous exécutons les lignes 61, 62 et 63, respectivement pour les valeurs 1, 2 et 3. Dans le cas où "a" a une autre valeur, la ligne 61 serait exécutée ; sauf dans le cas où "a" serait négatif, car là, nous obtiendrons une erreur fatale : "Illegal Function Call In 51".

Un nombre booléen est une valeur numérique représentant les valeurs logiques "Faux" et "Vrai" ("False" et "True" en anglais) qui peuvent être logiquement représentées par les valeurs numériques 0 et 1. En fait, le BASIC code "-1" pour la "Vrai".

Nous pouvons donc comparer des nombres et des chaînes de caractères. Lorsque j'écris "A"<"B", je regarde si l'ordre alphabétique est vérifié. Si j'écris "A"<"AA" j'obtiens Vrai (-1).

Une expression booléenne peut être une simple comparaison, mais aussi un regroupement de comparaisons à l'aide des opérateurs logiques (voir le mémento). Ainsi, "(a=1) or (a=2)" sera Vrai si la valeur de la variable "a" est 1 ou 2. Voyons un exemple intéressant :

Calcul de la fonction XOR en utilisant que les opérateurs logiques NOT et AND.
L'opérateur XOR nous retourne vrai si les deux opérandes ont des valeurs différentes. Donc, en supposant que "a" et "b" soient deux variables booléennes, nous pourrions remplacer XOR par a<>b. Avec NOT et AND, nous avons : (a = not(b)) and (not(a) = b).

Lorsque nous désirons effectuer plusieurs fois une opération équivalente (à une variable près), il est plus intéressant de pouvoir boucler un bloc de notre programme. Nous disposons de l'instruction "FOR" (voir le mémento) couplée à l'instruction "NEXT". Dans les langages BASIC plus évolués, nous aurons aussi l'instruction WHILE. Avec "FOR", nous allons faire évoluer une variable initialisée jusqu'à un nombre défini.

Avec ce petit programme, nous affichons les 20 valeurs successives de la variable "T". L'instruction NEXT définit la fin du bloc à répéter. La variable "T" est incrémentée à chaque tour de un. Vous pouvez spécifier la valeur d'incrémentation avec l'instruction STEP.

Ici, nous affichons les valeurs de "T", incrémentée de deux. La boucle se termine lorsque la valeur de "T" est supérieure à la valeur d'arrêt. Donc, nous n'affichons pas la valeur 21.

10 FOR A= -1 TO 0
20 FOR B= -1 TO 0
30 PRINT "A"A"B"B,A XOR B" "A<>B" "(A=NOT(B))AND(NOT(A)=B)
40 NEXT B,A

La fonction "RND" et "RND(nb_entier)" retourne un nombre réel de l'intervalle [0..1]. Nous parlons de pseudo-aléatoire, car ces nombres sont récupérés dans une liste de valeurs. Cette liste contient des valeurs qui ne sont pas modifiées pendant l'exécution d'un programme. Dans d'autre BASIC, l'instruction RANDOMIZE(nb_entier) permet de réinitialiser cette liste. Pour éviter d'obtenir toujours les mêmes nombres, je vous conseille d'effectuer un cycle de lecture dans l'attente de l'appuie d'une touche.

Le BASIC nous permet de positionner le curseur sur l'écran (voir coordonnées écran dans le mémento) avec l'instruction "LOCATE". Nous pouvons aussi obtenir sa localisation avec les fonctions CSRLIN et POS. Dans d'autre BASIC, vous utiliserez POS(0).

A première vue, ces instructions ne semblent pas être très utiles. Mais lorsque vous effectuez une tâche de fond, vous ne désirez pas troubler l'environnement de travail. Ex : vous affichez continuellement la valeur d'une variable sur l'écran sans troubler le programme.

Avec l'instruction PRINT, nous pouvons utiliser la fonction TAB(nb_entier), pour décaler le curseur à la colonne donnée en paramètre (sachant que la première colonne porte le numéro zéro).

Avec cette ligne, nous écrivons "GOWAP" à partir de la 10^ème colonne. Si le curseur est déjà une colonne de valeurs supérieures, le curseur sera placé sur la ligne suivante. Si le texte suivant devait être coupé, il serait automatiquement placé sur une nouvelle ligne.

La première ligne affiche le message sur la ligne suivante, et la deuxième affiche les deux éléments sur 2 lignes.

La fonction SPC(nb_entier) permet de générer une chaîne du nombre spécifié d'espaces. Si ce nombre est négatif, une chaîne vide est retournée.

La fonction SCREEN(x,y) retourne la valeur ASCII du caractère affiché sur l'écran à un emplacement désigné en paramètre. Dans d'autre langage, nous pouvons utiliser SCREEN(x,y,c) avec c = 0 (ou omis) pour lire un caractère, et c = 1 lire la valeur couleur du caractère.

Les instructions "GOSUB" et "RETURN" sont utilisées respectivement pour faire appel à un sous-programme, et en revenir. Un sous-programme, est un bloc d'instructions (portion du programme) qui, une fois achevé, reprend l'exécution du programme à l'instruction suivant le GOSUB d'appel. De ce fait, un sous-programme peut être appelé n'importe où dans un programme.

10 A=0
20 GOSUB 100
30 A=2
40 A$=INPUT$(1) : 'Attend une touche.
50 GOSUB 100
60 END
100 FOR T=0 TO 39
110 LOCATE T,A
120 IF T=A THEN PRINT "X" ELSE PRINT "-";
130 NEXT
140 RETURN

Avec ce programme, nous affichons une croix "X" à la colonne désignée par la valeur contenue dans la variable "A".

La première méthode que je vous ai expliquée pour lire une touche est avec la fonction INPUT$(nb). Mais, cette instruction attend le nombre de touches désignées avant de continuer. Avec la fonction INKEY$, vous lisez au vol le contenu du tampon clavier (mémoire contenant les dernières touches clavier tapées non lues). Dans le cas où il n'y aurait pas de touche dans le tampon, la chaîne retournée est vide.

10 ' Vidage du tampon
20 A$=INKEY$ : IF A$<>"" GOTO 20
30 PRINT "Appuyez sur une touche"
40 A$=INKEY$ : IF A$="" GOTO 40
50 PRINT "Vous avez tapé : "A$

Le BASIC nous propose l'instruction "COLOR" pour gérer les couleurs de nos caractères.

Les couleurs du TO7 ne sont pas les mêmes que celle des autres systèmes (PC par exemple). De ce fait, je vous propose de regarder dans le mémento : couleur TO7, couleur PC, COLOR.