classe StateMachine – accès à l’interface d’E/S programmable du RP2040¶

La classe StateMachine donne accès à l’interface PIO (E/S programmable) du RP2040.

Pour l’assemblage des programmes PIO, voir rp2.asm_pio().

Constructeurs¶

class rp2.StateMachine(id: int, program: Callable | None = None, *args, **kwargs)¶

Obtient la machine à états numérotée id. Le RP2040 possède deux instances PIO identiques, chacune avec 4 machines à états : il y a donc 8 machines à états au total, numérotées de 0 à 7.

Optionnellement, l’initialise avec le programme donné program : voir StateMachine.init.

Configure l’instance de machine à états pour exécuter le programme donné program.

Le programme est ajouté à la mémoire d’instructions de cette instance PIO. Si la mémoire d’instructions contient déjà ce programme, son décalage est réutilisé afin d’économiser de la mémoire d’instructions.

freq est la fréquence en Hz à laquelle faire fonctionner la machine à états. Par défaut, la fréquence de l’horloge système.

Le diviseur d’horloge est calculé comme system clock frequency / freq, il peut donc y avoir de légères erreurs d’arrondi.

Le diviseur d’horloge minimal possible est le 65536e de l’horloge système : ainsi, à la fréquence d’horloge système par défaut de 125 MHz, la valeur minimale de freq est 1908. Pour faire fonctionner les machines à états à des fréquences plus lentes, vous devrez réduire la vitesse de l’horloge système avec machine.freq().
in_base est la première broche à utiliser pour les instructions in().
out_base est la première broche à utiliser pour les instructions out().
set_base est la première broche à utiliser pour les instructions set().
jmp_pin est la première broche à utiliser pour les instructions jmp(pin, ...).
sideset_base est la première broche à utiliser pour le side-set.
in_shiftdir est le sens dans lequel l’ISR effectuera le décalage, soit PIO.SHIFT_LEFT soit PIO.SHIFT_RIGHT.
out_shiftdir est le sens dans lequel l’OSR effectuera le décalage, soit PIO.SHIFT_LEFT soit PIO.SHIFT_RIGHT.
push_thresh est le seuil en bits avant que l’auto-push ou le re-push conditionnel soit déclenché.
pull_thresh est le seuil en bits avant que l’auto-pull ou le re-pull conditionnel soit déclenché.

Remarque : les broches utilisées pour in_base doivent être configurées manuellement en entrée (ou autrement) afin que le PIO puisse voir le signal souhaité (elles peuvent être des broches d’entrée, des broches de sortie ou connectées à un autre périphérique). La broche jmp_pin peut également être configurée manuellement, mais sera par défaut une broche d’entrée.

active(value: bool | int | None = None, /) → bool¶

Obtient ou définit si la machine à états est actuellement en cours d’exécution.

>>> sm.active()
True
>>> sm.active(0)
False

restart() → None¶

Redémarre la machine à états et saute au début du programme.

Cette méthode efface l’état interne de la machine à états à l’aide du registre SM_RESTART du RP2040. Cela inclut :

les compteurs de décalage d’entrée et de sortie

le contenu du registre de décalage d’entrée

le compteur de délai

l’état d’attente sur IRQ

une instruction bloquée exécutée avec StateMachine.exec()

exec(instr: str | int) → None¶

Exécute une seule instruction PIO.

Si instr est une chaîne de caractères, utilise asm_pio_encode pour encoder l’instruction à partir de la chaîne donnée.

>>> sm.exec("set(0, 1)")

Si instr est un entier, il est traité comme une instruction en code machine PIO déjà encodée à exécuter.

>>> sm.exec(rp2.asm_pio_encode("out(y, 8)", 0))

get(buf: 'bytearray | array | None' = None, shift: int = 0) → int¶

Extrait un mot de la FIFO RX de la machine à états.

Si la FIFO est vide, la méthode bloque jusqu’à l’arrivée de données (c’est-à-dire jusqu’à ce que la machine à états pousse un mot).

La valeur est décalée vers la droite de shift bits avant d’être renvoyée, c’est-à-dire que la valeur de retour est word >> shift.

put(value: 'int | bytes | bytearray | array', shift: int = 0) → None¶

Pousse des mots sur la FIFO TX de la machine à états.

value peut être un entier, un tableau de type B, H ou I, ou un bytearray.

Cette méthode bloque jusqu’à ce que tous les mots aient été écrits dans la FIFO. Si la FIFO est, ou devient, pleine, la méthode bloque jusqu’à ce que la machine à états extraie suffisamment de mots pour achever l’écriture.

Chaque mot est d’abord décalé vers la gauche de shift bits, c’est-à-dire que la machine à états reçoit word << shift.

rx_fifo() → int¶

Renvoie le nombre de mots présents dans la FIFO RX de la machine à états. Une valeur de 0 indique que la FIFO est vide.

Utile pour vérifier si des données sont en attente de lecture, avant d’appeler StateMachine.get().

tx_fifo() → int¶

Renvoie le nombre de mots présents dans la FIFO TX de la machine à états. Une valeur de 0 indique que la FIFO est vide.

Utile pour vérifier s’il y a de la place pour pousser un autre mot avec StateMachine.put().

irq(handler: Callable[[StateMachine], None] | None = None, trigger: int = 0 | 1, hard: bool = False) → Callable¶

Renvoie l’objet IRQ pour la machine à états donnée.

Optionnellement, le configure.

Protocole tampon¶

La classe StateMachine prend en charge le buffer protocol, permettant un accès direct aux FIFO d’émission et de réception de chaque machine à états. Cela sert principalement à permettre de passer directement des objets StateMachine comme paramètres de lecture ou d’écriture lors de la configuration d’un canal rp2.DMA().