Les bases du langage Micropython

Carte Adafruit Feather STM32F405

Edition

Pour de programmer la carte en langage Python natif, un micrologiciel (firmware) contenant l’interpréteur MicroPython est installé dans la mémoire flash de la carte. Ce firmware peut-être mis à jour à partir d’une version plus récente disponible sur le site de MicroPython.

Le logiciel Thonny exploite pleinement la programmation des microcontrôleurs en MicroPython. Il permet deux types de programmation :

• directement dans l’interpréteur MicroPython (REPL) pour tester des instructions par exemple ;

• ou dans un script (fichier avec l’extension .py) qui peut-être sauvegarder sur la mémoire de la carte pour être exécuté de façon autonome sur la carte.

Avertissement

À chaque démarrage de la carte ou lors d’un reset, les fichiers setup.py puis main.py sont exécutés dans l’ordre. C’est dans le fichier main.py que doit être écrit le programme !

Librairie

C’est la librairie pyb qui rassemble les fonctions spécifiques à la carte.

Écrire sur une sortie digitale

L’exemple suivant met la broche D8 en sortie et à l’état bas.

>>> from pyb import Pin            # importation de Pin dans la librairie pyb
>>> pinD8 = Pin('D8',Pin.OUT)      # Broche D8 en sortie
>>> pinD8.low()                    # LED éteinte

Puis à l’état haut.

>>> pinD8.high()

Lire une entrée digitale

L’exemple suivant met la broche D8 en entrée puis lit et affiche son état.

from pyb import Pin        # importation de Pin de la librairie pyb
pinD8 = Pin('D8',Pin.IN)   # Broche D8 en entrée
val = pinD8.value()        # Lecture de l'état de la broche
print(val)                 # Affichage

Mesurer une tension (CAN)

La conversion analogique numérique (le nombre de bits dépend de la carte) est disponible sur les broches A0, A1, …

L’exemple suivant lit une tension sur l’entrée A0 avec une résolution de 12 bit.

from pyb import Pin, ADC
can = ADC(Pin('A0'))    # CAN sur la broche A0
N = can.read()          # lecture d'un entier de 0 à 4095
print(N*3.3/4095)       # Affichage de la tension

Acquisition d’une tension

Suivant la version du microcontrôleur, il est possible de réaliser une acquisition d’échantillons de tension avec l’aide d’un timer.

Exemple ci-dessous réalise une acquisition avec une carte Adafruit Feather STM32F405.

from pyb import Pin, ADC, Timer
from time import sleep_ms
import array

class Acquisiton:
   def __init__(self, broche, periode, nb_points):
      """ Constructeur
      broche    (str) : broche de l'entrée analogique
      periode (float) : periode d'échantillonage en µs
      nb_points (int) : nombre de points d'acquisition
      """
      self.frequence = 1/(T*1E-3)                                                     # Fréquence d'échantillonnage
      self.times = [i*periode for i in range(nb_points)]   # Liste des temps
      self.ADC = ADC(Pin(broche))                          # Sélection de la broche Analogique (A0, A1, ..)
      self.buffer = array.array("h", nb_points * [0x7FFF]) # h = signed short (int 2 octets)
      self.timer =  Timer(6, freq=self.frequence)          # Création d'un timer à la fréquence d'échantillonnage

   def start(self):
      """ Lance l'acquisition et retourne les listes temps et tensions
      """
      self.ADC.read_timed(self.buffer, self.timer)     # Lancement de l'acquisition
      self.tensions = [val for val in self.buffer]     # Conversion en liste
      return self.times, self.tensions

#### PROGRAMME PRINCIPAL ####
T = 0.01                           # période échantillonnage en µs
nb = 200                           # nombre d'échantillons
mesures = Acquisiton('A3', T, nb)  # Paramétrage de l'acquisition
t, u = mesures.start()             # Lancement de l'acquisition
print("t =", t)                    # Affichage de la liste du temps
print("u =", u)                    # Affichage de la liste de la tension

Générer une tension analogique (CNA)

La plupart des cartes intègre au moins un convertisseurs numérique-analogique. Voir la documentation pour connaître les broches concernées (ex. A0, A1, …)

L’exemple suivant génère une tension de 1,55 V sur la broche A0 avec une résolution de 8 bit par défaut.

from pyb import Pin, DAC
cna = DAC(Pin('A0'))     # CNA sur A0
cna.write(120)           # Ecriture de 120*3,3/255 = 1,55 V

Pour passer sur 12 bits :

from pyb import Pin, DAC
cna = DAC(Pin('A0'))     # CNA sur X5
cna.init(bits=12)        # Paramétrage sur 12 bit
cna.write(1500)          # Ecriture de 1500*3,3/4095 = 1,21 V

Note

Il est aussi possible de générer une tension périodique de forme quelconques.

Générer une tension MLI (PWM)

La génération d’une tension MLI est possible sur un canal d’un timer (4 canaux par timer). Voir brochage pour repérer les canaux des timers.

L’exemple suivant génère une tension MLI sur la broche D2 avec un rapport cyclique de 30%.

from pyb import Pin, Timer

pwm = Timer(2).channel(2, Timer.PWM, pin=Pin('D2'))  # pwm sur le canal 2 du Timer 2
pwm.pulse_width_percent(30)                          # réglage du rapport cyclique

Faire une pause

from time import sleep

sleep(1)  # Pause de 1 s

Mesurer une durée

Il est possible de mesurer la durée d’une impulsion à l’état haut ou l’état bas avec la fonction time_pulse_us() du module machine commun à tous les microcontrôleurs sous MicroPython.

L’exemple suivant mesure la durée (en microsecondes) à l’état haut d’une impulsion sur l’entrée D8.

from pyb import Pin
from machine import time_pulse_us

duree = time_pulse_us(Pin('D8'),1)