Aula 04 - Comunicação Serial UART, Barramento I2C e Displays OLED

Navegação Rápida

📍 Disciplina: 06 Projetos e Códigos Arduino | 🏠 Hub Principal

Metadados da Aula

• Área: 05 Eletrônica, Automação e Controle
• Carga Horária Equivalente: 4 horas-aula teóricas e de bancada
• Pré-requisitos: Eletrônica Digital, Microprocessadores e Lógica de Programação em C/C++
• Palavras-chave: UART, Baud Rate, UBRR, Buffer Circular de Recepção, Barramento I2C, Resistor de Pull-Up, SSD1306, GDDRAM, Adafruit GFX

---

📌 Sumário da Aula

1. 🧭 1. Contextualização e Objetivos de Aprendizagem
2. 📋 2. Sumário Executivo dos Tópicos
3. ⚡ 3. Fundamentação Teórica e Modelagem Matemática
   • 3.1 Protocolo UART Assíncrono e Cálculo do Gerador de Baud Rate
   • 3.2 Dinâmica do Buffer Circular de Recepção por Interrupção
   • 3.3 Protocolo Síncrono I2C / TWI e Dimensionamento de Resistores de Pull-Up
   • 3.4 Arquitetura do Controlador Gráfico OLED SSD1306 e Mapeamento de GDDRAM
4. 🖼️ 4. Diagrama Esquemático Integrado
5. 💻 5. Implementação de Software e Algoritmos de Comunicação
   • 5.1 Scanner de Endereços I2C com Tratamento de Erros
   • 5.2 Parser Serial Não-Bloqueante com Proteção de Overflow
   • 5.3 Dashboard Gráfico com Display OLED SSD1306 e Otimização de RAM
6. 📝 6. Banco de Questões de Fixação e Concursos Auditados
   • Questão 01 — Erro de Temporização e Tolerância de Baud Rate na USART do ATmega328P
   • Questão 02 — Dimensionamento Analítico dos Resistores de Pull-Up do Barramento I2C
   • Questão 03 — Análise de Alocação de Memória RAM para Display SSD1306
7. 📚 7. Referências Bibliográficas e Normas Técnicas

---

🧭 1. Contextualização e Objetivos de Aprendizagem

Em sistemas embarcados modernos e instrumentação industrial, microcontroladores raramente operam isolados. A transferência contínua de dados de telemetria, recepção de comandos de supervisórios e interfaceamento com periféricos visuais exigem protocolos de comunicação padronizados, com determinismo temporal e integridade de sinal garantidos.

Esta aula estuda os dois barramentos seriais fundamentais da plataforma Arduino Uno (baseada no microcontrolador Microchip/Atmel ATmega328P): a UART (Universal Asynchronous Receiver-Transmitter) e o barramento I2C (Inter-Integrated Circuit), concluindo com o interfaceamento do display gráfico OLED monocromático de alta definição baseado no chip controlador SSD1306.

Ao término desta aula, o engenheiro será capaz de:

• Dimensionar os registradores geradores de Baud Rate (UBRR0H:UBRR0L) e calcular o desvio percentual de frequência de transmissão para qualquer cristal oscilador.
• Compreender o mecanismo interno de filas circulares (ring buffers) operadas por interrupção na recepção serial da classe HardwareSerial.
• Dimensionar os limites mínimo e máximo dos resistores de terminação (pull-up) de linhas I2C (SDA e SCL) sob restrições de capacitância parasita e tempos de subida normatizados pela especificação NXP UM10204.
• Implementar algoritmos eficientes de varredura (I2C Scanner) e renderização em display OLED SSD1306 ($128\times 64$ pixels), gerenciando rigorosamente os $2048\text{ bytes}$ de SRAM do ATmega328P.

---

📋 2. Sumário Executivo dos Tópicos

• UART Assíncrona: Formato de quadro (frame) serial 8N1 (1 start bit, 8 data bits, sem paridade, 1 stop bit). Recepção acionada por borda de descida com sobreamostragem de $16\times$ no centro do bit.
• Divisor UBRR: Equacionamento do divisor de clock para taxas industriais padrão ($9600$, $19200$, $38400$, $57600$, $115200\text{ bps}$) operando a $16\text{ MHz}$.
• Buffer Circular (Ring Buffer): Fila FIFO de 64 bytes em software gerenciada pela rotina de serviço de interrupção (USART_RX_vect), isolando a latência do laço principal (loop).
• Barramento I2C (TWI - Two Wire Interface): Estrutura física dreno-aberto (open-drain) bidirecional com apenas dois condutores (SDA e SCL). Endereçamento de 7 bits, sinalizações de START, STOP, ACK/NACK e técnica de retenção de clock (clock stretching).
• Dimensionamento Elétrico de $R_p$: Limite inferior definido pela corrente máxima de afundamento $I_{OL}$ do transistor NMOS; limite superior determinado pelo tempo de subida $t_r$ e pela capacitância de linha $C_b$.
• Display OLED SSD1306: Painel autoemissivo de $128\times 64$ diodos orgânicos. Memória GDDRAM estruturada em 8 páginas de 128 colunas com organização vertical de bytes. Buffer de vídeo em RAM de $1024\text{ bytes}$ (50% da SRAM do ATmega328P).

---

⚡ 3. Fundamentação Teórica e Modelagem Matemática

