Module Python externe pour TI-Nspire

→ **MyCalcs** profile · by **Noury** » 02 Apr 2019, 11:38

Nous avons récemment utilisé une Nspire avec un esp8266 pour communiquer avec un serveur.
Comme c'est un peu la "mode" des modules externes Python, nous allons aujourd'hui nous en fabriquer un pour la TI-Nspire.
Il est vrai que MicroPython a été porté sur la Nspire, mais là nous allons l'installer sur un esp8266, et nous fabriquer un module Python externe pour 1,50€.

Nous allons avoir besoin de:
- un ordi (Linux, Windows ou Mac) équipé de Python
- un esp8266-01 (le plus petit, et le moins cher)
- un MicroPython pour esp8266 (à télécharger)
- un programme de flashage pour installer le MicroPython sur l'esp8288
- un adaptateur série FDTI USB vers TTL pouvant fonctionner en 3,3v
- un logiciel console série pour permettre une communication entre l'ordi et le module
- une TI-Nspire

Dans un premier temps nous allons utiliser un ordi juste pour préparer notre module.
Nous allons, comme pour le post précédent, utiliser un esp8266-01 qui est je le répète, le plus petit, et le moins cher de la famille.
Il n'a qu'un Mo de mémoire. Ceux qui en veulent en avoir plus pourront utiliser un esp8266-12e ou un esp8266-12f. Mais 1Mo devrait suffire pour notre besoin.

Commençons par le câblage. Il sera le suivant:

Mais pour programmer le module, nous devrons relier la broche GPIO 0 à la masse. Et ce durant l'upload du MicroPython sur le module uniquement. Le reste du temps, ce fil sera enlevé.

Le module sera alimenté par la calculatrice.

Récupérons le MicroPython.
Il faut aller sur la page http://micropython.org/download#esp8266
Nous allons prendre le dernier stable disponible. Au moment de l'écriture de cet article, il s'agit du fichier esp8266-20190125-v1.10.bin.

Pour l'installer sur le module, il nous faudra utiliser l'outil esptool
Pour le récupérer nous allons taper la commande suivante, car c'est un module python:
pip install esptool (à adapter en fonction de votre OS)

Nous allons ensuite effacer le contenu du module:
esptool.py --port le_bon_port erase_flash

Il faut remplacer "le_bon_port" par le port que vous utilisez
pour le connaître:
sur Mac: ls -ltr /dev/cu.* puis prendre le dernier de la liste ayant la date et l'heure du moment
sur Linux: ls -ltr /dev (il devrat s'appeler /dev/ttyUSB0 ou quelque chose de ce genre)
Pour Windows, je suis désolé, je ne connais pas bien cet OS.

Nous allons maintenant installer MicroPython sur le module:

esptool.py --port le_bon_port write_flash --flash_size=detect 0 esp8266-20190125-v1.10.bin
il faudra être dans le bon répertoire, et éventuellement indiquer le chemin du binaire téléchargé à installer.
Attendre que le flashage soit terminé.

Il faut ensuite mettre hors tension le module, et enlever le fil reliant GPIO 0 à la masse.

Test de la communication

relier le module à l'ordi via l'usb, lancer la console série de votre choix en 115200 8N1, mettez le module sous tension. Si tout va bien, le prompt Python devrait apparaître.
la console série doit être configurée pour envoyer CR et LF à la fin de chaque commande (Carriage et Linefeed)

Nous pouvons faire quelques essais

>>> print ('coucou')
coucou
>>>

>>> 10+5
15
>>>

Utilisation du Python à distance via le wifi

À ce stade, le module est configuré en mode serveur.
Nous allons voir qu'il est possible d'utiliser Python autrement que via le port série.
Nous allons l'utiliser à distance depuis un ordi via le wifi.

Il faut savoir que par défaut, le module a un serveur qui écoute sur le port 8266

Le module a par ailleurs l'dresse ip 192.168.4.1.
Il reste juste à activer ce serveur.
Pour ça, il faut taper:
>>> import webrepl_setup
puis suivre les instructions pour ajouter un mot de passe.
À la fin de ces manips, il faut accepter un reboot du module.

C'est fait, le serveur est activé et écoute.

Nous allons utiliser un navigateur (Chrome ou Firefox seulement) pour faire du Python à distance.

Il faut récupérer par git clone https://github.com/micropython/webrepl
Ou encore récupérer le fichier https://github.com/micropython/webrepl/ ... master.zip, puis le dézipper.
Il ne reste plus qu'à:
1 - se connecter au point d'accès MicroPython-XXXXXX (XXXXXX étant une partie de l'adresse MAC du module)
le mot de passe par défaut est "micropythoN" (N majuscule)
2 - ouvrir un navigateur, et aller en local sur l'adresse du fichier webrepl.html situé dans le répertoire issu du "dézippage"
3 - cliquer sur le bouton connect
4 - taper le mot de passe choisi précédemment

C'est bon, on peut faire du Python à distance.
C'est plus fort que le module proposé pour la TI-83 PCE!

Lecture et écriture de fichiers:
Le module possède un système de fichiers.
Il est de taille limitée, mais il est tout de même possible de créer des répertoires, des fichiers, puis de relire ces fichiers.

Exemple:

Création d'un fichier:

>>> f = open('mon_fichier.txt', 'w')
>>> f.write('ligne 1\n')
8
>>> f.write('ligne 2\n')
8
>>> f.write('ligne 3 et fin\n')
15
>>> f.close()

Contenu du répertoire:

>>> os.listdir()
['boot.py', 'webrepl_cfg.py', 'mon_fichier.txt']
>>>

Lecture du fichier mon_fichier.txt créé précédemment:

>>> f = open('mon_fichier.txt')
>>> f.read()
'ligne 1\nligne 2\nligne 3 et fin\n'
>>> f.close()
>>>

Il est également possible d'envoyer ou de récupérer des fichiers.

Beaucoup d'autres choses sont possibles. Pour aller plus loin, une excellente documentation est disponible ici http://docs.micropython.org/en/v1.9.4/e ... index.html

Nous allons maintenant utiliser MicroPython depuis la Nspire.

Là, il va falloir beaucoup de modestie!
Il faut voir cette application comme une version beta, si ce n'est alpha.

J'ai eu à choisir entre deux méthodes:
1 - le REPL standard ou interactif
Dans ce mode les touches tapées sont envoyées au device au fur et à mesure, de manière transparentes. Rien n'est affiché. Pour les retours, on affiche tout. C'est donc l'écho qui fait voir ce qui a été tapé.
On a également les réponses du modules (prompt, résultats et erreurs)
De plus, on peut bénéficier de l'éditeur intégré au Python.
J'ai toutefois rencontré des difficultés technique pour mettre en œuvre ce mode. Il aurait fallu avoir deux threads, un pour la lecture des caractères et l'envoi au module, un pour la lecture de l'UART et l'affichage sur l'écran.
Ndless n'est pas multithread. J'ai essayé avec les "tasks", mais il n'y a quasiment pas de doc.
C'est le mode que j'aurais souhaité utiliser. Mais je ne désarme pas.

2 - le raw REPL
C'est un mode qu'on peut qualifier de "batch" ou "script"
Tout ce qui est saisi est "bufferisé" et envoyé en une fois à l'esp8266.
Une fois que c'est fait, on lit les résultats jusqu'à la fin.
J'ai choisi ce mode dans l'immédiat. Je pourrai revenir sur ce choix plus tard après avoir trouvé comment utiliser les "tasks" de manière correcte.
C'est moins "interactif"
De plus, il n'y a pas possibilité d'éditer ce qui a été tapé.
Pour valider l'envoi au MicroPython, il faut appuyer sur la touche "entrée" une fois de plus.

Il faut bien garder en tête ce mode "batch".
Par exemple, taper
i=2*3
puis
i
n'affichera rien.

Pour afficher un résultat, il faudra taper:
i=2*3
print (i)

le "i" de la commande précédente, n'a de sens qu'en mode interactif.

Pour quitter, il faut taper "exit" en début de ligne à n'importe quel moment. Même en cours de saisie d'un script.

C'est un premier jet. Des améliorations seront possibles.
En particulier, la possibilité de gérer des "tasks" ou "threads" permettra d'avoir un véritable éditeur interactif.

Je reste à l'écoute des remarques et critiques, surtout que c'est loin d'être abouti.

Voici également quelques combinaisons de touches bien utiles:

Code: Select all: +---+-------------+ | : | shift . | +---+-------------+ | < | shift - | +---+-------------+ | > | shift + | +---+-------------+ | _ | ctrl - | +---+-------------+ | & | EE | +---+-------------+ | % | shift EE | +---+-------------+ | ; | shift , | +---+-------------+ | " | shift * | +---+-------------+ | \ | shift / | +---+-------------+ | | | shift = | +---+-------------+ | [ | shift ( | +---+-------------+ | ] | ctrl ( | +---+-------------+ | @ | ctrl EE | +---+-------------+ | ~ | shift enter | +---+-------------+ | ' | | <- pas trouvé, je suis preneur (quote simple) +---+-------------+

Une petite vue du résultat:

Dans la pratique, il n'y a pas autant de fils. Là, c'est parce que j'avais branché un analyseur logique.

→ **MyCalcs** profile · by **STaa** » 27 Apr 2019, 23:07

Très beau projet, je suis fan ! Est-ce que tu pourrais envoyer le code source sur github ou quelque chose de similaire? Et pourquoi s’embêter à utiliser le repl? Il ne serait pas possible de faire un genre de « console série » directement reliée à l’esp8266 ?

→ **MyCalcs** profile · by **Noury** » 27 Apr 2019, 23:22

Salut,

Merci.
Si c'est pour toi, le code est dans le zip joint au post.
Je n'ai pas jugé utile de le publier sur github, car insuffisant.

Pourquoi m'être embêté avec repl, et pas avoir utilisé la console ?
Parce que je n'y suis pas parvenu.
J'ai voulu écrire une app avec deux threads. Un qui se chargerait de lire le clavier uniquement, et d'envoyer les caractères à l'uart. Le second devait lui lire les retours uart, donc la sortie du MicroPython.
Pour être plus précis, les affichages ne devait être que ceux des retours.
On aurait alors eu une app quasi parfaite.
Mais Ndless ne sait pas gérer les threads.
J'ai essayé de me rabattre sur les tasks (notion similaire), mais ça n'a pas fonctionné. Le programme sous Ndless est ininterruptible.
J'ai demandé conseil à Vogtinator et à Levak, mais ni l'un, ni l'autre n'ont pu me répondre.
Voilà pourquoi j'ai finalement adopté la méthode REPL.
Mais je n'en suis pas satisfait, car elle a un gros défaut. Si des traitements mettent un certains temps à s'exécuter, on rate des résultats. Avec les threads, on avait une solution idéale. Dans ce cas, la Nspire aurait été une pure console.

→ **MyCalcs** profile · by **STaa** » 27 Apr 2019, 23:31

Je vois, merci beaucoup pour ces précisions. Comment as-tu découvert l’existence des tasks au fait? J’ai rien trouvé de mentionné dans les exemples du sdk (et hackspire est down)