6) Les fonctions de saisie et de modifications d’un programme.

Lorsque l’on met sous tension la machine virtuelle, il n’y a pas de programme présent dans la mémoire dédiée, sauf si l’on a validé l’option « c« . On peut aussi transférer un algorithme présent en EEPROM avec « c » du MENU de BASE. Toutefois, dans la « vie normale » de ce type d’appareil, la routine habituelle consiste à lui soumettre de nouvelles grilles de programme pour en tester l’efficacité. Bref, le plaisir de la programmation dans toute sa splendeur. Pour ce faire il faut disposer d’un ÉDITEUR de PROGRAMME, c’est à dire des fonctions qui :

Lister un programme ou visualiser la feuille perforée.

Préambule à la rédaction complète d’un nouveau programme, il me semble plus judicieux de commencer par l’étude des fonctions de listage et de visualisation de la grille perforée virtuelle. Dans ce but nous allons mettre l’algorithme Utilisateur n°52 à contribution. On commence donc par disposer sur le bureau la mini fiche n°52 ainsi que sa Fiche de PROGRAMME. Cet algorithme construit la suite des puissances de deux sous forme UNAIRE. L’ensemble du carrousel est au préalable forcé à « B » sauf le BIT situé sous la tête de L/E qui est initialisé à « 1« . (Peu importe la finalité de cet exemple, car c’est l’analyse de la structure du listage abordée ci-dessous qui ici présente de l’importance.)

MANIPULATIONS :
1) Étant en MENU de BASE, commande « c » suivie de la valeur 12 pour charger le programme.
2) Commande « l » pour Lister cet algorithme qui consomme dix TRANSITIONS sur les onze possibles.
En 1 on trouve la référence encadrée. Quand on rédige un nouveau programme on peut lui allouer n’importe quelle valeur arbitraire inférieure à 254 et supérieure à zéro. En 2 pour faciliter le repérage, et tout particulièrement quand on désirera modifier le code instruction par instruction, les lignes sont numérotées par ordre croissant de 1 à 33. (Et de 1 à 60 en mode ÉTENDU.)
3) Menu des OPTIONS avec « o » et observez dans la zone 3 coloriée en bleu qu’il y a trois autres fonctions qui seront étudiées plus tard et qui concerne la l’édition de programme. Touche « q« .

Exactement comme sur les feuilles à perforer pour la MATRICE on retrouve des colonnes identiques disposées dans le même ordre. À gauche en 3 les « inscriptions » de repérage des TRANSITIONS avec pour chacune trois lignes relatives aux états ordonnés du haut vers le bas respectivement « 1« , « 0 » et « B« . Puis on trouve les colonnes à perforer. En 4 on peut imposer l’écriture d’un « 1« , d’un « 0 » ou d’un « B« . En 5 on peut ajouter une rotation à Gauche ou à Droite. En 6 une transition est possible, à condition toutefois qu’un F dans la colonne 7 ne soit pas présent, et réciproquement. Dans l’encadré rouge on met en évidence les trois lignes relatives à la TRANSITION n°6. Dans l’encadré bleu une ligne « vide » qui ne comporte aucune instruction. Enfin, par exemple dans l’encadré vert une ligne qui fait écrire un « 1« , tourner à Gauche et « commuter » la came virtuelle sur la transition N°9.