3.1 Protocolo UART Assíncrono e Cálculo do Gerador de Baud Rate

A comunicação serial assíncrona por UART não compartilha uma linha física de clock entre transmissor e receptor. Para garantir a integridade dos dados transmitidos, ambos os dispositivos devem concordar previamente com uma taxa de transmissão idêntica denominada Baud Rate (símbolos por segundo, correspondente a bits por segundo na codificação binária direta NRZ).

3.1.1 Estrutura do Quadro Serial (Frame 8N1)

No estado de repouso (idle), a linha serial permanece em nível lógico alto ($V_{CC}=5\text{ V}$). A transmissão de um caractere obedece rigorosamente à seguinte sequência temporal:

1. Start Bit: Transição de nível alto para baixo ($1\to 0$) com duração de $1{\text{ T}}_{\text{bit}}$. O receptor detecta a borda de descida e sincroniza seu contador interno de sobreamostragem.
2. Bits de Dados (Payload): 8 bits transmitidos sequencialmente, do menos significativo (LSB - $D_0$) ao mais significativo (MSB - $D_7$).
3. Bit de Paridade (Opcional): Bit de redundância para detecção de erro em canal ruidoso. No padrão 8N1, o bit de paridade é omitido.
4. Stop Bit: Nível lógico alto ($1$) com duração mínima de 1 ou 2 tempos de bit ($1{\text{ T}}_{\text{bit}}$ ou $2{\text{ T}}_{\text{bit}}$), garantindo que a linha retorne ao estado idle antes do próximo start bit.

O tempo total de transmissão de um quadro de $N_{\text{bits}}=10\text{ bits}$ (1 start + 8 dados + 1 stop) à taxa $B$ é dado por:

$T_{\text{quadro}}=\frac{N_{\text{bits}}}{B}=\frac{10}{B}$

Para $B=9600\text{ bps}$, $T_{\text{quadro}}=\frac{10}{9600}\approx 1,0417\text{ ms}$. Para $B=115200\text{ bps}$, $T_{\text{quadro}}=\frac{10}{115200}\approx 86,81\mu \text{s}$.

3.1.2 Gerador de Baud Rate no ATmega328P

A USART0 do ATmega328P divide a frequência do oscilador mestre ($F_{\text{osc}}=16\text{ MHz}$) por meio de um contador pré-divisor programável de 12 bits formado pelos registradores UBRR0H (4 bits mais significativos) e UBRR0L (8 bits menos significativos).

No Modo Normal (com o bit $U2X0=0$ no registrador UCSR0A), a lógica de recepção opera com sobreamostragem de $16\times$:

$\text{Baud}=\frac{F_{\text{osc}}}{16(\text{UBRR0}+1)}$

Isolando o valor a ser carregado em $\text{UBRR0}$:

$\text{UBRR0}=\mathrm{round}\left(\frac{F_{\text{osc}}}{16\cdot \text{Baud}}-1\right)=\lfloor \frac{F_{\text{osc}}}{16\cdot \text{Baud}}-1+0,5\rfloor$

No Modo Dupla Velocidade ($U2X0=1$), a sobreamostragem é reduzida para $8\times$, permitindo taxas superiores com menor divisor:

$\text{Baud}=\frac{F_{\text{osc}}}{8(\text{UBRR0}+1)}⟹\text{UBRR0}=\mathrm{round}\left(\frac{F_{\text{osc}}}{8\cdot \text{Baud}}-1\right)$

Como $\text{UBRR0}$ assume apenas valores inteiros ($0\le \text{UBRR0}\le 4095$), a taxa real gerada ${\text{Baud}}_{\text{real}}$ difere ligeiramente da taxa nominal desejada ${\text{Baud}}_{\text{alvo}}$:

${\text{Baud}}_{\text{real}}=\frac{F_{\text{osc}}}{16({\text{UBRR0}}_{\text{calculado}}+1)}$

O erro percentual relativo é formalmente definido por:

${\epsilon }_{\text{baud}}=\left(\frac{{\text{Baud}}_{\text{real}}-{\text{Baud}}_{\text{alvo}}}{{\text{Baud}}_{\text{alvo}}}\right)\cdot 100\%$

Critério de Nyquist e Janela de Tolerância Assíncrona

Na recepção UART, a amostragem de cada bit ocorre no centro do intervalo de tempo teórico (pulso 8 de 16 da sobreamostragem). Para um quadro de 10 bits (Start + 8 dados + Stop), o acúmulo de desvio de temporização entre os dois relógios assíncronos não pode deslocar o ponto de amostragem do último bit (Stop bit) para fora de sua janela válida ($\pm 50\%$). Isso impõe um limite teórico máximo de tolerância de $\pm 4,5\%$. No entanto, em ambientes industriais com ruído eletromagnético e jitter, adota-se rigorosamente $|{\epsilon }_{\text{baud}}|\le 2,0\%$. Para $115200\text{ bps}$ com $F_{\text{osc}}=16\text{ MHz}$, o modo normal gera $-3,55\%$ de erro, sendo altamente recomendado ativar o modo $U2X0=1$ ($\text{UBRR0}=16$, ${\text{Baud}}_{\text{real}}=117647\text{ bps}$, erro de $+2,12\%$) ou utilizar cristais de frequência harmônica específica (ex.: $14,7456\text{ MHz}$ ou $18,4320\text{ MHz}$ com erro de $0,00\%$).

