clasa UART – magistrală de comunicație serială duplex¶

UART implementează protocolul standard de comunicație serială duplex UART/USART. La nivel fizic constă din 2 linii: RX și TX. Unitatea de comunicație este un caracter (a nu se confunda cu un caracter dintr-un șir) care poate avea o lățime de 8 sau 9 biți.

Obiectele UART pot fi create și inițializate folosind:

from machine import UART

uart = UART(3, 9600)                         # init with given baudrate
uart.init(9600, bits=8, parity=None, stop=1) # init with given parameters

Numărul de biți poate fi 7, 8 sau 9. Stop poate fi 1 sau 2. Cu parity=None, sunt acceptate doar 8 și 9 biți. Cu paritatea activată, sunt acceptate doar 7 și 8 biți.

Un obiect UART se comportă ca un obiect stream, iar citirea și scrierea se realizează folosind metodele standard pentru fluxuri:

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

Constructori¶

Construiește un obiect UART cu id-ul dat.

Metode¶

Inițializează magistrala UART cu parametrii dați:

baudrate este rata de ceas.

bits este numărul de biți per caracter, 7, 8 sau 9.

parity este paritatea, None, 0 (pară) sau 1 (impară).

stop este numărul de biți de stop, 1 sau 2.

Parametri suplimentari, doar de tip cuvânt-cheie, care pot fi acceptați de un port sunt:

tx specifică pinul TX care urmează să fie folosit.

rx specifică pinul RX care urmează să fie folosit.

rts specifică pinul RTS (ieșire) care urmează să fie folosit pentru controlul hardware al fluxului la recepție.

cts specifică pinul CTS (intrare) care urmează să fie folosit pentru controlul hardware al fluxului la transmisie.

txbuf specifică lungimea, în caractere, a tamponului (buffer) TX.

rxbuf specifică lungimea, în caractere, a tamponului (buffer) RX.

timeout specifică timpul de așteptare pentru primul caracter (în ms).

timeout_char specifică timpul de așteptare între caractere (în ms).

invert specifică ce linii să fie inversate.

0 nu va inversa liniile (starea de repaus a ambelor linii este nivelul logic ridicat).

UART.INV_TX va inversa linia TX (starea de repaus a liniei TX devine acum nivelul logic coborât).

UART.INV_RX va inversa linia RX (starea de repaus a liniei RX devine acum nivelul logic coborât).

UART.INV_TX | UART.INV_RX va inversa ambele linii (starea de repaus la nivelul logic coborât).

flow specifică ce semnale de control hardware al fluxului să fie folosite. Valoarea este o mască de biți.

0 va ignora semnalele de control hardware al fluxului.

UART.RTS va activa controlul fluxului la recepție folosind pinul de ieșire RTS pentru a semnaliza dacă FIFO-ul de recepție are spațiu suficient pentru a accepta mai multe date.

UART.CTS va activa controlul fluxului la transmisie prin întreruperea transmisiei atunci când pinul de intrare CTS semnalizează că receptorul rămâne fără spațiu de tampon (buffer).

UART.RTS | UART.CTS le va activa pe ambele, pentru control hardware complet al fluxului.

Notă

Este posibil să apelați init() de mai multe ori pe același obiect pentru a reconfigura UART din mers. Acest lucru permite folosirea unui singur periferic UART pentru a deservi diferite dispozitive conectate la diferiți pini GPIO. În acest caz, poate fi deservit un singur dispozitiv la un moment dat. De asemenea, nu apelați deinit(), deoarece acest lucru va împiedica apelarea din nou a init().

deinit() → None¶: Oprește magistrala UART.

Notă

Nu veți putea apela init() pe obiect după deinit(). În acest caz, trebuie creată o nouă instanță.

any() → int¶

Returnează un întreg ce numără caracterele care pot fi citite fără blocare. Va returna 0 dacă nu sunt caractere disponibile și un număr pozitiv dacă există caractere. Metoda poate returna 1 chiar dacă există mai mult de un caracter disponibil pentru citire.

Pentru o interogare mai sofisticată a caracterelor disponibile, folosiți select.poll:

poll = select.poll()
poll.register(uart, select.POLLIN)
poll.poll(timeout)

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