4) Le Listage par « l » est de type opérationnel. La fonction qui va suivre bascule directement dans le « je me fais un petit plaisir« . Frappez « n » étant en MENU de BASE et vous comprendrez visuellement la nature de ce qui s’affiche sur l’écran. On observe une feuille perforée virtuelle assez analogue à celle prévue par le prototype électromécanique, sauf qu’ici les trous sont automatiquement perforés sans avoir à prendre l’emportepièce. Les trous sont en noir. (Ils sont légèrement plus haut que les cercles non perforés, c’est la police de caractère du Moniteur de l’IDE qui impose cette petite imperfection.) Autant la symbolisation de la grille perforée constitue un luxe, autant le nombre de trous est interressant. Quand vous saisissez un algorithme, il est facile de se tromper. Si ce nombre ne correspond pas à celui de la Fiche il faut alors en chercher la raison.
5) Pour ce deuxième exemple nous allons transférer le programme Utilisateur de l’emplacement n°6 … car sa finalité est élémentaire. C’est un défi qui consiste à perforer une feuille de programme et obtenir un « dessin » artistique. En revanche l’algorithme doit fonctionner sur la machine. Il peut librement comporter des instructions « redondantes » et des lignes non utilisées. Il doit en outre avoir une instruction de Fin. Caractère « c » complété par 6. « l » qui ne visualise pas grand chose de spécial, uniquement les instructions d’un algorithme. Par contre, la lettre « n » fait apparaitre instantanément la particularité artistique de ce programme.

La saisie d’un algorithme complet.

Rédiger entièrement un nouvel algorithme sur la machine virtuelle est d’autant plus rapide que nous n’avons jamais besoin de passer en lettres MAJuscules. Il suffit avec rigueur de parcourir ligne à ligne la fiche de programme. Pour aborder les protocole de rédaction et de modifications d’un programme, on va se donner comme objectif de créer un programme qui :
• Part d’un barillet vierge sur lequel tous les pions sont escamotés à « B« .
• La tête de L/E sera dans une position quelquonque ainsi que l’origine.
• Pour simplifier le travail de saisie, on va forcer à « 1 » trois pions avec décalage à Droite.
• Pour chaque pion on utilisera une transition différente réparée de deux autres inutilisées.

Première étape : On prend une table de codage vierge, une gomme, un crayon et on cogite avec intensité. Glups que c’est difficile ! Puis on teste sur la Machine de Turing en papier décrite dans le tutoriel. On teste. Berk, c’est pas bon ! On recommence jusqu’à aboutir au tableau « creux » de la Fig.27 dont la grille ne devra comporter que 9 trous. Pour appréhender les nombreuses facettes de la saisie d’un programme avec analyse syntaxique immédiate, nous allons commettre volontairement quelques petites erreur, nous obligeant à effectuer des corrections. C’est parti, nous décidons de créer notre tout premier programme WOUACHEMENT original. Comme à chaque manipulation qui a pour but d’expérimenter un aspect particulier de l’utilisation de la machine : RESET !

Deuxième étape :
On code avec soin et sans erreur les instructions de la table de codage. Avant de passer aux nombreuses manipulations qui vont suivre, je vous invite fortement à lire l’intégralité des informations sur l’ANALYSEUR SYNTAXIQUE proposé en page 23. Comme je vais vous engager volontairement sur des erreurs déclenchant des alertes, suivez avec rigueur les exercices que je vous propose. Suite à un RESET le MENU de BASE est affiché et la table de la Fig.27 domine notre environnement.

MANIPULATIONS :
1) Touche « e » pour faire appel à l’éditeur de programme et confirmer l’effacement par « o« .
2) Comme référence on donne arbitrairement 123 par exemple.
L’éditeur attend les instructions que l’on désire inscrire suite à la LECTURE d’un État « 1 » alors que la came des TRANSITIONS est sur la position n°1. Chaque fois que l’on validera à vide on passera à la ligne suivante dans la grille de PROGRAMME.
3) Valider deux fois à vide pour « aller » sur Transition 1 Etat B. On va coder correctement cette ligne de programme en proposant la chaîne de caractères 1gt4 sauf qu’au lieu de frapper le 4 sur la touche du pavé numérique, vous utilisez celui du clavier principal et oubliez que MAJ n’est pas activée. La chaîne 1gt’ n’est pas acceptée. On corrige est cette fois on valide la saisie 1gt4.
4) Valider huit fois à vide pour « aller » sur Transition 4 Etat B. On devrait soumettre 1gt7, mais par étourderie on inverse les deux premiers caractères et on propose g1t7. L’analyseur syntaxique y voit une écriture contradictoire. Mais peu importe, la ligne était incorrecte et n’a pas été acceptée. On corrige et on valide la suite 1gt7.