---

3.2 Dinâmica do Buffer Circular de Recepção por Interrupção

O núcleo da biblioteca HardwareSerial do ecossistema Arduino implementa uma estrutura de dados de fila circular (ring buffer) gerenciada por interrupção de hardware para desacoplar a chegada física dos dados seriais da execução do laço principal loop().

3.2.1 Mecanismo de Interrupção USART_RX_vect

Sempre que a USART0 conclui a deserialização de um byte no registrador de deslocamento interno, a flag RXC0 (Receive Complete) no registrador UCSR0A é acionada, disparando o vetor de interrupção USART_RX_vect:

1. A CPU suspende a instrução corrente e empilha o Contador de Programa ($PC$).
2. A rotina ISR lê o byte armazenado no registrador físico UDR0.
3. O dado é inserido no vetor _rx_buffer na posição apontada pelo índice de cabeça (_rx_buffer_head).
4. O índice de cabeça avança circularmente: $\text{next\_head}=(\text{head}+1)(\mathrm{mod}{N}_{\text{buffer}})$
5. Caso $\text{next\_head}==\text{tail}$, ocorre overflow de buffer: o novo byte é descartado e uma flag de perda é configurada. Caso contrário, $\text{head}\leftarrow \text{next\_head}$.

3.2.2 Leitura em Nível de Aplicação com Serial.available() e Serial.read()

No espaço de execução do usuário, a função Serial.available() calcula a quantidade de bytes pendentes de leitura através da aritmética modular de ponteiros:

${\Delta }_{\text{bytes}}=(\text{head}-\text{tail}+N_{\text{buffer}})(\mathrm{mod}{N}_{\text{buffer}})$

Na implementação padrão do Arduino AVR Core:

• $N_{\text{buffer}}=64\text{ bytes}$ (definido por SERIAL_RX_BUFFER_SIZE).
• A leitura via Serial.read() extrai o dado da posição _rx_buffer_tail e incrementa o ponteiro: $\text{tail}=(\text{tail}+1)(\mathrm{mod}{N}_{\text{buffer}})$

Se o laço principal permanecer bloqueado por chamadas imperativas como delay(100) durante uma recepção a $115200\text{ bps}$ ($11520\text{ bytes/s}$), o buffer de 64 bytes transborda e sofre perda catastrófica de dados em apenas:

$t_{\text{overflow}}=\frac{N_{\text{buffer}}}{\text{Taxa de Bytes}}=\frac{64}{11520}\approx 5,55\text{ ms}$

Daí a exigência mandatória de estruturas assíncronas baseadas em máquinas de estados e temporização por millis().

---

3.3 Protocolo Síncrono I2C / TWI e Dimensionamento de Resistores de Pull-Up

O barramento I2C (Inter-Integrated Circuit), padronizado pela NXP Semiconductors (especificação UM10204), é um barramento serial síncrono, mestre-escravo, multimestre e bidirecional a dois fios:

• SDA (Serial Data): Linha de dados bidirecional. No Arduino Uno, mapeada fisicamente no pino analógico A4 (ou pino dedicado SDA no conector superior).
• SCL (Serial Clock): Linha de sincronismo gerada pelo mestre. Mapeada no pino analógico A5 (ou conector SCL).

3.3.1 Condições Físicas de Sinalização

O barramento utiliza transistores com estágio de saída dreno-aberto (open-drain ou coletor-aberto). Nenhum dispositivo pode forçar a linha para nível lógico alto ativamente; o nível $1$ é garantido passivamente pelos resistores de pull-up $R_p$. Essa topologia cria uma porta lógica Wired-AND inerente, eliminando curto-circuitos e viabilizando a arbitragem de múltiplos mestres e o recurso de clock stretching.

• Regra de Estabilidade de Dados: Durante o semi-ciclo em que $SCL=\text{HIGH}$, o nível lógico em $SDA$ deve permanecer estritamente estável. Mudanças de estado em $SDA$ só são autorizadas quando $SCL=\text{LOW}$.
• Condição de START (S): Transição de $HIGH\to LOW$ na linha $SDA$ enquanto $SCL$ permanece em nível $HIGH$.
• Condição de STOP (P): Transição de $LOW\to HIGH$ na linha $SDA$ enquanto $SCL$ permanece em nível $HIGH$.
• Byte de Endereço e Bit R/W: O mestre transmite 7 bits de endereço seguidos pelo 8º bit que define a operação:
  • $R/\overline{W}=0$: Operação de Escrita (Write).
  • $R/\overline{W}=1$: Operação de Leitura (Read).
• Acknowledge (ACK/NACK): No 9º pulso de clock gerado pelo mestre, o transmissor libera a linha $SDA$. O dispositivo receptor puxa ativamente $SDA$ para nível $LOW$ para confirmar o recebimento do byte (ACK). Se a linha permanecer em nível $HIGH$, sinaliza-se NACK (dispositivo ausente, ocupado ou fim de transmissão).

3.3.2 Dimensionamento Rigoroso dos Resistores de Pull-Up ($R_p$)

O dimensionamento de $R_p$ é delimitado por duas restrições físicas concorrentes:

1. Limite Inferior ($R_{p,\min }$ — Proteção de Corrente e Tensão $V_{OL}$)

Quando um transistor NMOS interno entra em saturação para puxar a linha para nível baixo, a corrente de afundamento (sink current) $I_{OL}$ não deve exceder a especificação máxima do componente ($I_{OL}\le 3\text{ mA}$ em barramento I2C Standard-Mode), mantendo a tensão residual de nível baixo abaixo de $V_{OL,\max }=0,4\text{ V}$:

$R_{p,\min }=\frac{V_{CC}-V_{OL,\max }}{I_{OL}}$

Para alimentação típica de $V_{CC}=5,0\text{ V}$:

$R_{p,\min }=\frac{5,0\text{ V}-0,4\text{ V}}{3,0\text{ mA}}=\frac{4,6}{3\cdot 10^{-3}}\approx 1533\Omega ⟹\boxed{R_{p,\min }\approx 1,5\text{ k}\Omega }$

2. Limite Superior ($R_{p,\max }$ — Tempo de Subida $t_r$ e Capacitância Parasita $C_b$)

A transição de nível lógico baixo para alto ocorre exclusivamente através do carregamento da capacitância parasita distribuída do barramento ($C_b$, formada pelas trilhas da PCB, pinos dos circuitos integrados e cabos) através de $R_p$. A equação diferencial de carga é:

$V(t)=V_{CC}\left(1-e^{-\frac{t}{R_p{C}_b}}\right)$

Pela norma NXP UM10204, os limiares lógicos de transição são definidos em:

• $V_{IL}=0,3\cdot V_{CC}$ (nível de início da transição de subida)
• $V_{IH}=0,7\cdot V_{CC}$ (nível de fim da transição de subida)

Calculando os instantes temporais:

$t_1=-R_p{C}_b\cdot \ln (1-0,3)=-R_p{C}_b\cdot \ln (0,7)\approx 0,3567\cdot R_p{C}_b$

$t_2=-R_p{C}_b\cdot \ln (1-0,7)=-R_p{C}_b\cdot \ln (0,3)\approx 1,2040\cdot R_p{C}_b$

O tempo de subida normatizado $t_r=t_2-t_1$ resulta em:

$t_r=(1,2040-0,3567)\cdot R_p{C}_b=0,8473\cdot R_p{C}_b$

Isolando o resistor de pull-up máximo permissível:

$\boxed{R_{p,\max }=\frac{t_{r,\max }}{0,8473\cdot C_b}}$

Para barramento operando em Modo Padrão (Standard-mode, $100\text{ kHz}$), a norma especifica $t_{r,\max }=1000\text{ ns}$ e capacitância máxima de barramento $C_{b,\max }=400\text{ pF}$. Para uma linha típica com $C_b=200\text{ pF}$:

$R_{p,\max }=\frac{1000\cdot 10^{-9}\text{ s}}{0,8473\cdot 200\cdot 10^{-12}\text{ F}}\approx \frac{1000}{0,1695}\approx 5900\Omega ⟹\boxed{R_{p,\max }\approx 5,9\text{ k}\Omega }$

Para Modo Rápido (Fast-mode, $400\text{ kHz}$), onde $t_{r,\max }=300\text{ ns}$:

$R_{p,\max }=\frac{300\cdot 10^{-9}\text{ s}}{0,8473\cdot 200\cdot 10^{-12}\text{ F}}\approx 1770\Omega ⟹\boxed{R_{p,\max }\approx 1,8\text{ k}\Omega }$

Pull-ups Internos do Microcontrolador ATmega328P

Os resistores de pull-up internos ativados pela biblioteca Wire.h possuem valor nominal entre $20\text{ k}\Omega$ e $50\text{ k}\Omega$. Como esse valor supera expressivamente o $R_{p,\max }$ normatizado para $C_b>50\text{ pF}$, o uso isolado dos pull-ups internos resulta em bordas de subida excessivamente lentas e falhas crônicas de comunicação em frequências acima de $100\text{ kHz}$. É mandatório incluir resistores externos de $4,7\text{ k}\Omega$ (para $100\text{ kHz}$) ou $2,2\text{ k}\Omega$ (para $400\text{ kHz}$).

---

3.4 Arquitetura do Controlador Gráfico OLED SSD1306 e Mapeamento de GDDRAM

O display OLED de 0,96 polegadas é amplamente utilizado em painéis de instrumentação devido ao seu contraste infinito (tecnologia emissiva onde cada subpixel é um diodo orgânico individual) e reduzido consumo de corrente.

3.4.1 Organização da Memória GDDRAM

O chip controlador Solomon Systech SSD1306 possui uma memória estática interna de vídeo denominada GDDRAM (Graphic Display Data RAM) de $128\times 64\text{ bits}=8192\text{ bits}=1024\text{ bytes}$.

A memória é mapeada em 8 Páginas horizontais (PAGE0 a PAGE7). Cada página possui 128 colunas de largura por 8 pixels de altura:

• Cada byte transmitido preenche uma coluna vertical de 8 pixels em uma determinada página.
• O bit $D_0$ corresponde ao pixel superior da página; o bit $D_7$ ao pixel inferior da mesma página.
• Um display monocromático de $128\times 64$ exige um buffer espelho (framebuffer) de: $\text{Tamanho do Framebuffer}=\frac{128\cdot 64}{8}=1024\text{ bytes}=1\text{ KiB}$

