Klasse UART – serieller Vollduplex-Kommunikationsbus¶

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

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

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 kann 7, 8 oder 9 sein. Parity kann None, 0 (gerade) oder 1 (ungerade) sein. Stop kann 1 oder 2 sein.

Hinweis: Mit parity=None werden nur 8 und 9 Bit unterstützt. Mit 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 Standard-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

Einzelne Zeichen können wie folgt gelesen/geschrieben werden:

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

Um zu prüfen, ob etwas zu lesen vorhanden ist, verwenden Sie:

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

Hinweis: Die Stream-Funktionen read, write usw. sind neu in MicroPython v1.3.4. Frühere Versionen verwenden uart.send und uart.recv.

Konstruktoren¶

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

Konstruiert ein UART-Objekt am angegebenen bus (ein ganzzahliger Peripherie-Index, z. B. 3 für UART3). Ohne zusätzliche Parameter wird das Objekt erstellt, aber nicht initialisiert (es behält die vorherigen Buseinstellungen bei, falls vorhanden); wenn zusätzliche Argumente angegeben werden, wird der Bus initialisiert. Siehe init() für die verfügbaren Parameter.

UART(3) ist auf jeder STM32 OpenMV Cam mit denselben Header-Pins verdrahtet:

Signal	Header-Pin
`TX`	`P4`
`RX`	`P5`

Auf einigen Boards sind zusätzliche UART-Busse verfügbar:

