class UART – дуплексная последовательная шина связи#

UART реализует стандартный дуплексный протокол последовательной связи UART/USART. На физическом уровне он состоит из 2 линий: RX и TX. Единицей передачи является символ (не путать с символом строки), который может иметь ширину 8 или 9 бит.

Объекты UART можно создавать и инициализировать так:

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 может быть равно 7, 8 или 9. Stop может быть равно 1 или 2. При parity=None поддерживаются только 8 и 9 бит. При включённом контроле чётности поддерживаются только 7 и 8 бит.

Объект UART ведёт себя как объект stream, и чтение и запись выполняются с помощью стандартных методов потока:

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

Конструкторы#

Создаёт объект UART с заданным id.

Методы#

Инициализирует шину UART с заданными параметрами:

baudrate — тактовая частота.
bits — количество бит на символ, 7, 8 или 9.
parity — контроль чётности, None, 0 (чётный) или 1 (нечётный).
stop — количество стоповых бит, 1 или 2.

Дополнительные параметры (только именованные), которые могут поддерживаться портом:

tx задаёт используемый вывод TX.
rx задаёт используемый вывод RX.
rts задаёт вывод RTS (выход), используемый для аппаратного управления потоком при приёме.
cts задаёт вывод CTS (вход), используемый для аппаратного управления потоком при передаче.
txbuf задаёт длину буфера TX в символах.
rxbuf задаёт длину буфера RX в символах.
timeout задаёт время ожидания первого символа (в мс).
timeout_char задаёт время ожидания между символами (в мс).
invert задаёт, какие линии инвертировать.

0 не будет инвертировать линии (состояние покоя обеих линий — логическая единица).
UART.INV_TX инвертирует линию TX (теперь состояние покоя линии TX — логический ноль).
UART.INV_RX инвертирует линию RX (теперь состояние покоя линии RX — логический ноль).
UART.INV_TX | UART.INV_RX инвертирует обе линии (состояние покоя — логический ноль).
flow задаёт, какие сигналы аппаратного управления потоком использовать. Значение является битовой маской.

0 будет игнорировать сигналы аппаратного управления потоком.
UART.RTS включит управление потоком при приёме, используя выходной вывод RTS для сигнализации о том, что в приёмном FIFO достаточно места для приёма новых данных.
UART.CTS включит управление потоком при передаче, приостанавливая передачу, когда входной вывод CTS сигнализирует о том, что у приёмника заканчивается место в буфере.
UART.RTS | UART.CTS включит оба варианта для полного аппаратного управления потоком.

Примечание

Метод init() можно вызывать несколько раз для одного и того же объекта, чтобы перенастраивать UART на лету. Это позволяет использовать одно периферийное устройство UART для обслуживания разных устройств, подключённых к разным выводам GPIO. В этом случае одновременно может обслуживаться только одно устройство. Также не вызывайте deinit(), так как это не позволит вызвать init() снова.

deinit() → None#: Выключает шину UART.

Примечание
Вы не сможете вызвать init() для объекта после deinit(). В этом случае нужно создать новый экземпляр.

any() → int#

Возвращает целое число, равное количеству символов, которые можно прочитать без блокировки. Возвращает 0, если нет доступных символов, и положительное число, если символы есть. Метод может вернуть 1, даже если для чтения доступно более одного символа.

Для более сложного определения количества доступных символов используйте select.poll:

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

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

Читает символы. Если задано nbytes, то читает не более указанного количества байт, иначе читает как можно больше данных. Может вернуться раньше при достижении тайм-аута. Тайм-аут настраивается в конструкторе.

Возвращаемое значение: объект bytes, содержащий прочитанные байты. Возвращает None при тайм-ауте.

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

Читает байты в buf. Если задано nbytes, то читает не более указанного количества байт. Иначе читает не более len(buf) байт. Может вернуться раньше при достижении тайм-аута. Тайм-аут настраивается в конструкторе.

Возвращаемое значение: количество байт, прочитанных и сохранённых в buf, или None при тайм-ауте.

readline() → bytes | None#

Читает строку, оканчивающуюся символом новой строки. Может вернуться раньше при достижении тайм-аута. Тайм-аут настраивается в конструкторе.

Возвращаемое значение: прочитанная строка или None при тайм-ауте.

write(buf: bytes) → int | None#

Записывает буфер байт в шину.

Возвращаемое значение: количество записанных байт или None при тайм-ауте.

sendbreak() → None#: Посылает условие break на шину — удерживает TX в низком состоянии дольше времени передачи одного символа. Доступно на STM32 и mimxrt; не предоставляется на alif.

readchar() → int#: Читает один символ из UART и возвращает его как целое число (или -1 при тайм-ауте). Имеет меньшие накладные расходы, чем read(1), так как объект bytes не выделяется. Только для STM32.

writechar(char: int) → None#: Записывает одиночный символ char (целое число в диапазоне 0 – 255) в UART. Имеет меньшие накладные расходы, чем write(), для отправки одного байта. Только для STM32.

flush() → None#: Блокируется до тех пор, пока каждый байт, находящийся в данный момент в буфере передачи, не будет выведен на TX. Вызывает OSError при тайм-ауте; тайм-аут вычисляется из размера буфера TX и настроенной скорости передачи, поэтому, если управление потоком не включено и приёмник не зависает, вызов возвращается задолго до тайм-аута.

txdone() → bool#: Возвращает True, когда нет передачи в процессе (буфер TX пуст, а сдвиговый регистр опустошён), и False в противном случае. Полезно как неблокирующая альтернатива flush().

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

Устанавливает функцию обратного вызова, срабатывающую при событиях UART.

handler — вызываемая функция. Она получает экземпляр UART в качестве единственного аргумента. Передайте None, чтобы удалить ранее установленный обработчик.

trigger — битовая маска из одной или нескольких констант IRQ_* (см. раздел Константы ниже), выбирающая, какие события вызывают функцию обратного вызова.

hard=True регистрирует обработчик аппаратного прерывания (меньшая задержка, но обработчик не должен выделять память). По умолчанию используется планируемая функция обратного вызова.

Возвращает объект irq.

Не каждый источник IRQ доступен на каждом порту — см. отдельные константы IRQ_* для информации о доступности по портам.

Константы#

RTS: int#: Передайте в flow для включения аппаратного управления потоком RTS на стороне приёма. Объедините с CTS через OR, чтобы включить оба варианта.

CTS: int#: Передайте в flow для включения аппаратного управления потоком CTS на стороне передачи.

IRQ_RXIDLE: int#: Флаг триггера irq(): срабатывает один раз после того, как один или несколько символов были приняты и линия RX перешла в состояние покоя. Доступно на всех портах OpenMV.

IRQ_RX: int#: Флаг триггера irq(): срабатывает после каждого принятого символа. Доступно на STM32 и alif.

IRQ_TXIDLE: int#: Флаг триггера irq(): срабатывает, когда последний символ передачи был выведен. Доступно на mimxrt и alif.

IRQ_BREAK: int#: Флаг триггера irq(): срабатывает при обнаружении условия break на RX. Недоступно ни на одном порту OpenMV.