Ici je vous entraine dans des erreurs qui généralement ne se produiront que rarement. En effet, la méthode rigoureuse pour rédiger un long programme consiste à garder un doigt ou déplacer une règle sur la TABLE du programme et à lire la ligne « presque à haute voix ». Dans ces conditions, on arrive à saisir un programme avec trente à quarante lignes sans erreur et en trois ou quatre minutes. Ce n’est que lorsque notre esprit s’égare un peu car un beau papillon vient de passer devant le fenêtre que l’on commet des erreurs d’inversion. Les diverses commandes de l’EDITEUR de PROGRAMME peuvent à tout moment être affichées en frappant la virgule durant la saisie. Le protocole pour revenir sur la ligne à éditer est indiqué dans le chapitre suivant en Fig.30 de la page 24.

5) Valider huit fois à vide pour « aller » sur Transition 7 Etat B. La ligne correcte à écrire serait 1gf. Pour compléter cette expérience on se trompe et on propose 1gt9 en supposant que la grille serait bien plus remplie et que l’on aurait lu la mauvaise ligne. Si l’on s’en tient au protocole de la zone bleue sur la Fig.30 pour quitter la saisie, le caractère « q » devrait être employé. Une autre façon est possible. Il suffit de valider et laisser en répétition. Tester cette façon de sortir.
Cette dernière expérience montre que dès que l’on valide la TRANSITION n°11 pour son dernier l’état « B« , le logiciel sait que l’on a terminé et nous ramène d’autorité dans le MENU de BASE. Comme l’option « f » est active, la sortie de saisie ne nous avertit pas de la non présence de « F« , lors du développement d’un algorithme il serait pertinent d’inverser l’option.
6) Touche « n » : Le nombre de trous est correct. Commande « l » pour Lister ce qui a été retenu par l »éditeur de texte. On réalise que la ligne n°21 pour Tr7-B ne correspond pas à ce qui est dans la TABLE. On va donc la corriger.
7) Frapper « m » pour Modifier le programme. Préciser que c’est la ligne n°21 qui est à reprendre. Proposer 1gt3f comme nouvelle ligne. L’erreur de syntaxe est détectée et la ligne est inchangée comme on peut le vérifier avec « l« . Proposer alors m>21 puis 1fg. OUPS, le bruiteur se déchaine. Décidément il en passe plein plein plein des papillons devant la fenêtre ! Bon, on se concentre et avec m>21 suivi de 1gf on code correctement la dernière ligne. On Liste cette grille qui est presque vide. Une commande « a » pour vérifier que le plateau est entièrement effacé puis « r » pour tester.
>>> CHAMPAGNE, on a écrit et corrigé notre premier algorithme … et il tourne !

Corriger un programme pendant sa saisie.

Autant corriger ligne à ligne comme précisé dans la troisième étape reste un peu indigeste, autant corriger individuellement une ligne dans l’EDITEUR de programme est facile et rapide. Pour tester les procédures « de déplacement » dans le listage, on va prendre comme objectif d’Ecrire le programme de la Fig.29 qui ne fait qu’incrémenter la came des TRANSITIONS, le BARILLET initial étant supposé « vierge », c’est à dire avec uniquement des pions à l’état « B« .
8) Cliquer sur le petit bouton d’initialisation de la carte Arduino NANO pour « repartir à zéro », ou fermer la fenêtre du Moniteur de l’IDE et y revenir. Le BARILLET est dans l’état attendu entièrement à « B« .
9) Touche « e » pour ouvrir l’éditeur. Pour l’effacement on peut au choix répondre « o » ou « n » car de toute façon actuellement la zone réservée à l’algorithme est vierge. Enfin, pour la référence on donne 123 par exemple histoire de ne pas se prendre la tête.
On va saisir les instructions en cascade, mais pour la ligne n°3 par exemple, on va se tromper et oublier de frapper le « t » qui signale que le chiffre qui suit est celui d’une transition. Dans ce qui suit V signifie que vous validez à vide sans indiquer de caractère pour sauter la ligne qui suit sans la modifier.
10) Avant de soumettre des lignes de codage, saisir « ? » ou mieux « , » pour avoir le rappel des commandes possibles. Cette directive est disponible à tout moment.
13) Touche standard « , » pour avoir l’aide qui s’affiche comme sur la Fig.30 sauf que vous observez que cette fois l’index n’a pas changé de ligne, et vous pourriez l’éditer directement sans avoir comme dans l’encadré rouge à corriger avec la consigne « < » qui fait revenir en arrière d’une ligne.
14) Proposer des « < » jusqu’à revenir sur la ligne n°3 à corriger. Puis « t2 » comme prévu.
15) Sur le clavier de l’ordinateur maintenir « V » en répétition jusqu’à revenir sur la ligne n°15, moyen facile et rapide de « descendre  » dans le listage. Mais vous dépassez jusqu’en ligne n°17.
16) Pas de problème, deux fois la consigne « < » suivi de « f » et enfin de « q » pour sortir.
17) Commande « l » pour Lister le programme et vérifier sa cohérence.
18) Enfin, touche « r » pour constater le fonctionnement correct de cet algorithme fabuleux.
                                                                      CHAMPAGNE !

