classe PIO – utilisation avancée du PIO

La classe PIO encapsule l’un des deux blocs d’E/S programmables (PIO) du RP2040. Chaque bloc PIO contient une mémoire d’instructions (32 instructions) partagée par quatre machines à états indépendantes, ainsi qu’une interface FIFO privée vers chaque machine à états et un contrôleur d’IRQ.

La plupart des scripts interagissent avec le PIO via StateMachine – cette classe est destinée aux cas d’utilisation avancés qui nécessitent de :

• Charger et retirer explicitement des programmes via add_program() / remove_program().

• Déplacer la base GPIO du PIO à travers la fenêtre de 32 broches de la puce via gpio_base().

• S’accrocher aux indicateurs d’IRQ à l’échelle du bloc via irq().

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

Constructeurs

class rp2.PIO(id: int)

Renvoie l’objet singleton PIO pour le bloc PIO identifié par id. Le RP2040 possède deux blocs PIO, numérotés 0 et 1. Lève ValueError pour tout autre id.

Méthodes

gpio_base(base: machine.Pin | int | None = None, /) → int

Obtient ou définit la base GPIO de ce bloc PIO.

Le PIO du RP2040 voit une fenêtre de 32 broches dans l’espace GPIO ; la fenêtre peut commencer à GPIO0 ou GPIO16. La base détermine quelle fenêtre est active pour toutes les machines à états de ce PIO.

Sans argument, renvoie la base actuelle (le numéro de broche GPIO, 0 ou 16).

Avec un argument, définit la base. base peut être une instance machine.Pin ou le numéro de broche entier, et doit correspondre à GPIO0 ou GPIO16. La base doit être définie avant qu’un programme soit ajouté ou qu’une machine à états soit construite sur ce bloc PIO.

add_program(program: Callable) → None

Charge program dans la mémoire d’instructions de ce PIO. La disposition mémoire résultante est réutilisée par toutes les machines à états de ce bloc PIO.

Chaque PIO ne dispose que de 32 instructions de mémoire de programme partagée entre tous les programmes ; si le nouveau programme ne tient pas, cette méthode lève OSError(ENOMEM). Le même programme peut être chargé sur les deux instances PIO, mais elles consomment des régions de mémoire distinctes.

remove_program(program: Callable | None = None, /) → None

Retire program de la mémoire d’instructions de ce PIO, libérant de l’espace pour de nouveaux programmes. Si program est omis, tous les programmes actuellement chargés sur ce PIO sont retirés.

Retirer un programme qui n’était pas chargé est sans effet (aucune exception).

state_machine(id: int, program: Callable | None = None, *args, **kwargs) → StateMachine

Renvoie l’une des quatre instances StateMachine appartenant à ce bloc PIO. id est l’index local de la machine à états (0 – 3).

Si program est fourni, la machine à états est configurée pour l’exécuter – tous les arguments positionnels/nommés sont transmis à StateMachine.init().

Exemple

>>> rp2.PIO(1).state_machine(3)
StateMachine(7)

L’identifiant global de la machine à états de l’objet renvoyé est pio_id * 4 + sm_id.

irq(handler: Callable[[PIO], None] | None = None, trigger: int = IRQ_SM0 | IRQ_SM1 | IRQ_SM2 | IRQ_SM3, hard: bool = False) → Callable

Obtient ou configure l’IRQ au niveau du bloc pour ce PIO.

handler est la fonction de rappel à déclencher lorsque l’une des IRQ de machine à états demandées se verrouille. Le gestionnaire reçoit cette instance PIO comme unique argument ; à l’intérieur du gestionnaire, les machines à états déclenchantes peuvent être identifiées via self.irq().flags() combiné par ET avec les constantes IRQ_SM*.

trigger est un masque de bits d’une ou plusieurs valeurs IRQ_SM0 .. IRQ_SM3. La valeur par défaut se déclenche sur n’importe quelle machine à états.

hard=True enregistre un gestionnaire d’interruption matérielle (aucune allocation sur le tas dans la fonction de rappel).

MicroPython associe l’IRQ 0 sur chaque bloc PIO ; l’IRQ 1 est réservée et n’est pas accessible depuis Python.

Constantes

IN_LOW: int

À passer à out_init / set_init / sideset_init de asm_pio() pour que la broche démarre comme une entrée pilotée à l’état bas (c’est-à-dire en haute impédance avec le tampon de sortie maintenant un 0).

IN_HIGH: int

À passer à out_init / set_init / sideset_init de asm_pio() pour que la broche démarre comme une entrée avec le tampon de sortie maintenant un 1.

OUT_LOW: int

À passer à out_init / set_init / sideset_init de asm_pio() pour que la broche démarre comme une sortie pilotée au niveau logique 0.

OUT_HIGH: int

À passer à out_init / set_init / sideset_init de asm_pio() pour que la broche démarre comme une sortie pilotée au niveau logique 1.

SHIFT_LEFT: int

À passer à in_shiftdir / out_shiftdir de asm_pio() ou StateMachine.init() pour que les décalages déplacent les bits vers le MSB.

SHIFT_RIGHT: int

À passer à in_shiftdir / out_shiftdir de asm_pio() ou StateMachine.init() pour que les décalages déplacent les bits vers le LSB.

JOIN_NONE: int

À passer à fifo_join de asm_pio() pour que la machine à états dispose de FIFO TX et RX séparées de 4 mots (la valeur par défaut).

JOIN_TX: int

À passer à fifo_join de asm_pio() pour que la FIFO TX soit doublée à 8 mots en absorbant la FIFO RX. La machine à états ne peut alors plus recevoir de données.

JOIN_RX: int

À passer à fifo_join de asm_pio() pour que la FIFO RX soit doublée à 8 mots en absorbant la FIFO TX. La machine à états ne peut alors plus transmettre de données.

IRQ_SM0: int

Indicateur trigger de irq() : la machine à états 0 a levé son IRQ.

IRQ_SM1: int

Indicateur trigger de irq() : la machine à états 1 a levé son IRQ.

IRQ_SM2: int

Indicateur trigger de irq() : la machine à états 2 a levé son IRQ.

IRQ_SM3: int

Indicateur trigger de irq() : la machine à états 3 a levé son IRQ.