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

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

Os objetos UART podem ser criados e inicializados usando:

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

Os bits podem ser 7, 8 ou 9. O stop pode ser 1 ou 2. 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 comporta-se 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

Construtores¶

Constrói um objeto UART com o id fornecido.

Métodos¶

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.

Parâmetros adicionais somente por palavra-chave que podem ser suportados por uma porta são:

tx especifica o pino TX a ser usado.

rx especifica o pino RX a ser usado.

rts especifica o pino RTS (saída) a ser usado para o controle de fluxo de recepção por hardware.

cts especifica o pino CTS (entrada) a ser usado para o controle de fluxo de transmissão por hardware.

txbuf especifica o comprimento em caracteres do buffer de TX.

rxbuf especifica o comprimento em caracteres do buffer de RX.

timeout especifica o tempo de espera pelo primeiro caractere (em ms).

timeout_char especifica o tempo de espera entre caracteres (em ms).

invert especifica quais linhas devem ser invertidas.

0 não inverte as linhas (o estado ocioso de ambas as linhas é nível lógico alto).

UART.INV_TX inverte a linha TX (o estado ocioso da linha TX passa a ser nível lógico baixo).

UART.INV_RX inverte a linha RX (o estado ocioso da linha RX passa a ser nível lógico baixo).

UART.INV_TX | UART.INV_RX inverte ambas as linhas (estado ocioso em nível lógico baixo).

flow especifica quais sinais de controle de fluxo por hardware usar. O valor é uma máscara de bits.

0 ignora os sinais de controle de fluxo por hardware.

UART.RTS habilita o controle de fluxo de recepção usando o pino de saída RTS para sinalizar se a FIFO de recepção tem espaço suficiente para aceitar mais dados.

UART.CTS habilita o controle de fluxo de transmissão pausando a transmissão quando o pino de entrada CTS sinaliza que o receptor está com pouco espaço de buffer.

UART.RTS | UART.CTS habilita ambos, para o controle de fluxo por hardware completo.

Nota

É possível chamar init() várias vezes no mesmo objeto para reconfigurar a UART em tempo de execução. Isso permite usar um único periférico UART para atender a diferentes dispositivos conectados a diferentes pinos GPIO. Nesse caso, apenas um dispositivo pode ser atendido por vez. Além disso, não chame deinit(), pois isso impedirá chamar init() novamente.

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

Nota

Você não conseguirá chamar init() no objeto após deinit(). Nesse caso, é necessário criar uma nova instância.

any() → int¶

Retorna um inteiro contando o número de caracteres que podem ser lidos sem bloqueio. Retorna 0 se não houver caracteres disponíveis e um número positivo se houver caracteres. O método pode retornar 1 mesmo que haja mais de um caractere disponível para leitura.

Para uma consulta mais sofisticada dos caracteres disponíveis, use select.poll:

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

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

Lê caracteres. Se nbytes for especificado, lê no máximo essa quantidade de bytes; caso contrário, lê o máximo de dados possível. Pode retornar mais cedo se um timeout for atingido. O timeout é configurável no construtor.

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

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. Pode retornar mais cedo se um timeout for atingido. O timeout é configurável no construtor.

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

readline() → bytes | None¶

Lê uma linha que termina com um caractere de nova linha. Pode retornar mais cedo se um timeout for atingido. O timeout é configurável no construtor.

Valor de retorno: a linha lida ou None em caso de timeout.

write(buf: bytes) → int | None¶

Escreve o buffer de bytes no barramento.

Valor de retorno: número de bytes escritos ou None em caso de timeout.

sendbreak() → None¶: Envia uma condição de break no barramento – mantém TX em nível baixo por mais tempo do que a duração de um caractere. Disponível em STM32 e mimxrt; não exposto em alif.

readchar() → int¶: Lê um único caractere da UART e o retorna como um inteiro (ou -1 em caso de timeout). Menor overhead do que read(1), já que nenhum objeto bytes é alocado. Apenas STM32.

writechar(char: int) → None¶: Escreve o único caractere char (um inteiro no intervalo 0 – 255) na UART. Menor overhead do que write() para envios de um único byte. Apenas STM32.

flush() → None¶: Bloqueia até que cada byte atualmente no buffer de transmissão tenha sido enviado por TX. Levanta OSError em caso de timeout; o timeout é derivado do tamanho do buffer de TX e da baud rate configurada, de modo que, a menos que o controle de fluxo esteja habilitado e o receptor trave, a chamada retorna bem antes do timeout.

txdone() → bool¶: Retorna True quando nenhuma transmissão está em andamento (o buffer de TX está vazio e o registrador de deslocamento foi esvaziado), e False caso contrário. Útil como uma alternativa não bloqueante a flush().

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

Instala um callback para ser disparado em eventos da UART.

handler é a função a ser invocada. Ela recebe a instância UART como seu único argumento. Passe None para remover um handler instalado anteriormente.

trigger é uma máscara de bits de uma ou mais constantes IRQ_* (veja Constantes abaixo) que selecionam quais eventos disparam o callback.

hard=True registra um handler de interrupção hard (menor latência, mas o handler não pode alocar). O padrão é um callback agendado.

Retorna um objeto irq.

Nem toda fonte de IRQ está disponível em todas as portas – consulte as constantes IRQ_* individuais para a disponibilidade por porta.

Constantes¶

RTS: int¶: Passe para flow para habilitar o controle de fluxo por hardware RTS no lado da recepção. Combine com CTS por meio de OR para habilitar ambos.

CTS: int¶: Passe para flow para habilitar o controle de fluxo por hardware CTS no lado da transmissão.

IRQ_RXIDLE: int¶: Flag de trigger de irq(): dispara uma vez depois que um ou mais caracteres forem recebidos e a linha RX ficar ociosa em seguida. Disponível em todas as portas OpenMV.

IRQ_RX: int¶: Flag de trigger de irq(): dispara após cada caractere recebido. Disponível em STM32 e alif.

IRQ_TXIDLE: int¶: Flag de trigger de irq(): dispara quando o último caractere de uma transmissão tiver sido enviado. Disponível em mimxrt e alif.

IRQ_BREAK: int¶: Flag de trigger de irq(): dispara quando uma condição de break é detectada em RX. Não disponível em nenhuma porta OpenMV.