class UART – duplex seriell kommunikationsbuss

UART implementerar det vanliga UART/USART-protokollet för duplex seriell kommunikation. På den fysiska nivån består det av 2 ledningar: RX och TX. Kommunikationsenheten är ett tecken (inte att förväxla med ett strängtecken) som kan vara 8 eller 9 bitar brett.

UART-objekt kan skapas och initieras med:

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 vara 7, 8 eller 9. Stop kan vara 1 eller 2. Med parity=None stöds endast 8 och 9 bitar. Med paritet aktiverad stöds endast 7 och 8 bitar.

Ett UART-objekt fungerar som ett stream-objekt och läsning och skrivning sker med de vanliga strömmetoderna:

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

Konstruktorer

class machine.UART(id: int, baudrate: int = 9600, bits: int = 8, parity: int | None = None, stop: int = 1, *, tx: Pin | None = None, rx: Pin | None = None, rts: Pin | None = None, cts: Pin | None = None, txbuf: int | None = None, rxbuf: int | None = None, timeout: int | None = None, timeout_char: int | None = None, invert: int = 0, flow: int = 0)

Konstruera ett UART-objekt med det angivna id:t.

Metoder

init(baudrate: int = 9600, bits: int = 8, parity: int | None = None, stop: int = 1, *, tx: Pin | None = None, rx: Pin | None = None, rts: Pin | None = None, cts: Pin | None = None, txbuf: int | None = None, rxbuf: int | None = None, timeout: int | None = None, timeout_char: int | None = None, invert: int = 0, flow: int = 0) → None

Initiera UART-bussen med de angivna parametrarna:

  • baudrate är klockfrekvensen.

  • bits är antalet bitar per tecken, 7, 8 eller 9.

  • parity är pariteten, None, 0 (jämn) eller 1 (udda).

  • stop är antalet stoppbitar, 1 eller 2.

Ytterligare parametrar (endast nyckelord) som kan stödjas av en port är:

  • tx anger vilket TX-stift som ska användas.

  • rx anger vilket RX-stift som ska användas.

  • rts anger vilket RTS-stift (utgång) som ska användas för hårdvarustyrd flödeskontroll vid mottagning.

  • cts anger vilket CTS-stift (ingång) som ska användas för hårdvarustyrd flödeskontroll vid sändning.

  • txbuf anger längden i tecken på TX-bufferten.

  • rxbuf anger längden i tecken på RX-bufferten.

  • timeout anger tiden att vänta på det första tecknet (i ms).

  • timeout_char anger tiden att vänta mellan tecken (i ms).

  • invert anger vilka ledningar som ska inverteras.

    • 0 inverterar inga ledningar (viloläget för båda ledningarna är logisk hög).

    • UART.INV_TX inverterar TX-ledningen (viloläget för TX-ledningen är nu logisk låg).

    • UART.INV_RX inverterar RX-ledningen (viloläget för RX-ledningen är nu logisk låg).

    • UART.INV_TX | UART.INV_RX inverterar båda ledningarna (viloläge vid logisk låg).

  • flow anger vilka hårdvarusignaler för flödeskontroll som ska användas. Värdet är en bitmask.

    • 0 ignorerar hårdvarusignaler för flödeskontroll.

    • UART.RTS aktiverar flödeskontroll vid mottagning genom att använda RTS-utgångsstiftet för att signalera om mottagnings-FIFO:n har tillräckligt med utrymme för att ta emot mer data.

    • UART.CTS aktiverar flödeskontroll vid sändning genom att pausa överföringen när CTS-ingångsstiftet signalerar att mottagaren håller på att få slut på buffertutrymme.

    • UART.RTS | UART.CTS aktiverar båda, för fullständig hårdvarustyrd flödeskontroll.

Anteckning

Det är möjligt att anropa init() flera gånger på samma objekt för att omkonfigurera UART under drift. Det gör det möjligt att använda en enda UART-kringutrustning för att betjäna olika enheter anslutna till olika GPIO-stift. Endast en enhet kan betjänas åt gången i det fallet. Anropa inte heller deinit() eftersom det förhindrar att init() anropas igen.

deinit() → None

Stäng av UART-bussen.

Anteckning

Du kommer inte att kunna anropa init() på objektet efter deinit(). En ny instans måste skapas i det fallet.

any() → int

