class UART – duplexer serieller Kommunikationsbus¶

UART implementiert das standardmäßige serielle Duplex-Kommunikationsprotokoll UART/USART. Auf der physikalischen Ebene besteht es aus 2 Leitungen: RX und TX. Die Kommunikationseinheit ist ein Zeichen (nicht zu verwechseln mit einem String-Zeichen), das 8 oder 9 Bit breit sein kann.

UART-Objekte können wie folgt erstellt und initialisiert werden:

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 kann 7, 8 oder 9 sein. Stop kann 1 oder 2 sein. Mit parity=None werden nur 8 und 9 Bit unterstützt. Bei aktivierter Parität werden nur 7 und 8 Bit unterstützt.

Ein UART-Objekt verhält sich wie ein stream-Objekt, und das Lesen und Schreiben erfolgt über die standardmäßigen 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

Konstruktoren¶

Erzeugt ein UART-Objekt mit der angegebenen ID.

Methoden¶

Initialisiert den UART-Bus mit den angegebenen Parametern:

baudrate ist die Taktrate.

bits ist die Anzahl der Bits pro Zeichen, 7, 8 oder 9.

parity ist die Parität, None, 0 (gerade) oder 1 (ungerade).

stop ist die Anzahl der Stoppbits, 1 oder 2.

Zusätzliche reine Schlüsselwort-Parameter, die von einem Port unterstützt werden können, sind:

tx gibt den zu verwendenden TX-Pin an.

rx gibt den zu verwendenden RX-Pin an.

rts gibt den RTS-Pin (Ausgang) an, der für die hardwarebasierte Empfangs-Flusssteuerung verwendet werden soll.

cts gibt den CTS-Pin (Eingang) an, der für die hardwarebasierte Sende-Flusssteuerung verwendet werden soll.

txbuf gibt die Länge des TX-Puffers in Zeichen an.

rxbuf gibt die Länge des RX-Puffers in Zeichen an.

timeout gibt die Wartezeit für das erste Zeichen an (in ms).

timeout_char gibt die Wartezeit zwischen Zeichen an (in ms).

invert gibt an, welche Leitungen invertiert werden sollen.

0 invertiert keine Leitungen (Ruhezustand beider Leitungen ist logisch High).

UART.INV_TX invertiert die TX-Leitung (Ruhezustand der TX-Leitung ist nun logisch Low).

UART.INV_RX invertiert die RX-Leitung (Ruhezustand der RX-Leitung ist nun logisch Low).

UART.INV_TX | UART.INV_RX invertiert beide Leitungen (Ruhezustand auf logisch Low).

flow gibt an, welche Hardware-Flusssteuerungssignale verwendet werden sollen. Der Wert ist eine Bitmaske.

0 ignoriert Hardware-Flusssteuerungssignale.

UART.RTS aktiviert die Empfangs-Flusssteuerung, indem der RTS-Ausgangspin signalisiert, ob der Empfangs-FIFO ausreichend Platz hat, um weitere Daten aufzunehmen.

UART.CTS aktiviert die Sende-Flusssteuerung, indem die Übertragung pausiert wird, wenn der CTS-Eingangspin signalisiert, dass beim Empfänger der Pufferspeicher knapp wird.

UART.RTS | UART.CTS aktiviert beide, für eine vollständige Hardware-Flusssteuerung.

Bemerkung

Es ist möglich, init() mehrfach auf demselben Objekt aufzurufen, um den UART im laufenden Betrieb neu zu konfigurieren. Dies erlaubt es, ein einzelnes UART-Peripheriegerät zur Bedienung verschiedener Geräte zu nutzen, die an unterschiedlichen GPIO-Pins angeschlossen sind. In diesem Fall kann jeweils nur ein Gerät bedient werden. Rufen Sie außerdem nicht deinit() auf, da dies einen erneuten Aufruf von init() verhindert.

deinit() → None¶: Schaltet den UART-Bus aus.

Bemerkung

Nach deinit() können Sie init() nicht mehr auf dem Objekt aufrufen. In diesem Fall muss eine neue Instanz erstellt werden.

any() → int¶

Gibt eine ganze Zahl zurück, die die Anzahl der Zeichen angibt, die ohne Blockieren gelesen werden können. Sie gibt 0 zurück, wenn keine Zeichen verfügbar sind, und eine positive Zahl, wenn Zeichen vorhanden sind. Die Methode kann 1 zurückgeben, auch wenn mehr als ein Zeichen zum Lesen verfügbar ist.

Für eine ausgefeiltere Abfrage der verfügbaren Zeichen verwenden Sie select.poll:

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

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

