class UART – duplex seriële communicatiebus¶

UART implementeert het standaard UART/USART duplex seriële communicatieprotocol. Op fysiek niveau bestaat het uit 2 lijnen: RX en TX. De communicatie-eenheid is een teken (niet te verwarren met een teken in een string) dat 8 of 9 bits breed kan zijn.

UART-objecten kunnen worden aangemaakt en geïnitialiseerd met:

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

Bits kan 7, 8 of 9 zijn. Stop kan 1 of 2 zijn. Met parity=None worden alleen 8 en 9 bits ondersteund. Met pariteit ingeschakeld worden alleen 7 en 8 bits ondersteund.

Een UART-object gedraagt zich als een stream-object en lezen en schrijven gebeurt met de standaard stream-methoden:

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

Constructors¶

Construeert een UART-object met de gegeven id.

Methoden¶

Initialiseert de UART-bus met de gegeven parameters:

baudrate is de kloksnelheid.

bits is het aantal bits per teken, 7, 8 of 9.

parity is de pariteit, None, 0 (even) of 1 (oneven).

stop is het aantal stopbits, 1 of 2.

Aanvullende parameters die alleen als trefwoord kunnen worden opgegeven en die door een port ondersteund kunnen worden zijn:

tx specificeert de te gebruiken TX-pin.

rx specificeert de te gebruiken RX-pin.

rts specificeert de te gebruiken RTS-pin (uitgang) voor hardwarematige ontvangstflowcontrol.

cts specificeert de te gebruiken CTS-pin (ingang) voor hardwarematige verzendflowcontrol.

txbuf specificeert de lengte in tekens van de TX-buffer.

rxbuf specificeert de lengte in tekens van de RX-buffer.

timeout specificeert de wachttijd voor het eerste teken (in ms).

timeout_char specificeert de wachttijd tussen tekens (in ms).

invert specificeert welke lijnen geïnverteerd moeten worden.

0 inverteert geen lijnen (de rusttoestand van beide lijnen is logisch hoog).

UART.INV_TX inverteert de TX-lijn (de rusttoestand van de TX-lijn is nu logisch laag).

UART.INV_RX inverteert de RX-lijn (de rusttoestand van de RX-lijn is nu logisch laag).

UART.INV_TX | UART.INV_RX inverteert beide lijnen (rusttoestand op logisch laag).

flow specificeert welke hardwarematige flowcontrolsignalen gebruikt moeten worden. De waarde is een bitmasker.

0 negeert hardwarematige flowcontrolsignalen.

UART.RTS schakelt ontvangstflowcontrol in door de RTS-uitgangspin te gebruiken om aan te geven of de ontvangst-FIFO voldoende ruimte heeft om meer data te accepteren.

UART.CTS schakelt verzendflowcontrol in door de verzending te pauzeren wanneer de CTS-ingangspin aangeeft dat de ontvanger weinig bufferruimte meer heeft.

UART.RTS | UART.CTS schakelt beide in, voor volledige hardwarematige flowcontrol.

Notitie

Het is mogelijk om init() meerdere keren op hetzelfde object aan te roepen om UART tijdens runtime te herconfigureren. Dit maakt het mogelijk om met één UART-randapparaat verschillende apparaten aangesloten op verschillende GPIO-pinnen te bedienen. In dat geval kan slechts één apparaat tegelijk worden bediend. Roep ook deinit() niet aan, omdat dit het opnieuw aanroepen van init() verhindert.

deinit() → None¶: Schakelt de UART-bus uit.

Notitie

Je kunt init() niet meer op het object aanroepen na deinit(). In dat geval moet er een nieuwe instantie worden aangemaakt.

any() → int¶

Geeft een geheel getal terug dat het aantal tekens telt dat gelezen kan worden zonder te blokkeren. Het geeft 0 terug als er geen tekens beschikbaar zijn en een positief getal als er tekens zijn. De methode kan 1 teruggeven, zelfs als er meer dan één teken beschikbaar is om te lezen.

Gebruik voor geavanceerdere opvragingen van beschikbare tekens select.poll:

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

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

