classe UART – bus de communication série en duplex¶

UART implémente le protocole standard de communication série en duplex UART/USART. Au niveau physique, il se compose de 2 lignes : RX et TX. L’unité de communication est un caractère (à ne pas confondre avec un caractère de chaîne) qui peut faire 8 ou 9 bits de large.

Les objets UART peuvent être créés et initialisés à l’aide de

from pyb import UART

# init with the given baudrate
uart = UART(3, 9600, timeout_char=1000)

# init with explicit parameters
uart.init(9600, bits=8, parity=None, stop=1, timeout_char=1000)

Bits peut valoir 7, 8 ou 9. Parity peut valoir None, 0 (pair) ou 1 (impair). Stop peut valoir 1 ou 2.

Note : avec parity=None, seuls 8 et 9 bits sont pris en charge. Avec la parité activée, seuls 7 et 8 bits sont pris en charge.

Un objet UART se comporte comme un objet stream et la lecture et l’écriture s’effectuent à l’aide des méthodes de flux standard

uart.read(10)       # read 10 characters, returns a bytes object
uart.read()         # read all available characters
uart.readline()     # read a line
uart.readinto(buf)  # read and store into the given buffer
uart.write('abc')   # write the 3 characters

Les caractères individuels peuvent être lus/écrits à l’aide de

uart.readchar()     # read 1 character and returns it as an integer
uart.writechar(42)  # write 1 character

Pour vérifier s’il y a quelque chose à lire, utilisez

uart.any()          # returns the number of characters waiting

Note : Les fonctions de flux read, write, etc. sont nouvelles dans MicroPython v1.3.4. Les versions antérieures utilisent uart.send et uart.recv.

Constructeurs¶

class pyb.UART(bus: int | str, *args, **kwargs)¶

Construit un objet UART sur le bus donné (un index entier de périphérique, par ex. 3 pour UART3). Sans paramètre supplémentaire, l’objet est créé mais non initialisé (il conserve les réglages précédents du bus, le cas échéant) ; si des arguments supplémentaires sont fournis, le bus est initialisé. Voir init() pour les paramètres disponibles.

UART(3) est câblé sur les mêmes broches d’en-tête sur toutes les OpenMV Cam STM32 :

Signal	Broche d’en-tête
`TX`	`P4`
`RX`	`P5`

Des bus UART supplémentaires sont disponibles sur certaines cartes :

Bus	Broche TX	Broche RX	Disponible sur
`UART(1)`	`P1`	`P0`	OpenMV Cam M7 / H7 / H7 Plus / Pure Thermal
`UART(4)`	`P2`	`P3`	OpenMV Cam N6
`UART(7)`	`P14`	`P13`	OpenMV Cam N6

Méthodes¶

init(baudrate: int, bits: int = 8, parity: int | None = None, stop: int = 1, *, timeout: int = 1000, flow: int = 0, timeout_char: int = 0, read_buf_len: int = 64) → None¶

Initialise le bus UART avec les paramètres donnés :

baudrate est la fréquence d’horloge.

bits est le nombre de bits par caractère, 7, 8 ou 9.

parity est la parité, None, 0 (pair) ou 1 (impair).

stop est le nombre de bits d’arrêt, 1 ou 2.

flow définit le type de contrôle de flux. Peut valoir 0, UART.RTS, UART.CTS ou UART.RTS | UART.CTS.

timeout est le délai d’attente en millisecondes pour l’écriture/lecture du premier caractère.

timeout_char est le délai d’attente en millisecondes entre les caractères lors de l’écriture ou de la lecture.

read_buf_len est la longueur en caractères du tampon de lecture (0 pour désactiver).

Cette méthode lèvera une exception si le débit en bauds n’a pas pu être réglé à moins de 5 % de la valeur souhaitée.

Note : avec parity=None, seuls 8 et 9 bits sont pris en charge. Avec la parité activée, seuls 7 et 8 bits sont pris en charge.

deinit() → None¶: Désactive le bus UART.

any() → int¶: Renvoie le nombre d’octets en attente (peut être 0).

read(nbytes: int | None = None) → bytes | None¶

Lit des caractères. Si nbytes est spécifié, lit au plus ce nombre d’octets. Si nbytes sont disponibles dans le tampon, renvoie immédiatement, sinon renvoie lorsque suffisamment de caractères arrivent ou que le délai d’attente expire.

Si nbytes n’est pas fourni, la méthode lit autant de données que possible. Elle renvoie une fois le délai d’attente écoulé.

Note : pour les caractères de 9 bits, chaque caractère occupe deux octets, nbytes doit être pair, et le nombre de caractères est nbytes/2.

Valeur de retour : un objet bytes contenant les octets lus. Renvoie None en cas d’expiration du délai.

readchar() → int¶

Reçoit un seul caractère sur le bus.

Valeur de retour : le caractère lu, sous forme d’entier. Renvoie -1 en cas d’expiration du délai.

