UART en MicroPython

UART (Universal Asynchronous Receiver-Transmitter) est un bus série point-à-point à deux fils : TX (transmission) et RX (réception), croisés entre deux devices. En MicroPython, on y accède par la classe UART du module [[micropython-modules|machine]]. On l’utilise pour faire dialoguer le Pico avec un autre microcontrôleur ou un module externe (GPS NEO-6M, Bluetooth HC-05, lecteur RFID). À la différence de l’Arduino Uno, la console REPL du Pico passe par l’USB (USB-CDC), pas par un UART matériel : les deux UART du Pico restent donc libres pour les modules — pas besoin de SoftwareSerial.

À quoi ça sert ?

UART est le bus le plus simple : 2 fils, pas d’horloge partagée, paramétrage minimal (baud rate + format). Cas d’usage : communiquer entre 2 microcontrôleurs, lire un module GPS (trames NMEA à 9600 bauds), dialoguer avec un module Bluetooth/Wi-Fi en mode AT, piloter un afficheur série. Limite : UART est point-à-point (1 ↔ 1). Pour plusieurs devices, utiliser un second UART, ou basculer sur I2C/SPI.

Procédure pas à pas

Quatre étapes : identifier les UART, câbler en croisant TX/RX, configurer le baud rate, écrire le code.

1. Identifier les UART du Pico

Le Pico expose deux UART matériels, UART0 et UART1, assignables à plusieurs broches selon le pinout :

UART	TX (défaut)	RX (défaut)
`UART0`	GP0	GP1
`UART1`	GP4	GP5

La console REPL est sur l’USB, indépendante : on garde print() vers Thonny tout en utilisant UART0 pour un module. C’est plus simple que sur Uno (où l’unique UART est partagé avec l’USB).

2. Câbler en croisant TX/RX

Règle inviolable : TX d’un côté → RX de l’autre. GND commun obligatoire.

Pico	Device externe
TX (GP0)	→ RX
RX (GP1)	← TX
GND	— GND

Câblage : liaison UART entre un Pico (TX GP0, RX GP1) et un périphérique — TX et RX croisés, GND commun|600

3. Configurer le baud rate

Le baud rate doit être identique aux deux bouts (9600, 115200…). Le module documente son débit par défaut (HC-05 : 9600, GPS NEO-6M : 9600). Format de trame : 8N1 par défaut (8 bits, sans parité, 1 stop).

4. Écrire le code

from machine import UART, Pin
from time import sleep
 
uart = UART(0, baudrate=9600, tx=Pin(0), rx=Pin(1))
 
while True:
    if uart.any():                 # octets disponibles ?
        data = uart.read()         # lit tout ce qui est en attente (bytes)
        print("Recu :", data)
    uart.write(b"ping\n")          # émet (bytes, pas str)
    sleep(1)

uart.any() indique le nombre d’octets reçus. uart.read() / uart.readline() lisent. uart.write() émet. On manipule des bytes (b"..."), pas des str — convertir au besoin (texte.encode() / data.decode()).

Exemple — Communication entre deux Pico

Un Pico A envoie un compteur. Un Pico B le reçoit, le décode, l’affiche.

Câblage : A GP0 (TX) → B GP1 (RX), A GP1 (RX) ← B GP0 (TX), GND commun.

Pico A (émetteur) :

from machine import UART, Pin
from time import sleep
 
uart = UART(0, baudrate=9600, tx=Pin(0), rx=Pin(1))
compteur = 0
 
while True:
    uart.write("{}\n".format(compteur).encode())   # trame terminée par \n
    print("Envoye :", compteur)
    compteur += 1
    sleep(1)

Pico B (récepteur) :

from machine import UART, Pin
 
uart = UART(0, baudrate=9600, tx=Pin(0), rx=Pin(1))
 
while True:
    if uart.any():
        ligne = uart.readline()        # lit jusqu'au \n (bytes)
        if ligne:
            valeur = int(ligne.decode().strip())   # bytes → texte → entier
            print("Recu :", valeur)

readline() lit jusqu’au marqueur \n : le récepteur sait ainsi où finit une valeur.

Pièges

TX/RX non croisés. Erreur n°1 : TX→TX, RX→RX. Rien ne passe. TX d’un côté → RX de l’autre.

Baud rate désaccordé. Mêmes bauds aux deux bouts, sinon symboles incompréhensibles.

Pas de GND commun. Sans masse partagée, pas de référence : la communication ne marche pas, même avec deux alimentations.

Confondre bytes et str. uart.write("texte") échoue : il faut des bytes (.encode()), et uart.read() renvoie des bytes (.decode() pour du texte).

Niveaux logiques incompatibles. Un module qui sort 5 V sur le RX du Pico (3,3 V) l’abîme : pont diviseur ou translateur (niveaux de tension).

Trame mal délimitée. Sans marqueur de fin (\n), le récepteur ne sait pas où une valeur finit. Utiliser readline() ou un protocole structuré.

Lire sans vérifier any(). uart.read() sans données renvoie None. Tester uart.any() (ou gérer None) évite une erreur.

Cas particulier — Adaptateur USB-série pour debug

Un adaptateur USB-série (CH340, CP2102) relie le PC à un UART sans passer par le Pico : intercepter un bus, tester un module Bluetooth/Wi-Fi en mode AT en direct, programmer une puce sans USB. Outil de paillasse très utile au debug.

Raccrochage projet

Étape 2 de la phase de preuve de concept — validation isolée d’un module UART (GPS, Bluetooth) avant intégration.
Étape 3 de la phase de preuve de concept — bus de commande entre sous-systèmes quand l’architecture sépare perception et commande sur plusieurs MCU.
Étape 2 de la phase d’intégration et tests — vérifier que les bus tiennent à pleine charge (débit, fiabilité, parasites).

UART est le bus à connaître en premier : 2 fils, et la passerelle vers une foule de modules. Sur le Pico, l’avantage est que ses 2 UART matériels sont libres (la console est sur l’USB).

Voir aussi

MicroPython — hub du module
Le REPL — la console (sur USB), distincte des UART matériels
Bus de communication — UART parmi les bus
I2C · SPI — pour plusieurs devices
UART — la notion transverse
UART sur Arduino — l’équivalent C++ (et SoftwareSerial)

TheSkillCodex

Explorateur