Leest tekens. Als nbytes is opgegeven, worden er hooguit zoveel bytes gelezen, anders wordt er zoveel data als mogelijk gelezen. De methode kan eerder terugkeren als er een timeout wordt bereikt. De timeout is configureerbaar in de constructor.

Retourwaarde: een bytes-object met de ingelezen bytes. Geeft None terug bij een timeout.

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

Leest bytes in buf. Als nbytes is opgegeven, worden er hooguit zoveel bytes gelezen. Anders worden er hooguit len(buf) bytes gelezen. De methode kan eerder terugkeren als er een timeout wordt bereikt. De timeout is configureerbaar in de constructor.

Retourwaarde: het aantal gelezen en in buf opgeslagen bytes, of None bij een timeout.

readline() → bytes | None¶

Leest een regel, eindigend op een newline-teken. De methode kan eerder terugkeren als er een timeout wordt bereikt. De timeout is configureerbaar in de constructor.

Retourwaarde: de gelezen regel of None bij een timeout.

write(buf: bytes) → int | None¶

Schrijft de buffer met bytes naar de bus.

Retourwaarde: het aantal geschreven bytes of None bij een timeout.

sendbreak() → None¶: Verstuurt een break-conditie op de bus – houdt TX laag gedurende langer dan één tekentijd. Beschikbaar op STM32 en mimxrt; niet beschikbaar op alif.

readchar() → int¶: Leest een enkel teken van de UART en geeft het terug als een geheel getal (of -1 bij een timeout). Lagere overhead dan read(1) omdat er geen bytes-object wordt gealloceerd. Alleen STM32.

writechar(char: int) → None¶: Schrijft het enkele teken char (een geheel getal in het bereik 0 – 255) naar de UART. Lagere overhead dan write() voor verzendingen van één byte. Alleen STM32.

flush() → None¶: Blokkeert totdat elke byte die zich momenteel in de verzendbuffer bevindt op TX is uitgeklokt. Genereert OSError bij een timeout; de timeout wordt afgeleid van de grootte van de TX-buffer en de geconfigureerde baudrate, dus tenzij flowcontrol is ingeschakeld en de ontvanger blokkeert, keert de aanroep ruim voor de timeout terug.

txdone() → bool¶: Geeft True terug wanneer er geen verzending gaande is (de TX-buffer is leeg en het schuifregister is geleegd), anders False. Nuttig als niet-blokkerend alternatief voor flush().

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

Installeert een callback die afgaat bij UART-events.

handler is de aan te roepen functie. Deze ontvangt de UART-instantie als enige argument. Geef None door om een eerder geïnstalleerde handler te verwijderen.

trigger is een bitmasker van een of meer IRQ_*-constanten (zie Constanten hieronder) dat selecteert welke events de callback laten afgaan.

hard=True registreert een hard-interrupt-handler (lagere latentie, maar de handler mag niet alloceren). De standaard is een ingeplande callback.

Geeft een irq-object terug.

Niet elke IRQ-bron is op elke port beschikbaar – zie de afzonderlijke IRQ_*-constanten voor de beschikbaarheid per port.

Constanten¶

RTS: int¶: Geef door aan flow om RTS-hardwareflowcontrol aan de ontvangstzijde in te schakelen. Combineer met CTS via OR om beide in te schakelen.

CTS: int¶: Geef door aan flow om CTS-hardwareflowcontrol aan de verzendzijde in te schakelen.

IRQ_RXIDLE: int¶: irq() triggervlag: gaat eenmalig af nadat een of meer tekens zijn ontvangen en de RX-lijn vervolgens inactief wordt. Beschikbaar op alle OpenMV-ports.

IRQ_RX: int¶: irq() triggervlag: gaat af na elk ontvangen teken. Beschikbaar op STM32 en alif.

IRQ_TXIDLE: int¶: irq() triggervlag: gaat af wanneer het laatste teken van een verzending is uitgeklokt. Beschikbaar op mimxrt en alif.

IRQ_BREAK: int¶: irq() triggervlag: gaat af wanneer er een break-conditie op RX wordt gedetecteerd. Niet beschikbaar op enige OpenMV-port.