Troisième étape :
Compléter, modifier un programme qui commence à fonctionner. Les manipulations qui vont suivre ne sont rentables que si le nombre de lignes à modifier reste faible ou en option Machine ETENDUE. S’il est important, il peut s’avérer bien plus rapide de tout réécrire depuis le début avec l’éditeur au lieu de corriger laborieusement ligne à ligne. Pour tester ce genre de manipulations on va rajouter deux sauts, séparés par une seule transition. Notre objectif : De la transition n°5 on sautera à la n°7, et de la n°7 on sautera à la n°9 avec à chaque instruction l’écriture d’un « 1 » et rotation à gauche.

MANIPULATIONS :
1) Frapper « m » pour Modifier le programme. Préciser que c’est la ligne 15 qui est à reprendre. Proposer alors la séquence 1gt7 comme nouvelle instruction.
2) Commande « m » et indiquer la ligne n°21. Saisir la chaîne 1gt9.
3) Enfin « m » et désigner la ligne n°27. Saisir le groupe 1gf. Sans que ce soit spécifiquement désagréable, s’il faut corriger 20 lignes ou plus, autant tout réécrire à partir de zéro.
4) Comme on a changé d’idée, on désire de plus modifier la référence de cet algorithme. Il suffit de faire appel à « x » et d’indiquer 100 par exemple. « l » pour vérifier notre travail.
5) La frappe de « r » confirme le fonctionnement correct. (CHAMPAGNE !)
6) Il se fait tard et vous désirez continuer à modifier ce programme demain ou en fin de la semaine prochaine. Caractère « s » pour sauvegarder. Proposer 10 pour l’emplacement qui actuellement est libre. Le listage de type « U » nous confirme que maintenant cet emplacement contient la grille référencée avec le n°100.

