Editions ENI Livres | Vidéos | e-Formations
MicroPython
Présentation
Même s’il existe quelques différences de syntaxe entre le langage Arduino (proche du langage C) et le MicroPython, il est assez facile de passer de l’un à l’autre.
En effet, les langages de programmation utilisent tous les mêmes principes. Vous retrouverez donc les variables, les conditions, les boucles, les fonctions, les bibliothèques, etc.
Cependant, avec le langage Arduino, le code source est compilé par l’ordinateur avant d’être téléversé sous forme de langage machine, tandis qu’en MicroPython, vous transférez (ou modifiez) directement le code source (sous forme de texte) dans l’Arduino, qui se charge ensuite de l’interpréter en temps réel.
Le MicroPython est moins performant que le C, mais il est parfait pour apprendre la programmation. L’utilisateur peut tester, modifier ou déboguer son code très facilement.
Un langage interprété nécessite un microcontrôleur plus puissant qu’un langage compilé (pour traduire à la volée le code source en langage machine). Le MicroPython est donc réservé aux microcontrôleurs récents. Pour cette raison les cartes compatibles fonctionnent toutes sous 3,3 V (au lieu de 5 V qui est l’ancien standard).
La fondation Arduino a beaucoup trop tardé avant de se rendre compte du potentiel du langage MicroPython (dommage que l’Arduino Uno R4 ne soit pas compatible).
Pour l’instant, seuls les Arduino NANO ESP32, Arduino NANO RP2040 CONNECT, Arduino NANO 33 BLE SENSE, Arduino GIGA R1 et quelques autres de la gamme pro peuvent utiliser le MicroPython, alors qu’il existe de nombreuses alternatives, souvent...
Blink
Une fois connecté, il est possible de communiquer avec l’Arduino en entrant directement les commandes dans la console (appelée aussi terminal ou REPL).
Pour commencer, tapez la ligne suivante pour importer dans l’Arduino la fonction Pin. Elle permet de contrôler les entrées/sorties de l’Arduino.
from machine import Pin Allumez la LED interne en envoyant la valeur 1 au GPIO 48 (déclaré comme une sortie).
Pin(48, Pin.OUT).value(1) Éteignez la LED en envoyant la valeur 0.
Pin(48, Pin.OUT).value(0) 
La console MicroPython
Vous pouvez répéter l’opération aussi longtemps que vous le souhaitez mais il serait certainement plus pratique d’utiliser un script pour automatiser le clignotement de la LED.
Pour cela, ouvrez le gestionnaire de fichiers en cliquant sur l’icône en haut à droite qui représente des fichiers empilés (File Manager), puis cliquez sur le fichier doté d’un signe + et créez un nouveau fichier nommé main.py (s’il n’est pas déjà créé).
Création du fichier main.py
Ouvrez le fichier main.py, il contiendra le programme.
Pour commencer, il est nécessaire d’importer les fonctions utilisées dans le programme. Pour marquer une pause dans le clignotement, nous aurons besoin de la fonction sleep du module time et bien...
LED RGB
L’Arduino Nano ESP possède aussi une LED RGB à anode commune (connectée aux GPIO 46, GPIO 0, GPIO 45 et à la borne 3,3 V). À cause de ce branchement, les LED s’allument quand les GPIO sont à 0 (GND) et s’éteignent quand ils sont à 1 (3,3 V).
LED RGB de l’Arduino Nano ESP
Voici un exemple de programme (inspiré de Blink) qui allume alternativement les LED rouge, verte et bleue.
# LED RGB numérique
# Importation des fonctions Pin et sleep
from machine import Pin
from time import sleep
# Création des objets led_rouge, led_verte, led_bleue
led_rouge = Pin(46, Pin.OUT)
led_verte = Pin(0, Pin.OUT)
led_bleue = Pin(45, Pin.OUT)
# Boucle infinie
while True:
# Allume la LED rouge
led_rouge.value(0)
# Pause d'une seconde
sleep(1)
# Éteint la LED rouge
led_rouge.value(1)
# Allume la LED verte
led_verte.value(0)
# Pause d'une seconde
sleep(1)
# Éteint la LED verte
led_verte.value(1)
# Allume la LED bleue
led_bleue.value(0)
# Pause d'une seconde
sleep(1)
# Éteint la LED bleue
led_bleue.value(1) Bien sûr, vous pouvez créer de nouvelles couleurs en mélangeant les trois couleurs de base, mais en numérique, les possibilités sont quand même très limitées.
Pour utiliser les sorties analogiques de l’Arduino, importez la fonction PWM du module machine (en plus de la fonction Pin).
from machine import Pin, PWM Créez les objets PWM.
led_rougePWM = PWM(Pin(46)) ...LED externe
Connectez une LED (avec une résistance de 1KΩ) à l’une des entrées/sorties de l’Arduino Nano ESP. Dans cet exemple, il s’agit de la borne D12, qui correspond au GPIO 47. Rien ne vous empêche d’en choisir une autre (à condition, bien sûr, d’adapter le code).
Branchement de la LED au GPIO 47
C’est le même principe qu’avec les LED internes : vous pouvez faire clignoter la LED en mode numérique (0 ou 1).
# LED Externe
# Importation des fonctions Pin et sleep
from machine import Pin
from time import sleep
# Création de l'objet led
led = Pin(47, Pin.OUT)
# Boucle infinie
while True:
# Allume la LED
led.on() # ou led.value(1)
# Pause d'une seconde
sleep(1)
# Éteint la LED
led.off() # ou led.value(0)
# Pause d'une seconde
sleep(1) Vous pouvez également faire varier sa luminosité en mode analogique (0 à 1 023 en 10 bits).
# LED externe boucle 10 bits
from machine import Pin, PWM
from time import sleep_ms
# Création de l'objet led_PWM
led_PWM = PWM(Pin(47))
# Boucle infinie
while True:
for lum in range(1023, -1, -1):
led_PWM.duty(lum)
sleep_ms(1)
for...Bouton-poussoir
à la borne D12 (GPIO 47) et le bouton-poussoir à la
borne D4 (GPIO 7). Mais comme d’habitude, rien ne vous empêche
de choisir d’autres entrée/sortie (à condition
bien sûr, d’adapter le code).
Branchement de la LED et du bouton-poussoir
Pour utiliser l’entrée numérique de l’Arduino, importez la fonction Pin du module machine.
from machine import Pin Créez un objet qui regroupe les références du bouton (en activant la résistance de pull-up interne de l’Arduino).
# Création de l'objet bouton (en mode pull-up)
bouton = Pin(7, Pin.IN, Pin.PULL_UP) La fonction value permet de connaître l’état du bouton. Avec ce branchement, le bouton renvoie la valeur numérique 1 au repos et 0 quand il est appuyé. Vous pouvez stocker cette valeur dans une variable ou l’utiliser directement dans une condition.
# Lecture et récupération de l'état du bouton etatBouton = bouton.value() 
Le bouton allume la LED
Voici un exemple de programme qui allume la LED quand on appuie sur le bouton.
# LED et bouton
# Importation des fonctions Pin et sleep
from machine import Pin
from time import sleep
# Création des objets led et bouton (pull-up)
led = Pin(47, Pin.OUT) ...Potentiomètre
à la
borne D12 (GPIO 47) et le potentiomètre à la borne
D7 (GPIO 10). Évidemment, vous pouvez utiliser d’autres
entrée/sortie en adaptant le programme).
Branchement de la LED et du potentiomètre
Pour utiliser une entrée de l’Arduino en mode analogique, nous aurons besoin des fonctions Pin et ADC du module machine.
from machine import Pin, ADC Créez ensuite un objet qui regroupe les références du potentiomètre (donnez-lui le nom que vous voulez).
potentiometre = ADC(Pin(10)) La valeur récupérée par la fonction read_u16 possède une résolution de 16 bits (entre 0 et 65 535). Vous pouvez la stocker dans une variable ou l’utiliser directement dans une condition.
valeurPotentiometre = potentiometre.read_u16() Dans cet exemple de code, le potentiomètre permet de modifier la luminosité de la LED, également en 16 bits. La valeur mesurée est affichée sur la console.
# LED et potentiomètre
# Importation des fonctions
from machine import Pin, PWM, ADC
from time import sleep
# Création des objets led_PWM et potentiomètre
led_PWM = PWM(Pin(47))
potentiometre = ADC(Pin(10))
# Boucle infinie
while True:
# Valeur du potentiomètre...Buzzer
Les sorties analogiques permettent aussi de jouer de la musique. Branchez un buzzer (passif) entre la borne D3 (GPIO 6) et la masse (GND). Il est possible d’utiliser une autre sortie mais dans ce cas, il faudra adapter le programme.
Branchement du buzzer
Pour générer une note, la membrane du buzzer doit vibrer à une certaine fréquence. Nous devons donc modifier la fréquence de la sortie analogique (qui, par défaut, est de 1 000) en fonction de la note à jouer. Par exemple, pour jouer la note La (de la troisième octave), le buzzer doit vibrer 440 fois par seconde.
N’oubliez pas ensuite de couper la sortie PWM, sinon la note sera jouée en continu.
# Buzzer note La
# Importation des fonctions
from machine import Pin, PWM
from time import sleep
# Création de l'objet buzzer
buzzer = PWM(Pin(6))
# Activation de la sortie PWM
buzzer.duty_u16(1000)
# Modification de la fréquence
buzzer.freq(440)
# Durée de la note
sleep(1)
# Désactivation de la sortie PWM
buzzer.duty_u16(0) Bien sûr, pour jouer un morceau de musique, il est plus simple de créer une fonction et d’indiquer dans ses paramètres la fréquence et la durée de la note.
# Buzzer Marseillaise
# Importation des fonctions
from machine import Pin, PWM
from time...LED adressables (Neopixel)
Pour contrôler un anneau ou une bande de LED adressables, reliez (par exemple) l’entrée IN à la sortie A3 (GPIO 10) de l’Arduino.
Si vous n’avez qu’une dizaine de LED, vous pouvez utiliser l’alimentation de l’Arduino (3,3 V et GND). Au-delà, il est conseillé d’ajouter une alimentation externe ou de réduire la luminosité.
Branchement d’un module Neopixel
Nous aurons besoin des fonctions Pin du module machine et NeoPixel du module Neopixel.
from machine import Pin
from neopixel import NeoPixel Créez ensuite un objet qui regroupe les références du module (numéro de GPIO et nombre de LED adressables).
# Création de l'objet ledNeopixels
nombre_de_LED = 12
ledNeopixels = NeoPixel(Pin(4, Pin.OUT), nombre_de_LED) Les LED sont numérotées de 0 à n-1. Pour définir la couleur d’une LED, il est nécessaire d’indiquer son numéro et la proportion de rouge, de vert et de bleu (entre 0 et 255). Vous pouvez bien sûr composer de nombreuses couleurs différentes en mélangeant les trois couleurs de base.
# 1
re
LED en rouge
ledNeopixels[0] = (255, 0, 0)
# 2
e
LED en vert
ledNeopixels[1] = (0, 255, 0)
# 3
e
LED en bleu
ledNeopixels[1]...Afficheur LCD Grove
1. Installation d’un module (bibliothèque)
Pour l’instant, nous avons seulement utilisé les fonctions MicroPython de base (installées par défaut avec le langage). Mais suivant votre matériel, vous aurez peut-être besoin d’installer de nouveaux modules.
En MicroPython, on parle plutôt de modules que de bibliothèques.
Pour cela, vous pouvez télécharger et lancer le MicroPython Package Installer que vous trouverez à l’adresse suivante : https://github.com/arduino/lab-micropython-package-installer/releases
Branchez l’Arduino et cliquez sur le bouton RELOAD s’il n’est pas détecté. Entrez les éléments caractéristiques matériels dans la barre de recherche (par exemple « lcd » pour l’afficheur LCD). N’hésitez pas à cliquer sur More info pour avoir plus de détails sur le module. Pour l’afficheur Grove LCD, vous pouvez choisir le module « micropython-i2c-lcd by Ubi de Feo », mais il est possible que d’autres conviennent aussi.
Cliquez ensuite sur le bouton INSTALL pour copier les fichiers dans le répertoire lib (libraries) de l’Arduino.
Installation d’un module (bibliothèque) MicroPython
Vous pouvez aussi télécharger votre module et le copier vous-même dans le répertoire lib avec le gestionnaire de fichiers Arduino...
Capteurs de température et d’humidité DHT
Il est possible d’utiliser les mêmes capteurs qu’avec le langage Arduino. Pour cela, il suffit d’installer les modules MicroPython correspondants. Dans cet exemple, il s’agit d’un capteur DHT 11 ou 22, mais bien sûr si vous possédez un autre modèle, le principe est exactement le même.
Connectez l’Arduino à l’ordinateur, lancez le logiciel MicroPython-Package-Installer, tapez « dth » dans la barre de recherche, choisissez la bibliothèque dht by MicroPython et cliquez sur Install.
Installation de la bibliothèque dht
Vous pouvez également télécharger le module à l’adresse suivante : https://github.com/micropython/micropython-lib/blob/master/micropython/drivers/sensor/dht/dht.py
Copiez-le alors vous-même dans le répertoire lib à l’aide du gestionnaire de fichiers Arduino Lab for MicroPython.
Dans cet exemple, le capteur est relié à la borne D2 (qui correspond au GPIO 5) et nous utiliserons un afficheur LCD monochrome relié au port I2C. Si vous le souhaitez, vous pouvez remplacer l’afficheur monochrome par un afficheur RGB, en adaptant le code et peut-être aussi le branchement.
Branchement du capteur DHT et de l’afficheur LCD
Pour lire les données du capteur DHT, nous avons besoin...
Retour au langage Arduino
Vous avez expérimenté le langage MicroPython et vous souhaitez maintenant revenir au langage Arduino ?
Pas de problème, voilà la procédure à suivre pour réinstaller le bootloader d’origine de l’Arduino Nano ESP32.
Attention, toutes les données contenues dans l’Arduino (programmes et bibliothèques MicroPython) seront effacées, alors n’oubliez pas de tout sauvegarder avant de supprimer le langage MicroPython.
Ouvrez l’IDE Arduino et acceptez toutes les mises à jour proposées.
Reliez ensemble les bornes B1 et GND.
Les bornes B1 et GND sont reliées
Branchez l’Arduino à l’ordinateur (ou appuyez sur le bouton RST, s’il était déjà branché). La LED RGB s’allume en vert.
Retirez le câble qui relie les bornes B1 et GND. La LED RGB s’allume en violet.
Allez dans Outils - Port et sélectionnez le port de la carte (COM11 dans cet exemple). L’Arduino peut être détecté comme un autre modèle de carte ESP32, mais à cette étape, cela n’a aucune importance.
Sélection du port COM
Allez dans Outils - Carte et sélectionnez Arduino ESP32 Boards - Arduino Nano ESP32 (il est possible que la carte soit déjà sélectionnée automatiquement).
Sélection...