3.4.2 Impacto Crítico na Memória SRAM do ATmega328P

O microcontrolador ATmega328P dispõe de exatamente $2048\text{ bytes}$ ($2\text{ KiB}$) de memória de dados SRAM. A biblioteca Adafruit_SSD1306 aloca dinamicamente o buffer completo de tela na RAM para permitir operações gráficas avançadas (desenho de retas, círculos e texto proporcional com buffer duplo):

$\text{Ocupac¸a˜o do Buffer de Vıˊdeo}=\frac{1024\text{ bytes}}{2048\text{ bytes}}=50\%\text{ da SRAM total}$

Restam apenas $1024\text{ bytes}$ para:

• Pilha de execução (Stack - retorno de funções e interrupções);
• Variáveis globais e estáticas do programa;
• Buffers de comunicação da UART ($64\text{ bytes}$ para RX $+64\text{ bytes}$ para TX $=128\text{ bytes}$);
• Buffers internos da biblioteca Wire ($32\text{ bytes}\times 2=64\text{ bytes}$).

Alerta de Stack Overflow e a Macro F()

Qualquer uso descuidado de strings literais (Serial.println("Mensagem muito longa...");) consome SRAM preciosa, pois o compilador C++ copia todas as strings da Flash para a RAM durante o boot. O esgotamento da memória causa colisão imediata entre a pilha (Stack) e a área de dados globais (Heap), resultando em travamentos intermitentes e reinicializações espontâneas por watchdog. A diretiva de engenharia obrigatória é encapsular todas as strings na macro F():

Serial.println(F("Texto alocado exclusivamente na memoria Flash ROM"));

---

🖼️ 4. Diagrama Esquemático Integrado

O diagrama técnico a seguir sintetiza a arquitetura completa abordada nesta aula: o fluxo assíncrono do receptor UART com buffer circular de 64 bytes e a topologia física de barramento I2C com resistores de pull-up externos acionando o display gráfico OLED SSD1306:

---

💻 5. Implementação de Software e Algoritmos de Comunicação

5.1 Scanner de Endereços I2C com Tratamento de Erros

O algoritmo fundamental de diagnóstico em barramentos I2C realiza a varredura sistemática dos 127 endereços válidos de 7 bits ($0x01$ a $0x7F$), transmitindo um quadro de controle vazio e monitorando a resposta de ACK:

#include <Wire.h>
 
void setup() {
    Serial.begin(115200);
    while (!Serial); // Aguarda conexao do terminal USB nativo
    
    Wire.begin(); // Inicializa o modulo TWI como mestre
    Wire.setClock(400000L); // Configura barramento I2C para Fast-Mode (400 kHz)
    
    Serial.println(F("========================================"));
    Serial.println(F("   VARREDURA DO BARRAMENTO I2C (TWI)    "));
    Serial.println(F("========================================"));
}
 
void loop() {
    byte statusRetorno;
    int dispositivosEncontrados = 0;
    
    Serial.println(F("Iniciando varredura de enderecos 0x01 a 0x7E..."));
    
    for (byte endereco = 1; endereco < 127; endereco++) {
        // Envia condicao de START e byte de endereco com bit R/W = 0 (Escrita)
        Wire.beginTransmission(endereco);
        // Finaliza transmissao e captura o status do nono bit (ACK/NACK)
        statusRetorno = Wire.endTransmission();
        
        if (statusRetorno == 0) {
            Serial.print(F(" -> Dispositivo detectado no endereco: 0x"));
            if (endereco < 16) Serial.print(F("0"));
            Serial.print(endereco, HEX);
            
            // Identificacao de perifericos comuns de instrumentacao
            if (endereco == 0x3C || endereco == 0x3D) {
                Serial.println(F(" (Display OLED SSD1306)"));
            } else if (endereco == 0x27 || endereco == 0x3F) {
                Serial.println(F(" (Expansor PCF8574 para LCD 16x2)"));
            } else if (endereco == 0x68) {
                Serial.println(F(" (RTC DS3231 ou IMU MPU-6050)"));
            } else {
                Serial.println();
            }
            dispositivosEncontrados++;
        } else if (statusRetorno == 4) {
            Serial.print(F(" -> Erro critico de barramento no endereco: 0x"));
            if (endereco < 16) Serial.print(F("0"));
            Serial.println(endereco, HEX);
        }
    }
    
    if (dispositivosEncontrados == 0) {
        Serial.println(F("Nenhum periferico I2C respondeu com ACK."));
        Serial.println(F("Verifique as linhas SDA/SCL e os resistores de pull-up."));
    } else {
        Serial.print(F("Varredura concluida. Dispositivos ativos: "));
        Serial.println(dispositivosEncontrados);
    }
    
    Serial.println(F("Aguardando 10 segundos para nova varredura...\n"));
    delay(10000);
}

---

5.2 Parser Serial Não-Bloqueante com Proteção de Overflow

Em automação, comandos seriais enviados por sistemas SCADA chegam como cadeias ASCII terminadas em nova linha (\n). O código a seguir implementa uma máquina de recepção assíncrona com buffer local e proteção estrita contra estouro de memória:

#include <Arduino.h>
 