Liest Zeichen. Wenn nbytes angegeben ist, werden höchstens so viele Bytes gelesen, andernfalls werden so viele Daten wie möglich gelesen. Die Methode kann früher zurückkehren, wenn ein Timeout erreicht wird. Das Timeout ist im Konstruktor konfigurierbar.

Rückgabewert: ein Bytes-Objekt, das die eingelesenen Bytes enthält. Gibt bei Timeout None zurück.

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

Liest Bytes in buf. Wenn nbytes angegeben ist, werden höchstens so viele Bytes gelesen. Andernfalls werden höchstens len(buf) Bytes gelesen. Die Methode kann früher zurückkehren, wenn ein Timeout erreicht wird. Das Timeout ist im Konstruktor konfigurierbar.

Rückgabewert: Anzahl der gelesenen und in buf gespeicherten Bytes oder None bei Timeout.

readline() → bytes | None¶

Liest eine Zeile, die mit einem Zeilenumbruchzeichen endet. Die Methode kann früher zurückkehren, wenn ein Timeout erreicht wird. Das Timeout ist im Konstruktor konfigurierbar.

Rückgabewert: die gelesene Zeile oder None bei Timeout.

write(buf: bytes) → int | None¶

Schreibt den Byte-Puffer auf den Bus.

Rückgabewert: Anzahl der geschriebenen Bytes oder None bei Timeout.

sendbreak() → None¶: Sendet eine Break-Bedingung auf dem Bus – treibt TX länger als die Dauer eines Zeichens auf Low. Verfügbar auf STM32 und mimxrt; auf alif nicht verfügbar.

readchar() → int¶: Liest ein einzelnes Zeichen vom UART und gibt es als ganze Zahl zurück (oder -1 bei Timeout). Geringerer Overhead als read(1), da kein bytes-Objekt allokiert wird. Nur STM32.

writechar(char: int) → None¶: Schreibt das einzelne Zeichen char (eine ganze Zahl im Bereich 0 – 255) auf den UART. Geringerer Overhead als write() für Einzelbyte-Sendungen. Nur STM32.

flush() → None¶: Blockiert, bis jedes Byte, das sich aktuell im Sendepuffer befindet, auf TX herausgetaktet wurde. Löst bei Timeout einen OSError aus; das Timeout wird aus der Größe des TX-Puffers und der konfigurierten Baudrate abgeleitet, sodass der Aufruf weit vor dem Timeout zurückkehrt, sofern nicht die Flusssteuerung aktiviert ist und der Empfänger stockt.

txdone() → bool¶: Gibt True zurück, wenn keine Übertragung im Gange ist (der TX-Puffer ist leer und das Schieberegister ist geleert), andernfalls False. Nützlich als nicht blockierende Alternative zu flush().

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

Installiert einen Callback, der bei UART-Ereignissen ausgelöst wird.

handler ist die aufzurufende Funktion. Sie erhält die UART-Instanz als einziges Argument. Übergeben Sie None, um einen zuvor installierten Handler zu entfernen.

trigger ist eine Bitmaske aus einer oder mehreren IRQ_*-Konstanten (siehe Konstanten unten), die auswählt, welche Ereignisse den Callback auslösen.

hard=True registriert einen Hard-Interrupt-Handler (geringere Latenz, aber der Handler darf nicht allokieren). Standard ist ein geplanter Callback.

Gibt ein IRQ-Objekt zurück.

Nicht jede IRQ-Quelle ist auf jedem Port verfügbar – siehe die einzelnen IRQ_*-Konstanten für die Verfügbarkeit je Port.

Konstanten¶

RTS: int¶: An flow übergeben, um die RTS-Hardware-Flusssteuerung auf der Empfangsseite zu aktivieren. Kombinieren Sie sie über OR mit CTS, um beide zu aktivieren.

CTS: int¶: An flow übergeben, um die CTS-Hardware-Flusssteuerung auf der Sendeseite zu aktivieren.

IRQ_RXIDLE: int¶: irq()-Trigger-Flag: wird einmal ausgelöst, nachdem ein oder mehrere Zeichen empfangen wurden und die RX-Leitung anschließend in den Ruhezustand übergeht. Auf allen OpenMV-Ports verfügbar.

IRQ_RX: int¶: irq()-Trigger-Flag: wird nach jedem empfangenen Zeichen ausgelöst. Verfügbar auf STM32 und alif.

IRQ_TXIDLE: int¶: irq()-Trigger-Flag: wird ausgelöst, wenn das letzte Zeichen einer Übertragung herausgetaktet wurde. Verfügbar auf mimxrt und alif.

IRQ_BREAK: int¶: irq()-Trigger-Flag: wird ausgelöst, wenn eine Break-Bedingung auf RX erkannt wird. Auf keinem OpenMV-Port verfügbar.