Citește caractere. Dacă nbytes este specificat, citește cel mult atâția octeți, altfel citește cât de multe date posibil. Poate returna mai devreme dacă se atinge un timeout. Timeout-ul este configurabil în constructor.

Valoare returnată: un obiect bytes ce conține octeții citiți. Returnează None la timeout.

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

Citește octeți în buf. Dacă nbytes este specificat, citește cel mult atâția octeți. Altfel, citește cel mult len(buf) octeți. Poate returna mai devreme dacă se atinge un timeout. Timeout-ul este configurabil în constructor.

Valoare returnată: numărul de octeți citiți și stocați în buf sau None la timeout.

readline() → bytes | None¶

Citește o linie, care se termină cu un caracter de linie nouă. Poate returna mai devreme dacă se atinge un timeout. Timeout-ul este configurabil în constructor.

Valoare returnată: linia citită sau None la timeout.

write(buf: bytes) → int | None¶

Scrie tamponul (buffer) de octeți pe magistrală.

Valoare returnată: numărul de octeți scriși sau None la timeout.

sendbreak() → None¶: Trimite o condiție de break pe magistrală – menține TX la nivel coborât pentru o durată mai lungă decât timpul unui caracter. Disponibilă pe STM32 și mimxrt; nu este expusă pe alif.

readchar() → int¶: Citește un singur caracter din UART și îl returnează ca întreg (sau -1 la timeout). Are o suprasarcină mai mică decât read(1), deoarece nu se alocă niciun obiect bytes. Doar STM32.

writechar(char: int) → None¶: Scrie un singur caracter char (un întreg în intervalul 0 – 255) în UART. Are o suprasarcină mai mică decât write() pentru trimiteri de un singur octet. Doar STM32.

flush() → None¶: Blochează execuția până când fiecare octet aflat în prezent în tamponul de transmisie a fost transmis pe TX. Generează OSError la timeout; timeout-ul este derivat din dimensiunea tamponului TX și rata baud configurată, astfel încât, dacă nu este activat controlul fluxului și receptorul nu se blochează, apelul revine cu mult înainte de timeout.

txdone() → bool¶: Returnează True atunci când nu este nicio transmisie în curs (tamponul TX este gol și registrul de deplasare s-a golit), False în caz contrar. Util ca alternativă neblocantă la flush().

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

Instalează o funcție de retroapelare (callback) care să se declanșeze la evenimente UART.

handler este funcția care urmează să fie apelată. Primește instanța UART ca unic argument. Transmiteți None pentru a elimina un handler instalat anterior.

trigger este o mască de biți cu una sau mai multe constante IRQ_* (vezi Constante mai jos) care selectează ce evenimente declanșează funcția de retroapelare (callback).

hard=True înregistrează un handler de întrerupere hard (latență mai mică, dar handler-ul nu trebuie să aloce memorie). Implicit se folosește o funcție de retroapelare (callback) programată.

Returnează un obiect irq.

Nu fiecare sursă IRQ este disponibilă pe fiecare port – vezi constantele individuale IRQ_* pentru disponibilitatea pe fiecare port.

Constante¶

RTS: int¶: Transmiteți către flow pentru a activa controlul hardware al fluxului RTS pe partea de recepție. Combinați cu CTS prin OR pentru a le activa pe ambele.

CTS: int¶: Transmiteți către flow pentru a activa controlul hardware al fluxului CTS pe partea de transmisie.

IRQ_RXIDLE: int¶: Indicator de declanșare irq(): se declanșează o dată după ce unul sau mai multe caractere au fost recepționate, iar linia RX trece apoi în repaus. Disponibil pe toate porturile OpenMV.

IRQ_RX: int¶: Indicator de declanșare irq(): se declanșează după fiecare caracter recepționat. Disponibil pe STM32 și alif.

IRQ_TXIDLE: int¶: Indicator de declanșare irq(): se declanșează când ultimul caracter al unei transmisii a fost transmis. Disponibil pe mimxrt și alif.

IRQ_BREAK: int¶: Indicator de declanșare irq(): se declanșează când este detectată o condiție de break pe RX. Nu este disponibil pe niciun port OpenMV.