Blog ENI : Toute la veille numérique !
-25€ dès 75€ sur les livres en ligne, vidéos... avec le code FUSEE25. J'en profite !
Accès illimité 24h/24 à tous nos livres & vidéos ! 
Découvrez la Bibliothèque Numérique ENI. Cliquez ici
  1. Livres et vidéos
  2. MicroPython et Pyboard
  3. Classes MicroPython courantes
Extrait - MicroPython et Pyboard Python sur microcontrôleur : de la prise en main à l'utilisation avancée
Extraits du livre
MicroPython et Pyboard Python sur microcontrôleur : de la prise en main à l'utilisation avancée
3 avis
Revenir à la page d'achat du livre

Classes MicroPython courantes

Les classes MicroPython en français

Il n’est pas d’usage de traduire la documentation officielle. Cependant, dans le cadre de MicroPython, il y a des classes incontournables comme Pin et sa compagne Signal.

Il est donc d’un certain intérêt de rendre ce savoir accessible au plus grand nombre et ce y compris nos plus jeunes adeptes, qui ne sont pas forcément à l’aise avec la langue de Shakespeare.

Cette section rependra quelques traductions des éléments clés. En tout état de cause, une documentation complète est disponible sur : https://docs.micropython.org/en/latest/

La classe ADC

La classe ADC est utilisée pour lire une valeur analogique entre 0 et 3,3 V sur l’une des broches :

  • X19 à X22 en bas de la carte (entrée ADC blindée) sur une entrée analogique.

  • X11, X12 sur le côté gauche de la carte.

  • X1 à X8 et Y11, Y12 sur le côté droit de la carte.

Le convertisseur analogique/numérique (ADC pour Analogic/Digital Converter) dispose d’une résolution 12 bits. La lecture du convertisseur retourne donc une valeur entre 0 et 4095.

import pyb 
 
