MicroMod-RP2040 / Pico: utiliser Thonny IDE comme environnement de découverte pour MicroPython

mercredi 12 janvier 2022 , ,

Bonjour à tous,

Si vous utilisez MicroPython sur un ESP32, Raspberry-Pi Pico ou toute carte exploitant le MCU RP2040 (comme le MicroMod-RP2040 de Sparkfun) alors cet article vous intéressera certainement.

Pour une fois, je laisse de côté les outils en ligne de commande pour me concentrer sur un outil Graphique Thonny: un IDE Python pour débutant.
Thonny IDE est un environnement multiplateforme (Linux, Windows, Mac) proposant de nombreuses fonctionnalités d'édition, de débogage et support de multiples version de Python.

Installer Thonny IDE

Il est important d'installer une version récente de Thonny pour pouvoir bénéficier avancées récentes de la plateforme et des greffons.

Le site thonny.org contient les instructions nécessaires pour 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

Sous 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

Thonny : Espace de travail 

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 du code Python.

Thonny & 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)".

Changer d'interpréteur Python

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 un RP2040 (comme le MicroMod-RP2040). 


Faire clignoter la LED

Sur le MicroMod-RP2040 (comme sur le Pico), la LED de statut est branchée sur la broche GP25.

MicroMod-RP2040 de SparkFun et
carrier board Machine Learning

Le code du précédent article pour contrôler la LED de statut (sur GP25) peut être saisi directement dans la section "shell" de Thonny.  

from machine import Pin
led = Pin(25, Pin.OUT)
led.value(1) # allume la LED
led.value(0) # éteint la LED

Code que dont on peut constater l'exécution sur la capture suivante:

Exécution de code REPL directement depuis Thonny

Exécuter un fichier

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 code 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 )

Que l'on sauve dans un fichier sous le nom "demo.py" soit sur l'ordinateur, soit sur la carte microcontrôleur.
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 script il faut presser:

  • le bouton "Start"
     
  • le menu "Run | Run current script" ou
  • presser la touche "F5"

Exécution d'un fichier sur la plateforme MicroPython

L'exécution du script affiche également les messages print() dans la section Shell en plus de faire pulser la LED de statut sur la carte.

Le script peut être arrêté:

  • En pressant le bouton "Stop"
  • En pressant la combinaison de touche "Ctrl+C"

Utiliser le Plotter

Le plotter peut être activé par l'intermédiaire du menu "View |  Plotter".
Cette action affiche un outil graphique dans la section shell.

Activation du Plotter (à droite)

Le Plotter reprend les données numériques affichée dans session REPL. Lorsque la ligne contient exclusivement une valeur numérique, celle-ci est reprise dans le plotter.

Dans l'exemple suivant, nommé demo2.py, utilise une fonction gamma pour faire pulser la LED de statut sur le GPIO. C'est qu'une progression proportionnel du signal PWM ne produit pas une évolution proportionnelle 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é.

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 )

Ce qui produit le résultat suivant dans Thonny. La valeur numérique produite dans la session REPL est également reproduite dans le Plotter.

Visualisation des données PWM (commande de la LED) dans le plotter

Plotter de plusieurs courbes

En modifiant un peu le code du script, il est possible de retourner la valeur PWM sans correction gamma et avec correction gamme. En encodant ces valeurs dans un tuple, le plotter peut alors dessiner plusieurs courbes.

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 )

Ce qui produit le résultat suivant dans Thonny.

Plusieurs courbes dans le Plotter

Le lecteur notera que les données sont retournée sous forme d'un tuple (pwm, pwm_gamma) . Par conséquent, la première valeur est la courbe proportionnelle et la seconde la courbe corrigée. 

Le graphique du Plotter indique, dans son coin inférieur droit, quel est la couleur correspondante à la position de la donnée dans le tuple.

System shell - Pure REPL

Il est également possible de démarrer une session REPL avec la plateforme MicroPython dans un vrai terminal (donc sans passer par le volet "Shell" de Thonny.

Le menu "Tools | Open System Shell.." ouvre une fenêtre terminal.

Session shell autonome dans Thonny

Cela permet, par exemple, d'interagir directement avec le REPL de la plateforme MicroPython sans couche logiciel intermédiaire (celle de Thonny).

Notes:

  • Thonny doit être connecté sur la plateforme MicroPython pour que cette fonctionnalité fonctionne correctement. 
  • Le gestionnaire de fichiers permet de voir 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.

C'est bibliothèques sont généralement des scripts python (ex: ce fichier bme280.py) permettant d'utiliser un capteur spécifique (capteur BME280 de pression et température I2C).

Cela tombe bien, Thonny dispose d'un outil de transfert de fichier entre l'ordinateur et la plateforme MicroPython.
Il est accessible via le menu "View | Files".

Activer le gestionnaire de fichiers

 Ce qui affiche le gestionnaire de fichier.

Détails du gestionnaire de fichiers de Thonny

Pour transférer une fichier de l'ordinateur vers la carte MicroPython, il faut :

  1. sélectionner un fichier dans le volet "Ordinateur" (computer en anglais).
  2. Activer le menu contextuel
  3. 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.

Téléverser le fichier sélectionné sur le microcontrôleur
(dans son répertoire racine)

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.

 

Voici qui termine cette petite découverte de Thonny.
Une très agréable surprise en fin de compte.




Écrire un commentaire

Aucun commentaire

Inscription à : Publier les commentaires ( Atom )