readinto(buf: bytearray, nbytes: int | None = None) → int | None¶

Lit des octets dans buf. Si nbytes est spécifié, lit au plus ce nombre d’octets. Sinon, lit au plus len(buf) octets.

Valeur de retour : nombre d’octets lus et stockés dans buf ou None en cas d’expiration du délai.

readline() → bytes | None¶

Lit une ligne, se terminant par un caractère de saut de ligne. Si une telle ligne existe, le retour est immédiat. Si le délai d’attente expire, toutes les données disponibles sont renvoyées, qu’un saut de ligne existe ou non.

Valeur de retour : la ligne lue ou None en cas d’expiration du délai si aucune donnée n’est disponible.

write(buf: bytes | bytearray | str) → int | None¶

Écrit le tampon d’octets sur le bus. Si les caractères font 7 ou 8 bits de large, alors chaque octet est un caractère. Si les caractères font 9 bits de large, alors deux octets sont utilisés pour chaque caractère (petit-boutiste), et buf doit contenir un nombre pair d’octets.

Valeur de retour : nombre d’octets écrits. Si un délai d’attente expire et qu’aucun octet n’a été écrit, renvoie None.

writechar(char: int) → None¶: Écrit un seul caractère sur le bus. char est un entier à écrire. Voir la section Contrôle de flux CTS ci-dessous pour la sémantique de blocage lorsque le contrôle de flux CTS est activé.

sendbreak() → None¶: Envoie une condition de break sur le bus. Cela maintient le bus à l’état bas pendant une durée de 13 bits.

Constantes¶

RTS: int¶: Indicateur binaire pour l’argument flow de init() ; active le contrôle de flux matériel RTS (request-to-send) sur le chemin de réception.

CTS: int¶: Indicateur binaire pour l’argument flow de init() ; active le contrôle de flux matériel CTS (clear-to-send) sur le chemin de transmission. Peut être combiné par OU avec RTS pour activer les deux directions.

Contrôle de flux¶

UART(3) prend en charge le contrôle de flux matériel RTS/CTS. Sur les OpenMV Cam M7, H7, H7 Plus et Pure Thermal, les broches de contrôle de flux sont :

(TX, RX, nRTS, nCTS) = (P4, P5, P1, P2)

Sur l’OpenMV Cam N6, seul nRTS est exposé (sur la broche d’en-tête P7) ; nCTS n’est pas routé vers l’en-tête d’E/S.

Dans les paragraphes suivants, le terme « cible » désigne le périphérique connecté à l’UART.

Lorsque la méthode init() de l’UART est appelée avec flow défini sur l’une ou les deux valeurs UART.RTS et UART.CTS, les broches de contrôle de flux concernées sont configurées. nRTS est une sortie active à l’état bas et nCTS est une entrée active à l’état bas avec résistance de tirage activée. Pour câbler le contrôle de flux, connectez le nCTS de l’OpenMV Cam au nRTS de la cible et le nRTS de l’OpenMV Cam au nCTS de la cible.

CTS : la cible contrôle l’émetteur de l’OpenMV Cam¶

Si le contrôle de flux CTS est activé, le comportement d’écriture est le suivant :

Si la méthode UART.write(buf) de l’OpenMV Cam est appelée, la transmission se met en pause pendant les périodes où nCTS est False. Cela entraînera une expiration du délai si l’intégralité du tampon n’a pas été transmise pendant la période de délai. La méthode renvoie le nombre d’octets écrits, permettant à l’utilisateur d’écrire le reste des données si nécessaire. En cas d’expiration du délai, un caractère restera dans l’UART en attente de nCTS. Le nombre d’octets composant ce caractère sera inclus dans la valeur de retour.

Si UART.writechar() est appelée lorsque nCTS est False, la méthode expirera à moins que la cible n’affirme nCTS à temps. En cas d’expiration, OSError 116 sera levée. Le caractère sera transmis dès que la cible affirme nCTS.

RTS : l’OpenMV Cam contrôle l’émetteur de la cible¶

Si le contrôle de flux RTS est activé, le comportement est le suivant :

Si l’entrée tamponnée est utilisée (read_buf_len > 0), les caractères entrants sont mis en tampon. Si le tampon devient plein, le prochain caractère à arriver fera passer nRTS à False : la cible doit cesser la transmission. nRTS passera à True lorsque les caractères seront lus depuis le tampon.

Notez que la méthode any() renvoie le nombre d’octets dans le tampon. Supposons une longueur de tampon de N octets. Si le tampon devient plein et qu’un autre caractère arrive, nRTS sera mis à False, et any() renverra le décompte N. Lorsque les caractères seront lus, le caractère supplémentaire sera placé dans le tampon et sera inclus dans le résultat d’un appel ultérieur à any().

Si l’entrée tamponnée n’est pas utilisée (read_buf_len == 0), l’arrivée d’un caractère fera passer nRTS à False jusqu’à ce que le caractère soit lu.