# Crée un objet ‘analogique' sur la broche 
adc = pyb.ADC( ‘X22' ) 
 
# Lire une valeur analogique 
val = adc.read() 
 
# Valeur en tension 
volts = val * 3.3 / 4095 

1. Constructeur

Classe pyb.ADC(pin)

Crée un objet ADC sur la broche associée à l’argument pin. L’objet créé permet de lire la valeur sur l’entrée analogique.

2. Méthodes

Méthode ADC.read()

Lit une valeur sur l’entrée analogique. Retourne une valeur entre 0 et 4095.

Méthode ADC.read_timed( buffer, timer )

Permet de réaliser des lectures chronométrées sur l’entrée analogique et de stocker ces lectures dans la mémoire tampon buffer. Les échantillons sont accumulés à la fréquence (débit) dictée...

La classe ADCAll

La classe ADCAll permet d’accéder à toutes les entrées analogiques, y compris celles relevant des informations propres au microcontrôleur comme la température, tension de référence, etc.

Instancier cette classe modifie le masque de capture de toutes les entrées analogiques. À utiliser avec précaution.

import pyb 
 
# Créer l'objet ADCAll 
adc = pyb.ADCAll(resolution) 
 
# Créer l'objet ADCAll pour les canaux sélectionnés 
adc = pyb.ADCAll(resolution, mask) 
 
# Lecture d'un canal donné (numéroté de 1 à 15) 
val = adc.read_channel( canal ) 
 
# Lire la température du microcontrôleur 
val = adc.read_core_temp() 
 
# Lire l'entrée VBAT du MCU 
val = adc.read_core_vbat() 
 
# Lire la tension de référence du microcontrôleur 
val = adc.read_core_vref() 
 
# Lire la tension d'alimentation du MCU 
val = adc.read_vref() 

Les informations de température du MCU (information pré-traitée), VREF et VBAT sont disponibles sur les canaux ADC 16, 17 et 18. Une mise à l’échelle appropriée est prise en charge en fonction de la tension de référence (habituellement 3,3 V).

Le capteur de température présent...

La classe DAC

La classe DAC est utilisée pour produire une valeur analogique entre 0 et 3,3 V sur l’une des broches X5 pour DAC(1) et X6 pour DAC(2).

Le convertisseur numérique/analogique (DAC pour Digital/Analogic Converter) dispose d’une résolution 12 bits. Le convertisseur est donc piloté avec une valeur numérique située entre 0 et 4095.

À noter que, par défaut, le convertisseur est configuré en 8 bits (donc pour des valeurs entre 0 et 255).

import pyb 
 
# Crée un objet ‘SORTIE analogique' sur la broche 
dac = pyb.DAC(1, bits=12) # X5 
 
# Envoyer une valeur sur la sortie DAC 
dac.write(4095) # fixer la sortie à 3.3 V  
 
# Valeur en tension 
volts = 1.25 
val = int( volts / 3.3 * 4095 ) 
dac.write( val ) # fixer la sortie à 1.25 V 

1. Constructeur

Classe pyb.DAC(port, bits=8)

Crée un objet de type DAC sur le port mentionné (1 pour la broche X5, 2 pour la broche X6).

Le paramètre bits indique la précision du convertisseur. Les valeurs possibles sont :

  • 8 : résolution 8 bits, donc pour des valeurs comprises entre 0 et 255.

  • 12 : résolution 12 bits, donc pour des valeurs comprises entre 0 et 4095.

2. Méthodes

Méthode DAC.init( bits=8 )

Réinitialise le convertisseur numérique/analogique en précisant la résolution...

La classe I2C

La classe I2C prend en charge la communication sur le bus 2 fils du même nom. Le bus est constitué des signaux SDA pour les données et SCL pour le signal d’horloge.

Ce bus a été traité de façon détaillée dans le chapitre sur la programmation de la Pyboard (cf. Programmer - Bus I2C).

images/07RI34b.png

Emplacement des bus I2C sur la Pyboard

À noter que l’affichage d’un objet de type I2C affiche des informations sur sa configuration.

Lorsqu’un bus I2C est créé avec la mention des broches, c’est le support logiciel I2C (bit-banging) qui est utilisé à la place du pilote matériel.

from machine import I2C 
 
# Créer une instance du bus I2C(1) sur SDA=X10 et SCL=X9 
# Fréquence de bus à 400 kHz 
i2c = I2C(1, freq=400000)   
 
# Création du bus I2C avec pilote logiciel (bit-banging) 
i2c = I2C( sda=Pin(‘Y12'), scl=Pin(‘Y11'), freq=10000 ) 
 
# Scanner le bus I2C (retourne une liste d'adresses) 
i2c.scan() 
 
# Envoyer les octets 49, 50, 52 sur le périphérique I2C 
# à l'adresse 42. 
i2c.writeto(42, b'124') 
# Idem appel précédent. 
i2c.writeto(42, bytes([49,50,52]) ) 
 
# Lire 4 octets depuis le périphérique à l'adresse 42          
i2c.readfrom(42, 4) 
 
# Lecture de 3 octets sur le périphérique I2C à l'adresse 42. 
# Débuter la lecture à l'adresse mémoire 8. 
i2c.readfrom_mem(42, 8, 3) 
 
# Écrire un octet contenant la valeur 16 (codification 
# hexadécimale) sur le périphérique à l'adresse 42. L'écriture 
# débute à l'adresse mémoire 2 sur le périphérique. 
i2c.writeto_mem(42, 2, b'\x10') 

1. Constructeur

Classe machine.I2C( id=-1, *, scl, sda, freq=400000 )

Construit et retourne un nouvel objet I2C en utilisant les paramètres suivants :

  • id : identifie un périphérique I2C particulier (un périphérique matériel). La valeur par défaut est -1 qui sélectionne le pilote I2C logiciel...

La classe LCD160CR

La classe LCD160CR permet de prendre le contrôle de l’écran MicroPython officiel (LCD160CR).

images/09RI117.png

LCD160CR - affichage d’une image

La classe LCD160CR offre une interface pour manipuler l’afficheur. Créer une instance de cette classe et utiliser ses méthodes pour dessiner sur l’écran et obtenir le statut de la partie tactile. 

Par exemple :

import lcd160cr 
 
lcd = lcd160cr.LCD160CR('X') 
lcd.set_orient(lcd160cr.PORTRAIT) 
lcd.set_pos(0, 0) 
lcd.set_text_color(lcd.rgb(255, 0, 0), lcd.rgb(0, 0, 0)) 
lcd.set_font(1) 
lcd.write('Hello MicroPython!') 
print('touch:', lcd.get_touch()) 

Pour plus de détails, il est possible de se référer à la documentation officielle : https://docs.micropython.org/en/latest/library/lcd160cr.html

1. Constructeur

Classe lcd160cr.LCD160CR(connect=None, *, pwr=None, i2c=None, spi=None, i2c_addr=98)

Crée un objet LCD160CR. Les paramètres sont les suivants :

  • connect : est une chaîne de caractères identifiant la connexion physique de l’afficheur LCD sur la carte. Les valeurs valides sont "X", "Y", "XY", "YX". Utiliser "X" lorsque l’afficheur est connecté sur la position X (skin X) tandis que "Y" est utilisé lorsque l’écran est connecté sur la position Y (skin Y). "XY" et "YX" sont utilisés lorsque l’afficheur est connecté sur le côté droit ou gauche de la Pyboard.

  • pwr : est un objet de type Pin connecté sur la broche power/enabled de l’afficheur.

  • i2c : est un objet I2C connecté sur l’interface I2C de l’afficheur.

  • spi : est un objet SPI connecté sur l’interface SPI de l’afficheur.

  • i2c_addr : est l’adresse I2C par défaut de l’afficheur.

Il y a deux façons de créer un objet LCD160CR :

  • Avec une valeur valide pour connect (X, Y, XY, YX).

  • Avec des valeurs valides pour tous les autres paramètres pwr, i2c et spi.

Si une valeur valide est communiquée à connect, alors aucun des autres paramètres pwr, i2c ou spi ne doivent être passés comme paramètre (ils sont à None). Les instances pour pwr, i2c ou spi seront...

La classe Pin

Les objets pin sont utilisés pour contrôler les broches, également connues sous le nom de GPIO (General Purpose Input/Output, broche d’entrée/sortie à usage général). Les objets pin sont généralement associés à une broche physique capable de lire la tension d’entrée ou de fixer la tension de sortie. La classe Pin dispose de méthodes pour fixer le mode de la broche (IN pour entrée, OUT pour sortie, etc.) et des méthodes pour lire ou fixer l’état logique de la broche. Les opérations sur les broches analogiques utilisent la classe ADC.

Un objet pin est créé en utilisant un paramètre identifiant de la broche physique de manière unique (sans ambiguïté). Les formes permises pour l’identifiant et pour la broche physique que l’identifiant indique sont spécifiques au portage MicroPython. Les possibilités pour l’identifiant sont un entier, une chaîne de caractères, un tuple avec port et numéro de broche.

1. Constructeur

Classe machine.Pin(id, mode=-1, pull=-1, *, value, drive, alt)

Accéder à la broche matérielle (GPIO) associée à l’identifiant id. Si des arguments complémentaires sont fournis au constructeur, alors ceux-ci sont utilisés pour initialiser la broche. Tous les arguments non spécifiés resteront dans leur état précédent.

  • id : est obligatoire et peut être un objet arbitraire. Les types de valeur possibles sont : int (un identifiant interne de la broche), str (un nom de broche) et tuple (une paire de valeurs : port, numéro broche).

  • mode : spécifie le mode de la broche, qui peut être l’une des valeurs suivantes :

  • Pin.IN : la broche est configurée en entrée. Vue de l’extérieur, la broche présente une haute impédance.

  • Pin.OUT : la broche est configurée comme une sortie (normale).

  • Pin.OPEN_DRAIN : la broche est configurée comme une sortie à drain ouvert (open-drain). Une sortie à drain ouvert fonctionne comme suit : si la valeur est fixée à 0, la broche est activée au niveau bas ; si la valeur de la sortie est à 1, alors la broche présente une grande...

La classe RTC

La classe RTC (Real Time Clock) est utilisée pour dialoguer avec le périphérique horloge temps réel présent sur la carte. Le périphérique RTC utilise une source d’alimentation auxiliaire (une pile bouton) pour continuer à égrainer le temps même lorsque la plateforme est hors tension.

rtc = pyb.RTC() 
 
# Fixer l'heure sur l'horloge RTC 
rtc.datetime((2019, 8, 29, 4, 12, 56, 0, 0)) 
 
# Afficher la date et l'heure 
print( rtc.datetime() ) 
# Produit le résultat suivant  
(2019, 8, 29, 4, 13, 0, 14, 10) 

1. Constructeur

Classe pyb.RTC

Constructeur de la classe RTC.

2. Méthodes

Méthode RTC.datetime( [datetime_tuple] )

Permet d’obtenir (ou de fixer) la date et l’heure de l’horloge RTC.

Sans argument, cette méthode retourne un tuple avec 8 éléments contenant les informations de date et d’heure.

Avec un argument (qui doit être un tuple de 8 éléments), l’appel fixe la date et l’heure de l’horloge RTC (les subseconds sont réinitialisées à 255 sur une Pyboard originale).

Le tuple de 8 éléments contient les éléments (year, month, day, weekday, hours, minutesseconds, subseconds)

  • year : année.

  • month : mois de l’année (de 1 à 12).

  • day : jour...

La classe Servo

La classe Servo de la bibliothèque pyb permet de commander facilement des servomoteur à 3 fils (masse, alimentation et signal) tels que ceux utilisés dans le monde du modélisme.

Il est possible de connecter quatre servomoteurs sur la Pyboard. Les broches X1 à X4 offrent le signal de commande tandis que les deux broches connexes permettent de brancher l’alimentation et la masse du servomoteur.

import pyb 
 
s1 = pyb.Servo(1)   # Servomoteur sur la broche X1 
s2 = pyb.Servo(2)   # Servomoteur sur la broche X2 
 
s1.angle(45)        # servo 1 à 45 degrés 
s2.angle(0)         # servo 2 à 0 degré 
 
# Mouvement synchrone des serveurs 1 et 2 (durée 1500 ms = 1,5 sec) 
s1.angle(-60, 1500) 
s2.angle(30, 1500) 

Les objets Servo utilisent le timer 5 pour produire la sortie PWM. Il est possible d’utiliser le timer 5 pour le contrôle de servomoteurs ou autre utilisation, mais pas les deux en même temps.

1. Constructeur

Classe pyb.Servo(id)

Crée un objet servomoteur. Le paramètre id (de 1 à 4) correspond à la broche à commander de X1 à X4.

2. Méthodes

Méthode Servo.angle([angle, time=0])

Permet de fixer un angle en argument ou d’obtenir l’angle actuel du servo (lorsqu’appelée sans...

La classe Signal

La classe Signal est une simple extension de la classe Pin. À la différence de Pin, qui ne peut recevoir que les états absolus 1 et 0, un Signal peut être dans un état activé (on) ou désactivé (off), peu importe si la broche fonctionne en logique inversée (active-low) ou pas. Une broche en logique inversée a un signal considéré comme activé lorsque la broche est placée au niveau bas. En d’autres termes, Signal ajoute le support de l’inversion logique à la classe Pin.

Bien que cela semble un simple ajout, c’est exactement ce qui est nécessaire pour supporter un large éventail de périphériques simples de façon à les rendre portables sur différentes plateformes, ce qui est l’un des buts principaux de MicroPython. Indépendamment du fait que la plateforme utilisateur dispose d’une LED activée au niveau haut (active-high) ou au niveau bas (active-low), soit un relais normalement ouvert ou normalement fermé, il est possible de développer une application qui fonctionnera dans chacun de ces cas et qui capture la différence de configuration matérielle dans les quelques lignes du fichier de configuration de votre application.

from machine import Pin, Signal 
 
# Une LED en logique positive (active-high) sur broche 0 
led1_pin = Pin(0...

La classe SPI

SPI est un protocole série synchrone (communication dans les deux sens en duplex) qui est piloté par un maître de bus. Au niveau physique, le bus est constitué de trois signaux : SCK (signal d’horloge), MOSI (Master Out, Slave In), MISO (Master In, Slave Out).

De multiples périphériques peuvent partager le même bus. Chaque périphérique doit alors être contrôlé par un quatrième signal SS (Slave Select = sélection esclave) pour activer le périphérique particulier sur le bus avec lequel la communication doit prendre place. La gestion du signal SS doit être réalisée par le code utilisateur (via une classe machine.Pin).

Il n’est pas rare que le signal SS soit nécessaire, même avec un seul périphérique. Dans ce cas, il servira à gérer les transactions avec le périphérique SPI.

Le signal SS doit être placé au niveau haut dès la création de l’objet Pin. En effet, le signal SS (souvent noté /SS) fonctionne en logique inverse. Le périphérique est sélectionné lorsque SS passe au niveau bas.

images/04RI54.png

Emplacement des bus SPI sur la Pyboard

1. Constructeur

Classe machine.SPI(id, ...)

Constructeur de l’objet SPI sur le bus mentionné par id. Les valeurs possibles pour id dépendent de la plateforme matérielle....

La classe Timer

La classe Timer de la bibliothèque pyb permet de commander facilement les timers de la carte Pyboard.

Les timers peuvent être utilisés pour de nombreuses tâches. Pour l’instant, seul le cas le plus simple est implémenté : l’appel d’une fonction de façon périodique.

Chaque timer est constitué d’un compteur qui compte à un certain débit. La vitesse de comptage correspond à la fréquence d’horloge périphérique (en Hz) divisée par le prescaler du timer. Lorsque le compteur atteint sa valeur périodique (period) alors il déclenche un événement et le compteur revient à zéro. En utilisant une méthode callback, alors l’événement du timer est capable d’appeler du code Python.

Voici un exemple qui change l’état d’une LED à fréquence fixe :

import pyb 
tim = pyb.Timer(4)    # Utilisation du timer 4 
tim.init(freq=2)      # Déclenchement à 2 Hz (2x par seconde) 
tim.callback(lambda t:pyb.LED(1).toggle()) 

1. Constructeur

Classe pyb.Timer(id, ...)

Construit un nouvel objet timer pour l’identifiant id mentionné. Si des arguments complémentaires sont fournis, alors le timer est initialisé avec init(...). id qui peut être une valeur entre 1 et 14.

2. Méthodes

Méthode Timer.init(*, freq, prescaler, period)

Initialise le timer. L’initialisation doit se faire soit en mentionnant la fréquence freq (en Hz), soit le couple prescaler et period.

# Active le déclenchement à 100 Hz (100x par seconde) 
tim.init(freq=100) 
 
# Fixe directement le prescaler et la période 
tim.init(prescaler=83, period=999)   

Les arguments sont :

  • freq : spécifie la fréquence périodique du timer. Cette fréquence peut être vue comme celle utilisée par le timer pour exécuter un cycle complet.

  • prescaler : entre 0 et 0xFFFF, spécifie la valeur qui doit être chargée dans le registre prescaler du timer (PSC). La source d’horloge du timer est divisée par (prescaler + 1) pour générer l’horloge du timer. Les timers 2 à 7 et 12 à...

Classe TimerChannel

Cette classe permet d’initialiser un canal pour un timer.

Les canaux (timer channels) sont utilisés pour capturer ou générer un signal en exploitant un timer. 

Un objet de type TimerChannel est créé en utilisant la méthode Timer.channel().

1. Méthodes

Méthode timerchannel.callback(fun)

Fixe la fonction de rappel à appeler lorsque le canal du timer déclenche l’événement. La fonction de rappel fun doit pouvoir recevoir un argument qui est l’objet timer. Si fun est à None, alors la fonction de rappel est désactivée.

Méthode timerchannel.capture([value])

Permet de capturer ou fixer la valeur capturée associée avec le canal. capture, compare et pulse_width sont des alias pour la même fonction. capture est un nom logique à utiliser lorsque le canal est configuré en mode de capture (input capture mode).

Méthode timerchannel.compare([value])

Permet de capturer ou fixer la valeur de comparaison associée avec le canal. capture, compare et pulse_width sont des alias pour la même fonction.

Méthode timerchannel.pulse_width([value])

Capture ou fixe la valeur de la largeur d’impulsion associée avec un canal. capture, compare et pulse_width sont des alias pour la même fonction. pulse_width est le nom logique utilisé par le canal lorsqu’il...

Classe UART

La classe UART implémente le standard de communication série UART/USART en duplex. Au niveau physique, un UART est constitué de deux lignes : RX et TX.

L’unité de communication est le caractère qui peut être constitué de 8 ou 9 bits de large, donc plutôt un octet. À ne pas confondre avec une chaîne de caractères qui est, aujourd’hui, un élément de type Unicode.

images/07RI34b.png

Emplacement des UART sur la Pyboard-D

Un objet UART peut être créé en utilisant les moyens suivants :

from machine import UART 
# Créé en mentionnant le périphérique matériel et le débit. 
uart = UART(1, 9600) 
 
# Créé en deux temps avec précision des paramètres 
# dans la méthode init 
uart = UART(1) 
uart.init(9600, bits=8, parity=None, stop=1) 

Les paramètres supportés diffèrent en fonction de la carte :

  • Pyboard : le paramètre bits peut être 7, 8 ou 9. Le paramètre stop peut être 1 ou 2. Avec une parité parity=None, seuls 8 ou 9 bits de données supportés. Avec une parité activée, seuls 7 ou 8 bits sont supportés.

  • WiPy/CC3200 : le paramètre bits peut être 5, 6, 7, 8. Le paramètre stop peut être 1 ou 2.

Un objet UART peut agir comme un flux (un stream) pour y lire/écrire des données à l’aide des méthodes d’un objet stream :

# Lecture de 10 caractères. Retourne un type bytes 
data = uart.read(10) 
 
# Lecture de toutes...