Comunicação UART pelo monitor serial

UART é uma comunicação serial assíncrona: os dispositivos trocam bits sem uma linha de clock compartilhada. Cada lado tem uma linha para transmitir (TX) e outra para receber (RX). Para que a conversa funcione, transmissor e receptor precisam estar configurados de modo compatível — esse formato será detalhado no próximo passo.

Os sinais UART do Uno R3 usam níveis lógicos de 5 V. Antes de ligar outro dispositivo aos pinos seriais, confirme que ele aceita esses níveis e que haverá uma referência de terra comum.

Não basta o conector “parecer compatível”: tensão, função de cada pino e referência elétrica precisam ser compatíveis.

Nesta prática, o computador conversa com o ATmega328P por este caminho:

Monitor serial local → USB → ponte USB-UART da placa → UART do ATmega328P

O cabo USB não é ligado diretamente aos sinais TX e RX do microcontrolador. A ponte presente no Uno converte a comunicação USB do computador para a UART lógica usada pelo ATmega328P.

Associe cada elemento à sua função ou conexão correta.

Cada byte na UART é enviado dentro de um quadro. Como não há clock compartilhado, a linha fica em repouso no nível alto e o receptor usa a transição para baixo do início para se sincronizar.

Um quadro pode ter: bit de início, bits de dados, paridade opcional e um ou mais bits de parada. As duas pontas precisam usar a mesma configuração para interpretar corretamente os mesmos instantes e bits.

Observe a sequência temporal: repouso alto, início baixo, oito intervalos de dados e parada alta.

A notação 8N1 resume a configuração mais comum:

• 8: oito bits de dados;
• N: nenhuma paridade (None);
• 1: um bit de parada.

Há ainda 1 bit de início. Portanto, um byte em 8N1 ocupa 10 bits na linha: 1 + 8 + 1. A paridade é um campo possível em outras configurações, mas não existe em 8N1.

Complete a expressão para o tempo nominal de transmissão de N bytes consecutivos em UART 8N1, à taxa de R bit/s:

T = {{lacuna}}

Coloque os campos de um quadro 8N1 na ordem em que atravessam a linha. Considere o byte já pronto para ser transmitido.

Para esta prática, use apenas seu Uno R3, um cabo USB de dados, um computador e a IDE Arduino já preparada. Não conecte sensores, adaptadores nem outros dispositivos aos pinos D0/RX e D1/TX.

O cabo USB já estabelece o caminho entre o computador e a UART do microcontrolador por meio da ponte USB-UART da placa. Portanto, não é preciso montar fios de UART externos.

No setup(), inicialize a comunicação com Serial.begin(9600);. O valor 9600 é a taxa de 9600 bit/s escolhida para esta prática.

No Uno R3, Serial.begin(9600) usa a configuração padrão 8N1: 8 bits de dados, nenhuma paridade e 1 bit de parada. O monitor serial precisa usar uma taxa correspondente para interpretar a comunicação corretamente.

Grave este sketch mínimo no Uno R3. Em seguida, abra o monitor serial configurado em 9600 baud: a área de saída permanecerá vazia.

Depois de gravar o sketch, abra o Monitor Serial na IDE. Selecione a porta que corresponde ao Uno R3 e ajuste a taxa para 9600 baud, igual ao valor usado em Serial.begin(9600).

No seletor de término de linha, escolha Sem final de linha. Mais adiante, você enviará comandos de um caractere; essa opção evita que o monitor acrescente bytes extras a cada envio.

Uma linha é formada em partes

Depois de inicializar a comunicação com Serial.begin(9600), use Serial.print() para enviar partes que devem continuar na mesma linha. Use Serial.println() na última parte para encerrar a linha e posicionar o cursor na próxima.

Exemplo de intenção: enviar o rótulo contador=, depois o valor atual e, por fim, iniciar uma nova linha para a próxima leitura.

Quando você passa um número a Serial.print, ele é convertido para sua representação decimal em texto. Assim, o valor 7 envia o caractere 7; o valor 125 envia três caracteres: 1, 2 e 5.

Isso não é o envio do valor binário bruto. Aqui, o objetivo é uma saída humana e legível no monitor.

Copie este sketch para a IDE Arduino, envie ao Uno R3 e abra o monitor serial local em 9600 baud. O programa reutiliza a temporização não bloqueante com millis() para transmitir um contador a cada segundo.