const byte BUFFER_CMD_SIZE = 32;
char bufferComando[BUFFER_CMD_SIZE];
byte indiceBuffer = 0;
bool comandoCompleto = false;
 
void processarComando(const char* cmd) {
    Serial.print(F("[SUPERVISORIO] Comando recebido: "));
    Serial.println(cmd);
    
    if (strcmp(cmd, "RELE_ON") == 0) {
        digitalWrite(13, HIGH);
        Serial.println(F("STATUS:OK;VAL:1"));
    } else if (strcmp(cmd, "RELE_OFF") == 0) {
        digitalWrite(13, LOW);
        Serial.println(F("STATUS:OK;VAL:0"));
    } else if (strncmp(cmd, "PWM=", 4) == 0) {
        int valorPWM = atoi(&cmd[4]);
        valorPWM = constrain(valorPWM, 0, 255);
        analogWrite(6, valorPWM);
        Serial.print(F("STATUS:OK;PWM:"));
        Serial.println(valorPWM);
    } else {
        Serial.println(F("STATUS:ERRO_COMANDO_INVALIDO"));
    }
}
 
void setup() {
    pinMode(13, OUTPUT);
    pinMode(6, OUTPUT);
    Serial.begin(115200);
    Serial.println(F("UART Parser Ativo @ 115200 bps. Envie comandos terminados em \\n."));
}
 
void loop() {
    // Leitura assincrona nao-bloqueante da fila serial do hardware
    while (Serial.available() > 0 && !comandoCompleto) {
        char caractereRecebido = (char)Serial.read();
        
        if (caractereRecebido == '\n' || caractereRecebido == '\r') {
            if (indiceBuffer > 0) {
                bufferComando[indiceBuffer] = '\0'; // Finalizador de string C
                comandoCompleto = true;
            }
        } else {
            if (indiceBuffer < (BUFFER_CMD_SIZE - 1)) {
                bufferComando[indiceBuffer++] = caractereRecebido;
            } else {
                // Tratamento preventivo de overflow de buffer local
                indiceBuffer = 0;
                Serial.println(F("ALERTA: Buffer de comando estourado. Linha descartada."));
            }
        }
    }
    
    // Executa a acao quando a mensagem estiver integralmente no buffer
    if (comandoCompleto) {
        processarComando(bufferComando);
        indiceBuffer = 0;
        comandoCompleto = false;
    }
    
    // O laço principal permanece livre para tarefas de tempo real e controle
}

---

5.3 Dashboard Gráfico com Display OLED SSD1306 e Otimização de RAM

A aplicação a seguir coleta a tensão de um transdutor analógico no pino A0, desenha uma interface visual com barra de progresso gráfica proporcional e transmite os dados para a UART, utilizando $100\%$ das constantes de texto na memória Flash:

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
 
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET    -1 // Compartilha reset com o microcontrolador
#define I2C_ADDRESS   0x3C // Endereco tipico do display OLED 0.96"
 
// Aloca o buffer de tela de 1024 bytes na memoria SRAM
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
 
unsigned long ultimoUpdate = 0;
const unsigned long INTERVALO_REFRESH_MS = 100; // Taxa de atualizacao de 10 Hz
 
void desenharInterface(int leituraBruta, float tensaoVolts) {
    display.clearDisplay(); // Limpa o buffer de video
    
    // Cabecalho estilizado
    display.setTextSize(1);
    display.setTextColor(SSD1306_WHITE);
    display.setCursor(0, 0);
    display.print(F("TELEMETRIA ELETRICA"));
    display.drawFastHLine(0, 10, SCREEN_WIDTH, SSD1306_WHITE);
    
    // Leituras numericas principais
    display.setCursor(0, 16);
    display.print(F("Tensao ADC: "));
    display.print(tensaoVolts, 2);
    display.print(F(" V"));
    
    display.setCursor(0, 28);
    display.print(F("Cod. Digital: "));
    display.print(leituraBruta);
    display.print(F(" / 1023"));
    
    // Desenho de Barra Grafica Horizontal Dinamica
    // Moldura externa da barra: x=0, y=42, w=128, h=14
    display.drawRect(0, 42, 128, 14, SSD1306_WHITE);
    
    // Preenchimento interno proporcional (0 a 124 pixels de largura)
    int larguraBarra = map(leituraBruta, 0, 1023, 0, 124);
    display.fillRect(2, 44, larguraBarra, 10, SSD1306_WHITE);
    
    // Linha inferior de status
    display.setCursor(0, 57);
    display.print(F("I2C 400kHz | Modo Seguro"));
    
    // Transfere o buffer completo de 1024 bytes via barramento I2C para a GDDRAM
    display.display();
}
 
void setup() {
    Serial.begin(115200);
    
    // Inicializacao do display com inicializacao da tensao interna via charge-pump
    if (!display.begin(SSD1306_SWITCHCAPVCC, I2C_ADDRESS)) {
        Serial.println(F("ERRO CRITICO: Falha na alocacao ou conexao do OLED SSD1306."));
        for (;;); // Trava o sistema por seguranca
    }
    
    Wire.setClock(400000L); // Ajusta I2C para 400 kHz para transmissao veloz do framebuffer
    display.clearDisplay();
    display.display();
    
    Serial.println(F("Sistema OLED Inicializado com Sucesso."));
}
 