Quatrième étape :
Chaque fois que l’on doit adopter une « tradition » logique, se pose le problème d’avoir à sélectionner la norme la plus évidente. Hors, la logique des uns peut correspondre à une vision opposée des autres. Cette antinomie dans les façons de raisonner engendre un rationnel qui ne dépend au final que de la façon très personnelle dont on construit notre pensée.
– Hé, Nulentout, t’as été faire un séjour dans une secte ? Je pige rien du tout à ton baratin.
РTu as raison cher Dudule, je vais ̩courter ma philosophie p̩remptoire de comptoir et utiliser un verbiage plus simple.
Dans l’idée purement théorique de Machine imaginé par Turing, la bande de papier est de longueur infinie, concept qui ne pose strictement aucun problème en mathématiques, le symbole    lui est du reste réservé. Ce n’est envisageable que dans l’immatériel, car dans la pratique elle aurait une masse infinie, serait pratiquement impossible à faire bouger et courberait l’espace temps comme le prédit sans contestation possible la théorie de la relativité annoncée par un certain Einstein.
– Encore, mais il va pas bien du tout le Nulentout aujourd’hui !
– OK, je me calme.
Vraisemblablement, on peut imaginer qu’Alan aurait privilégié de déplacer la Tête de L/E dont la masse serait considérablement plus faible. C’est cette vision des choses que l’on retrouve sur un grand nombre d’exemples qui sont proposés sur Internet et dont je me suis inspiré. Hors sur de nombreuses machines mécaniques, les concepteurs préfèrent de loin avoir une tête de L/E immobile et déplacer « la bande de papier ». C’est exactement ce que fait le prototype électromécanique, sauf que la bande de papier est refermée sur elle même et tourne au lieu de se translater.
Du coup, pour « perforer notre grille virtuelle », on doit mentalement changer les G en D et les D en G avec une probabilité de risque d’erreur qui tend vers « beaucoup » par valeur définitive. Aussi, je vous suggère fortement de procéder en deux étapes. La première consiste à saisir l’algorithme comme vous le trouvez sur la toile. Puis « ligne à ligne » on effectue l’inversion. Et comme cette modification en manuel est totalement irrationnelle, le programme de la carte Arduino NANO intègre une fonction qui va effectuer automatiquement ce travail à notre place.

MANIPULATIONS :
1) Frapper une fois de plus la touche « o » pour revenir dans le menu des OPTIONS.
2) Commande « o » pour invoquer cet outil, et confirmer avec « o« .
3) Touche « q » pour revenir au MENU de BASE suivie de « l » pour Lister le programme.
On observe qu’effectivement les trois G initiaux sont bien remplacés par des D.
4) Déclencher une exécution avec « r« , cette fois les « 1 » sont écrits « de l’autre coté ».

Un standard personnel.

D’une façon générale, chaque fois qu’un programme fonctionne et qu’il reste au moins une transition disponible, j’ajoute en tête de grille une transition pour pouvoir placer les données à droite de la Tête de L/E et ainsi trouver les pions initiaux bien en vue quand on déclenche l’exécution. Comme exemple typique on va reprendre l’algorithme de la Fig.27 donné en page 21, mais en partant d’un BARILLET avec des « 0 » pour avoir une donnée visuelle à dégager sur la machine.

MANIPULATIONS :
1) Pour recommencer sur une configuration globale propre, RESET sur la carte Arduino.
2) Touche « e » pour invoquer l’EDITEUR de PROGRAMME puis « o » suivi de « 123« .
3) Dans l’ordre saisir « V 1gt4 » puis avec des « V » aller sur la ligne n°11.
4) Saisir la suite « 1gt7 » puis avec des « V » aller sur la ligne n°20.
5) Terminer par « 1gf » puis sortie avec « q » pour revenir au MENU de BASE.
6) On va Initialiser le BARILLET avec « i » suivi de « o » et trois fois 30.
7) Pour les données on propose « 000« , la Fig.31 traduisant le résultat obtenu. (Attention : Trois fois zéro.)
8) Un petit RUN avec « r » pour vérifier que le programme fonctionne.
On décide maintenant de positionner la tête de L/E à gauche des données, le programme doit alors faire tourner le plateau de la machine jusqu’à trouver un « 0 ». Dans ce but il faut décaler tout le programme d’une transition vers « le bas » pour pouvoir sur la transition n°1 installer les instructions de déplacement de la tête. Le problème, c’est que toutes les instructions de type Trn doivent être incrémentées. C’est tellement rébarbatif à faire que le logiciel de la carte Arduino NANO prévoit une fonction pour réaliser cette transposition de façon automatique.
Considérons la Fig.32 qui résume le travail que doit accomplir cette option à notre place. En première action, elle doit déplacer l’ensemble de la « grille de trous » d’une transition vers le bas, à condition toutefois qu’il reste au moins trois lignes de disponibles dans Tr11 ou Tr20 si le mode ETENDU est actif. Cette première étape est coloriée en vert pastel sur la Fig.32 montrant le « haut » du listage. Puis, la transition Tr1 est remplacée automatiquement par le code du cadre colorié en rouge. Comme le logiciel ne peut pas savoir si le pion de gauche de la donnée sera un « 1 » ou un « 0« , arbitrairement le logiciel de la carte Arduino NANO privilégie le « 1« , et il sera à la charge de l’opérateur de corriger l’algorithme si nécessaire. La Fig.32 est en réalité un « montage » pour visualiser ce que donnerait la fonction « m » si la troisième étape n’avait pas été prévues. Les instructions mises en évidence en bleu programmées dans l’original pointeraient une transition pas assez loin. La dernière étape que doit réaliser le logiciel consiste alors à incrémenter toutes les instructions Trn sauf la première naturellement.