Returnerar ett heltal som räknar antalet tecken som kan läsas utan blockering. Det returnerar 0 om inga tecken är tillgängliga och ett positivt tal om det finns tecken. Metoden kan returnera 1 även om det finns fler än ett tecken tillgängligt för läsning.

För mer avancerad förfrågan om tillgängliga tecken, använd select.poll:

poll = select.poll()
poll.register(uart, select.POLLIN)
poll.poll(timeout)
read(nbytes: int | None = None, /) → bytes | None

Läs tecken. Om nbytes anges läses som mest så många byte, annars läses så mycket data som möjligt. Det kan returnera tidigare om en timeout nås. Timeouten kan konfigureras i konstruktorn.

Returvärde: ett bytes-objekt som innehåller de inlästa byten. Returnerar None vid timeout.

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

Läs byte in i buf. Om nbytes anges läses som mest så många byte. Annars läses som mest len(buf) byte. Det kan returnera tidigare om en timeout nås. Timeouten kan konfigureras i konstruktorn.

Returvärde: antalet byte som lästs och lagrats i buf eller None vid timeout.

readline() → bytes | None

Läs en rad som avslutas med ett radslutstecken. Det kan returnera tidigare om en timeout nås. Timeouten kan konfigureras i konstruktorn.

Returvärde: den inlästa raden eller None vid timeout.

write(buf: bytes) → int | None

Skriv bytebufferten till bussen.

Returvärde: antalet skrivna byte eller None vid timeout.

sendbreak() → None

Skicka ett break-tillstånd på bussen – dra TX låg under längre tid än en teckentid. Tillgänglig på STM32 och mimxrt; exponeras inte på alif.

readchar() → int

Läs ett enstaka tecken från UART och returnera det som ett heltal (eller -1 vid timeout). Lägre omkostnad än read(1) eftersom inget bytes-objekt allokeras. Endast STM32.

writechar(char: int) → None

Skriv det enstaka tecknet char (ett heltal i intervallet 0 – 255) till UART. Lägre omkostnad än write() för sändningar av en enda byte. Endast STM32.

flush() → None

Blockera tills varje byte som för närvarande finns i sändningsbufferten har klockats ut på TX. Utlöser OSError vid timeout; timeouten härleds från TX-buffertens storlek och den konfigurerade baudhastigheten, så om inte flödeskontroll är aktiverad och mottagaren stannar, returnerar anropet långt innan timeouten.

txdone() → bool

Returnerar True när ingen överföring pågår (TX-bufferten är tom och skiftregistret har tömts), False annars. Användbart som ett icke-blockerande alternativ till flush().

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

Installera ett återanrop som ska utlösas vid UART-händelser.

handler är funktionen som ska anropas. Den får UART-instansen som sitt enda argument. Skicka None för att ta bort en tidigare installerad hanterare.

trigger är en bitmask av en eller flera IRQ_*-konstanter (se Konstanter nedan) som väljer vilka händelser som utlöser återanropet.

hard=True registrerar en hård-avbrottshanterare (lägre latens, men hanteraren får inte allokera). Standardvärdet är ett schemalagt återanrop.

Returnerar ett irq-objekt.

Inte alla IRQ-källor är tillgängliga på alla portar – se de enskilda IRQ_*-konstanterna för tillgänglighet per port.

Konstanter

RTS: int

Skicka till flow för att aktivera RTS-hårdvaruflödeskontroll på mottagningssidan. Kombinera med CTS via OR för att aktivera båda.

CTS: int

Skicka till flow för att aktivera CTS-hårdvaruflödeskontroll på sändningssidan.

IRQ_RXIDLE: int

irq()-utlösningsflagga: utlöses en gång efter att ett eller flera tecken har tagits emot och RX-ledningen sedan går i viloläge. Tillgänglig på alla OpenMV-portar.

IRQ_RX: int

irq()-utlösningsflagga: utlöses efter varje mottaget tecken. Tillgänglig på STM32 och alif.

IRQ_TXIDLE: int

irq()-utlösningsflagga: utlöses när det sista tecknet i en sändning har klockats ut. Tillgänglig på mimxrt och alif.

IRQ_BREAK: int

irq()-utlösningsflagga: utlöses när ett break-tillstånd detekteras på RX. Inte tillgänglig på någon OpenMV-port.