Bus	TX-Pin	RX-Pin	Verfügbar auf
`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

Methoden¶

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¶

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.

flow legt den Typ der Flusssteuerung fest. Kann 0, UART.RTS, UART.CTS oder UART.RTS | UART.CTS sein.

timeout ist die Zeitüberschreitung in Millisekunden, die auf das Schreiben/Lesen des ersten Zeichens gewartet wird.

timeout_char ist die Zeitüberschreitung in Millisekunden, die beim Schreiben oder Lesen zwischen Zeichen gewartet wird.

read_buf_len ist die Zeichenlänge des Lesepuffers (0 zum Deaktivieren).

Diese Methode löst eine Ausnahme aus, wenn die Baudrate nicht innerhalb von 5 % des gewünschten Werts eingestellt werden konnte.

Hinweis: Mit parity=None werden nur 8 und 9 Bit unterstützt. Mit aktivierter Parität werden nur 7 und 8 Bit unterstützt.

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

any() → int¶: Gibt die Anzahl der wartenden Bytes zurück (kann 0 sein).

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

Liest Zeichen. Wenn nbytes angegeben ist, werden höchstens so viele Bytes gelesen. Wenn nbytes im Puffer verfügbar sind, kehrt die Methode sofort zurück, andernfalls kehrt sie zurück, wenn genügend Zeichen eintreffen oder die Zeitüberschreitung abläuft.

Wenn nbytes nicht angegeben ist, liest die Methode so viele Daten wie möglich. Sie kehrt zurück, nachdem die Zeitüberschreitung abgelaufen ist.

Hinweis: Bei 9-Bit-Zeichen belegt jedes Zeichen zwei Bytes, nbytes muss gerade sein, und die Anzahl der Zeichen ist nbytes/2.

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

readchar() → int¶

Empfängt ein einzelnes Zeichen auf dem Bus.

Rückgabewert: Das gelesene Zeichen als Ganzzahl. Gibt bei Zeitüberschreitung -1 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.

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

readline() → bytes | None¶

Liest eine Zeile, die mit einem Zeilenumbruchzeichen endet. Wenn eine solche Zeile existiert, erfolgt die Rückgabe sofort. Wenn die Zeitüberschreitung abläuft, werden alle verfügbaren Daten zurückgegeben, unabhängig davon, ob ein Zeilenumbruch existiert.

Rückgabewert: die gelesene Zeile oder None bei Zeitüberschreitung, wenn keine Daten verfügbar sind.

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

Schreibt den Byte-Puffer auf den Bus. Wenn Zeichen 7 oder 8 Bit breit sind, ist jedes Byte ein Zeichen. Wenn Zeichen 9 Bit breit sind, werden zwei Bytes für jedes Zeichen verwendet (Little Endian), und buf muss eine gerade Anzahl von Bytes enthalten.

Rückgabewert: Anzahl der geschriebenen Bytes. Wenn eine Zeitüberschreitung auftritt und keine Bytes geschrieben wurden, wird None zurückgegeben.

writechar(char: int) → None¶: Schreibt ein einzelnes Zeichen auf den Bus. char ist eine Ganzzahl, die geschrieben werden soll. Siehe den Abschnitt CTS-Flusssteuerung weiter unten für die Blockierungssemantik bei aktivierter CTS-Flusssteuerung.

sendbreak() → None¶: Sendet eine Break-Bedingung auf dem Bus. Dies zieht den Bus für die Dauer von 13 Bit auf Low.

Konstanten¶

RTS: int¶: Bit-Flag für das Argument flow von init(); aktiviert die RTS-Hardware-Flusssteuerung (request-to-send) auf dem Empfangspfad.

CTS: int¶: Bit-Flag für das Argument flow von init(); aktiviert die CTS-Hardware-Flusssteuerung (clear-to-send) auf dem Sendepfad. Kann mit RTS per OR verknüpft werden, um beide Richtungen zu aktivieren.

Flusssteuerung¶

UART(3) unterstützt die RTS/CTS-Hardware-Flusssteuerung. Auf der OpenMV Cam M7, H7, H7 Plus und Pure Thermal sind die Flusssteuerungs-Pins:

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

Auf der OpenMV Cam N6 ist nur nRTS herausgeführt (an Header-Pin P7); nCTS ist nicht zum I/O-Header geführt.

In den folgenden Absätzen bezieht sich der Begriff „Ziel“ auf das mit dem UART verbundene Gerät.

Wenn die init()-Methode des UART mit flow aufgerufen wird, das auf einen oder beide der Werte UART.RTS und UART.CTS gesetzt ist, werden die entsprechenden Flusssteuerungs-Pins konfiguriert. nRTS ist ein Active-Low-Ausgang und nCTS ist ein Active-Low-Eingang mit aktiviertem Pull-up. Um die Flusssteuerung zu verdrahten, verbinden Sie nCTS der OpenMV Cam mit nRTS des Ziels und nRTS der OpenMV Cam mit nCTS des Ziels.

CTS: Ziel steuert den Sender der OpenMV Cam¶

Wenn die CTS-Flusssteuerung aktiviert ist, ist das Schreibverhalten wie folgt:

Wenn die UART.write(buf)-Methode der OpenMV Cam aufgerufen wird, wird die Übertragung für alle Zeiträume angehalten, in denen nCTS False ist. Dies führt zu einer Zeitüberschreitung, wenn der gesamte Puffer nicht innerhalb des Zeitüberschreitungszeitraums übertragen wurde. Die Methode gibt die Anzahl der geschriebenen Bytes zurück, sodass der Benutzer bei Bedarf die restlichen Daten schreiben kann. Im Falle einer Zeitüberschreitung verbleibt ein Zeichen im UART und wartet auf nCTS. Die Anzahl der Bytes, aus denen dieses Zeichen besteht, wird im Rückgabewert berücksichtigt.

Wenn UART.writechar() aufgerufen wird, während nCTS False ist, läuft die Methode in eine Zeitüberschreitung, es sei denn, das Ziel setzt nCTS rechtzeitig. Bei einer Zeitüberschreitung wird OSError 116 ausgelöst. Das Zeichen wird übertragen, sobald das Ziel nCTS setzt.

RTS: OpenMV Cam steuert den Sender des Ziels¶

Wenn die RTS-Flusssteuerung aktiviert ist, ist das Verhalten wie folgt:

Wenn gepufferte Eingabe verwendet wird (read_buf_len > 0), werden eingehende Zeichen gepuffert. Wenn der Puffer voll wird, bewirkt das nächste eintreffende Zeichen, dass nRTS auf False geht: Das Ziel sollte die Übertragung einstellen. nRTS geht auf True, wenn Zeichen aus dem Puffer gelesen werden.

Beachten Sie, dass die any()-Methode die Anzahl der Bytes im Puffer zurückgibt. Nehmen Sie eine Pufferlänge von N Bytes an. Wenn der Puffer voll wird und ein weiteres Zeichen eintrifft, wird nRTS auf False gesetzt, und any() gibt die Anzahl N zurück. Wenn Zeichen gelesen werden, wird das zusätzliche Zeichen in den Puffer eingefügt und im Ergebnis eines nachfolgenden any()-Aufrufs berücksichtigt.

Wenn keine gepufferte Eingabe verwendet wird (read_buf_len == 0), bewirkt das Eintreffen eines Zeichens, dass nRTS auf False geht, bis das Zeichen gelesen wird.