void loop() {
    unsigned long agora = millis();
    
    if (agora - ultimoUpdate >= INTERVALO_REFRESH_MS) {
        ultimoUpdate = agora;
        
        int adcValor = analogRead(A0);
        float tensao = (adcValor * 5.0) / 1023.0;
        
        desenharInterface(adcValor, tensao);
    }
}

---

📝 6. Banco de Questões de Fixação e Concursos Auditados

Questão 01 — Erro de Temporização e Tolerância de Baud Rate na USART do ATmega328P

(Petrobras — Engenharia Eletrônica / Adaptada)
Um microcontrolador ATmega328P operando com frequência de clock de $F_{\text{osc}}=16,000\text{ MHz}$ deve estabelecer comunicação serial assíncrona no padrão 8N1 a uma taxa nominal de $115200\text{ bps}$.
a) Calcule o valor inteiro que deve ser configurado no registrador de 12 bits UBRR0 operando no modo normal ($U2X0=0$).
b) Determine a taxa de transmissão real (${\text{Baud}}_{\text{real}}$) obtida e o respectivo erro percentual ${\epsilon }_{\text{baud}}$.
c) Avalie se a comunicação é viável em ambientes ruidosos sob a ótica da tolerância máxima aceitável de temporização assíncrona.

💡 Resolução Analítica Passo a Passo:

a) Cálculo de UBRR0 no modo normal ($U2X0=0$): A fórmula fundamental do divisor é: $\text{UBRR0}=\mathrm{round}\left(\frac{F_{\text{osc}}}{16\cdot \text{Baud}}-1\right)$ Substituindo os valores: $\text{UBRR0}=\frac{16\cdot 10^6}{16\cdot 115200}-1=\frac{1\cdot 10^6}{115200}-1\approx 8,6805-1=7,6805$ Arredondando para o inteiro mais próximo: $\boxed{\text{UBRR0}=8}$

b) Cálculo da taxa real e do erro percentual: A taxa efetivamente sintetizada pelo hardware com $\text{UBRR0}=8$ é: ${\text{Baud}}_{\text{real}}=\frac{16\cdot 10^6}{16\cdot (8+1)}=\frac{10^6}{9}\approx 111111,11\text{ bps}$ O erro percentual relativo é: ${\epsilon }_{\text{baud}}=\left(\frac{{\text{Baud}}_{\text{real}}-{\text{Baud}}_{\text{alvo}}}{{\text{Baud}}_{\text{alvo}}}\right)\cdot 100\%=\left(\frac{111111,11-115200}{115200}\right)\cdot 100\%$ ${\epsilon }_{\text{baud}}=\left(\frac{-4088,89}{115200}\right)\cdot 100\%\approx \boxed{-3,55\%}$

c) Avaliação de Integridade:
Embora o erro teórico de $-3,55\%$ esteja estritamente dentro do limite assintótico teórico de falha catastrófica ($\pm 4,5\%$), ele ultrapassa o limite de confiabilidade industrial ($\pm 2,0\%$). Qualquer desvio térmico no cristal oscilador de quartzo ou ruído na borda do start bit resultará em amostragem fora da janela do Stop bit, gerando erros recorrentes de Frame Error (bit FE0 ativo). Recomenda-se ativar o modo $U2X0=1$, onde $\text{UBRR0}=16$ resulta em ${\text{Baud}}_{\text{real}}=117647\text{ bps}$ com erro reduzido de $+2,12\%$.

---

Questão 02 — Dimensionamento Analítico dos Resistores de Pull-Up do Barramento I2C

(Marinha do Brasil — Corpo de Engenheiros / Eletrônica)
Um barramento de instrumentação I2C operando em Fast-Mode ($f_{\text{SCL}}=400\text{ kHz}$) com nível de alimentação de $V_{CC}=5,0\text{ V}$ conecta um mestre ATmega328P a três sensores inteligentes e um display OLED. Medições de bancada revelam que a capacitância total distribuída no barramento (trilhas, conectores e pinos de entrada) é de $C_b=180\text{ pF}$.
Sabendo que os transistores NMOS de saída dos componentes garantem $V_{OL,\max }=0,4\text{ V}$ sob corrente de dreno de $I_{OL}=3\text{ mA}$, e que a norma NXP UM10204 estipula tempo de subida máximo de $t_{r,\max }=300\text{ ns}$ para a faixa de $0,3V_{CC}$ a $0,7V_{CC}$:
a) Calcule a faixa admissível $[R_{p,\min },R_{p,\max }]$ para os resistores de pull-up do barramento.
b) Selecione o valor comercial padrão (série E12) ótimo e calcule o tempo de subida $t_r$ resultante.

💡 Resolução Analítica Passo a Passo:

a) Determinação dos Limites Teóricos:

1. Limite Inferior ($R_{p,\min }$): $R_{p,\min }=\frac{V_{CC}-V_{OL,\max }}{I_{OL}}=\frac{5,0-0,4}{3,0\cdot 10^{-3}}=\frac{4,6}{3\cdot 10^{-3}}\approx 1533\Omega ⟹\boxed{R_{p,\min }\approx 1,53\text{ k}\Omega }$

