As placas microcontroladoras requerem a comunicação de dados com muitos outros dispositivos que incluem sensores, atuadores, outros microcontroladores e microcomputadores. Esta transferência ou troca de dados é realizada através de interfaces seriais usando protocolos padrão como UART, I2C, SPI, 1-wire, etc. UART é um dos protocolos comuns de comunicação de dados seriais disponíveis em quase todos os microcontroladores. UART é um protocolo de comunicação de dados serial bidirecional ponto a ponto. Os sensores geralmente comunicam dados com microcontroladores e microcomputadores usando protocolos I2C ou SPI, pois os sensores sempre se comportam como dispositivos escravos que geralmente requerem apenas a transmissão de dados para os microcontroladores/microcomputadores. Quase não há necessidade de comunicação bidirecional de dados por sensores.
No entanto, qualquer comunicação de dados com outros microcontroladores ou microcomputadores precisa ser estritamente ponto a ponto e bidirecional. UART é o protocolo de comunicação serial mais útil neste cenário. O protocolo UART é útil quando um microcomputador ou outro microcontrolador mestre orienta sistemas microcontroladores em rede como ESP8266 ou ESP32. Este artigo examinará a classe UART do módulo de máquina MicroPython e explorará como ela pode ser usada para comunicação serial de dados em ESP8266 e ESP32.
Módulo de máquina MicroPython
Além dos módulos Python3 reimplementados, o MicroPython possui vários módulos nativos para lidar com funções e dispositivos de hardware. Um desses módulos é uma máquina responsável por lidar com muitas funções vitais do microcontrolador. O módulo inclui classes para controlar entrada/saída digital, controlar sinais de saída de dispositivos externos, modulação por largura de pulso, conversão de analógico para digital, controlar periféricos ADC, UART, SPI, I2C, I2S, temporizador, RTC, temporizador Watchdog e gerenciamento de cartão SD .
Classe UART
A classe UART faz parte do módulo da máquina. Ele implementa o protocolo UART/USART padrão. UART requer duas linhas – Rx e Tx para comunicação full-duplex. O Rx e o Tx de um microcontrolador estão conectados ao Tx e ao Rx do outro, respectivamente. Esta classe é importada em um script MicroPython usando as instruções a seguir.
da importação de máquina UART
A instanciação de um objeto UART deve seguir isto. A função construtora do objeto UART é a seguinte.
classe máquina.UART(id,…)
O método construtor requer essencialmente a especificação do ID UART como argumento. Muitos outros argumentos podem ser passados dentro do método construtor. Esses argumentos são os mesmos definidos para o método UART.init . Iremos discuti-los em breve. Alguns dos exemplos válidos de instanciação de um objeto UART são os seguintes.
uart = UART(0)
uart = UART(0, taxa de transmissão=9600)
uart1 = UART(1, taxa de transmissão=9600, tx=33, rx=32)
Os outros métodos disponíveis na classe UART são os seguintes.
UART.init : Este método é usado para inicializar o objeto UART. Possui o seguinte protótipo.
UART.init(taxa de transmissão=9600, bits=8, paridade=Nenhum, parada=1, *,…)
Os parâmetros a seguir são passados para a chamada do método.
taxa de transmissão: Esta é a taxa de transmissão em bps. Deve ser passado como um argumento.
bits: É o número de bits por caractere. Pode ser 7, 8 ou 9. O padrão é 8.
paridade: especifica o bit de paridade. Pode ser par (0) ou ímpar (1).
stop: especifica o número de bits de parada. Pode ser 1 ou 2.
tx: Especifica o pino de transmissão na porta a ser usada.
rx: Especifica o pino do receptor na porta a ser usada.
rtc: especifica o pino rtc na porta a ser usada. O rtc é o pino de saída usado para controle de fluxo de recepção de hardware.
cts: especifica o pino cts na porta a ser usada. O cts é o pino de entrada usado para controle de fluxo de transmissão de hardware.
txbuf: Especifica o tamanho do buffer do transmissor em vários caracteres.
rxbuf: Especifica o tamanho do buffer do receptor em vários caracteres.
timeout: especifica o tempo em milissegundos de espera para receber o primeiro caractere.
timeout_char: especifica o tempo em milissegundos de espera entre os caracteres.
inverter: especifica a linha a ser invertida. Pode ser definido como 0, UART.INV_TX, UART.INV_RX e UART.INV_TX UART.INV_RX. Se definido como 0, nenhuma linha será invertida. Se definido como UART.INV_TX, a linha de transmissão será invertida. Se definido como UART.INV_RX, a linha do receptor será invertida. Se definido como UART.INV_TX UART.INV_RX, as linhas do transmissor e do receptor estão invertidas. A inversão inverte os níveis lógicos TTL, ou seja, de lógica positiva para lógica negativa ou de lógica negativa para lógica positiva.
flow: especifica o controle de fluxo do hardware. Pode ser definido como 0, UART.RTS, UART.CTS e UART.RTS UART.CTS.. Se definido como 0, os sinais de controle de fluxo de hardware serão ignorados. Se definido como UART.RTS, habilita o sinal RTS desde que o receptor FIFO tenha espaço suficiente para acomodar mais dados. Se definido como UART.CTS, o sinal CTS será habilitado. Quando o sinal CTS, a transmissão é pausada se o receptor estiver com pouco espaço no buffer. Se definido como UART.RTS UART.CTS, os sinais RTS e CTS estão habilitados.
Claramente, o MicroPython permite um controle preciso da comunicação UART. Isso fica evidente pelo número de parâmetros de configuração permitidos no método UART.init .
UART.deinit : Ao chamar este método, o barramento UART é desabilitado.
UART.read((nbytes)): este método lê o número de caracteres especificados como argumento do buffer do receptor. Se nenhum argumento for passado, ele lê todos os caracteres no buffer do receptor. Ele pode não retornar nada ou retornar mais cedo se o tempo limite for atingido.
UART.readinto(buf(,nbytes)): este método lê o número de caracteres especificados como argumento no buffer do receptor. Se nenhum argumento for passado, ele lê todos os caracteres disponíveis no buffer do receptor. Ele pode não ler nada ou retornar mais cedo se o tempo limite for atingido.
UART.readline : Este método lê uma linha de caracteres. Um caractere de nova linha termina uma linha. Pode não retornar nenhum se o tempo limite for atingido.
UART.write(buf): Este método grava caracteres especificados na linha de transmissão.
UART.sendbreak : Este método envia uma condição de interrupção no barramento. Ele reduz as linhas por um período mais longo.
UART.irq(gatilho, prioridade=1, manipulador=Nenhum, wake=machine.IDLE): Este método invoca um retorno de chamada (função) quando os dados são recebidos no UART. Aceita quatro parâmetros. O gatilho só pode ser UART.RX_ANY. A prioridade define o nível de prioridade que pode estar entre 1~7. Um número mais alto indica prioridade mais alta. O manipulador é a função de retorno de chamada. É opcional. O wake pode ser o único machine.IDLE.
UART.qualquer : Este método retorna o número de caracteres disponíveis para leitura. Ele retorna 0 se nenhum caractere estiver disponível para leitura. Pode retornar 1 ou o número exato de caracteres disponíveis para leitura se um ou mais caracteres estiverem disponíveis. Isso depende da porta específica.
UART em ESP8266
No ESP8266, existem dois periféricos UART disponíveis – UART0 e UART1. UART0 possui linhas nos pinos GPIO1 (UART0 TX) e GPIO3 (UART0 RX). UART1 possui linhas nos pinos GPIO2 (UART1 TX) e GPIO8 (UART1 RX).
Portas UART no módulo ESP8266.
O GPIO8 está conectado internamente ao chip flash; apenas o UART1 é o transmissor. O UART0 é anexado por padrão ao Web REPL. O uso do UART0 para comunicação de dados serial deve primeiro ser desconectado do REPL. O UART0 pode ser desanexado do REPL usando o seguinte trecho de código.
importar sistema operacional
os.dupterm(Nenhum, 1)
Após desconectar o UART0 do REPL, ele pode ser usado para comunicação serial de dados. O método construtor da classe UART pode ser usado para instanciar um objeto UART. O método init pode ser usado no objeto para configurar o UART. Os métodos read e readline podem ser usados para ler do UART, e o método write pode ser usado para transmitir dados seriais pelo UART.
da importação de máquina UART
uart = UART(0, taxa de transmissão=9600)
uart.write('Olá')
uart.read
Uma vez concluído o requisito de comunicação serial, o UART0 deve ser reconectado ao REPL. O UART0 pode ser reanexado ao REPL usando o seguinte trecho de código.
importar sistema operacional, máquina
uart = máquina.UART(0, 115200)
os.duterm(uart, 1)
UART em ESP32
Existem três periféricos UART no ESP32 – UART0, UART1 e UART2. Cada UART é conectado a pinos padrão conforme listado na tabela abaixo.
Assim como no ESP32-DevKit-V1, apenas UART0 e UART2 são expostos. Dependendo da variante ESP32, alguns desses pinos podem ser compartilhados ou reservados para flash, PSRAM ou outros periféricos. Isso é mostrado na imagem abaixo.
Portas UART no módulo ESP32
MicroPython permite multiplexar qualquer GPIO com os UARTs de hardware do ESP32. Portanto, independentemente de quais pinos padrão estão expostos ou não, todos os três UARTs podem ser usados em um script MicroPython. Ao instanciar um objeto UART para ESP32, os pinos Rx e Tx também devem ser passados como argumentos.
Usando UART em ESP8266 e ESP32
ESP8266 e ESP32 são usados principalmente em aplicativos de rede com suporte Wi-Fi. Em muitas dessas aplicações, o microcontrolador mestre que gerencia funções incorporadas é outro microcontrolador, enquanto o ESP8266 ou ESP32 desempenha um papel secundário no tratamento apenas da comunicação e do controle da rede. Nessas aplicações, o UART é a única opção para comunicação de dados entre o ESP8266/ESP32 e o controlador principal do dispositivo. Alguns sensores e módulos também podem fornecer uma interface UART juntamente com I2C ou SPI para comunicar dados de sensores ou sinais de controle. Aqui, novamente, UART em ESP8266/ESP32 pode ser utilizado.
Comunicação de dados seriais UART com MicroPython
A seguir está um exemplo de script MicroPython para testar a comunicação UART no ESP8266.
importar sistema operacional, máquina
da importação de máquina UART
os.dupterm(Nenhum, 1)
uart = UART(0, taxa de transmissão=9600)
uart.write('Olá')
uart.read(5)
os.duterm(uart, 1)
A seguir está um exemplo de script MicroPython para testar a comunicação UART no ESP32.
da importação de máquina UART
uart = UART(1, taxa de transmissão=9600, tx=33, rx=32)
uart.write('olá')
uart.read(5)