MANIPULATIONS (Suite) :
9) Directive « o » pour aller dans le Menu des OPTIONS.
10) Option « m« , confirmée par « o« . Touche « q » pour revenir au MENU de BASE.
11) Caractère « l » pour Lister le programme et constater qu’effectivement les transitions concernées ont correctement été incrémentées conduisant à un programme cohérent dont l’algorithme est identique à celui de l’original, avec la première transition ajoutée au tout début.

11) Touche « m« , indiquer 1 pour la ligne et valider à vide. Le logiciel nous prévient que maintenant cette ligne est vide, donc effacée. Ce n’est qu’un avertissement pour inciter le programmeur à vérifier ce qu’il a fait. Du reste cliquer sur « l » pour vérifier que la ligne n°1 est bien effacée.
12) Commande « m« , indiquer 2 pour la ligne à compléter et proposer « t2« . Lister pour vérifier la cohérence du programme. Il nous reste à déplacer la tête de L/E à gauche des données pour s’assurer que le programme continue de fonctionner correctement indépendamment de cette position :
13) Frapper « = » puis 25 par exemple.

14) Imposer « o« , puis « a » et confirmer avec « o » pour annuler toutes les options du RUN.
15) Caractère « p » pour activer le mode PAS à PAS et « l » pour annuler le Listage.
16) Ne pas oublier « v » pour visualiser le plateau virtuel de la machine.
17) Indiquer « q » pour revenir au MENU de BASE.
18) Enfin « r » pour déclencher les hostilités.
19) Valider à vide plusieurs fois pour voir le plateau tourner dans un premier temps, puis les rotations assorties des écritures des « 1 » qui remplacent les « 0 » conformément à ce que prévoir l’algorithme.

20) RESET, « c » suivi de 1 pour charger le programme n°1 en mémoire dédiée.
21) Imposer « o« , puis « e » et accepter le mode Machine ETENDUE. Comme le programme qui était en mémoire n’a pas la référence 254, le logiciel nous prévient qu’il a été transformé.
22) Touche « q« , puis dans le MENU de BASE frapper « l » pour voir ce que ça donne. Le listage est devenu plus long, les instructions ont été conservées, et la référence a été changée en 254.
23) « o » pour revenir dans les options. Puis « m » et « o » deux fois suivi de « q » et de « l« . On constate que l’on peut « translater » plusieurs fois le programme, car la fonction « m » des options n’analyse pas l’algorithme qui peut être absolument quelconque. Elle ne fait qu’ajouter une transition « spéciale typique » au tout début et incrémenter tous les Trn.
24) Touche « m » et préciser 60 puis « f » pour « consommer » la dernière transition. « l » pour vérifier.
25) Réitérer « o » puis « m » pour tenter une nouvelle Modification « conventionnelle ».
26) Caractère « o » pour accepter. Comme il ne reste plus une transition de disponible en fin de listage, le logiciel prévient l’opérateur par un BIP sonore et le texte « Place insuffisante.« .
Nous avons passé en revue de détails tous les menus disponibles sur cette petite unité informatique si discrète dans le tiroir de rangement. Du moins j’espère n’avoir rien oublié. De toute façon, pratiquement l’intégralité du comportement logiciel est résumé dans les très nombreux affichages de l’écran vidéo. Pour clore cette formation on va « faire tourner l’HORLOGE système ».

La suite est ici.