2. Limite Superior ($R_{p,\max }$): A constante de proporcionalidade da equação diferencial de carga para a faixa de $30\%$ a $70\%$ de $V_{CC}$ é: $k=\ln (0,7)-\ln (0,3)=\ln \left(\frac{0,7}{0,3}\right)=\ln (2,3333)\approx 0,8473$ Logo: $R_{p,\max }=\frac{t_{r,\max }}{0,8473\cdot C_b}=\frac{300\cdot 10^{-9}}{0,8473\cdot 180\cdot 10^{-12}}=\frac{300}{0,1525}\approx \boxed{1967\Omega \approx 1,97\text{ k}\Omega }$

A faixa admissível é: $\boxed{1,53\text{ k}\Omega \le R_p\le 1,97\text{ k}\Omega }$

b) Seleção de Componente Comercial:
Na série comercial E12 ($10\%$), o valor padronizado contido rigorosamente no intervalo $[1,53\text{ k}\Omega ,1,97\text{ k}\Omega ]$ é: $\boxed{R_p=1,8\text{ k}\Omega }$ O tempo de subida real proporcionado por esse resistor será: $t_r=0,8473\cdot R_p\cdot C_b=0,8473\cdot 1800\cdot 180\cdot 10^{-12}\approx 274,5\text{ ns}$ Como $274,5\text{ ns}<300\text{ ns}$, o critério da norma NXP é plenamente atendido.

---

Questão 03 — Análise de Alocação de Memória RAM para Display SSD1306

(ENADE — Engenharia de Controle e Automação / Adaptada)
Considere um sistema baseado no microcontrolador ATmega328P ($2048\text{ bytes}$ de SRAM) que utiliza um display gráfico OLED SSD1306 ($128\times 64$ pixels monocromático).
a) Calcule o consumo exato em bytes do framebuffer de vídeo mantido na SRAM pela biblioteca gráfica Adafruit SSD1306.
b) Se a aplicação declara variáveis globais estáticas totalizando $450\text{ bytes}$ e utiliza a porta serial com buffers padrão ($128\text{ bytes}$ no total), determine o espaço restante disponível para a pilha de execução (Stack).
c) Explique a consequência técnica caso o desenvolvedor declare uma matriz local de números de ponto flutuante float dados[150]; no escopo da função loop().

💡 Resolução Analítica Passo a Passo:

a) Cálculo do Framebuffer:
O display possui $128$ colunas e $64$ linhas, onde cada pixel ocupa exatamente $1\text{ bit}$ (ligado ou desligado): $\text{Bits de Vıˊdeo}=128\times 64=8192\text{ bits}$ Convertendo para bytes: $\text{Bytes}=\frac{8192}{8}=\boxed{1024\text{ bytes}(1\text{ KiB})}$

b) Balanço de Memória SRAM:
A alocação estática e de periféricos soma:

• Framebuffer OLED: $1024\text{ bytes}$
• Buffers de hardware UART (RX + TX): $64+64=128\text{ bytes}$
• Variáveis globais do sistema: $450\text{ bytes}$ $\text{Memoˊria Ocupada}=1024+128+450=1602\text{ bytes}$ Espaço residual para o Stack e variáveis locais dinâmicas: $\text{SRAM Restante}=2048-1602=\boxed{446\text{ bytes}}$

c) Análise de Falha por Stack Overflow:
A declaração de uma variável local no escopo de uma função aloca espaço diretamente no topo da pilha (Stack). Em sistemas AVR de 8 bits, cada elemento do tipo float (padrão IEEE 754 de precisão simples) ocupa exatamente $4\text{ bytes}$.
Portanto, a matriz exige: $\text{Memoˊria da Matriz}=150\times 4\text{ bytes}=600\text{ bytes}$ Como a pilha dispõe de apenas $446\text{ bytes}$, a tentativa de alocação de $600\text{ bytes}$ causa um transbordamento imediato de pilha (Stack Overflow): o ponteiro de pilha $SP$ (Stack Pointer) invade e sobrescreve a área de variáveis globais e o final do framebuffer do display. Os sintomas observados na bancada são: corrupção visual instantânea da tela OLED, travamento do laço de controle ou reinicialização em laço infinito (bootloop) causada pelo corrompimento do endereço de retorno desempilhado pelo microcontrolador.

---

📚 7. Referências Bibliográficas e Normas Técnicas

1. ATMEL / MICROCHIP. ATmega328P 8-bit AVR Microcontroller with 32K Bytes In-System Programmable Flash Datasheet. Document DS40002061B, 2018.
2. NXP SEMICONDUCTORS. UM10204: I2C-bus specification and user manual. Rev. 7.0, 2021.
3. SOLOMON SYSTECH. SSD1306: 128 x 64 Dot Matrix OLED/PLED Segment/Common Driver with Controller Datasheet. Rev. 1.1, 2008.
4. MONK, Simon. Programação com Arduino: Começando com Sketches. 2. ed. Porto Alegre: Bookman, 2017.
5. MARGOLIS, Michael. Arduino Cookbook: Recipes to Begin, Expand, and Enhance Your Projects. 3. ed. Sebastopol: O’Reilly Media, 2020.
6. BANZI, Massimo; SHILOH, Michael. Getting Started with Arduino: The Open Source Electronics Prototyping Platform. 4. ed. Maker Media, 2022.
7. VALDEZ, Frank. Designing with Logic: I2C Bus Pull-Up Resistor Calculation. Texas Instruments Application Report SLVA689, 2015.