P2E-Thonny-IDE-FR
A propos de Thonny IDE
Thonny est un environnement open-source de développement (IDE) pour débutant en Python supporté sur Linux, Windows, Mac.
Il permet non seulement de programmer en Python sur un Ordinateur mais supporte également les langages Python sur microcontrôleur (MicroPython, CircuitPython et autres dérivés).
Thonny IDE n'est pas le seul environnement permettant de travailler avec des microcontrôleurs sous Python mais il est certainement le plus simple a prendre en main.
Source: Thonny.org
Installer Thonny
Windows, MAC, Linux
Le site de Thonny.org propose les paquets d'installation et instructions nécessaire à l'installation de Thonny IDE.
Sur Raspberry-Pi
Pour disposer de dernières avancées de Thonny sur votre Raspberry-Pi, il suffit d'exécuter la commande suivante dans un terminal:
$ sudo apt update && sudo apt upgrade -y
Sur Linux
Si vous disposez d'un autre système Linux, vous pouvez installer Thonny avec l'utilitaire pip (ou pip3 pour python3).
$ pip3 install thonny
Espace de travail Thonny
Très sobre, l'environnement se résume (de haut en bas):
- une barre de menu,
- une barre d'outil (icône),
- d'un éditeur de texte/code (la partie principale)
- Une interface Shell (tout en bas) permettant de tester rapidement des instructions Python.
Thonny et MicroPython
La barre de statut (en bas de l'écran) affiche la version de l'interpréteur Python utilisé dans Thonny IDE.
En cliquant sur ce libellé, il est possible de sélectionner un autre interpréteur dont "MicroPython (Raspberry Pi Pico)".
Une fois sélectionné, le Thonny établit une connexion avec l'interpréteur en ligne de commande présent sur la carte microcontrôleur.
Si celle-ci échoue, vous pouvez réessayer en pressant le bouton "stop" dans la barre d'outil pour faire une nouvelle tentative de connexion.
L'image-ci dessous montre l'interface shell MicroPython (tel qu'il est exécuté sur le microcontrôleur). Cela vaut autant pour un Raspberry Pico que pour tout autre plateforme utilisant MicroPython (comme le Raspberry-Pi Pico).
Faire clignoter la LED
La plupart des plateformes disposent d'une LED utilisateur. Dans le cas du Pico et du Pico 2, celle-ci est branchée sur le GP25 (GPIO 25).
Le code ci-dessous peut être directement saisi dans le volet "Shell" de Thonny IDE pour contrôler la LED de statut (sur GP25).
from machine import Pin
led = Pin(25, Pin.OUT)
led.value(1) # allume la LED
led.value(0) # éteint la LED
led.value(1)
led.value()
Ce même code que l'on peut identifier dans la capture d'écran-ci-dessous.
A noter:
- appeler la méthode value() sans argument permet d'interroger l'état d'une broche.
- sur un Pico Wireless, il faut utiliser "LED" au lieu de 25.
Exécuter un fichier script
Thonny permet également d'écrire du code Python dans un fichier et de l'exécuter en une seule fois sur la plateforme MicroPython cible.
Dans l'exemple suivant la luminosité de la LED de statut est contrôlée à l'aide d'un signal PWM (valeur entre 0 et 65534 pour un cycle utile de 0 à 100% .
C'est le cas de script suivant:
import time
led = PWM( Pin(25 ))
counter = 0
while True:
print( counter )
counter += 1
for i in range( 0, 100, 5 ):
led.duty_u16( int(65534*i/100) )
time.sleep_ms( 50 )
for i in range( 0, 100, 5 ):
led.duty_u16( int(65534*(100-i)/100) )
time.sleep_ms( 50 )
Script qu'il est possible de sauver dans un fichier, sous le nom "demo.py", soit sur l'ordinateur, soit sur la carte microcontrôleur MicroPython.
Peu importe l'emplacement du fichier (ordinateur ou microcontrôleur), il sera exécuté sur le microcontrôleur dans une session REPL.
Pour exécuter le contenu du fichier il faut (au choix):
- presser le bouton "Start"
dans la barre d'outils, - activer le point de menu "Run | Run current script",
- presser la touche "F5"
En plus de faire pulser la LED de statut sur la carte, l'exécution du script affiche des informations dans le volet shell! Il s'agit des messages produit par la fonction print().
Le script peut être arrêté:
- en pressant le bouton "Stop",
- en pressant la combinaison de touche "Ctrl+C"
Utiliser le Plotter
Courbe simple
Le plotter peut être activé par l'intermédiaire du menu "View | Plotter".
Cette action affiche un outil de représentation graphique dans le volet Shell.
Le Plotter inspecte les informations renvoyées dans session REPL (via la fonction Python print()).
Si une ligne contient une ou plusieurs valeurs numériques alors l'information est renvoyée au Plotter qui ajouter une nouvelle entrée dans le graphique.
Dans l'exemple ci-dessous, nommé demo2.py, la fonction gamma() est utilisée pour pulser la LED de statut du GPIO 25.
La fonction gamma() est utilisée car la progression arithmétique (linéaire) du signal PWM ne produit pas une perception linéaire de la luminosité de la LED (voir livre MicroPython et Pyboard, Edition ENI).
La correction gamma permet de corriger cet inconvénient de non proportionnalité entre la commande et effet perçu.
from machine import Pin, PWM
import time
led = PWM( Pin(25 ))
def gamma( pc ):
return pow(pc/100,2.2)*100
while True:
for i in range( 0, 100, 5 ):
pwm_val = int(gamma(i)*65534/100)
led.duty_u16( pwm_val )
print( pwm_val )
time.sleep_ms( 20 )
for i in range( 0, 100, 5 ):
pwm_val = int(gamma(100-i)*65534/100)
led.duty_u16( pwm_val )
print( pwm_val )
time.sleep_ms( 20 )
Etant donné que le script affiche les valeurs PWM utilisée pour le contrôle PWM, il est possible d'en faire un rendu graphique.
Le graphique montre clairement que la progression n'est plus linéaire.
Courbes multiples
Plotter est capable d'effectuer le rendu de plusieurs courbes en même temps.
Dans l'exemple-ci dessous, le script est modifié pour renvoyer un tuple de données vers la session REPL.
from machine import Pin, PWM
import time
led = PWM( Pin(25 ))
def gamma( pc ):
return pow(pc/100,2.2)*100
while True:
for i in range( 0, 100, 5 ):
pwm = int( i*65534/100 )
pwm_gamma = int(gamma(i)*65534/100)
led.duty_u16( pwm_gamma )
print( (pwm, pwm_gamma) )
time.sleep_ms( 20 )
for i in range( 0, 100, 5 ):
pwm = int((100-i)*65534/100)
pwm_gamma = int(gamma(100-i)*65534/100)
led.duty_u16( pwm_gamma )
print( (pwm, pwm_gamma) )
time.sleep_ms( 20 )
Une fois lancé, le script retourne la valeur PWM et cette même valeur corrigée par la fonction gamma().
Les données sont retournées sous forme d'un tuple (pwm, pwm_gamma) . La première valeur est linéaire tandis que la seconde est corrigée.
Le graphique du Plotter indique, dans le coin inférieur droit, la couleur correspondant à la position de la donnée dans le tuple.
System shell (REPL)
Il est également possible de démarrer une session REPL avec la plateforme MicroPython comme le fait RShell ou MPRemote.
Il s'agit d'un vrai terminal REPL permettant de dialoguer directement avec la plateforme MicroPython sans passer par la couche logiciel intermédiaire de Thonny.
Le menu "Tools | Open System Shell.." ouvre une fenêtre terminal.
Notes
- Thonny doit être connecté sur la plateforme MicroPython pour que cette fonctionnalité fonctionne correctement.
- Le gestionnaire de fichiers permet de savoir facilement si Thonny est connecté ou non sur la carte MicroPython.
- Il n'est pas possible d'ouvrir deux sessions terminal en même temps sur le microcontrôleur MicroPython.
Gestionnaire de fichiers
Il courant d'avoir besoin d'une bibliothèque spécifique sur la carte MicroPython.
Cela nécessite de pouvoir transférer un (ou plusieurs) fichiers sur la carte MicroPython.
Ces bibliothèques sont généralement des scripts python (ex: ce fichier bme280.py) permettant d'utiliser un capteur spécifique (capteur de pression et température I2C BME280).
Cela tombe bien, Thonny dispose d'un outil de transfert de fichiers entre l'ordinateur et la plateforme MicroPython.
Celui-ci est accessible via le menu "View | Files".
Ce qui affiche le gestionnaire de fichiers de Thonny.
- La partie supérieure affiche les fichiers de l'ordinateur.
- La partie inférieure affiche les fichiers de la plateforme MicroPython.
 |
La partie inférieure du gestionnaire de fichiers n'est pas visible si Thonny est dans l'incapacité de dialoguer avec le microcontrôleur MicroPython. |
Pour transférer une fichier de l'ordinateur vers la carte MicroPython, il faut :
- sélectionner un fichier dans le volet "Ordinateur" (computer en anglais).
- activer le menu contextuel (avec un click droit de la souris)
- sélectionner l'option "Téléverser vers" (Upload to en anglais).
A noter: le "/" indiqué dans le menu correspond au répertoire de destination actuellement sélectionner sur le microcontrôleur.
En explorant les différentes options des menus contextuels (côté ordinateur ou côté microcontrôleur), il est assez facile d'identifier les différentes fonctionnalités disponibles.