classe UART – barramento de comunicação serial duplex¶

A UART implementa o protocolo padrão de comunicações seriais duplex UART/USART. No nível físico, ela consiste em 2 linhas: RX e TX. A unidade de comunicação é um caractere (que não deve ser confundido com um caractere de string) que pode ter 8 ou 9 bits de largura.

Objetos UART podem ser criados e inicializados usando:

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 pode ser 7, 8 ou 9. A paridade pode ser None, 0 (par) ou 1 (ímpar). Stop pode ser 1 ou 2.

Observação: com parity=None, apenas 8 e 9 bits são suportados. Com a paridade habilitada, apenas 7 e 8 bits são suportados.

Um objeto UART age como um objeto stream e a leitura e a escrita são feitas usando os métodos padrão de 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

Caracteres individuais podem ser lidos/escritos usando:

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

Para verificar se há algo a ser lido, use:

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

Observação: As funções de stream read, write, etc. são novas na MicroPython v1.3.4. Versões anteriores usam uart.send e uart.recv.

Construtores¶

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

Constrói um objeto UART no bus fornecido (um índice inteiro de periférico, por exemplo 3 para UART3). Sem parâmetros adicionais, o objeto é criado mas não inicializado (ele mantém as configurações anteriores do barramento, se houver); se argumentos extras forem fornecidos, o barramento é inicializado. Consulte init() para os parâmetros disponíveis.

UART(3) está conectado aos mesmos pinos do header em toda OpenMV Cam STM32:

Sinal	Pino do header
`TX`	`P4`
`RX`	`P5`

Barramentos UART adicionais estão disponíveis em algumas placas:

Barramento	Pino TX	Pino RX	Disponível em
`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

Métodos¶

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¶

Inicializa o barramento UART com os parâmetros fornecidos:

baudrate é a taxa de clock.

bits é o número de bits por caractere, 7, 8 ou 9.

parity é a paridade, None, 0 (par) ou 1 (ímpar).

stop é o número de stop bits, 1 ou 2.

flow define o tipo de controle de fluxo. Pode ser 0, UART.RTS, UART.CTS ou UART.RTS | UART.CTS.

timeout é o tempo limite em milissegundos para aguardar a escrita/leitura do primeiro caractere.

timeout_char é o tempo limite em milissegundos para aguardar entre caracteres durante a escrita ou leitura.

read_buf_len é o comprimento em caracteres do buffer de leitura (0 para desabilitar).

Este método lançará uma exceção se a baudrate não puder ser definida dentro de 5% do valor desejado.

Observação: com parity=None, apenas 8 e 9 bits são suportados. Com a paridade habilitada, apenas 7 e 8 bits são suportados.

deinit() → None¶: Desliga o barramento UART.

any() → int¶: Retorna o número de bytes aguardando (pode ser 0).

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

Lê caracteres. Se nbytes for especificado, lê no máximo essa quantidade de bytes. Se nbytes estiverem disponíveis no buffer, retorna imediatamente; caso contrário, retorna quando caracteres suficientes chegarem ou quando o tempo limite expirar.

Se nbytes não for fornecido, o método lê a maior quantidade de dados possível. Ele retorna após o tempo limite ter expirado.

Observação: para caracteres de 9 bits, cada caractere ocupa dois bytes, nbytes deve ser par, e o número de caracteres é nbytes/2.

Valor de retorno: um objeto bytes contendo os bytes lidos. Retorna None em caso de tempo limite.

readchar() → int¶

Recebe um único caractere no barramento.

Valor de retorno: O caractere lido, como um inteiro. Retorna -1 em caso de tempo limite.

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

Lê bytes para dentro de buf. Se nbytes for especificado, lê no máximo essa quantidade de bytes. Caso contrário, lê no máximo len(buf) bytes.

Valor de retorno: número de bytes lidos e armazenados em buf ou None em caso de tempo limite.

readline() → bytes | None¶

Lê uma linha, terminada por um caractere de nova linha. Se tal linha existir, o retorno é imediato. Se o tempo limite expirar, todos os dados disponíveis são retornados independentemente de existir ou não uma nova linha.

Valor de retorno: a linha lida ou None em caso de tempo limite se nenhum dado estiver disponível.

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

Escreve o buffer de bytes no barramento. Se os caracteres tiverem 7 ou 8 bits de largura, então cada byte é um caractere. Se os caracteres tiverem 9 bits de largura, então dois bytes são usados para cada caractere (little endian), e buf deve conter um número par de bytes.

Valor de retorno: número de bytes escritos. Se ocorrer um tempo limite e nenhum byte tiver sido escrito, retorna None.

writechar(char: int) → None¶: Escreve um único caractere no barramento. char é um inteiro a ser escrito. Consulte a seção Controle de fluxo CTS abaixo para a semântica de bloqueio quando o controle de fluxo CTS está habilitado.

sendbreak() → None¶: Envia uma condição de break no barramento. Isso mantém o barramento em nível baixo por uma duração de 13 bits.

Constantes¶

RTS: int¶: Flag de bit para o argumento flow de init(); habilita o controle de fluxo por hardware RTS (request-to-send) no caminho de recepção.

CTS: int¶: Flag de bit para o argumento flow de init(); habilita o controle de fluxo por hardware CTS (clear-to-send) no caminho de transmissão. Pode ser combinado via OR com RTS para habilitar ambas as direções.

Controle de Fluxo¶

UART(3) suporta controle de fluxo por hardware RTS/CTS. Nas OpenMV Cam M7, H7, H7 Plus e Pure Thermal os pinos de controle de fluxo são:

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

Na OpenMV Cam N6 apenas nRTS é exposto (no pino P7 do header); nCTS não é roteado para o header de I/O.

Nos parágrafos a seguir, o termo “alvo” refere-se ao dispositivo conectado à UART.

Quando o método init() da UART é chamado com flow definido como um ou ambos de UART.RTS e UART.CTS, os pinos de controle de fluxo relevantes são configurados. nRTS é uma saída ativa em nível baixo e nCTS é uma entrada ativa em nível baixo com pull-up habilitado. Para conectar o controle de fluxo, ligue o nCTS da OpenMV Cam ao nRTS do alvo e o nRTS da OpenMV Cam ao nCTS do alvo.

CTS: o alvo controla o transmissor da OpenMV Cam¶

Se o controle de fluxo CTS estiver habilitado, o comportamento de escrita é o seguinte:

Se o método UART.write(buf) da OpenMV Cam for chamado, a transmissão será interrompida durante qualquer período em que nCTS for False. Isso resultará em um tempo limite se o buffer inteiro não tiver sido transmitido dentro do período de tempo limite. O método retorna o número de bytes escritos, permitindo que o usuário escreva o restante dos dados se necessário. Em caso de tempo limite, um caractere permanecerá na UART aguardando nCTS. O número de bytes que compõem esse caractere será incluído no valor de retorno.

Se UART.writechar() for chamado quando nCTS for False, o método atingirá o tempo limite a menos que o alvo afirme nCTS a tempo. Se atingir o tempo limite, OSError 116 será lançado. O caractere será transmitido assim que o alvo afirmar nCTS.

RTS: a OpenMV Cam controla o transmissor do alvo¶

Se o controle de fluxo RTS estiver habilitado, o comportamento é o seguinte:

Se a entrada com buffer for usada (read_buf_len > 0), os caracteres recebidos são armazenados em buffer. Se o buffer ficar cheio, o próximo caractere a chegar fará com que nRTS vá para False: o alvo deve cessar a transmissão. nRTS irá para True quando os caracteres forem lidos do buffer.

Observe que o método any() retorna o número de bytes no buffer. Suponha um comprimento de buffer de N bytes. Se o buffer ficar cheio e outro caractere chegar, nRTS será definido como False, e any() retornará a contagem N. Quando os caracteres forem lidos, o caractere adicional será colocado no buffer e será incluído no resultado de uma chamada subsequente de any().

Se a entrada com buffer não for usada (read_buf_len == 0), a chegada de um caractere fará com que nRTS vá para False até que o caractere seja lido.