klassen UART – dubbelriktad seriell kommunikationsbuss¶

UART implementerar det vanliga dubbelriktade seriella kommunikationsprotokollet UART/USART. På fysisk nivå består det av 2 ledningar: RX och TX. Kommunikationsenheten är ett tecken (ska inte förväxlas med ett strängtecken) som kan vara 8 eller 9 bitar brett.

UART-objekt kan skapas och initieras med:

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 kan vara 7, 8 eller 9. Parity kan vara None, 0 (jämn) eller 1 (udda). Stop kan vara 1 eller 2.

Obs: 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

Enskilda tecken kan läsas/skrivas med:

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

För att kontrollera om det finns något att läsa, använd:

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

Obs: Strömfunktionerna read, write osv. är nya i MicroPython v1.3.4. Tidigare versioner använder uart.send och uart.recv.

Konstruktorer¶

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

Konstruera ett UART-objekt på den angivna bus (ett heltal som anger kringutrustningens index, t.ex. 3 för UART3). Utan ytterligare parametrar skapas objektet men initieras inte (det behåller de tidigare bussinställningarna, om några finns); om extra argument anges initieras bussen. Se init() för tillgängliga parametrar.

UART(3) är kopplad till samma kontaktstift på varje STM32 OpenMV Cam:

Signal	Kontaktstift
`TX`	`P4`
`RX`	`P5`

Ytterligare UART-bussar är tillgängliga på vissa kort:

Buss	TX-stift	RX-stift	Tillgänglig på
`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

Metoder¶

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¶

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.

flow anger typen av flödeskontroll. Kan vara 0, UART.RTS, UART.CTS eller UART.RTS | UART.CTS.

timeout är timeouten i millisekunder för att vänta på skrivning/läsning av det första tecknet.

timeout_char är timeouten i millisekunder för att vänta mellan tecken under skrivning eller läsning.

read_buf_len är teckenlängden för läsbufferten (0 för att inaktivera).

Denna metod ger upphov till ett undantag om baudhastigheten inte kunde ställas in inom 5 % av det önskade värdet.

Obs: med parity=None stöds endast 8 och 9 bitar. Med paritet aktiverad stöds endast 7 och 8 bitar.

deinit() → None¶: Stäng av UART-bussen.

any() → int¶: Returnerar antalet byte som väntar (kan vara 0).

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

Läs tecken. Om nbytes anges läses högst så många byte. Om nbytes finns tillgängliga i bufferten returnerar metoden omedelbart, annars returnerar den när tillräckligt många tecken anländer eller timeouten löper ut.

Om nbytes inte anges läser metoden så mycket data som möjligt. Den returnerar efter att timeouten har löpt ut.

Obs: för 9-bitars tecken upptar varje tecken två byte, nbytes måste vara jämnt, och antalet tecken är nbytes/2.

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

readchar() → int¶

Ta emot ett enstaka tecken på bussen.

Returvärde: Det inlästa tecknet, som ett heltal. Returnerar -1 vid timeout.

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

Läs byte in i buf. Om nbytes anges läses högst så många byte. Annars läses högst len(buf) byte.

Returvärde: antalet byte som lästes in och lagrades i buf eller None vid timeout.

readline() → bytes | None¶

Läs en rad som avslutas med ett radslutstecken. Om en sådan rad finns returnerar metoden omedelbart. Om timeouten löper ut returneras all tillgänglig data oavsett om det finns ett radslutstecken eller inte.

Returvärde: den inlästa raden eller None vid timeout om ingen data är tillgänglig.

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

Skriv bufferten med byte till bussen. Om tecknen är 7 eller 8 bitar breda är varje byte ett tecken. Om tecknen är 9 bitar breda används två byte för varje tecken (little endian), och buf måste innehålla ett jämnt antal byte.

Returvärde: antalet skrivna byte. Om en timeout inträffar och inga byte skrevs returneras None.

writechar(char: int) → None¶: Skriv ett enstaka tecken på bussen. char är ett heltal som ska skrivas. Se avsnittet CTS-flödeskontroll nedan för blockerande semantik när CTS-flödeskontroll är aktiverad.

sendbreak() → None¶: Skicka ett break-tillstånd på bussen. Detta drar bussen låg under en period på 13 bitar.

Konstanter¶

RTS: int¶: Bitflagga för argumentet flow till init(); aktiverar RTS-hårdvaruflödeskontroll (request-to-send) på mottagningsvägen.

CTS: int¶: Bitflagga för argumentet flow till init(); aktiverar CTS-hårdvaruflödeskontroll (clear-to-send) på sändningsvägen. Kan OR:as med RTS för att aktivera båda riktningarna.

Flödeskontroll¶

UART(3) stöder RTS/CTS-hårdvaruflödeskontroll. På OpenMV Cam M7, H7, H7 Plus och Pure Thermal är flödeskontrollstiften:

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

På OpenMV Cam N6 är endast nRTS exponerad (på kontaktstift P7); nCTS är inte dragen till I/O-kontakten.

I de följande styckena syftar termen ”target” på den enhet som är ansluten till UART:en.

När UART:ens init()-metod anropas med flow satt till en eller båda av UART.RTS och UART.CTS konfigureras de relevanta flödeskontrollstiften. nRTS är en aktiv-låg utgång och nCTS är en aktiv-låg ingång med pull-up aktiverad. För att koppla upp flödeskontroll, anslut OpenMV Cam:ens nCTS till target:ens nRTS och OpenMV Cam:ens nRTS till target:ens nCTS.

CTS: target styr OpenMV Cam-sändaren¶

Om CTS-flödeskontroll är aktiverad är skrivbeteendet följande:

Om OpenMV Cam:ens UART.write(buf)-metod anropas kommer överföringen att avstanna under de perioder då nCTS är False. Detta resulterar i en timeout om hela bufferten inte överfördes inom timeoutperioden. Metoden returnerar antalet skrivna byte, vilket gör det möjligt för användaren att vid behov skriva resten av datan. Vid en timeout kommer ett tecken att kvarstå i UART:en i väntan på nCTS. Antalet byte som utgör detta tecken inkluderas i returvärdet.

Om UART.writechar() anropas när nCTS är False kommer metoden att få timeout om inte target hävdar nCTS i tid. Om den får timeout kommer OSError 116 att utlösas. Tecknet kommer att överföras så snart target hävdar nCTS.

RTS: OpenMV Cam styr target:ens sändare¶

Om RTS-flödeskontroll är aktiverad är beteendet följande:

Om buffrad inmatning används (read_buf_len > 0) buffras inkommande tecken. Om bufferten blir full kommer nästa tecken som anländer att få nRTS att gå False: target bör upphöra med överföringen. nRTS går True när tecken läses från bufferten.

Observera att any()-metoden returnerar antalet byte i bufferten. Anta en buffertlängd på N byte. Om bufferten blir full och ytterligare ett tecken anländer kommer nRTS att sättas till False, och any() returnerar antalet N. När tecken läses placeras det extra tecknet i bufferten och inkluderas i resultatet av ett efterföljande any()-anrop.

Om buffrad inmatning inte används (read_buf_len == 0) kommer ankomsten av ett tecken att få nRTS att gå False tills tecknet läses.