Appareils série (UART)¶

Côté programme, machine.UART produit une vraie trame électrique sur deux broches du microcontrôleur (API). Au bout du fil, Peripherals fournit cinq appareils série : ils décodent ce qu'ils reçoivent, bit par bit, et répondent par une vraie trame à leur tour.

Tension de la broche d'émission (mcu.GP0.v) dans l'exemple Uart.Loopback : bit de start à 0, 8 bits de données (poids faible en tête), bit de stop à 1.

Câblage¶

Deux fils croisés et une masse commune, comme sur un vrai montage :

from machine import Pin, UART
import time

uart = UART(0, baudrate=1200, tx=Pin(5), rx=Pin(4))
uart.write(b'AT+TEMP\n')
time.sleep_ms(200)              # laisser le temps à la réponse d'arriver
if uart.any():
    print(uart.readline())      # b'TEMP=21.5\r\n'

La réception ne réveille pas le programme : il interroge la liaison avec any(), read() ou readline().

Les appareils fournis¶

Tous partagent les mêmes connecteurs et paramètres ; ils ne diffèrent que par leurs valeurs par défaut et leur icône.

Connecteurs¶

Paramètres¶

Comportement et liaison (onglet General)¶

Table de commandes (onglet Table, mode Table)¶

Entrées / sorties (onglet Inputs / outputs)¶

Électrique (onglet Electrical)¶

Décrire l'appareil par une table¶

Une seule chaîne décrit toutes les commandes : "CMD=>REPONSE|CMD=>REPONSE". Les caractères | et => sont réservés. Une commande est reconnue quand la ligne reçue complète (sans son terminateur) lui est identique.

commandTable = "AT+TEMP=>TEMP={v1:.1f}\r\n|AT+ID=>SIM-TEMP-1\r\n|SET {o1}=>OK\r\n"

Avec cette table, le programme lit la température par la liaison série et renvoie une commande par la même liaison. valueOut[1] la transmet au reste du modèle : c'est ce que fait l'exemple Uart.Regulation, une régulation complète à travers les deux seuls fils de la liaison.

Décrire l'appareil par un script Python¶

Avec behaviour = Script, le fichier scriptPath remplace la table. Il définit jusqu'à trois fonctions, toutes facultatives :

etat = 'ARRET'          # variables de module : l'état de l'appareil,
lectures = 0            # qui persiste d'un appel à l'autre

def on_receive(ligne, t, v):        # une fois par ligne complète reçue
    global etat, lectures
    if ligne == b'START':
        etat = 'MARCHE'
        return b'OK\r\n'
    if ligne == b'READ' and etat == 'MARCHE':
        lectures += 1
        return 'VAL=%.2f N=%d\r\n' % (v[0], lectures)
    return b'ERR\r\n'

def on_tick(t, v):                  # toutes les `period` secondes, si définie
    return None

def outputs():                      # relue après chaque appel -> valueOut
    return (1.0 if etat == 'MARCHE' else 0.0, lectures)

Règles à connaître :

• Le script est chargé une fois par appareil : deux appareils utilisant le même fichier ont chacun leurs propres variables.
• Chaque ligne n'est livrée qu'une fois, même si la simulation réévalue plusieurs fois le même instant : une machine d'état ne rejoue jamais ses transitions.
• Les fonctions doivent se terminer sans attendre : pas de sleep() (c'est responseDelay qui diffère une réponse), pas de machine ni de time, qui appartiennent au microcontrôleur. Le fichier doit être autonome (pas d'import de fichiers voisins).
• print() s'affiche dans le journal, préfixé du nom de l'appareil. Une exception arrête la simulation.

Point de départ : copier Resources/Scripts/Device/generic.py. Exemples : Uart.EchoPy, Uart.GpsPy, Uart.StateMachinePy.

Grandeurs à tracer¶

Boucler la liaison sur le microcontrôleur lui-même¶

Pour observer la trame d'un MCU seul, sans appareil, on relie sa broche TX à sa broche RX. Pas par un simple fil : un connect() direct entre deux broches du même MCU fait disparaître la tension pilotée des résultats. Passer par une résistance de 1 kΩ, avec un condensateur de 1 nF de la broche RX vers la masse, comme dans l'exemple Uart.Loopback ; la trame n'en est pas déformée (constante de temps ≈ 1 µs, pour des bits de 833 µs à 1200 bauds).

Exemples¶