Complete as chamadas para produzir uma linha como contador=8 e depois iniciar a próxima linha. A primeira lacuna deve manter o rótulo e o valor na mesma linha; a segunda deve encerrar essa linha.

Um comando de um caractere cabe em um char. Em C/C++, escreva um caractere literal entre aspas simples:

• '1' representa o caractere 1;
• '0' representa o caractere 0.

Na prática, cada envio no monitor será um comando independente: '1' pedirá para ligar o LED integrado; '0', para desligá-lo. Isso não é ainda o código de recepção: aqui vamos definir corretamente o que cada byte significa.

Declarações de caracteres usadas para representar comandos.

O computador codifica caracteres em bytes. Para os dois comandos desta prática, a correspondência ASCII é suficiente:

O programa não precisa parar até chegar um comando. A UART guarda temporariamente os bytes que já chegaram em um buffer de recepção. Em cada passagem por loop(), consulte esse buffer e só trate uma entrada quando houver algo disponível.

Serial.available() informa quantos bytes aguardam leitura. Se retornar 0, nenhum byte está pronto agora: o loop() segue para as outras tarefas, como atualizar o contador periódico.

Depois de confirmar que há dado, use Serial.read(). Essa função lê e remove um byte do buffer.

Embora um byte tenha valores de 0 a 255, Serial.read() retorna um int. Assim, ela também pode sinalizar -1 quando não há byte para ler. Preserve o retorno em int até confirmar que ele é válido; só então ele pode ser tratado como um caractere.

Nesta prática, a condição com available() faz a leitura somente quando existe ao menos um byte. A verificação de -1 ainda deixa o trecho seguro caso a leitura não produza um byte válido.

Leia no máximo um byte quando ele já estiver disponível.

Use este sketch completo no seu Uno R3. Ele mantém o contador enviado a cada segundo e aceita um comando por passagem do loop():

• envie 1 para ligar o LED integrado;
• envie 0 para desligá-lo;
• outros caracteres são ignorados.

Abra o monitor serial na porta do Uno, selecione 9600 baud e Sem final de linha. Durante esta prática, não conecte dispositivos externos aos pinos D0/RX e D1/TX.

Grave o sketch. Sem enviar nada, o contador continua. Depois, envie 1 e 0, um caractere por vez.

Entre o seu sketch e a UART há filas temporárias, chamadas buffers. Elas ajudam o programa e a transmissão física a trabalharem em ritmos diferentes, mas têm capacidade limitada.

• Buffer de transmissão (TX): recebe os bytes que Serial.print() e Serial.println() querem enviar; a UART os transmite depois.
• Buffer de recepção (RX): guarda os bytes que chegaram até o sketch fazer Serial.read().

Pense em cada buffer como uma fila: bytes entram por uma ponta e saem pela outra. Se a fila encher, há consequências diferentes na saída e na entrada.

Em 8N1, a capacidade nominal é aproximadamente R/10 bytes por segundo, pois cada byte ocupa 10 bits no quadro. A 9600 bit/s, isso dá cerca de 960 bytes/s em condições ideais.

Esse valor não é uma meta de uso: deixe folga. O monitor, a USB e o próprio programa têm variações e pausas. Para esta prática, uma linha curta a cada segundo e consultas frequentes à recepção são um ritmo moderado.

Evite transformar o loop() em uma fonte contínua de mensagens. Antes de adicionar uma impressão, pergunte: ela é necessária para observar o comportamento?

Você vai reunir a transmissão periódica e a recepção de comandos em um único sketch. O contador deve continuar aparecendo mesmo quando nenhum caractere chega ao Uno: a leitura serial só ocorre quando há byte disponível.

Grave este sketch no Uno R3. Ele envia um contador a cada segundo e atende, quando disponíveis, os comandos 1 e 0.

Abra o monitor serial da porta do Uno e selecione 9600 baud e Sem final de linha. Envie um único caractere por vez:

1. Envie 1: o LED integrado deve acender.
2. Envie 0: o LED integrado deve apagar.
3. Não envie nada por alguns segundos: as linhas contador=... devem continuar crescendo.

Se enviar retorno de carro ou nova linha junto ao comando, eles serão bytes extras. Por isso, mantenha Sem final de linha nesta prática.

Considere a linha transmitida contador=12 pelo println a 9600 bit/s em 8N1. Ela contém 8 letras, o sinal =, 2 dígitos e os 2 bytes finais de println: 13 bytes ao todo. Cada byte ocupa 10 bits no enquadramento 8N1.