Kit Avançado Componentes Eletrônicos Para Arduino Caixa AE001

Introdução

Este curso apresenta uma formação técnica completa em computação física, eletrônica analógica e digital e sistemas embarcados baseada na plataforma Arduino Uno R3 (microcontrolador ATmega328P) e no conjunto de componentes do Kit Avançado de Componentes Eletrônicos para Arduino Caixa AE001 (KUONGSHUN AE001 UNO KIT RFID LEARNING SUITE). Ao longo de 29 lições práticas organizadas na ordem rigorosa da documentação original do fabricante — partindo da Lição 0 até a Lição 28 — são explorados os princípios fundamentais da instrumentação eletroeletrônica, conversores analógico-digitais (ADC — Analog-to-Digital Converter), modulação por largura de pulso (PWM — Pulse Width Modulation), expansão de portas com registradores de deslocamento serial-paralelo, sensoriamento ambiental, atuadores eletromecânicos, displays alfanuméricos e multiplexados, comunicação por radiação infravermelha (IR — Infrared), radiofrequência em 13,56 MHz (RFID — Radio-Frequency Identification) e barramentos de comunicação síncrona e assíncrona (UART, I2C e SPI).

O material foi estruturado com rigor didático e profundidade de engenharia para atender desde o estudante e entusiasta iniciante até desenvolvedores que necessitam dominar o comportamento físico dos componentes, o cálculo elétrico de polarização e temporização, e a programação de firmware em linguagem C++ com comentários exaustivos linha a linha. Toda a jornada é apresentada nesta página única e autocontida, com esquemáticos detalhados, diagramas visuais de montagem em matriz de contatos (breadboard), tabelas de ligação pino a pino, caixas de bibliotecas com instruções de instalação direta ou manual, procedimentos de teste com resultados esperados no circuito e no Monitor Serial, e um guia de diagnóstico e solução de falhas (Troubleshooting) estruturado para resolver rapidamente erros comuns de compilação, portas seriais e cabeamento.

O que você vai aprender:

• Compreender a arquitetura interna do microcontrolador ATmega328P, seus registradores, portas digitais, canais analógicos e timers de hardware
• Aplicar a Lei de Ohm e equações de dimensionamento elétrico para polarizar diodos emissores de luz (LEDs), divisores de tensão e transistores de chaveamento
• Utilizar chaves táteis, sensores de inclinação tipo esfera (tilt switch), potenciômetros e sensores analógicos e digitais
• Controlar transdutores sonoros piezoelétricos com buzzers ativos e passivos, gerando melodias e frequências audíveis
• Modelar o acionamento angular de precisão em micro servomotores SG90 através de trens de pulsos PWM
• Realizar varredura matricial em teclados de membrana 4x4 decodificando linhas e colunas por software
• Efetuar medições higrométricas e térmicas com sensor digital DHT11 e transdutor linear analógico LM35
• Monitorar níveis de líquidos e intensidade sonora com módulos analógico-digitais comparadores baseados no circuito integrado LM393
• Capturar e decodificar trens de pulsos infravermelhos modulados a 38 kHz emitidos por controles remotos no protocolo NEC
• Operar displays matriciais de LED 8x8 e módulos LCD 16x2 com interface I2C baseada no expansor PCF8574
• Expandir as saídas do Arduino utilizando o circuito integrado registrador de deslocamento 74HC595 para controlar 8 LEDs e displays de 7 segmentos de 1 e 4 dígitos multiplexados
• Ler e autenticar cartões e chaveiros de proximidade Mifare Classic através do módulo transceptor RFID RC522 em barramento SPI
• Comutar cargas elétricas de corrente contínua através de módulo relé de 1 canal com isolamento óptico
• Controlar velocidade, sentido de rotação e posicionamento angular de motor de passo unipolar 28BYJ-48 através de driver Darlington ULN2003
• Diagnosticar sistematicamente anomalias elétricas, erros de compilação e conflitos de porta serial com o Guia Diagnóstico

Material utilizado: Kits para Arduino na loja RoboBuilders

---

Visão Geral do Kit e Arquitetura de Hardware

O kit KUONGSHUN AE001 UNO KIT RFID LEARNING SUITE (referência comercial RoboBuilders: Kit Avançado Componentes Eletrônicos Para Arduino Caixa AE001) adota como unidade central de processamento a placa compatível Arduino Uno R3, equipada com o microcontrolador de 8 bits de arquitetura AVR ATmega328P da Microchip/Atmel. O sistema opera em frequência de clock de 16 MHz estabilizada por cristal piezoelétrico externo, oferecendo tempo de ciclo de instrução de 62,5 nanossegundos para a grande maioria das instruções de máquina de ciclo único do conjunto RISC (Reduced Instruction Set Computer).

Especificações Técnicas da Placa Arduino Uno R3

Parâmetro de Engenharia	Especificação Técnica	Descrição e Limites Operacionais
Microcontrolador Central	Microchip ATmega328P	Arquitetura AVR RISC de 8 bits, 32 registradores de uso geral
Tensão Lógica de Operação	5,0 VDC	Nível lógico alto ($V_{OH} \ge 4{,}2\,\text{V}$), baixo ($V_{OL} \le 0{,}9\,\text{V}$)
Tensão de Entrada Recomendada	7,0 V a 12,0 VDC	Conector Jack P4 central positivo ou pino VIN
Limites Absolutos de Alimentação	6,0 V a 20,0 VDC	Tensões acima de 12 V causam aquecimento severo do regulador linear LDO
Portas Digitais de Entrada/Saída	14 pinos (D0 a D13)	Corrente nominal de 20 mA por pino; corrente máxima absoluta de 40 mA
Canais PWM por Hardware	6 pinos (D3, D5, D6, D9, D10, D11)	Resolução de 8 bits (256 níveis), temporizadores Timer0, Timer1 e Timer2
Canais de Entrada Analógica	6 canais (A0 a A5)	Conversor ADC de 10 bits de aproximações sucessivas (0 a 1023 passos)
Memória Flash de Programa	32 KB	0,5 KB ocupados pelo gerenciador de inicialização (bootloader Optiboot)
Memória SRAM de Dados	2 KB	Armazenamento de variáveis de execução, pilha e registradores
Memória EEPROM Não-Volátil	1 KB	Armazenamento persistente regravável por software byte a byte
Frequência de Clock	16,0 MHz	Ressonador cerâmico externo com tolerância de $\pm 0{,}5\%$
Corrente Máxima no Barramento 5V	~500 mA (USB) / ~800 mA (VIN)	Limitada pelo fusível rearmável PTC na USB ou LDO onboard
Corrente Máxima no Barramento 3,3V	50 mA a 150 mA	Fornecida por regulador linear dedicado onboard (LP2985 ou similar)
Interface USB-Serial	ATmega16U2 / CH340G	Ponte de comunicação serial assíncrona USB-UART e controle de auto-reset

Modelos Matemáticos e Fórmulas de Engenharia Fundamentais

No desenvolvimento dos projetos deste kit, o dimensionamento elétrico dos circuitos periféricos e o processamento digital dos sinais adquiridos baseiam-se em leis fundamentais da física e da eletrônica.

A quantização do conversor analógico-digital (ADC) relaciona a tensão analógica contínua $V_{IN}$ presente no pino de entrada com a palavra binária inteira resultante de 10 bits (0 a 1023), adotando como referência analógica padrão $V_{REF} = 5{,}0\,\text{V}$:

$$ADC = \left\lfloor \frac{V_{IN} \times 1023}{V_{REF}} \right \rfloor$$

Para obter o valor analógico de tensão em volts a partir do valor lido pela função analogRead():

$$V_{IN} = \frac{ADC \times 5{,}0\,\text{V}}{1023}$$

A modulação por largura de pulso (PWM) sintetiza uma tensão média contínua aparente $V_{MED}$ através da variação da razão cíclica (duty cycle $D$) de uma onda quadrada de alta frequência:

$$D = \frac{t_{ON}}{T} \times 100\%$$ $$V_{MED} = \frac{t_{ON}}{T} \times V_{CC}$$

No Arduino Uno R3, a chamada de função analogWrite(pino, valor) mapeia o intervalo de 0 a 255 no ciclo de trabalho proporcional:

$$D = \frac{\text{valor}}{255}$$ $$V_{MED} = \left( \frac{\text{valor}}{255} \right) \times 5{,}0\,\text{V}$$

O dimensionamento de resistores limitadores de corrente para diodos emissores de luz (LEDs) decorre diretamente da Primeira Lei de Ohm e da Lei das Tensões de Kirchhoff aplicada à malha fechada:

$$V = R \times I$$ $$R_{LIM} = \frac{V_{CC} - V_{D}}{I_{D}}$$

onde $V_{CC}$ é a tensão de alimentação (5,0 V), $V_{D}$ é a queda de tensão direta no diodo semicondutor (~1,8 V a 2,2 V para LEDs vermelhos e amarelos; ~3,0 V a 3,4 V para LEDs azuis, verdes e brancos) e $I_{D}$ é a corrente direta de polarização desejada (tipicamente 10 mA a 15 mA para operação luminosa contínua segura sem sobrecarga térmica).

A potência elétrica dissipada no resistor em regime estacionário é dada por:

$$P = R \times I_{D}^{2}$$ $$P = (V_{CC} - V_{D}) \times I_{D}$$

Para um circuito de LED com $V_{CC} = 5{,}0\,\text{V}$, $V_{D} = 2{,}0\,\text{V}$ e $I_{D} = 13{,}6\,\text{mA}$, temos $R_{LIM} = (5{,}0 - 2{,}0) / 0{,}0136 \approx 220\,\Omega$, e a dissipação é $P = 3{,}0 \times 0{,}0136 \approx 40{,}8\,\text{mW}$, muito abaixo do limite padrão de 250 mW dos resistores de 1/4W do kit.

Nos circuitos baseados em sensores resistivos (como fotocélulas LDR, termistores NTC e sensores de chama), utiliza-se uma topologia de divisor de tensão passivo para converter variações de resistência física $\Delta R_{S}$ em tensões mensuráveis $V_{OUT}$ pelo conversor analógico:

$$V_{OUT} = V_{CC} \times \left( \frac{R_{DIV}}{R_{S} + R_{DIV}} \right)$$

onde $R_{S}$ é a resistência dinâmica do sensor e $R_{DIV}$ é o resistor de referência fixo conectado ao terra (ou ao barramento de 5V).

Para o acionamento de motores de passo com redução mecânica (modelo 28BYJ-48 com razão de redução nominal de 64:1 e 32 passos internos por revolução completa do rotor no modo de passo completo), o número de passos de comando por volta do eixo externo de saída é obtido por:

$$\text{Passos por Volta} = 32 \times 64 = 2048$$ $$\theta_{PASSO} = \frac{360^{\circ}}{2048} \approx 0{,}17578^{\circ}$$

Mapa de Barramentos e Distribuição de Pinos do Arduino Uno R3

Barramento / Função	Pinos Físicos do Arduino Uno	Protocolo / Descrição de Uso nos Projetos
UART Serial Hardware	D0 (RX) e D1 (TX)	Comunicação bidirecional com PC a 9600 ou 115200 bps via cabo USB
Interrupções Externas	D2 (INT0) e D3 (INT1)	Disparo imediato por borda de subida, descida ou mudança de estado lógico
Saídas PWM Rápidas	D3, D5, D6, D9, D10, D11	Timer0 (D5/D6 a ~976 Hz), Timer1 (D9/D10 a ~490 Hz), Timer2 (D3/D11 a ~490 Hz)
Barramento SPI Hardware	D10 (SS), D11 (MOSI), D12 (MISO), D13 (SCK)	Comunicação de alta velocidade em quatro fios com o módulo RFID RC522
Barramento I2C Hardware	A4 (SDA — Dados) e A5 (SCL — Clock)	Barramento bifilar de dois fios com endereçamento para display LCD 16x2
Entradas Analógicas	A0 a A5	Medição de tensão contínua de 0 a 5V com resolução nominal de 4,88 mV/passo
Expansor 74HC595	3 pinos digitais configuráveis (ex.: D2, D3, D4)	Interface serial síncrona de 3 vias (Data, Latch e Clock) via shiftOut()
Varredura Matricial 4x4	8 pinos digitais (ex.: D2 a D9)	Varredura periódica de 4 linhas e 4 colunas com resistores de pull-up
Interface 1-Wire DHT11	1 pino digital bidirecional (ex.: D2)	Protocolo proprietário temporizado com pulsos de início e leitura contínua
Interface 3 Fios DS1302	3 pinos digitais (ex.: D5, D6, D7)	Comunicação síncrona com linhas CE/RST, DAT (I/O) e CLK para RTC

Inventário Completo do Kit AE001 (Packing List Oficial)

A caixa organizadora transparente com divisórias plásticas do kit KUONGSHUN AE001 reúne um conjunto completo de componentes eletroeletrônicos para prototipagem rápida e experimentação prática:

• 1x Placa microcontroladora compatível com Arduino Uno R3 (ATmega328P em soquete DIP-28, conector USB fêmea tipo B e conector Jack P4 de 2,1 mm)
• 1x Cabo de comunicação e alimentação USB tipo A macho para tipo B macho de alta durabilidade
• 1x Matriz de contatos (breadboard) modelo MB-102 com 830 pontos de conexão e trilhos laterais de alimentação independentes
• 1x Protoshield de prototipagem para Arduino Uno com mini matriz de contatos de 170 furos acoplável
• 1x Fonte de alimentação externa bivolt com saída estabilizada de 9,0 VDC a 1,0 A e plugue P4 central positivo
• 1x Cabo adaptador para bateria de 9V (clipe para bateria com conector P4 central positivo)
• 1x Módulo Display LCD alfanumérico 16x2 (fundo azul com caracteres brancos) com placa adaptadora I2C integrada (chip PCF8574)
• 1x Módulo Leitor/Gravador de identificação por radiofrequência RFID RC522 (frequência de 13,56 MHz) com barra de pinos soldada
• 1x Cartão de identificação RFID Mifare Classic 1K tipo chaveiro plástico azul
• 1x Cartão de identificação RFID Mifare Classic 1K formato cartão de crédito branco com antena espiral interna
• 1x Micro servomotor analógico modelo TowerPro SG90 (rotação de 0° a 180°, torque de 1,6 kgf·cm) com 3 braços intercambiáveis e parafusos
• 1x Motor de passo unipolar de 4 fases modelo 28BYJ-48 (tensão nominal de 5 VDC, redução 64:1)
• 1x Módulo placa de acionamento para motor de passo baseada na matriz de transistores Darlington ULN2003 com 4 LEDs indicadores de fase
• 1x Módulo Joystick analógico de 2 eixos ortogonais (potenciômetros independentes para eixos X e Y) com botão pulsador integrado no eixo Z
• 1x Teclado matricial de membrana flexível 4x4 (16 teclas numéricas e de comando) com conector fêmea de 8 vias passo 2,54 mm
• 1x Módulo sensor de temperatura e umidade digital modelo DHT11 montado em placa de suporte com resistor de pull-up
• 1x Sensor de temperatura analógico de precisão em encapsulamento plástico TO-92 modelo LM35DZ (escala linear de +10,0 mV/°C)
• 1x Módulo sensor de nível e presença de água com trilhas condutivas expostas paralelas em placa de fibra
• 1x Módulo Relógio de Tempo Real (RTC) modelo DS1302 com suporte para bateria de lítio de backup CR2025/CR2032 e cristal de 32,768 kHz
• 1x Módulo sensor acústico / detector de palmas de alta sensibilidade com microfone de eletreto e comparador LM393
• 1x Sensor óptico de chama com fototransistor infravermelho de 760 nm a 1100 nm (encapsulamento tipo LED de 5 mm)
• 1x Módulo Relé eletromecânico de 1 canal para 5 VDC com isolamento óptico por optoacoplador e terminais em barra de bornes a parafuso
• 1x Módulo Matriz de LEDs 8x8 vermelha com 64 pontos luminosos independentes
• 1x Display numérico de 7 segmentos de 1 dígito com ponto decimal (cátodo comum)
• 1x Display numérico de 7 segmentos de 4 dígitos multiplexados com pontos decimais (cátodo comum)
• 1x Circuito integrado registrador de deslocamento de 8 bits serial-in paralelo-out modelo 74HC595N (encapsulamento DIP-16)
• 1x Módulo receptor de radiação infravermelha (IR) de três terminais modelo AX-1838HS (frequência portadora de 38 kHz)
• 1x Controle remoto infravermelho compacto de 21 teclas plásticas com pilha de lítio CR2025
• 1x Módulo LED RGB difuso montado em placa com pinos de conexão passo 2,54 mm
• 1x Buzzer piezoelétrico do tipo ativo (5 VDC com oscilador sonoro interno fixo e etiqueta de proteção selada)
• 1x Buzzer piezoelétrico do tipo passivo (5 VDC necessitando de sinal alternado PWM para geração de áudio)
• 1x Sensor de inclinação mecânico de esfera condutora (tilt ball switch) encapsulado em cilindro metálico selado
• 2x Sensores fotoelétricos LDR (resistores dependentes de luz à base de sulfeto de cádmio CDS de 5 mm)
• 1x Termistor NTC de 10 kΩ modelo MF52D (coeficiente térmico negativo de resistência)
• 1x Transistor NPN de alta corrente modelo PN2222 em encapsulamento plástico TO-92
• 2x Transistores NPN de uso geral modelo S8050 em encapsulamento plástico TO-92
• 2x Diodos retificadores de silício para 1000 V e 1 A modelo 1N4007
• 5x Chaves táteis de comando tipo push-button de 4 terminais para inserção direta em protoboard
• 2x Potenciômetros rotativos lineares de 10 kΩ com haste plástica estriada
• 5x LEDs difusos de 5 mm na cor Vermelha
• 5x LEDs difusos de 5 mm na cor Verde
• 5x LEDs difusos de 5 mm na cor Amarela
• 5x LEDs difusos de 5 mm na cor Azul
• 5x LEDs difusos de 5 mm na cor Branca
• 120x Resistores de precisão de 1/4 W (película de carbono/metal a 1%) agrupados em fitas com valores de 220 Ω, 1 kΩ e 10 kΩ
• 4x Capacitores cerâmicos de disco de desacoplamento (valores de 22 pF e 100 nF / 104)
• 2x Capacitores eletrolíticos de alumínio polarizados de 10 µF e 100 µF para 50 V
• 65x Cabos flexíveis de ligação tipo macho-macho (jumpers de protoboard em comprimentos e cores variados)
• 20x Cabos tipo fêmea-macho de fita destacável (jumpers DuPont de 20 cm)
• 1x Caixa organizadora rígida com divisórias internas e fecho duplo para transporte seguro de todos os componentes

A somatória física atinge mais de 270 componentes individuais, viabilizando desde experimentos básicos de chaveamento elétrico até sistemas automatizados complexos de controle de acesso, sensoriamento climático e instrumentação industrial.

---

Preparação do Ambiente de Desenvolvimento e Toolchain

Para compilar e transferir o firmware para a placa Arduino Uno R3, utiliza-se a ferramenta oficial Arduino Integrated Development Environment (IDE), recomendando-se a versão moderna estável Arduino IDE 2.3.x (com compatibilidade integral com a versão legada estável Arduino IDE 1.8.19 para computadores com sistemas operacionais de 32 bits).

Procedimento de Instalação no Windows

1. Acesse o portal oficial https://www.arduino.cc/en/software e realize o download do instalador executável para Windows (Windows Win 10 and newer, 64 bits).
2. Execute o assistente de instalação com privilégios de administrador. Certifique-se de manter marcadas as opções para instalação do núcleo de placas oficiais AVR e dos drivers USB de suporte.
3. Conecte a placa Arduino Uno R3 a uma porta USB 2.0 ou 3.0 do computador utilizando o cabo azul tipo A-B incluso no kit. O LED indicador verde de alimentação (ON) da placa deve acender imediatamente com brilho constante.

4. Abra o Gerenciador de Dispositivos do Windows (pressione as teclas Windows + X e selecione Gerenciador de Dispositivos) e expanda a categoria Portas (COM e LPT).
   • Em placas Uno R3 com chip conversor ATmega16U2, o sistema operacional reconhecerá o circuito automaticamente como Arduino Uno (COMx).
   • Em placas que empregam o chip de comunicação serial CH340G, o item será listado como USB-SERIAL CH340 (COMx). Se houver um símbolo de exclamação amarelo indicando ausência de driver assinado, execute o utilitário CH341SER.EXE presente no pacote de suporte original do kit e clique no botão INSTALL.

Seleção de Placa e Porta de Comunicação na Arduino IDE

1. Na barra superior ou no menu principal da Arduino IDE, navegue até Ferramentas > Placa > Arduino AVR Boards e selecione rigorosamente a opção Arduino Uno.
2. Em seguida, acesse Ferramentas > Porta e marque a porta serial identificada no passo anterior (por exemplo, COM3, COM4 ou COM7). A porta serial COM1 nunca deve ser utilizada, pois corresponde à interface serial física interna legada da placa-mãe do computador.
3. Para validar o canal de comunicação física antes de iniciar a programação, acesse Ferramentas > Obter Informações da Placa. A janela de diálogo deve retornar os identificadores oficiais do microcontrolador (BN: Arduino Uno, VID: 2341, PID: 0043).

Operação do Monitor Serial e do Plotter Serial

O Monitor Serial (Ctrl + Shift + M) é a interface bidirecional assíncrona para troca de informações e depuração entre o microcontrolador ATmega328P e o computador:

• Taxa de Transmissão (Baud Rate): O valor selecionado no seletor suspenso no canto inferior direito do Monitor Serial (padrão 9600 baud) DEVE coincidir com o parâmetro numérico definido no comando Serial.begin(9600); dentro da função setup(). Se houver discrepância de taxa, a tela exibirá ruído e caracteres truncados.
• Terminador de Linha: Mantenha selecionada a opção Ambos NL & CR (Both NL & CR) ao interagir com códigos que aguardam caracteres digitados no teclado, garantindo o envio dos bytes \r (0x0D) e \n (0x0A).
• Serial Plotter (Ctrl + Shift + L): Interface gráfica embutida que renderiza em tempo real curvas contínuas para variáveis numéricas impressas via Serial.println(valor).

Tabela-Mestre de Bibliotecas do Curso AE001

A tabela a seguir consolida todas as bibliotecas necessárias para os projetos deste curso, indicando a versão pinada recomendada para garantir compatibilidade estrutural com o código, além do método de instalação no Gerenciador e link de espelho oficial em arquivo compactado ZIP.

Biblioteca (#include)	Busca no Gerenciador da IDE	Versão Pinada	Download ZIP (Espelho Oficial)	Lições que Utilizam
Keypad.h	Keypad por Mark Stanley, Alexander Brevig	3.1.1	Chris—A/Keypad	Lição 10
dht_nonblocking.h	DHT nonblocking por Ole Wolf	1.0.0	olewolf/dht_nonblocking	Lição 11
IRremote.h	IRremote por shirriff, z3t0 (versão legada 2.x)	2.8.0	z3t0/Arduino-IRremote (v2.8.0)	Lição 13
LedControl.h	LedControl por Eberhard Fahle	1.0.6	wayoda/LedControl	Lição 14
RtcDS1302.h	RTC by Makuna	2.4.2	Makuna/Rtc	Lição 17
MFRC522.h	MFRC522 por GithubCommunity	1.4.11	miguelbalboa/rfid	Lição 19
LiquidCrystal_I2C.h	LiquidCrystal I2C por Frank de Brabander	1.1.2	johnrickman/LiquidCrystal_I2C	Lição 20
pitches.h	Arquivo de cabeçalho local no sketch	N/A	pitches.h oficial Arduino	Lição 6
Servo.h	Embutida no núcleo padrão da IDE	1.2.1	Integrada na IDE Arduino (nada a baixar)	Lição 8
Stepper.h	Embutida no núcleo padrão da IDE	1.1.4	Integrada na IDE Arduino (nada a baixar)	Lição 28
SPI.h e Wire.h	Embutidas no núcleo AVR do Arduino	N/A	Integradas no compilador AVR (nada a baixar)	Lições 19 e 20

⚠️ Atenção sobre a biblioteca IRremote: O código original da fabricante na Lição 13 adota as classes clássicas da versão 2.x (IRrecv e decode_results). A instalação inadvertida das versões 3.x ou 4.x do Gerenciador causará erros de compilação. Instale rigorosamente a versão 2.8.0 ou importe o arquivo compactado IRremote.zip contido no pacote didático do kit.

---

Lições Práticas do Kit AE001

Lição 0: Instalação e Configuração da Arduino IDE

A Lição 0 estabelece o ponto de partida operacional do desenvolvimento embarcado, guiando a instalação da ferramenta de software, o reconhecimento de portas de hardware pelo sistema operacional e a verificação do compilador cruzado AVR-GCC.

Procedimento Passo a Passo de Configuração

1. Execute o instalador oficial baixado do portal arduino.cc.
2. Concorde com os termos de licença e mantenha selecionadas as caixas de diálogo para instalação do compilador, dos drivers USB e da criação de atalhos na área de trabalho.
3. Conecte a placa Arduino Uno R3 ao computador via cabo USB tipo A-B.
4. Abra o Gerenciador de Dispositivos e confirme a criação de uma nova porta COM sob Portas (COM e LPT) sem símbolos de erro.
5. Inicie a Arduino IDE, selecione a placa Arduino Uno e a porta serial correspondente.
6. A Lição 0 é concluída com sucesso quando a barra de status inferior da IDE exibe a identificação permanente Arduino Uno em COMx.

---

Lição 1: Inclusão de Bibliotecas e Comunicação com o Monitor Serial

A Lição 1 introduz o conceito fundamental de bibliotecas em C/C++ como módulos de código reutilizáveis compostos por arquivos de cabeçalho (.h) e implementações compiladas (.cpp), além de demonstrar o uso do periférico de hardware USART (Universal Synchronous and Asynchronous Receiver-Transmitter) do ATmega328P para troca de mensagens de texto entre a placa e o computador através da interface USB.

Métodos de Instalação de Bibliotecas no Arduino

Existem três metodologias oficiais para adicionar bibliotecas ao ambiente:

1. Pelo Gerenciador de Bibliotecas (Library Manager): Acesse Sketch > Incluir Biblioteca > Gerenciar Bibliotecas..., digite o nome do pacote na caixa de busca, selecione a versão exata desejada e clique no botão Instalar.
2. Por Arquivo Compactado (.ZIP): Acesse Sketch > Incluir Biblioteca > Adicionar Biblioteca .ZIP... e selecione o arquivo compactado sem descompactá-lo previamente. A IDE descompactará os arquivos automaticamente para a pasta libraries do usuário.
3. Instalação Manual: Descompacte os arquivos diretamente no diretório Documentos/Arduino/libraries/NomeDaBiblioteca/, garantindo que os arquivos .h e .cpp estejam localizados na raiz da pasta da biblioteca, sem pastas intermediárias duplicadas.

Teste de Comunicação Serial Assíncrona

Para verificar o funcionamento do canal serial, execute o sketch a seguir, que inicializa o periférico USART a 9600 bits por segundo e transmite uma mensagem de boas-vindas com contador numérico progressivo a cada segundo.

// Licao 1: Teste de comunicacao serial assincrona UART com o microcontrolador ATmega328P
// Declaracao de variavel inteira global para contagem de ciclos
unsigned long contadorCiclos = 0; // Armazena a contagem progressiva de mensagens transmitidas

void setup() {
  // Inicializa a comunicacao serial na taxa padrao de 9600 bits por segundo (baud rate)
  Serial.begin(9600);
  // Aguarda 100 milissegundos para estabilizacao eletrica do canal serial USB
  delay(100);
  // Envia mensagem de texto inicial com quebra de linha automatica (CR + LF)
  Serial.println("==================================================");
  Serial.println("RoboBuilders - Kit Avancado Arduino Caixa AE001");
  Serial.println("Licao 1: Comunicacao Serial UART Inicializada!");
  Serial.println("==================================================");
}

void loop() {
  // Envia o rotulo identificador do ciclo
  Serial.print("Status do Sistema - Ciclo de execucao: ");
  // Imprime o valor numerico atual da variavel contadora
  Serial.println(contadorCiclos);
  // Incrementa o contador em uma unidade
  contadorCiclos++;
  // Pausa a execucao por 1000 milissegundos (1 segundo) antes da proxima transmissao
  delay(1000);
}

Gravação e Procedimento de Teste

1. Clique no botão Carregar (Upload) na barra superior da IDE.
2. Observe os LEDs indicadores TX e RX da placa Arduino piscando rapidamente durante a transferência do binário.
3. Abra o Monitor Serial (Ctrl + Shift + M) e certifique-se de que a taxa de comunicação no canto inferior esteja configurada exatamente em 9600 baud.
4. Resultado Esperado: O Monitor Serial exibirá o cabeçalho de boas-vindas e passará a imprimir continuamente linhas indicando o incremento de ciclos a cada 1 segundo.

---

Lição 2: Blink — Piscar o LED Integrado (Pino 13)

A Lição 2 é o primeiro experimento físico de controle de saída digital no Arduino Uno R3. O circuito utiliza o diodo emissor de luz montado na própria placa de circuito impresso, identificado pela letra L, o qual está eletricamente conectado ao pino digital D13 através de um amplificador operacional configurado como seguidor de tensão (buffer de alta impedância) para não sobrecarregar as linhas do barramento.

Teoria de Funcionamento e Registradores de Entrada/Saída

No microcontrolador ATmega328P, os pinos de entrada e saída de uso geral (GPIO — General Purpose Input/Output) são organizados em três portas de 8 bits: PORTB (pinos digitais D8 a D13), PORTC (entradas analógicas A0 a A5) e PORTD (pinos digitais D0 a D7). O pino digital 13 corresponde fisicamente ao bit 5 do registrador PORTB (denominado PB5).

Quando configuramos o pino como saída através do comando pinMode(13, OUTPUT), o compilador ativa o bit 5 no registrador de direção de dados DDRB (Data Direction Register B). Ao aplicar digitalWrite(13, HIGH), o bit correspondente no registrador PORTB é levado ao nível lógico alto, estabelecendo uma diferença de potencial de +5,0 V no pino e drenando corrente através do LED integrado em direção ao terra (GND). A chamada digitalWrite(13, LOW) zera a tensão, cessando a circulação de corrente e apagando o diodo.

O período de oscilação $T$ e a frequência de comutação $f$ são dados por:

$$T = t_{ALTO} + t_{BAIXO} = 1000\,\text{ms} + 1000\,\text{ms} = 2000\,\text{ms} = 2{,}0\,\text{s}$$ $$f = \frac{1}{T} = \frac{1}{2{,}0\,\text{s}} = 0{,}5\,\text{Hz}$$

Componentes Necessários

Componente	Quantidade	Descrição / Observação
Placa compatível Arduino Uno R3	1	Microcontrolador ATmega328P com LED L no pino D13
Cabo de comunicação USB A-B	1	Conexão para transmissão de dados e alimentação de 5V

Código-Fonte Completo Comentado

// Licao 2: Blink - Piscar o LED integrado no pino 13
// Declaracao de constante inteira para indicar o pino do LED L integrado
const int pinoLED = 13; // Pino digital 13 mapeado no bit 5 da porta PORTB (PB5)

void setup() {
  // Configura o pino digital 13 como saida digital no registrador DDRB
  pinMode(pinoLED, OUTPUT);
}

void loop() {
  // Escreve nivel logico alto (+5V) no pino 13, acendendo o LED L
  digitalWrite(pinoLED, HIGH);
  // Mantem o estado alto pelo intervalo de 1000 milissegundos (1 segundo)
  delay(1000);
  // Escreve nivel logico baixo (0V/GND) no pino 13, apagando o LED L
  digitalWrite(pinoLED, LOW);
  // Mantem o estado baixo pelo intervalo de 1000 milissegundos (1 segundo)
  delay(1000);
}

Gravação e Resultado Esperado

1. Conecte o cabo USB à placa e ao computador.
2. Carregue o sketch para a placa Arduino Uno R3.
3. Resultado Esperado: O LED miniatura amarelo/laranja identificado com a letra L próximo ao botão de reset começará a piscar ritmicamente, permanecendo aceso durante exatamente 1 segundo e apagado durante 1 segundo, repetindo o ciclo indefinidamente.

---

Lição 3: LED e Resistores Limitadores de Corrente

A Lição 3 aprofunda a física dos semicondutores optoeletrônicos e o dimensionamento rigoroso de resistores elétricos de limitação de corrente. Diferente de uma lâmpada incandescente, o diodo emissor de luz (LED) é um dispositivo semicondutor não-linear que conduz corrente somente quando polarizado diretamente e apresenta uma resistência dinâmica extremamente baixa após superar sua barreira de potencial de junção ($V_D$).

Modelo Matemático de Polarização do Diodo

Se um LED for conectado diretamente a uma fonte de tensão contínua de 5 V sem resistor limitador, a corrente através da junção PN crescerá exponencialmente de acordo com a equação de Shockley:

$$I_D = I_S \left( e^{\frac{q V_D}{n k T}} - 1 \right)$$

Isso provocará destruição imediata do cristal semicondutor por avalanche térmica. Para garantir a integridade do circuito, um resistor limitador $R_{LIM}$ deve ser obrigatoriamente associado em série:

$$R_{LIM} = \frac{V_{CC} - V_D}{I_D}$$

Ao testar três valores distintos de resistência fornecidos no kit ($220\,\Omega$, $1\,\text{k}\Omega$ e $10\,\text{k}\Omega$), a corrente resultante calculada para um LED vermelho ($V_D \approx 1{,}9\,\text{V}$) sob alimentação $V_{CC} = 5{,}0\,\text{V}$ varia drasticamente:

$$I_{220\,\Omega} = \frac{5{,}0\,\text{V} - 1{,}9\,\text{V}}{220\,\Omega} = \frac{3{,}1\,\text{V}}{220\,\Omega} \approx 14{,}09\,\text{mA}$$ $$I_{1\,\text{k}\Omega} = \frac{5{,}0\,\text{V} - 1{,}9\,\text{V}}{1000\,\Omega} = \frac{3{,}1\,\text{V}}{1000\,\Omega} \approx 3{,}10\,\text{mA}$$ $$I_{10\,\text{k}\Omega} = \frac{5{,}0\,\text{V} - 1{,}9\,\text{V}}{10000\,\Omega} = \frac{3{,}1\,\text{V}}{10000\,\Omega} \approx 0{,}31\,\text{mA}$$

A potência luminosa emitida é proporcional à corrente elétrica direta, demonstrando experimentalmente a relação inversa entre a resistência ôhmica e a intensidade de brilho observada.

Componentes Necessários

Componente	Quantidade	Descrição / Observação
Placa compatível Arduino Uno R3	1	Fonte regulada de alimentação de 5V e terra (GND)
Matriz de contatos (Breadboard 830 furos)	1	Base para inserção temporária dos componentes
LED difuso vermelho de 5 mm	1	Terminal longo = Ânodo (+); chanfro/terminal curto = Cátodo (-)
Resistor de filme de carbono 220 Ω (1/4W)	1	Código de cores: Vermelho, Vermelho, Marrom, Dourado
Resistor de filme de carbono 1 kΩ (1/4W)	1	Código de cores: Marrom, Preto, Vermelho, Dourado
Resistor de filme de carbono 10 kΩ (1/4W)	1	Código de cores: Marrom, Preto, Laranja, Dourado
Cabos jumper macho-macho flexíveis	2	Fios para conexão entre protoboard e pinos do Arduino

Tabela de Conexões Elétricas

Componente / Terminal	Conexão de Origem	Conexão de Destino	Função Elétrica
Resistor Série (220 Ω / 1 kΩ / 10 kΩ)	Pino 5V do Arduino	Ânodo do LED (perna mais longa)	Fornece corrente limitada ao diodo
Cátodo do LED (perna mais curta com chanfro)	Linha de conexão do cátodo	Pino GND do Arduino	Retorno de corrente para o terra

Código-Fonte de Demonstração Interativa via PWM

Além do teste estático na linha de 5V, podemos conectar o Ânodo do LED ao pino digital D9 (habilitado com modulação PWM) para variar programaticamente a tensão média eficaz através de uma rotina de pulsando suave (fading):

// Licao 3: Controle de brilho e polarizacao de LED via PWM
// Declaracao do pino digital associado ao temporizador Timer1
const int pinoPWM = 9; // Pino digital 9 com saida PWM por hardware

void setup() {
  // Configura o pino 9 como saida digital de potencia
  pinMode(pinoPWM, OUTPUT);
}

void loop() {
  // Ciclo crescente de brilho: duty cycle de 0% ate 100% (0 a 255 passos)
  for (int brilho = 0; brilho <= 255; brilho++) {
    // Escreve o valor do ciclo de trabalho no registrador OCR1A
    analogWrite(pinoPWM, brilho);
    // Aguarda 10 milissegundos para transicao visualmente suave aos olhos humanos
    delay(10);
  }
  
  // Ciclo decrescente de brilho: duty cycle de 100% ate 0% (255 a 0 passos)
  for (int brilho = 255; brilho >= 0; brilho--) {
    // Atualiza a razao ciclica do sinal PWM no pino 9
    analogWrite(pinoPWM, brilho);
    // Aguarda 10 milissegundos por incremento
    delay(10);
  }
}

Gravação e Procedimento de Teste

1. Monte o circuito na protoboard inicialmente alimentando o resistor de $220\,\Omega$ através do pino 5V do Arduino e fechando o cátodo do LED no GND. Observe o brilho intenso do LED.
2. Substitua o resistor de $220\,\Omega$ pelo resistor de $1\,\text{k}\Omega$. O brilho sofrerá uma atenuação visível, operando a aproximadamente 3 mA.
3. Substitua pelo resistor de $10\,\text{k}\Omega$. A corrente cairá para meros 0,3 mA, tornando o brilho tênue, quase imperceptível em ambientes claros.
4. Transfira a conexão positiva do resistor para o pino D9 e carregue o código de modulação PWM.
5. Resultado Esperado: O LED passará a pulsar continuamente de forma progressiva e suave, demonstrando que a rápida comutação digital em alta frequência (490 Hz no pino D9) produz uma percepção visual de variação contínua de intensidade luminosa graças à persistência retiniana.

---

Lição 4: Entradas Digitais com Chaves Push-Button

A Lição 4 apresenta o sensoriamento de eventos discretos binários utilizando interruptores mecânicos de contato momentâneo (push-buttons táteis) e o conceito indispensável de resistores de polarização para definição de nível lógico (pull-up e pull-down).

Teoria de Operação e Efeito de Linha Flutuante

Um pino digital de entrada do ATmega328P apresenta uma impedância de entrada elevadíssima (da ordem de $100\,\text{M}\Omega$). Caso um botão seja conectado entre o pino e os +5 V sem nenhum outro componente, ao soltar o botão o pino permanecerá eletricamente desconectado (em estado flutuante ou floating). Nessa condição, capacitâncias parasitas e interferências eletromagnéticas ambientais farão a entrada oscilar aleatoriamente entre níveis lógicos HIGH e LOW.

Para solucionar o problema, utiliza-se um resistor de pull-down (conectado ao GND) ou um resistor de pull-up (conectado aos +5 V). No circuito oficial da Lição 4, os botões aplicam nível alto ao pino digital quando pressionados, enquanto um resistor de $10\,\text{k}\Omega$ garante nível lógico LOW estável quando a tecla está em repouso. O código utiliza duas chaves: o acionamento de uma delas comuta o LED para estado ligado, enquanto a outra o desliga.

Componentes Necessários

Componente	Quantidade	Descrição / Observação
Placa compatível Arduino Uno R3	1	Unidade de controle e alimentação
Matriz de contatos (Breadboard 830 furos)	1	Base para conexões mecânicas
LED difuso vermelho de 5 mm	1	Indicador óptico de estado
Resistor de 220 Ω (1/4W)	1	Limitador de corrente do LED
Chaves táteis push-button (4 terminais)	2	Botão 1 (Ligar) e Botão 2 (Desligar)
Resistores de 10 kΩ (1/4W)	2	Resistores de pull-down para os botões
Cabos jumper macho-macho flexíveis	7	Fios de ligação

Tabela de Conexões Elétricas

Componente / Terminal	Pino no Arduino Uno	Função Operacional
Botão 1 (Liga) — Terminal de Sinal	Pino Digital D2	Entrada digital para comando de ligar o LED
Botão 2 (Desliga) — Terminal de Sinal	Pino Digital D3	Entrada digital para comando de desligar o LED
Terminal Comum dos Botões	Barramento 5V	Fornece nível lógico alto (+5V) quando a tecla fecha
Resistores de Pull-down (10 kΩ)	Barramento GND	Mantém os pinos D2 e D3 em 0V quando botões abertos
Ânodo do LED (via resistor 220 Ω)	Pino Digital D5	Saída de controle do LED
Cátodo do LED	Barramento GND	Retorno ao potencial de referência

Código-Fonte Oficial Comentado

// Licao 4: Entradas digitais com duas chaves push-button e LED indicador
// Definicao das portas digitais conectadas aos componentes
int ledPin = 5;       // Pino digital 5 conectado ao anodo do LED (atraves do resistor de 220R)
int buttonApin = 2;   // Pino digital 2 conectado ao botao de acionamento (Ligar)
int buttonBpin = 3;   // Pino digital 3 conectado ao botao de desligamento (Desligar)

void setup() {
  // Configura a porta D5 como saida digital para acionamento do LED
  pinMode(ledPin, OUTPUT);
  // Configura as portas D2 e D3 como entradas digitais com monitoramento externo
  pinMode(buttonApin, INPUT);
  pinMode(buttonBpin, INPUT);
}

void loop() {
  // Verifica se o botao A foi pressionado (nivel logico ALTO recebido em D2)
  if (digitalRead(buttonApin) == HIGH) {
    // Escreve nivel logico alto em D5, fornecendo 5V e acendendo o LED
    digitalWrite(ledPin, HIGH);
  }
  
  // Verifica se o botao B foi pressionado (nivel logico ALTO recebido em D3)
  if (digitalRead(buttonBpin) == HIGH) {
    // Escreve nivel logico baixo em D5, cortando a corrente e apagando o LED
    digitalWrite(ledPin, LOW);
  }
}

Gravação e Procedimento de Teste

1. Monte os dois botões atravessando o canal central divisor da protoboard para evitar curto-circuito interno entre os terminais paralelos.
2. Ligue os resistores de pull-down de $10\,\text{k}\Omega$ de cada pino digital para a linha de terra (GND).
3. Carregue o sketch para a placa Arduino Uno R3.
4. Resultado Esperado: O LED permanece inicialmente apagado. Ao pressionar e soltar o Botão A (pino D2), o LED acende e permanece aceso indefinidamente. Ao pressionar o Botão B (pino D3), o LED apaga e permanece desligado, simulando uma função clássica de relé de retenção com memória biestável (Flip-Flop).

---

Lição 5: Emissão Sonora com Buzzer Ativo

A Lição 5 explora a instrumentação de alertas acústicos através de um buzzer ativo (Active Buzzer), analisando as diferenças construtivas fundamentais entre transdutores eletroacústicos ativos e passivos.

Princípio Físico e Diferença entre Buzzer Ativo e Passivo

Um buzzer piezoelétrico ativo possui em seu interior um circuito oscilador oscilante analógico transistorizado pré-sintonizado na frequência de ressonância mecânica do diafragma cerâmico (tipicamente entre 2,0 kHz e 2,5 kHz). Consequentemente, para emitir som, o componente requer apenas a aplicação de uma tensão contínua contínua em seus terminais ($V_{CC} = 5\,\text{V}$). Não é necessário gerar ondas quadradas por software:

• Buzzer Ativo: Fundo geralmente selado com resina epóxi preta lisa; traz comumente um adesivo protetor destacável com o sinal de polaridade positiva + no topo; emite tom fixo e estridente sob nível lógico contínuo HIGH.
• Buzzer Passivo: Fundo com placa de circuito impresso verde visível e componentes expostos; não possui oscilador interno e necessita de um trem de pulsos AC/PWM alternados para defletir o diafragma na frequência desejada.

Componentes Necessários

Componente	Quantidade	Descrição / Observação
Placa compatível Arduino Uno R3	1	Unidade controladora
Buzzer Piezoelétrico Ativo (5V)	1	Transdutor com oscilador interno (terminal longo = positivo)
Cabos jumper fêmea-macho ou macho-macho	2	Fios para interconexão direta

Tabela de Conexões Elétricas

Terminal do Buzzer	Conexão no Arduino Uno	Observação Elétrica
Terminal Positivo (+) / Perna Longa	Pino Digital D12	Fornece sinal de disparo contínuo de 5V
Terminal Negativo (-) / Perna Curta	Pino GND do Arduino	Retorno ao potencial de referência de 0V

Código-Fonte Oficial Comentado

// Licao 5: Emissao sonora intermitente com buzzer piezoeletrico ativo
// Declaracao do pino digital de controle do buzzer
int buzzer = 12; // Pino digital 12 conectado ao terminal positivo do buzzer ativo

void setup() {
  // Configura o pino digital 12 como saida digital no registrador de dados DDRB
  pinMode(buzzer, OUTPUT);
}

void loop() {
  unsigned char i; // Declaracao de variavel local de controle de laco
  
  // Primeiro laco de alerta: emite pulsos rapidos de som
  for (i = 0; i < 80; i++) {
    digitalWrite(buzzer, HIGH); // Liga o oscilador interno do buzzer aplicando +5V
    delay(1);                   // Mantem o pulso sonoro por 1 milissegundo
    digitalWrite(buzzer, LOW);  // Desliga o oscilador cortando para 0V
    delay(1);                   // Pausa por 1 milissegundo
  }
  
  // Segundo laco de alerta: emite pulsos de cadencia mais lenta
  for (i = 0; i < 100; i++) {
    digitalWrite(buzzer, HIGH); // Liga o buzzer ativo
    delay(2);                   // Mantem nivel alto por 2 milissegundos
    digitalWrite(buzzer, LOW);  // Corta a alimentacao do buzzer
    delay(2);                   // Mantem nivel baixo por 2 milissegundos
  }
}

Gravação e Procedimento de Teste

1. Conecte o terminal positivo do buzzer ativo ao pino digital D12 do Arduino e o terminal negativo ao pino GND. Remova o adesivo plástico protetor superior para liberar a propagação acústica total.
2. Carregue o sketch para a placa Arduino Uno R3.
3. Resultado Esperado: O buzzer emitirá um padrão sonoro contínuo com alternância rítmica entre rajadas de bipes em duas tonalidades mecânicas distintas, confirmando o disparo elétrico do oscilador interno.

---

Lição 6: Tons Musicais com Buzzer Passivo e Tabela pitches.h

A Lição 6 estuda a síntese de frequências acústicas e a geração de melodias completas com um buzzer passivo, controlando diretamente a frequência do sinal de excitação aplicado através da função nativa tone() e de uma tabela de constantes de afinação musical (pitches.h).

Síntese Sonora e Fórmulas de Frequência Musical

O buzzer passivo opera como um alto-falante miniatura desprovido de oscilador: quando uma corrente alternada percorre sua bobina ou elemento piezoelétrico, o diafragma flexiona-se mecanicamente na exata frequência do sinal elétrico recebido. Na escala diatônica ocidental temperada (com afinação padrão na nota Lá4 a $440\,\text{Hz}$), a frequência $f_n$ de qualquer semitom em relação a uma frequência de referência $f_0$ é calculada pela lei exponencial da escala logarítmica:

$$f_n = f_0 \times 2^{\frac{n}{12}}$$

Para sintetizar essas notas com precisão milimétrica de temporização, a biblioteca embutida do Arduino utiliza o temporizador de hardware Timer2 para alternar o estado do pino digital no semiperíodo exato de cada frequência:

$$T_{NOTA} = \frac{1}{f_{NOTA}}$$ $$t_{SEMI} = \frac{T_{NOTA}}{2} = \frac{1}{2 \times f_{NOTA}}$$

Por exemplo, para a nota Dó central (C4, $f \approx 262\,\text{Hz}$), o período é de $3{,}82\,\text{ms}$, e o microcontrolador comuta o pino a cada $1{,}91\,\text{ms}$.

📦 Bibliotecas desta lição:

• Arquivo de cabeçalho local pitches.h (tabela de frequências das notas musicais em Hertz).
• Como incluir: Crie uma nova aba na Arduino IDE clicando na seta do canto superior direito e selecione Nova Aba (New Tab), digitando rigorosamente o nome pitches.h. Cole a tabela de notas clássica do Arduino ou copie o arquivo pitches.h existente na pasta da Lição 6 do kit.

Componentes Necessários

Componente	Quantidade	Descrição / Observação
Placa compatível Arduino Uno R3	1	Gera as ondas quadradas através de timers internos
Buzzer Piezoelétrico Passivo (5V)	1	Transdutor acústico sem oscilador interno
Cabos jumper flexíveis	2	Fios para conexão aos pinos D8 e GND

Tabela de Conexões Elétricas

Terminal do Buzzer Passivo	Conexão no Arduino Uno	Descrição da Ligação
Terminal Positivo (+)	Pino Digital D8	Recebe o sinal de frequência de onda quadrada modulada
Terminal Negativo (-)	Pino GND do Arduino	Retorno ao terra de referência

Código-Fonte Oficial Comentado

// Licao 6: Sintese de notas musicais com buzzer passivo e tone()
#include "pitches.h" // Inclui a tabela com os valores de frequencia de cada nota musical

// Vetor com a sequencia de notas da melodia musical
int melody[] = {
  NOTE_C4, NOTE_G3, NOTE_G3, NOTE_A3, NOTE_G3, 0, NOTE_B3, NOTE_C4
};

// Duracao correspondente de cada nota: 4 = seminima (quarto de tempo), 8 = colcheia (oitavo)
int noteDurations[] = {
  4, 8, 8, 4, 4, 4, 4, 4
};

void setup() {
  // Itera atraves das 8 notas contidas no vetor da melodia
  for (int thisNote = 0; thisNote < 8; thisNote++) {
    // Calcula a duracao em milissegundos dividindo um segundo pelo divisor da nota
    int noteDuration = 1000 / noteDurations[thisNote];
    // Dispara a geracao da frequencia no pino digital 8 pelo tempo calculado
    tone(8, melody[thisNote], noteDuration);
    
    // Para distinguir notas consecutivas, define-se uma pausa minima entre elas
    // A recomendacao de engenharia acustica e somar 30% ao tempo da nota
    int pauseBetweenNotes = noteDuration * 1.30;
    delay(pauseBetweenNotes);
    
    // Interrompe a emissao no pino 8 antes da proxima nota da sequencia
    noTone(8);
  }
}

void loop() {
  // A melodia e executada apenas uma vez na funcao setup(); o loop permanece ocioso
}

Gravação e Procedimento de Teste

1. Certifique-se de que a aba pitches.h esteja criada ao lado do sketch principal contendo as diretivas #define NOTE_C4 262, #define NOTE_G3 196, etc.
2. Conecte o buzzer passivo entre o pino D8 e o GND.
3. Carregue o sketch para a placa Arduino Uno R3.
4. Resultado Esperado: O buzzer passivo executará perfeitamente a frase melódica clássica de 8 notas afinadas e fará uma pausa, demonstrando o controle de afinação por hardware via temporizador AVR.

---

Lição 7: Sensor Inclinômetro de Esfera (Tilt Ball Switch)

A Lição 7 introduz o sensoriamento de atitude e inclinação física estática através de um sensor mecânico de esfera condutora (Tilt Ball Switch), que opera como uma chave comutada pela gravidade.

Física do Sensor e Chaveamento por Gravidade

O sensor de inclinação de esfera consiste em uma câmara cilíndrica vedada contendo dois terminais condutores banhados a ouro na base e uma microesfera metálica livre em seu interior. Quando o sensor é mantido na posição vertical com os terminais apontados para baixo, a força gravitacional $\vec{F}_g = m \vec{g}$ posiciona a esfera de metal em contato simultâneo com ambos os terminais, fechando o circuito elétrico (baixa resistência, $R \approx 0\,\Omega$). Quando o conjunto é inclinado além de um ângulo crítico (tipicamente $\theta > 15^{\circ}$ a $30^{\circ}$ em relação à vertical), a esfera desloca-se pela gravidade para a extremidade oposta da cápsula, abrindo os contatos e elevando a resistência a níveis infinitos ($R > 100\,\text{M}\Omega$).

Para simplificar o circuito e eliminar a necessidade de resistores discretos na protoboard, o sketch ativa o resistor de pull-up interno do microcontrolador ATmega328P ($R_{PULL-UP} \approx 20\,\text{k}\Omega \text{ a } 50\,\text{k}\Omega$) através da configuração pinMode(pin, INPUT_PULLUP).

Componentes Necessários

Componente	Quantidade	Descrição / Observação
Placa compatível Arduino Uno R3	1	Processamento lógico e leitura de nível
Sensor de inclinação tipo esfera (Tilt Switch)	1	Chave gravitacional de 2 terminais metálicos
Cabos jumper fêmea-macho ou macho-macho	2	Interconexão entre sensor e Arduino

Tabela de Conexões Elétricas

Terminal do Sensor Tilt	Conexão no Arduino Uno	Função Elétrica
Terminal 1 (sem polaridade)	Pino Digital D2	Entrada digital configurada como INPUT_PULLUP
Terminal 2 (sem polaridade)	Pino GND do Arduino	Referência de terra para fechamento de contato

Código-Fonte Oficial Comentado

// Licao 7: Sensor de inclinacao mecanico de esfera (Tilt Ball Switch)
// Declaracao dos pinos utilizados no circuito
int ledPin = 13;      // Utiliza o LED L embarcado na placa Arduino como indicador visual
int switchPin = 2;    // Pino digital 2 conectado a chave de inclinacao

void setup() {
  // Configura o pino 13 como saida digital para acionamento do LED
  pinMode(ledPin, OUTPUT);
  // Ativa o resistor interno de PULL-UP de aproximadamente 30k no pino 2
  // Dessa forma, quando a chave estiver aberta, o pino le HIGH (+5V)
  // Quando o sensor for inclinado e a esfera fechar o contato com o terra, o pino le LOW (0V)
  pinMode(switchPin, INPUT_PULLUP);
}

void loop() {
  // Le o estado logico presente no pino digital 2
  int switchState = digitalRead(switchPin);
  
  // Se o sensor estiver inclinado para baixo, a esfera conecta o pino ao GND (nivel LOW)
  if (switchState == LOW) {
    digitalWrite(ledPin, HIGH); // Acende o LED indicador onboard
  } else {
    // Se o sensor estiver em repouso vertical, os terminais abrem (nivel HIGH pelo pull-up)
    digitalWrite(ledPin, LOW);  // Apaga o LED indicador onboard
  }
}

Gravação e Procedimento de Teste

1. Conecte os dois terminais do sensor de inclinação entre o pino digital D2 e o terminal GND do Arduino Uno R3 (como o sensor é uma chave mecânica pura, não possui polaridade).
2. Carregue o sketch para a placa.
3. Segure o sensor com a ponta dos dedos e incline-o para a posição horizontal ou de cabeça para baixo.
4. Resultado Esperado: O LED L na placa acende imediatamente ao inclinar o sensor (quando a esfera metálica une os contatos e leva o pino a nível lógico baixo) e apaga assim que o sensor retorna à posição vertical inicial.

---

Lição 8: Servomotor SG90 e Modulação por Largura de Pulso

A Lição 8 apresenta o controle eletromecânico de posicionamento angular de precisão utilizando o micro servomotor analógico TowerPro SG90, explorando o protocolo de modulação por largura de pulso (PPM/PWM) e a biblioteca padrão Servo.h.

Princípio de Operação do Servomotor e Sinal de Controle

Um servomotor integra em um único invólucro um micromotor DC de corrente contínua, uma caixa de redução de engrenagens plásticas de alto torque, um potenciômetro acoplado ao eixo de saída (para realimentação de posição de malha fechada) e uma placa de controle analógica proporcional.

O comando de posição não é dado pela tensão contínua aplicada no fio de sinal, mas sim pela largura do pulso em nível alto ($t_{PULSO}$) repetido periodicamente a cada $20\,\text{ms}$ (frequência de quadro de $50\,\text{Hz}$):

$$T_{QUADRO} = 20\,\text{ms} \quad (f = 50\,\text{Hz})$$

• Pulso de $t_{PULSO} \approx 1{,}0\,\text{ms}$ posiciona o eixo na extremidade esquerda ($0^{\circ}$)
• Pulso de $t_{PULSO} \approx 1{,}5\,\text{ms}$ posiciona o eixo na posição central ($90^{\circ}$)
• Pulso de $t_{PULSO} \approx 2{,}0\,\text{ms}$ posiciona o eixo na extremidade direita ($180^{\circ}$)

A biblioteca Servo.h utiliza as interrupções do Timer1 de 16 bits do microcontrolador ATmega328P para sintetizar pulsos com resolução de microssegundos sem ocupar o ciclo da CPU.

📦 Bibliotecas desta lição:

• Servo.h (Biblioteca nativa do núcleo padrão da Arduino IDE).
• Nada a baixar: já vem embutida no ambiente de compilação.

Componentes Necessários

Componente	Quantidade	Descrição / Observação
Placa compatível Arduino Uno R3	1	Gera o sinal de temporização PWM de 50 Hz
Micro Servomotor SG90 (9g)	1	Rotação angular de 0° a 180° com torque de 1,6 kgf·cm
Cabos jumper flexíveis	3	Conexão para Sinal (Laranja), VCC (Vermelho) e GND (Marrom)

Tabela de Conexões Elétricas

Fio do Conector do Servo SG90	Cor do Cabo	Pino no Arduino Uno	Função Elétrica
Linha de Sinal de Controle	Laranja / Amarelo	Pino Digital D9	Trem de pulsos PWM com temporização de 1 a 2 ms
Linha de Alimentação ($V_{CC}$)	Vermelho	Pino 5V do Arduino	Tensão contínua estabilizada de 5V
Linha de Terra (GND)	Marrom / Preto	Pino GND do Arduino	Referência de retorno de corrente

Código-Fonte Oficial Comentado

// Licao 8: Varredura angular suave com micro servomotor SG90 e Servo.h
#include <Servo.h> // Inclui a biblioteca oficial de controle de servos por hardware

Servo myservo;  // Cria o objeto da classe Servo para gerenciar o atuador
int pos = 0;    // Variavel para armazenar o angulo de comando em graus (0 a 180)

void setup() {
  // Vincula o pino digital 9 ao objeto Servo configurado
  myservo.attach(9);
}

void loop() {
  // Varredura angular no sentido horario: de 0 graus ate 180 graus em passos de 1 grau
  for (pos = 0; pos <= 180; pos += 1) {
    // Transmite a nova posicao angular em graus para o gerador de pulsos
    myservo.write(pos);
    // Aguarda 15 milissegundos para que as engrenagens alcancem fisicamente a posicao
    delay(15);
  }
  
  // Varredura angular no sentido anti-horario: de 180 graus de volta para 0 graus
  for (pos = 180; pos >= 0; pos -= 1) {
    // Atualiza a largura do pulso correspondente ao angulo
    myservo.write(pos);
    // Aguarda 15 milissegundos para estabilizacao mecanica
    delay(15);
  }
}

Gravação e Procedimento de Teste

1. Encaixe uma das cruzetas plásticas inclusas no eixo do servomotor SG90 para visualizar com clareza o movimento angular.
2. Ligue os três fios conforme a tabela de conexões: Laranja em D9, Vermelho em 5V e Marrom em GND.
3. Carregue o sketch para a placa Arduino Uno R3.
4. Resultado Esperado: O braço do servo iniciará um movimento contínuo e suave de pêndulo, girando de $0^{\circ}$ a $180^{\circ}$ em velocidade constante e retornando suavemente a $0^{\circ}$, repetindo o ciclo de varredura.

---

Lição 9: Módulo LED RGB e Mistura Aditiva de Cores

A Lição 9 aborda a teoria da cor aditiva e o controle fotométrico de diodos emissores de luz multicoloridos utilizando o Módulo LED RGB acionado por três canais independentes de modulação PWM.

Modelo de Cores RGB e Teoria Aditiva

O olho humano possui três tipos de células fotorreceptoras cônicas na retina sensíveis a comprimentos de onda de pico específicos: vermelho ($\sim 700\,\text{nm}$), verde ($\sim 546\,\text{nm}$) e azul ($\sim 435\,\text{nm}$). O sistema RGB (Red, Green, Blue) recria qualquer tonalidade perceptível do espectro visível variando a densidade de fluxo luminoso de cada primária através da síntese aditiva:

• Vermelho + Verde = Amarelo
• Verde + Azul = Ciano
• Vermelho + Azul = Magenta
• Vermelho + Verde + Azul = Branco

Com 8 bits de resolução em cada canal PWM ($2^8 = 256$ níveis discretos de 0 a 255), o número total de combinações cromáticas possíveis atinge:

$$N_{CORES} = 256 \times 256 \times 256 = 2^{24} = 16.777.216 \text{ cores}$$

O módulo do kit possui resistores limitadores onboard ou utiliza cátodo comum (pino GND compartilhado). O firmware varia os ciclos de trabalho individuais para alternar entre as cores primárias, secundárias e o branco.

Componentes Necessários

Componente	Quantidade	Descrição / Observação
Placa compatível Arduino Uno R3	1	Gera 3 saídas PWM sincronizadas
Módulo LED RGB difuso	1	4 pinos: Vermelho (R), Verde (G), Azul (B) e Terra (-)
Cabos jumper fêmea-macho flexíveis	4	Interconexão com a barra de pinos do Arduino

Tabela de Conexões Elétricas

Pino do Módulo RGB	Conexão no Arduino Uno	Canal PWM / Função
Terminal R (Red / Vermelho)	Pino Digital D11	Saída PWM associada ao temporizador Timer2 (OC2A)
Terminal G (Green / Verde)	Pino Digital D10	Saída PWM associada ao temporizador Timer1 (OC1B)
Terminal B (Blue / Azul)	Pino Digital D9	Saída PWM associada ao temporizador Timer1 (OC1A)
Terminal (-) / GND (Cátodo)	Pino GND do Arduino	Retorno comum de corrente elétrica

Código-Fonte Oficial Comentado

// Licao 9: Mistura aditiva de cores com Modulo LED RGB e PWM
// Definicao das portas com saida PWM por hardware
int redPin = 11;    // Pino D11 conectado ao canal Vermelho (R)
int greenPin = 10;  // Pino D10 conectado ao canal Verde (G)
int bluePin = 9;    // Pino D9 conectado ao canal Azul (B)

void setup() {
  // Configura os tres pinos PWM como saidas digitais
  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);
}

// Funcao auxiliar para escrita simultanea dos tres canais PWM
void setColor(int red, int green, int blue) {
  // Aplica o valor de ciclo de trabalho (0 a 255) em cada canal
  analogWrite(redPin, red);
  analogWrite(greenPin, green);
  analogWrite(bluePin, blue);
}

void loop() {
  // 1. Vermelho puro (apenas o canal R ligado em 100%)
  setColor(255, 0, 0);
  delay(1000);
  
  // 2. Verde puro (apenas o canal G ligado em 100%)
  setColor(0, 255, 0);
  delay(1000);
  
  // 3. Azul puro (apenas o canal B ligado em 100%)
  setColor(0, 0, 255);
  delay(1000);
  
  // 4. Amarelo (mistura de Vermelho e Verde)
  setColor(255, 255, 0);
  delay(1000);
  
  // 5. Roxo / Magenta (mistura de Vermelho e Azul)
  setColor(255, 0, 255);
  delay(1000);
  
  // 6. Ciano / Aqua (mistura de Verde e Azul)
  setColor(0, 255, 255);
  delay(1000);
  
  // 7. Branco completo (todos os tres canais saturados)
  setColor(255, 255, 255);
  delay(1000);
}

Gravação e Procedimento de Teste

1. Conecte os pinos do módulo RGB diretamente aos pinos D11, D10, D9 e GND do Arduino Uno R3 utilizando quatro jumpers fêmea-macho.
2. Carregue o sketch para a placa.
3. Resultado Esperado: O LED RGB exibirá uma sequência luminosa de cores com transição de 1 segundo entre cada estado: Vermelho $\to$ Verde $\to$ Azul $\to$ Amarelo $\to$ Roxo $\to$ Ciano $\to$ Branco, comprovando a teoria da síntese aditiva tricromática.

---

Lição 10: Teclado de Membrana Matricial 4x4

A Lição 10 explora a técnica de multiplexação espacial de chaves através de um teclado matricial de membrana 4x4 (composto por 16 teclas numéricas e funcionais), demonstrando como decodificar dezenas de entradas físicas utilizando um número reduzido de portas digitais do microcontrolador.

Princípio de Varredura Matricial de Linhas e Colunas

Se cada um dos 16 botões fosse conectado individualmente a uma porta digital do Arduino Uno R3, seriam necessários 16 pinos de entrada, esgotando todas as 14 portas digitais disponíveis da placa. A topologia matricial organiza os contatos na interseção de 4 linhas condutoras ($R_1, R_2, R_3, R_4$) e 4 colunas condutoras ($C_1, C_2, C_3, C_4$), totalizando:

$$N_{PINOS} = N_{LINHAS} + N_{COLUNAS} = 4 + 4 = 8 \text{ pinos}$$ $$N_{TECLAS} = N_{LINHAS} \times N_{COLUNAS} = 4 \times 4 = 16 \text{ teclas}$$

O algoritmo de varredura executado pela biblioteca Keypad.h funciona de forma periódica:

1. Todas as linhas são configuradas como saídas digitais em nível alto (HIGH), e as colunas são mantidas como entradas com resistores de pull-up ativados (HIGH).
2. O microcontrolador comuta uma linha de cada vez para nível lógico baixo (LOW), mantendo as demais em nível alto.
3. Se o usuário pressionar uma tecla localizada nessa linha, a coluna correspondente será puxada para nível lógico baixo (LOW).
4. Ao ler qual linha estava em nível baixo e qual coluna foi aterrada, a biblioteca calcula imediatamente as coordenadas da matriz e identifica o caractere associado.

📦 Bibliotecas desta lição:

• Keypad.h (por Mark Stanley e Alexander Brevig — versão recomendada 3.1.1).
• Instalação: Acesse Sketch > Incluir Biblioteca > Gerenciar Bibliotecas..., pesquise por Keypad e instale a biblioteca de autoria de Mark Stanley / Alexander Brevig.

Componentes Necessários

Componente	Quantidade	Descrição / Observação
Placa compatível Arduino Uno R3	1	Microcontrolador central
Teclado de Membrana Matricial 4x4	1	16 teclas (0-9, *, #, A, B, C, D) com conector de 8 vias
Cabos jumper macho-macho ou fêmea-macho	8	Conexão para as 4 linhas e 4 colunas

Tabela de Conexões Elétricas

Via do Conector Flat (Esq. p/ Dir.)	Sinal da Matriz	Pino no Arduino Uno	Descrição da Linha/Coluna
Pino 1 do Conector	Linha 1 ($R_1$)	Pino Digital D9	Linha superior contendo teclas [1, 2, 3, A]
Pino 2 do Conector	Linha 2 ($R_2$)	Pino Digital D8	Segunda linha contendo teclas [4, 5, 6, B]
Pino 3 do Conector	Linha 3 ($R_3$)	Pino Digital D7	Terceira linha contendo teclas [7, 8, 9, C]
Pino 4 do Conector	Linha 4 ($R_4$)	Pino Digital D6	Linha inferior contendo teclas [*, 0, #, D]
Pino 5 do Conector	Coluna 1 ($C_1$)	Pino Digital D5	Primeira coluna contendo teclas [1, 4, 7, *]
Pino 6 do Conector	Coluna 2 ($C_2$)	Pino Digital D4	Segunda coluna contendo teclas [2, 5, 8, 0]
Pino 7 do Conector	Coluna 3 ($C_3$)	Pino Digital D3	Terceira coluna contendo teclas [3, 6, 9, #]
Pino 8 do Conector	Coluna 4 ($C_4$)	Pino Digital D2	Quarta coluna contendo teclas [A, B, C, D]

Código-Fonte Oficial Comentado

// Licao 10: Leitura de teclado de membrana matricial 4x4 com a biblioteca Keypad
#include <Keypad.h> // Inclui a biblioteca especializada em varredura matricial

const byte ROWS = 4; // Quatro linhas na matriz de contatos
const byte COLS = 4; // Quatro colunas na matriz de contatos

// Mapa bidimensional definindo os caracteres correspondentes a cada intersecao
char hexaKeys[ROWS][COLS] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};

// Mapeamento dos pinos digitais conectados as linhas da matriz
byte rowPins[ROWS] = {9, 8, 7, 6}; 
// Mapeamento dos pinos digitais conectados as colunas da matriz
byte colPins[COLS] = {5, 4, 3, 2}; 

// Instancia o objeto customKeypad passando o mapa, pinagem e dimensoes
Keypad customKeypad = Keypad(makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS); 

void setup() {
  // Inicializa o canal serial para transmissao das teclas pressionadas
  Serial.begin(9600);
  Serial.println("Licao 10: Teclado Matricial 4x4 Ativo! Pressione uma tecla...");
}
  
void loop() {
  // Executa a varredura e captura a tecla atualmente pressionada (retorna NO_KEY se nenhuma)
  char customKey = customKeypad.getKey();
  
  // Se alguma tecla foi detectada
  if (customKey) {
    // Imprime o caractere imediatamente no Monitor Serial
    Serial.print("Tecla Pressionada: ");
    Serial.println(customKey);
  }
}

Gravação e Procedimento de Teste

1. Conecte as 8 vias do teclado de membrana aos pinos digitais D9 a D2 na ordem rigorosa da tabela de ligações.
2. Carregue o sketch para o Arduino Uno R3.
3. Abra o Monitor Serial (Ctrl + Shift + M) configurado a 9600 baud.
4. Pressione individualmente as teclas numéricas de 0 a 9, os caracteres especiais * e #, e as letras de comando A, B, C e D.
5. Resultado Esperado: Cada toque na membrana exibe instantaneamente o caractere correto na janela serial sem duplo acionamento indevido, comprovando a eficácia do algoritmo de debouncing da biblioteca.

---

Lição 11: Sensor Digital de Temperatura e Umidade DHT11

A Lição 11 aborda o sensoriamento meteorológico ambiental utilizando o sensor digital integrado DHT11, capaz de medir temperatura ambiente e umidade relativa do ar através de uma interface digital serial proprietária assíncrona de linha única (Single-Bus 1-Wire).

Transdutores Internos e Protocolo de Comunicação Serial

O sensor DHT11 abriga em seu interior dois elementos de sensoriamento:

1. Transdutor Higrométrico: Um polímero resistivo cuja condutância elétrica varia em função da adsorção superficial de moléculas de vapor de água presentes no ar.
2. Transdutor Térmico: Um termistor NTC (Negative Temperature Coefficient) de precisão, cuja resistência decai exponencialmente com o aumento da temperatura ambiente:

$$R(T) = R_0 \times e^{\beta \left( \frac{1}{T} - \frac{1}{T_0} \right)}$$

Um microcontrolador de 8 bits interno digitaliza essas grandezas e transmite um pacote serial de 40 bits (5 bytes) contendo:

• Byte 0: Parte inteira da umidade relativa (%)
• Byte 1: Parte decimal da umidade (zero no DHT11)
• Byte 2: Parte inteira da temperatura (°C)
• Byte 3: Parte decimal da temperatura (zero no DHT11)
• Byte 4: Soma de verificação de redundância (Checksum):

$$\text{Checksum} = (\text{Byte}_0 + \text{Byte}_1 + \text{Byte}_2 + \text{Byte}_3) \ \& \ 0\text{xFF}$$

A biblioteca não-bloqueante dht_nonblocking.h realiza a temporização dos pulsos sem travar a execução do código principal por laços vazios de delay.

📦 Bibliotecas desta lição:

• dht_nonblocking.h (por Ole Wolf — versão recomendada 1.0.0).
• Instalação: No Gerenciador de Bibliotecas da IDE, pesquise por dht_nonblocking de autoria de Ole Wolf e clique em Instalar, ou utilize o arquivo DHT.zip contido na pasta da Lição 11 do kit.

Componentes Necessários

Componente	Quantidade	Descrição / Observação
Placa compatível Arduino Uno R3	1	Coleta e processa a telemetria ambiental
Módulo Sensor de Umidade e Temperatura DHT11	1	Faixa: 20-90% RH (precisão $\pm 5\%$), 0-50 °C (precisão $\pm 2^{\circ}\text{C}$)
Cabos jumper fêmea-macho	3	Conexão para VCC, GND e Sinal de Dados

Tabela de Conexões Elétricas

Pino do Módulo DHT11	Conexão no Arduino Uno	Função Elétrica
Pino VCC / (+)	Pino 5V do Arduino	Alimentação contínua de 5,0 V
Pino GND / (-)	Pino GND do Arduino	Retorno ao terra de referência
Pino DATA / OUT (Sinal)	Pino Digital D2	Linha de comunicação serial bidirecional 1-Wire

Código-Fonte Oficial Comentado

// Licao 11: Sensoriamento climatico com sensor digital DHT11 e dht_nonblocking
#include <dht_nonblocking.h> // Inclui a biblioteca nao-bloqueante para leitura do DHT11

#define DHT_SENSOR_TYPE DHT_TYPE_11 // Define a constante identificando o modelo como DHT11
static const int DHT_SENSOR_PIN = 2; // Pino digital 2 conectado a linha de dados do sensor

// Instancia o objeto de comunicacao com o sensor no pino D2
DHT_nonblocking dht_sensor(DHT_SENSOR_PIN, DHT_SENSOR_TYPE);

void setup() {
  // Inicializa o Monitor Serial para exibicao dos dados termohigrometricos
  Serial.begin(9600);
  Serial.println("Licao 11: Sensor DHT11 Inicializado com Sucesso!");
}

// Funcao auxiliar estatica que monitora a taxa de amostragem maxima de 0,5 Hz (a cada 2 segundos)
static bool measure_environment(float *temperature, float *humidity) {
  static unsigned long measurement_timestamp = millis();

  // Verifica se ja transcorreram mais de 4000 milissegundos desde a ultima leitura valida
  if (millis() - measurement_timestamp > 4000ul) {
    // Executa a chamada nao-bloqueante para captura dos 40 bits do sensor
    if (dht_sensor.measure(temperature, humidity) == true) {
      measurement_timestamp = millis(); // Atualiza a estampa temporal
      return true; // Retorna verdadeiro indicando leitura bem-sucedida e valida
    }
  }
  return false; // Retorna falso enquanto aguarda a janela termica de medicao
}

void loop() {
  float temperature; // Variavel de ponto flutuante para temperatura em graus Celsius
  float humidity;    // Variavel de ponto flutuante para umidade relativa percentual

  // Executa a medicao nao-bloqueante
  if (measure_environment(&temperature, &humidity) == true) {
    // Imprime os valores com formatacao tecnica no Monitor Serial
    Serial.print("T = ");
    Serial.print(temperature, 1); // Exibe com uma casa decimal
    Serial.print(" deg. C, H = ");
    Serial.print(humidity, 1);
    Serial.println("%");
  }
}

Gravação e Procedimento de Teste

1. Conecte o módulo DHT11 conforme a tabela: VCC em 5V, GND em GND e DATA em D2.
2. Carregue o sketch para a placa Arduino Uno R3.
3. Abra o Monitor Serial a 9600 baud.
4. Resultado Esperado: A cada intervalo regular de aproximadamente 4 segundos, uma nova linha será transmitida exibindo a temperatura ambiente em graus Celsius (ex.: T = 24.0 deg. C) e a umidade relativa do ar (ex.: H = 58.0%). Aproxime suavemente as mãos aquecidas do sensor para observar a resposta imediata da curva de umidade.

---

Lição 12: Módulo Joystick Analógico de Dois Eixos e Botão Integrado

A Lição 12 aborda o controle manual proporcional em dois graus de liberdade através do módulo joystick analógico, idêntico ao mecanismo de alavancas de consoles de videogame como PlayStation e Xbox.

Arquitetura de Potenciômetros Ortogonais e Equações de Leitura

O joystick analógico é constituído por dois potenciômetros de filme de carbono de $10\,\text{k}\Omega$ montados perpendicularmente em um suporte cardan mecânico em $90^{\circ}$. A deflexão da alavanca plástica movimenta simultaneamente os dois eixos independentes:

• Eixo X (Horizontal): O cursor do primeiro potenciômetro varia sua tensão de saída entre $0\,\text{V}$ (totalmente à esquerda) passando por $2{,}5\,\text{V}$ (repouso central) até $5{,}0\,\text{V}$ (totalmente à direita).
• Eixo Y (Vertical): O cursor do segundo potenciômetro varia igualmente de $0\,\text{V}$ (para baixo) a $5{,}0\,\text{V}$ (para cima).
• Eixo Z (Chave Push SW): Um microswitch tátil sob a haste fecha o contato ao pressionar o polegar verticalmente.

As tensões nos eixos X e Y são convertidas pelo ADC de 10 bits do ATmega328P em números inteiros de 0 a 1023:

$$X = \frac{V_X}{5{,}0\,\text{V}} \times 1023 \approx 512 \quad (\text{na posição de repouso})$$ $$Y = \frac{V_Y}{5{,}0\,\text{V}} \times 1023 \approx 512 \quad (\text{na posição de repouso})$$

Componentes Necessários

Componente	Quantidade	Descrição / Observação
Placa compatível Arduino Uno R3	1	Converte canais analógicos e monitora chave digital
Módulo Joystick Analógico de 2 Eixos	1	Dois potenciômetros de 10k e chave pulsadora tátil
Cabos jumper fêmea-macho	5	Conexão para VCC, GND, VRx, VRy e SW

Tabela de Conexões Elétricas

Pino do Módulo Joystick	Pino no Arduino Uno	Tipo de Sinal / Descrição
Pino VCC (+5V)	Pino 5V do Arduino	Alimentação contínua dos potenciômetros
Pino GND	Pino GND do Arduino	Referência comum de terra
Pino VRx (Eixo Horizontal)	Pino Analógico A0	Leitura analógica de 0 a 1023 (tensão proporcional ao eixo X)
Pino VRy (Eixo Vertical)	Pino Analógico A1	Leitura analógica de 0 a 1023 (tensão proporcional ao eixo Y)
Pino SW (Push Switch)	Pino Digital D2	Entrada digital para detecção de clique vertical no botão

Código-Fonte Oficial Comentado

// Licao 12: Aquisicao de coordenadas bidimensionais com joystick analogico
// Mapeamento dos pinos de conexao com o microcontrolador
const int SW_pin = 2; // Pino digital 2 conectado a chave tatil integrada no eixo Z
const int X_pin = 0;  // Entrada analogica A0 conectada ao potenciometro do eixo X
const int Y_pin = 1;  // Entrada analogica A1 conectada ao potenciometro do eixo Y

void setup() {
  // Configura a chave do joystick como entrada com resistor interno de PULL-UP ativado
  // O botao liga o pino ao GND ao ser pressionado (leitura LOW)
  pinMode(SW_pin, INPUT_PULLUP);
  
  // Inicializa o canal serial na taxa de 9600 bps para telemetria em tempo real
  Serial.begin(9600);
  Serial.println("Licao 12: Modulo Joystick Analogico Inicializado!");
}

void loop() {
  // Realiza a leitura da chave digital do joystick (0 = pressionado, 1 = liberado)
  int botao = digitalRead(SW_pin);
  // Realiza a conversao analogico-digital de 10 bits no eixo X (retorna 0 a 1023)
  int valorX = analogRead(X_pin);
  // Realiza a conversao analogico-digital de 10 bits no eixo Y (retorna 0 a 1023)
  int valorY = analogRead(Y_pin);
  
  // Transmite as leituras formatadas no Monitor Serial
  Serial.print("Chave SW: ");
  Serial.print(botao);
  Serial.print(" | Eixo X: ");
  Serial.print(valorX);
  Serial.print(" | Eixo Y: ");
  Serial.println(valorY);
  
  // Intervalo de 200 milissegundos para viabilizar leitura confortavel na tela
  delay(200);
}

Gravação e Procedimento de Teste

1. Ligue os 5 pinos do módulo joystick ao Arduino conforme a tabela: VCC em 5V, GND em GND, VRx em A0, VRy em A1 e SW em D2.
2. Carregue o sketch para a placa Arduino Uno R3.
3. Abra o Monitor Serial (Ctrl + Shift + M) a 9600 baud.
4. Mantenha a alavanca no centro e confira se os eixos X e Y marcam aproximadamente 500 a 520 e o switch marca 1.
5. Mova a alavanca para os extremos cardeais (Norte, Sul, Leste, Oeste) e pressione o botão para baixo.
6. Resultado Esperado: O valor de X varia suavemente de 0 até 1023, o valor de Y varia de 0 até 1023 e o botão comuta para 0 quando pressionado, fornecendo um controle bidimensional completo para jogos ou robôs móveis.

---

Lição 13: Receptor de Infravermelho (IR) e Controle Remoto

A Lição 13 estuda a transmissão sem fio óptica de comandos codificados através de radiação infravermelha (IR — Infrared) modulada a 38 kHz, utilizando o sensor receptor de três terminais AX-1838HS e um transmissor de controle remoto de 21 teclas baseado no protocolo industrial NEC.

Modulação a 38 kHz e Formato do Protocolo NEC

A luz solar e as lâmpadas artificiais emitem radiação infravermelha constante no ambiente. Para isolar o sinal útil desse ruído óptico de fundo, o controle remoto modula seu feixe em uma frequência portadora de 38 kHz:

$$f_{CARRIER} = 38\,\text{kHz} \implies T_{CARRIER} = \frac{1}{38000\,\text{s}} \approx 26{,}3\,\mu\text{s}$$

O componente receptor AX-1838HS possui em seu invólucro um fotodiodo de silício com filtro óptico passa-faixa para $940\,\text{nm}$, um amplificador de ganho automático (AGC), um filtro sintonizado em 38 kHz e um desmodulador digital interno:

• Quando detecta uma rajada de 38 kHz no ar, sua saída de coletor aberto vai a nível lógico baixo (LOW).
• Quando não há emissão de 38 kHz, a saída permanece em nível lógico alto (HIGH).

O protocolo NEC codifica cada tecla em uma sequência de 32 bits estruturada em:

1. Pulso inicial de disparo (Leader Code): rajada de $9\,\text{ms}$ seguida de espaço de $4{,}5\,\text{ms}$.
2. Código de endereço de 8 bits do fabricante do aparelho.
3. Código de endereço invertido (para verificação de integridade).
4. Código de comando de 8 bits da tecla pressionada.
5. Código de comando invertido bit a bit (~Comando) para garantia de paridade absoluta.

📦 Bibliotecas desta lição:

• IRremote.h (por shirriff e z3t0 — versão recomendada fixa 2.8.0).
• ⚠️ Atenção: Instale a versão 2.8.0 pelo menu de versões do Gerenciador de Bibliotecas ou adicione o arquivo compactado IRremote.zip da pasta da Lição 13 do kit. Versões 3.x ou 4.x quebram a compilação desta lição.

Componentes Necessários

Componente	Quantidade	Descrição / Observação
Placa compatível Arduino Uno R3	1	Decodifica os trens de pulsos recebidos
Sensor Receptor Infravermelho AX-1838HS	1	Receptor integrado a 38 kHz (Sinal, GND, VCC)
Mini Controle Remoto IR de 21 Teclas	1	Transmissor com bateria de lítio CR2025 inclusa
Cabos jumper fêmea-macho flexíveis	3	Conexão dos terminais do sensor

Tabela de Conexões Elétricas

Terminal do Receptor AX-1838HS	Pino no Arduino Uno	Observação Técnica
Terminal de Sinal (OUT / S)	Pino Digital D11	Entrada digital conectada ao circuito de captura do Timer
Terminal de Alimentação (VCC)	Pino 5V do Arduino	Alimentação estabilizada de 5,0 V
Terminal de Terra (GND / -)	Pino GND do Arduino	Retorno ao terra de referência

Código-Fonte Oficial Comentado

// Licao 13: Decodificacao de controle remoto infravermelho no protocolo NEC
#include "IRremote.h" // Inclui a biblioteca IRremote (versao 2.8.0 compativel)

int receiver = 11; // Pino digital 11 conectado a saida de sinal do sensor AX-1838HS

IRrecv irrecv(receiver);     // Instancia o objeto receptor associado ao pino D11
decode_results results;      // Estrutura de dados para armazenar o pacote decodificado

// Funcao de traducao que mapeia o codigo hexadecimal do protocolo NEC no nome da tecla
void translateIR() {
  switch(results.value) {
    case 0xFFA25D: Serial.println("Tecla: POWER"); break;
    case 0xFFE21D: Serial.println("Tecla: FUNC/STOP"); break;
    case 0xFF629D: Serial.println("Tecla: VOL+"); break;
    case 0xFF22DD: Serial.println("Tecla: FAST BACK"); break;
    case 0xFF02FD: Serial.println("Tecla: PAUSE"); break;
    case 0xFFC23D: Serial.println("Tecla: FAST FORWARD"); break;
    case 0xFFE01F: Serial.println("Tecla: DOWN"); break;
    case 0xFFA857: Serial.println("Tecla: VOL-"); break;
    case 0xFF906F: Serial.println("Tecla: UP"); break;
    case 0xFF9867: Serial.println("Tecla: EQ"); break;
    case 0xFFB04F: Serial.println("Tecla: ST/REPT"); break;
    case 0xFF6897: Serial.println("Tecla: 0"); break;
    case 0xFF30CF: Serial.println("Tecla: 1"); break;
    case 0xFF18E7: Serial.println("Tecla: 2"); break;
    case 0xFF7A85: Serial.println("Tecla: 3"); break;
    case 0xFF10EF: Serial.println("Tecla: 4"); break;
    case 0xFF38C7: Serial.println("Tecla: 5"); break;
    case 0xFF5AA5: Serial.println("Tecla: 6"); break;
    case 0xFF42BD: Serial.println("Tecla: 7"); break;
    case 0xFF4AB5: Serial.println("Tecla: 8"); break;
    case 0xFF52AD: Serial.println("Tecla: 9"); break;
    case 0xFFFFFFFF: Serial.println("Tecla: REPETICAO"); break;
    default: 
      Serial.print("Outro Codigo Recebido: 0x");
      Serial.println(results.value, HEX);
  }
  delay(500); // Pausa para evitar deteccoes duplicadas acidentais
}

void setup() {
  Serial.begin(9600); // Inicializa o Monitor Serial
  Serial.println("Licao 13: Receptor IR Inicializado! Aponte o controle e tecle...");
  irrecv.enableIRIn(); // Inicia o processo de interrupcao de captura do receptor IR
}

void loop() {
  // Verifica se um trem de pulsos completo foi recebido e decodificado
  if (irrecv.decode(&results)) {
    translateIR();       // Decodifica e imprime o nome da tecla
    irrecv.resume();     // Libera o registrador para receber a proxima transmissao
  }
}

Gravação e Procedimento de Teste

1. Puxe a lingueta plástica transparente isoladora da bateria de lítio CR2025 do controle remoto para energizar o transmissor.
2. Ligue os três terminais do receptor IR aos pinos D11, 5V e GND do Arduino Uno R3.
3. Carregue o sketch para a placa e abra o Monitor Serial a 9600 baud.
4. Aponte o controle remoto em direção ao domo escuro do receptor e pressione botões como POWER, VOL+, 1, 2 e 3.
5. Resultado Esperado: A tela do Monitor Serial exibirá imediatamente a identificação exata de cada tecla pressionada (ex.: Tecla: POWER), comprovando a recepção sem fio e a correlação da tabela de códigos hexadecimais NEC.

---

Lição 14: Matriz de LEDs 8x8

A Lição 14 explora o acionamento de matrizes de exibição bidimensional através de uma Matriz de LEDs 8x8 (totalizando 64 pontos luminosos discretos ou pixels), introduzindo a técnica fundamental de multiplexação temporal e persistência da visão humana (POV — Persistence of Vision).

Princípio de Multiplexação Temporal e Fisiologia Visual

Controlar 64 LEDs de maneira estática independente exigiria 64 saídas digitais individuais. Na matriz 8x8, todos os ânodos dos LEDs de cada coluna são interligados eletricamente em uma barra vertical ($C_0 \dots C_7$), enquanto todos os cátodos dos LEDs de cada linha são unidos em uma barra horizontal ($R_0 \dots R_7$). Dessa forma, com apenas $8 + 8 = 16$ pinos do microcontrolador controla-se o arranjo completo:

Para acender um pixel na coordenada $(x, y)$:

1. Aplica-se nível lógico alto (+5 V) no Ânodo da coluna correspondente $x$.
2. Aplica-se nível lógico baixo (0 V / GND) no cátodo da linha correspondente $y$.
3. Todas as outras colunas recebem 0 V e as outras linhas recebem +5 V, mantendo os demais 63 LEDs reversamente polarizados ou sem ddp suficiente para condução.

Para exibir um caractere ou figura completa (por exemplo, o algarismo “0”), o microcontrolador acende sequencialmente cada ponto ativo por um tempo infinitesimal ($t_{EXPOSICAO} \approx 1\,\text{ms}$). Como o ciclo completo de varredura das 8 linhas ocorre a uma taxa superior a 60 Hz:

$$f_{QUADRO} = \frac{1}{8 \times 1\,\text{ms}} = 125\,\text{Hz}$$

A retina humana não percebe o chaveamento intermitente, integrando os pulsos discretos em uma imagem estática contínua e estável graças ao fenômeno da persistência retiniana.

Componentes Necessários

Componente	Quantidade	Descrição / Observação
Placa compatível Arduino Uno R3	1	Unidade geradora dos sinais de varredura matricial
Matriz de LEDs 8x8 vermelha (16 pinos)	1	64 LEDs dispostos em arranjo matricial Ânodo/cátodo
Cabos jumper flexíveis	16	Conexão de todas as linhas e colunas aos pinos da placa

Tabela de Conexões Elétricas

Terminal da Matriz 8x8	Barramento	Pino no Arduino Uno	Função Operacional
Colunas 0 a 7 (ânodos)	Colunas $C_0$ a $C_7$	Pinos Digitais D2 a D9	Aplica nível alto (+5V) nos pontos acesos da coluna
Linhas 0 a 3 (Cátodos)	Linhas $R_0$ a $R_3$	Pinos Digitais D10 a D13	Comuta para nível baixo (GND) para drenar corrente
Linhas 4 a 7 (Cátodos)	Linhas $R_4$ a $R_7$	Pinos Analógicos A0 a A3 (D14-D17)	Operam como saídas digitais drenadoras (nível LOW)

Código-Fonte Oficial Comentado

// Licao 14: Varredura matricial direta com Matriz de LEDs 8x8 exibindo o digito 0
// Mapa em bytes para formacao do caractere "0" em grade de 8x8 pixels
unsigned char Text[] = {0x00, 0x1c, 0x22, 0x22, 0x22, 0x22, 0x22, 0x1c};

// Funcao para apagar todos os pixels desligando colunas e desabilitando linhas
void clear_(void) {
  // Colunas (D2 a D9): desliga aplicando nivel logico baixo (0V)
  for (int i = 2; i < 10; i++) {
    digitalWrite(i, LOW);
  }
  // Linhas (D10 a D17 / A3): desabilita aplicando nivel logico alto (+5V)
  for (int i = 0; i < 8; i++) {
    digitalWrite(i + 10, HIGH);
  }
}

// Funcao grafica para acender um pixel individual na coordenada (x, y)
void Draw_point(unsigned char x, unsigned char y) {
  clear_(); // Apaga o display antes de desenhar o ponto atual
  digitalWrite(x + 2, HIGH);  // Ativa o anodo da coluna x (+5V)
  digitalWrite(y + 10, LOW);  // Ativa o catodo da linha y (GND)
  delay(1);                   // Mantem aceso por 1 milissegundo para integracao visual
}

// Funcao de renderizacao que decodifica o vetor de bytes bit a bit
void show_num(void) {
  unsigned char i, j, data;
  for (i = 0; i < 8; i++) {
    data = Text[i]; // Carrega o padrao binario da linha i
    for (j = 0; j < 8; j++) {
      // Se o bit menos significativo for 1, acende o pixel correspondente
      if (data & 0x01) {
        Draw_point(j, i);
      }
      data >>= 1; // Desloca os bits para a direita para avaliar o proximo pixel
    }
  }
}

void setup() {
  // Configura todas as portas de D2 ate D17 (A3) como saidas digitais de controle
  for (int i = 2; i < 18; i++) {
    pinMode(i, OUTPUT);
  }
  clear_(); // Inicializa o display totalmente apagado
}

void loop() {
  show_num(); // Executa continuamente a varredura matricial do caractere
}

Gravação e Procedimento de Teste

1. Encaixe a matriz 8x8 na protoboard ou interligue suas 16 vias diretamente aos pinos D2 a D13 e A0 a A3 (utilizados como pinos digitais 14 a 17) do Arduino Uno R3.
2. Carregue o sketch para a placa.
3. Resultado Esperado: Os 64 LEDs vermelhos formarão imediatamente a imagem límpida e brilhante do algarismo 0 iluminado no centro da matriz sem cintilação perceptível, demonstrando a potência da varredura temporal por software.

---

Lição 15: Sensor de Temperatura Analógico Linear LM35

A Lição 15 estuda a medição termométrica analógica de alta precisão através do circuito integrado transdutor de temperatura LM35DZ, explorando calibração em escala Celsius direta e condicionamento analógico-digital de grandezas físicas.

Física do Transdutor e Relação Linear Tensão-Temperatura

Diferente de termistores e termopares, o LM35 é um sensor monolítico semicondutor calibrado diretamente na escala Celsius (°C). Sua tensão de saída $V_{OUT}$ é rigorosamente linear e proporcional à temperatura absoluta:

$$V_{OUT} = 10{,}0\,\frac{\text{mV}}{^{\circ}\text{C}} \times T$$

• A $0^{\circ}\text{C}$, $V_{OUT} = 0\,\text{mV} = 0{,}00\,\text{V}$
• A $25^{\circ}\text{C}$, $V_{OUT} = 250\,\text{mV} = 0{,}25\,\text{V}$
• A $100^{\circ}\text{C}$, $V_{OUT} = 1000\,\text{mV} = 1{,}00\,\text{V}$

O conversor ADC do ATmega328P quantiza o sinal analógico em 1024 degraus. Com $V_{REF} = 5{,}0\,\text{V}$, cada passo discreto do conversor (resolução analógica) equivale a:

$$\Delta V_{ADC} = \frac{5{,}0\,\text{V}}{1024} \approx 4{,}8828\,\text{mV/passo}$$

A relação exata para conversão do valor bruto lido pelo conversor $ADC$ na temperatura física em graus Celsius é obtida por:

$$V_{IN} = ADC \times \left( \frac{5{,}0\,\text{V}}{1024} \right)$$ $$T(^{\circ}\text{C}) = \frac{V_{IN}}{0{,}010\,\text{V/}^{\circ}\text{C}} = \frac{ADC \times 5{,}0 \times 100}{1024} = \frac{ADC \times 500}{1024} = \frac{125 \times ADC}{256}$$

A expressão aritmética inteira dat = (125 * val) >> 8; utilizada pelo fabricante implementa exatamente essa relação analítica em álgebra de ponto fixo, substituindo uma divisão computacionalmente custosa por um deslocamento de bits à direita (>> 8), executado em apenas um ciclo de instrução do microcontrolador.

Componentes Necessários

Componente	Quantidade	Descrição / Observação
Placa compatível Arduino Uno R3	1	Efetua a conversão analógico-digital de 10 bits
Sensor Analógico de Temperatura LM35DZ	1	Encapsulamento TO-92 (faixa de medição de 0 a +100 °C)
Cabos jumper flexíveis	3	Conexões de alimentação e sinal

Tabela de Conexões Elétricas

Terminal do LM35 (Chanfro voltado para você)	Conexão no Arduino	Descrição Elétrica
Pino Esquerdo: $V_{CC}$ (Pino 1)	Pino 5V do Arduino	Tensão contínua de alimentação (4V a 20V)
Pino Central: $V_{OUT}$ (Pino 2)	Pino Analógico A0	Tensão analógica linear de $10\,\text{mV}/^{\circ}\text{C}$
Pino Direito: GND (Pino 3)	Pino GND do Arduino	Retorno ao terra de referência

⚠️ Atenção à pinagem do LM35: Olhando o sensor com o chanfro plano voltado para os seus olhos e os terminais apontados para baixo: Pino 1 (esquerda) = +5V, Pino 2 (centro) = Sinal Analógico A0, Pino 3 (direita) = GND. Inverter os pinos 1 e 3 colocará o chip em polarização reversa, provocando aquecimento severo instantâneo e inutilizando do componente.

Código-Fonte Oficial Comentado

// Licao 15: Termometria de precisao com sensor linear LM35DZ e operacao de ponto fixo
int potPin = 0; // Define o canal de entrada analogica A0 para leitura do LM35

void setup() {
  // Inicializa a comunicacao serial a 9600 bps para telemetria termica
  Serial.begin(9600);
  Serial.println("Licao 15: Termometro com Sensor Linear LM35 Inicializado!");
}

void loop() {
  int val; // Armazena o valor inteiro bruto quantizado pelo ADC (0 a 1023)
  int dat; // Armazena o valor processado da temperatura em graus Celsius inteiros
  
  // Realiza a leitura da tensao analizada no pino A0
  val = analogRead(potPin);
  
  // Formula de conversao otimizada em ponto fixo: T = (val * 500) / 1024 = (125 * val) / 256
  // O operador de deslocamento de 8 bits a direita (>> 8) equivale a dividir por 256
  dat = (125 * val) >> 8;
  
  // Imprime a telemetria termica formatada no Monitor Serial
  Serial.print("Temperatura LM35: ");
  Serial.print(dat);
  Serial.println(" C");
  
  // Aguarda 500 milissegundos antes da proxima amostragem
  delay(500);
}

Gravação e Procedimento de Teste

1. Monte o LM35 com atenção redobrada à ordem dos terminais na protoboard.
2. Carregue o sketch para o Arduino Uno R3 e abra o Monitor Serial a 9600 baud.
3. Observe a temperatura ambiente estabilizada (tipicamente entre 22 C e 27 C).
4. Encoste a polpa do polegar no encapsulamento plástico do LM35 para transferir calor corporal.
5. Resultado Esperado: A leitura no Monitor Serial subirá quase instantaneamente grau a grau até atingir aproximadamente 32 C a 35 C, demonstrando a sensibilidade e linearidade do semicondutor.

---

Lição 16: Sensor Resistivo de Nível e Presença de água

A Lição 16 apresenta o monitoramento de fluidos condutores através do módulo sensor resistivo de nível de água, analisando a eletroquímica da condutividade iônica e o tratamento de sinais ruidosos com histerese e filtros de média.

Princípio Físico e Condutividade Eletrolítica

A água potável contém íons e sais minerais dissolvidos (como $\text{Na}^+$, $\text{Ca}^{2+}$, $\text{Cl}^-$ e $\text{HCO}_3^-$) que a tornam um condutor eletrolítico de corrente elétrica. O sensor possui dez trilhas condutoras de cobre expostas intercaladas em paralelo: cinco trilhas conectadas à linha positiva e cinco trilhas conectadas à linha de terra através de um resistor de polarização (pull-down).

Quando a lâmina do sensor é imersa em líquido:

• O menisco de água une as trilhas paralelas, estabelecendo pontes condutivas de corrente elétrica.
• Quanto mais profunda a imersão da lâmina, maior é a área superficial molhada $A$ e menor é a resistência ôhmica equivalente entre as pistas:

$$R_{AGUA} = \rho \times \frac{L}{A}$$

A tensão analógica resultante medida no divisor de tensão sobe de forma quase proporcional à profundidade submersa:

$$V_{OUT} = 5{,}0\,\text{V} \times \left( \frac{R_{PULL-DOWN}}{R_{AGUA} + R_{PULL-DOWN}} \right)$$

Quando a lâmina está completamente seca no ar, $R_{AGUA} \to \infty$ e a tensão no canal analógico é de $0\,\text{V}$ (leitura ADC próxima de 0). À medida que a água sobe pelas trilhas, o valor quantizado no canal A0 cresce progressivamente, atingindo valores entre 400 e 700 para imersão total.

Componentes Necessários

Componente	Quantidade	Descrição / Observação
Placa compatível Arduino Uno R3	1	Digitalização analógica e processamento
Módulo Sensor de Nível de água	1	Placa com trilhas expostas e terminais (+, -, S)
Recipiente plástico com água limpa	1	Recipiente pequeno para teste prático de imersão
Cabos jumper fêmea-macho	3	Conexão para VCC, GND e Sinal analógico

Tabela de Conexões Elétricas

Pino do Módulo de Nível	Conexão no Arduino Uno	Função Elétrica
Pino (+) / VCC	Pino 5V do Arduino	Fornece alimentação positiva de 5V para as trilhas
Pino (-) / GND	Pino GND do Arduino	Referência de terra
Pino (S) / Signal	Pino Analógico A0	Sinal analógico de tensão proporcional ao nível

Código-Fonte Oficial Comentado

// Licao 16: Monitoramento de nivel e presenca de agua com filtragem de ruido
int adc_id = 0;           // Define o canal analogico A0 para aquisicao do sensor
int HistoryValue = 0;     // Armazena a ultima leitura estavel para deteccao de histerese
char printBuffer[128];    // Buffer para formatacao de mensagens via sprintf()

void setup() {
  // Inicializa o Monitor Serial na taxa padrao de 9600 bps
  Serial.begin(9600);
  Serial.println("Licao 16: Sensor de Nivel de Agua Inicializado!");
}

void loop() {
  // Realiza a leitura analogica instantanea de 10 bits no pino A0
  int value = analogRead(adc_id);
  
  // Aplica filtro de histerese: so transmite nova mensagem se a variacao superar o limiar de ruido (delta > 10)
  if (((HistoryValue >= value) && ((HistoryValue - value) > 10)) || 
      ((HistoryValue <= value) && ((value - HistoryValue) > 10))) {
    
    // Atualiza o historico com o novo valor estavel
    HistoryValue = value;
    
    // Formata a string contendo a leitura atualizada
    sprintf(printBuffer, "Nivel de Agua Detectado (ADC 0-1023): %d", value);
    Serial.println(printBuffer);
    
    // Classificacao qualitativa por faixas de profundidade
    if (value < 50) {
      Serial.println(">> Status: Sensor Seco / Recipiente Vazio");
    } else if (value >= 50 && value < 300) {
      Serial.println(">> Status: Nivel Baixo detectado");
    } else if (value >= 300 && value < 550) {
      Serial.println(">> Status: Nivel Medio / Operacional");
    } else {
      Serial.println(">> Status: Nivel Alto / Alerta de Transbordamento!");
    }
  }
  
  // Pausa de 200 milissegundos entre verificacoes
  delay(200);
}

Gravação e Procedimento de Teste

1. Conecte o sensor de nível de água conforme a tabela aos pinos 5V, GND e A0 do Arduino Uno R3.
2. Carregue o sketch para a placa e abra o Monitor Serial.
3. Com o sensor seco sobre a bancada, o Monitor Serial registrará leituras inferiores a 50 (Sensor Seco).
4. Mergulhe gradualmente a ponta inferior das trilhas em um copo com água limpa.
5. Resultado Esperado: À medida que a lâmina afunda no líquido, novas leituras são transmitidas com valores crescentes (150, 320, 580), indicando a transição de Nível Baixo $\to$ Nível Médio $\to$ Nível Alto com total imunidade a pequenas oscilações graças ao filtro de histerese por software.

---

Lição 17: Módulo Relógio de Tempo Real (RTC) DS1302

A Lição 17 introduz a cronometragem calendárica de alta precisão imune a quedas de energia elétrica através do módulo RTC DS1302, operando com barramento síncrono serial de 3 fios e bateria de backup tipo moeda de lítio.

Arquitetura de Relógio e Cristal Oscilador de 32,768 kHz

Quando uma placa microcontrolada Arduino é desligada ou reiniciada, seus registradores internos de temporização perdem a referência temporal absoluta. O circuito integrado DS1302 resolve esse problema mantendo em funcionamento autônomo um oscilador de frequência ultraestável alimentado por um cristal de quartzo piezoelétrico de corte diapasão que vibra exatamente a:

$$f_{CRISTAL} = 32.768\,\text{Hz} = 2^{15}\,\text{Hz}$$

Essa frequência é ideal para sistemas digitais de computação temporal: ao passar por uma cadeia de 15 flip-flops divisores binários em cascata ($2^{15}$), o sinal é reduzido a exatamente um pulso de clock de $1{,}0\,\text{Hz}$ (um segundo exato):

$$f_{SEGUNDO} = \frac{32768\,\text{Hz}}{2^{15}} = 1{,}00000\,\text{Hz}$$

O circuito integrado mantém contadores independentes para segundos, minutos, horas, dia do mês, mês, dia da semana e ano com compensação automática para anos bissextos até o ano 2100. Em caso de corte na alimentação primária de 5V da USB, o circuito comuta internamente sem interrupção para a bateria de lítio de 3 V (CR2025/CR2032), drenando menos de 300 nanoamperes ($I < 0{,}3\,\mu\text{A}$), o que permite manter o horário preciso por mais de 5 a 10 anos ininterruptos.

A comunicação serial de 3 vias compreende:

• CE / RST: Linha de habilitação de chip (Chip Enable — ativa em nível alto).
• SCLK / CLK: Linha de clock síncrono de temporização dos bits.
• I/O / DAT: Linha de dados bidirecional serial.

📦 Bibliotecas desta lição:

• RtcDS1302.h e ThreeWire.h (da biblioteca RTC by Makuna — versão recomendada 2.4.2).
• Instalação: No Gerenciador de Bibliotecas da Arduino IDE, pesquise por RTC by Makuna e clique em Instalar, ou utilize o pacote Rtc_by_Makuna.zip contido no pacote oficial do kit.

Componentes Necessários

Componente	Quantidade	Descrição / Observação
Placa compatível Arduino Uno R3	1	Unidade mestre do barramento de 3 vias
Módulo RTC DS1302 com Bateria	1	Relógio de tempo real com cristal de 32,768 kHz
Bateria de lítio moeda CR2025 ou CR2032 (3V)	1	Bateria de backup para retenção de horário
Cabos jumper fêmea-macho flexíveis	5	Conexão para VCC, GND, CLK, DAT e RST

Tabela de Conexões Elétricas

Pino do Módulo DS1302	Pino no Arduino Uno	Linha do Protocolo / Função
Pino VCC	Pino 5V do Arduino	Tensão contínua de alimentação primária (5,0 V)
Pino GND	Pino GND do Arduino	Referência comum de terra
Pino CLK / SCLK	Pino Digital D5	Linha de sinal de clock síncrono gerado pelo mestre
Pino DAT / IO	Pino Digital D4	Linha bidirecional serial de transferência de dados
Pino RST / CE	Pino Digital D2	Linha de habilitação de chip (Chip Enable / Reset)

Código-Fonte Oficial Comentado

// Licao 17: Relogio de Tempo Real (RTC) DS1302 com leitura/gravacao de data e memoria
#include <ThreeWire.h>   // Suporte a comunicacao síncrona de 3 fios
#include <RtcDS1302.h>   // Biblioteca de controle do chip RTC DS1302

// Configura os pinos fisicos de ligacao com o chip: IO/DAT = D4, SCLK = D5, CE/RST = D2
ThreeWire myWire(4, 5, 2); 
RtcDS1302<ThreeWire> Rtc(myWire); // Instancia o gerenciador do relogio

// Funcao auxiliar para formatacao e impressao da data e horario completos
void printDateTime(const RtcDateTime& dt) {
  char datestring[26];
  // Formata a data no padrao DD/MM/AAAA HH:MM:SS
  snprintf_P(datestring, 
             countof(datestring),
             PSTR("%02u/%02u/%04u %02u:%02u:%02u"),
             dt.Day(),
             dt.Month(),
             dt.Year(),
             dt.Hour(),
             dt.Minute(),
             dt.Second() );
  Serial.print(datestring);
}

// Macro para contagem de elementos de matrizes
#define countof(a) (sizeof(a) / sizeof(a[0]))

void setup() {
  Serial.begin(9600); // Inicializa comunicacao serial a 9600 bps
  Serial.println("Licao 17: Modulo RTC DS1302 Inicializando...");

  Rtc.Begin(); // Inicializa o hardware do relogio e os pinos de controle

  // Registra a estampa de data e hora em que este sketch foi compilado pelo computador
  RtcDateTime compiled = RtcDateTime(__DATE__, __TIME__);
  printDateTime(compiled);
  Serial.println(" <- Horario de compilacao do firmware");

  // Se o relogio nao estiver configurado previamente ou perdeu bateria
  if (!Rtc.IsDateTimeValid()) {
    Serial.println("Aviso: RTC perdeu confianca temporal! Gravando horario de compilacao...");
    Rtc.SetDateTime(compiled); // Sincroniza com o horario do computador
  }

  // Se o oscilador estiver travado por registrador interno, destrava-o
  if (Rtc.GetIsWriteProtected()) {
    Serial.println("Destravando protecao contra gravacao...");
    Rtc.SetIsWriteProtected(false);
  }

  if (!Rtc.GetIsRunning()) {
    Serial.println("Disparando o oscilador do cristal de 32kHz...");
    Rtc.SetIsRunning(true);
  }

  RtcDateTime now = Rtc.GetDateTime();
  if (now < compiled) {
    Serial.println("Atualizando RTC para o horario mais recente...");
    Rtc.SetDateTime(compiled);
  }
  
  Serial.println("Relogio RTC pronto e sincronizado!");
}

void loop() {
  // Captura o instante temporal exato do chip DS1302
  RtcDateTime now = Rtc.GetDateTime();

  // Imprime a data e hora formatadas
  Serial.print("Horario Oficial: ");
  printDateTime(now);
  Serial.println();

  // Aguarda 1000 milissegundos (1 segundo exato) para a proxima atualizacao
  delay(1000);
}

Gravação e Procedimento de Teste

1. Encaixe uma bateria moeda CR2025 ou CR2032 no soquete metálico do módulo DS1302 (com o polo positivo + voltado para cima).
2. Ligue os pinos do módulo ao Arduino Uno R3: VCC em 5V, GND em GND, CLK em D5, DAT em D4 e RST em D2.
3. Carregue o sketch para a placa Arduino e abra o Monitor Serial a 9600 baud.
4. Resultado Esperado: O Monitor Serial exibirá o horário em que o sketch foi compilado e passará a imprimir a cada segundo a data e o horário atualizados com avanço milimétrico de segundos (ex.: Horario Oficial: 14/09/2026 14:32:01). Desconecte o cabo USB do computador por 2 minutos, reconecte-o e abra o Monitor Serial novamente: o relógio continuará marcando o horário rigorosamente exato sem ter perdido sequer um segundo, comprovando a autonomia da bateria de backup.

---

Lição 18: Módulo Sensor de Som e Microfone com Comparador LM393

A Lição 18 apresenta a instrumentação eletroacústica e o condicionamento de sinais de áudio utilizando o Módulo Sensor de Som de Alta Sensibilidade, composto por uma cápsula de microfone de eletreto omnidirecional e um circuito comparador analógico de precisão baseado no circuito integrado LM393.

Transdução de Pressão Acústica e Comparação de Tensão

O ar em vibração acústica incide sobre uma membrana condutora elástica ultrafina no microfone de eletreto, alterando a distância entre placas $d$ de um capacitor pré-carregado eletrostaticamente com carga $Q$. A variação mecânica induz uma tensão elétrica proporcional à pressão sonora $p(t)$:

$$C = \frac{\varepsilon A}{d} \implies V(t) = \frac{Q}{C(t)} = \frac{Q \cdot d(t)}{\varepsilon A}$$

O módulo disponibiliza simultaneamente duas saídas operacionais:

1. Saída Analógica (AO): Fornece o sinal de tensão alternado contínuo amplificado em torno de uma tensão de polarização de repouso ($V_{DC} \approx 2{,}5\,\text{V}$), permitindo analisar a amplitude da onda sonora via conversor ADC (A0).
2. Saída Digital (DO): Conectada ao comparador de tensão LM393. Um trimpot multivoltas integrado calibra a tensão de referência $V_{REF}$ no terminal inversor (-). Sempre que o pico acústico supera $V_{REF}$, a saída comuta bruscamente para nível lógico baixo (LOW), acendendo o LED indicador L2 do módulo e disparando o pino digital D3.

Componentes Necessários

Componente	Quantidade	Descrição / Observação
Placa compatível Arduino Uno R3	1	Realiza leitura analógica e monitoramento de disparo
Módulo Sensor de Som com LM393	1	Microfone de eletreto com saídas AO e DO
Cabos jumper fêmea-macho flexíveis	4	Conexões para VCC, GND, AO e DO

Tabela de Conexões Elétricas

Pino do Módulo de Som	Pino no Arduino Uno	Descrição Elétrica
Pino VCC (+)	Pino 5V do Arduino	Alimentação estabilizada de 5,0 V
Pino GND (-)	Pino GND do Arduino	Retorno de terra
Pino AO (Analog Output)	Pino Analógico A0	Medição contínua da forma de onda de pressão sonora
Pino DO (Digital Output)	Pino Digital D3	Sinal binário comparado de disparo (palmas/ruído alto)

Código-Fonte Oficial Comentado

// Licao 18: Sensoriamento acustico hibrido (Analogico e Digital) com comparador LM393
int sensorAnalogPin = A0;   // Entrada analogica A0 conectada a saida AO do modulo
int sensorDigitalPin = 3;   // Entrada digital D3 conectada a saida comparada DO
int Led13 = 13;             // LED embarcado na placa utilizado como sinalizador

int analogValue = 0;        // Variavel para armazenar a amplitude instantanea lida pelo ADC
int digitalValue;           // Variavel para armazenar o nivel logico da saida comparadora

void setup() {
  // Configura o pino digital D3 como entrada para o sinal do comparador LM393
  pinMode(sensorDigitalPin, INPUT);
  // Configura o pino D13 como saida digital para acionamento do LED indicador
  pinMode(Led13, OUTPUT);
  // Inicializa o Monitor Serial a 9600 bps para telemetria
  Serial.begin(9600);
  Serial.println("Licao 18: Sensor de Som com LM393 Inicializado!");
}

void loop() {
  // Le o valor analogico instantaneo do microfone (0 a 1023)
  analogValue = analogRead(sensorAnalogPin);
  // Le o estado logico digital da saida comparadora (0 = som detectado, 1 = silencio)
  digitalValue = digitalRead(sensorDigitalPin);
  
  // Transmite as leituras para acompanhamento no Serial Plotter ou Monitor Serial
  Serial.print("Analogico AO: ");
  Serial.print(analogValue);
  Serial.print(" | Digital DO: ");
  Serial.println(digitalValue);
  
  // Se o som ambiente ultrapassar o limiar ajustado no trimpot (DO vai a LOW)
  if (digitalValue == LOW) {
    digitalWrite(Led13, HIGH); // Acende o LED da placa indicando deteccao sonora
  } else {
    digitalWrite(Led13, LOW);  // Mantem o LED apagado em repouso
  }
  
  // Breve intervalo para amostragem
  delay(50);
}

Gravação e Procedimento de Teste

1. Conecte os 4 pinos do módulo ao Arduino Uno R3: VCC em 5V, GND em GND, AO em A0 e DO em D3.
2. Carregue o sketch e abra o Serial Plotter (Ctrl + Shift + L) na velocidade 9600 baud.
3. Em silêncio relativo, observe a linha de base analógica próxima a 512.
4. Gire cuidadosamente o parafuso do trimpot azul com uma chave de fenda até que o LED vermelho L2 do módulo apague e fique no limiar exato de sensibilidade.
5. Bata palmas próximo ao sensor.
6. Resultado Esperado: O sinal analógico registrará uma oscilação vertical acentuada na tela gráfica, a saída digital DO comutará instantaneamente e o LED 13 piscará em perfeita sincronia com cada palma.

---

Lição 19: Sistema de Identificação por Radiofrequência (RFID) RC522

A Lição 19 aborda a tecnologia sem fio de identificação por radiofrequência (RFID — Radio-Frequency Identification) de campo próximo operando na frequência padrão industrial de 13,56 MHz, através do transceptor MFRC522 da NXP com interface de comunicação serial síncrona de alta velocidade SPI (Serial Peripheral Interface).

Princípio de Acoplamento Indutivo Ressonante e Barramento SPI

Os cartões e chaveiros do padrão Mifare Classic 1K são transponders passivos desprovidos de bateria interna. Quando o cartão é aproximado da antena espiral do módulo RC522, o campo magnético oscilante de alta frequência gerado a 13,56 MHz induz por acoplamento magnético de transformador de núcleo de ar uma força eletromotriz na bobina interna da etiqueta:

$$\mathcal{E} = -\frac{d\Phi_B}{dt} = -\frac{d}{dt} \iint \vec{B} \cdot d\vec{A}$$

Essa energia é retificada internamente por uma ponte de diodos e alimenta o chip de silício do cartão, que transmite de volta seu identificador numérico único de fábrica (UID — Unique Identifier) através de modulação por variação de carga (Load Modulation).

A comunicação entre o microcontrolador ATmega328P e o chip MFRC522 é realizada pelo barramento SPI, constituído por 4 linhas síncronas dedicadas:

• MOSI (Master Out Slave In): Pino digital D11 do Arduino (transmissão do mestre para o escravo).
• MISO (Master In Slave Out): Pino digital D12 do Arduino (recepção de dados do escravo).
• SCK (Serial Clock): Pino digital D13 do Arduino (sinal de sincronismo gerado pelo mestre a até 10 MHz).
• SDA / SS (Slave Select): Pino digital D10 do Arduino (seleciona o periférico ativo quando em nível baixo).
• RST (Reset): Pino digital D9 (linha de reinicialização de hardware).

⛔️ Perigo e Atenção Crítica de Alimentação: O circuito integrado MFRC522 opera estritamente com tensão contínua de 3,3 VDC. Conectar o pino VCC do módulo ao barramento de 5V do Arduino causará queima imediata do chip transceptor! Ligue o VCC obrigatoriamente no pino de 3.3V da placa Arduino Uno R3. As linhas lógicas de sinal toleram os níveis de 5V da Uno.

📦 Bibliotecas desta lição:

• SPI.h (embutida no compilador da Arduino IDE).
• MFRC522.h (por GithubCommunity — versão recomendada 1.4.11).
• Instalação: Acesse Sketch > Incluir Biblioteca > Gerenciar Bibliotecas..., digite MFRC522 e instale a biblioteca mantida por GithubCommunity.

Componentes Necessários

Componente	Quantidade	Descrição / Observação
Placa compatível Arduino Uno R3	1	Mestre do barramento SPI
Módulo Leitor RFID RC522 (13,56 MHz)	1	Alimentado estritamente em 3,3 V
Cartão Mifare Classic 1K branco	1	Tag passiva em formato de cartão plástico
Chaveiro Mifare Classic 1K azul	1	Tag passiva tipo chaveiro compacto
Cabos jumper fêmea-macho flexíveis	7	Fios para o barramento SPI e alimentação

Tabela de Conexões Elétricas

Pino do Módulo RC522	Conexão no Arduino Uno	Sinal do Barramento SPI / Função
Pino VCC (3.3V)	Pino 3.3V do Arduino	OBRIGATÓRIO 3.3V — Nunca conecte no 5V!
Pino RST	Pino Digital D9	Linha de reinicialização de hardware (Reset)
Pino GND	Pino GND do Arduino	Referência comum de terra
Pino IRQ	Não conectado	Linha de interrupção (não utilizada neste sketch)
Pino MISO	Pino Digital D12	Linha SPI MISO (Master In Slave Out)
Pino MOSI	Pino Digital D11	Linha SPI MOSI (Master Out Slave In)
Pino SCK	Pino Digital D13	Linha SPI SCK (Serial Clock)
Pino SDA / NSS	Pino Digital D10	Linha SPI SS (Slave Select / Chip Enable)

Código-Fonte Oficial Comentado

// Licao 19: Leitura de UID e identificacao de tags RFID Mifare com MFRC522
#include <SPI.h>     // Inclui a biblioteca de comunicacao serial sincrona SPI
#include <MFRC522.h> // Inclui a biblioteca de controle do modulo RFID RC522

#define RST_PIN  9   // Pino digital 9 para a linha de reset do modulo MFRC522
#define SS_PIN   10  // Pino digital 10 para selecao do dispositivo escravo (Slave Select)

MFRC522 mfrc522(SS_PIN, RST_PIN); // Instancia o objeto RFID configurado nos pinos D10 e D9

void setup() {
  Serial.begin(9600); // Inicializa comunicacao serial a 9600 bps
  while (!Serial);    // Aguarda abertura do canal serial USB
  
  SPI.begin();        // Inicializa o barramento SPI de hardware nos pinos 11, 12 e 13
  mfrc522.PCD_Init(); // Inicializa e configura os registradores internos do chip MFRC522
  
  Serial.println("==================================================");
  Serial.println("Licao 19: Leitor RFID RC522 Inicializado!");
  Serial.println("Aproxime um cartao ou chaveiro Mifare da antena...");
  Serial.println("==================================================");
}

void loop() {
  // Verifica se ha um novo cartao RFID presente no campo eletromagnetico
  if (!mfrc522.PICC_IsNewCardPresent()) {
    return; // Se nenhum cartao foi detectado, encerra este ciclo da funcao loop
  }

  // Executa a leitura serial dos dados de identificacao do cartao
  if (!mfrc522.PICC_ReadCardSerial()) {
    return; // Se a transmissao falhou por perda de sinal, retorna
  }

  // Imprime os detalhes do cartao detectado
  Serial.print(">> Cartao Detectado! UID da Tag (Hex): ");
  String conteudoUID = "";
  
  // Varre os 4 bytes do identificador unico (UID de 32 bits)
  for (byte i = 0; i < mfrc522.uid.size; i++) {
    // Adiciona zero a esquerda se o byte for menor que 0x10 para formatacao padrao
    Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
    Serial.print(mfrc522.uid.uidByte[i], HEX);
  }
  Serial.println();

  // Imprime o tipo da tecnologia PICC detectada
  MFRC522::PICC_Type piccType = mfrc522.PICC_GetType(mfrc522.uid.sak);
  Serial.print("Tipo da Tag RFID: ");
  Serial.println(mfrc522.PICC_GetTypeName(piccType));
  
  // Encerra a sessao criptografica com a tag atual antes da proxima leitura
  mfrc522.PICC_HaltA();
  // Finaliza a criptografia de canal no modulo
  mfrc522.PCD_StopCrypto1();
  
  delay(1000); // Pausa de 1 segundo para evitar leituras repetidas da mesma tag
}

Gravação e Procedimento de Teste

1. Conecte com máxima atenção o pino VCC do módulo RC522 no pino 3.3V da placa Arduino Uno R3. Conecte os demais pinos do barramento SPI (RST em D9, GND em GND, MISO em D12, MOSI em D11, SCK em D13 e SDA em D10).
2. Carregue o sketch para a placa Arduino e abra o Monitor Serial a 9600 baud.
3. Aproxime o chaveiro azul a cerca de 2 a 3 cm da face frontal do leitor.
4. O Monitor Serial exibirá o código hexadecimal único (por exemplo: UID da Tag (Hex): A3 5B 8F 2D) e o tipo PICC: MIFARE 1KB.
5. Aproxime em seguida o cartão branco e observe um código UID diferente, confirmando a capacidade do sistema de distinguir cartões para controle de acesso físico automatizado.

---

Lição 20: Display de Cristal Líquido LCD 16x2 com Módulo I2C PCF8574

A Lição 20 estuda a comunicação serial síncrona bifilar I2C (Inter-Integrated Circuit) para controle de displays alfanuméricos de cristal líquido LCD 16x2 baseados no controlador padrão industrial HD44780, utilizando uma placa adaptadora baseada no expansor de portas I/O de 8 bits PCF8574.

Princípio do Barramento I2C e Economia de Pinos

O display LCD 16x2 convencional opera em barramento paralelo de 4 ou 8 bits de dados ($D_4 \dots D_7$), exigindo no mínimo 6 a 10 pinos digitais do Arduino Uno R3 (RS, EN, D4, D5, D6, D7 e controle de backlight). A placa adaptadora traseira utiliza o circuito integrado PCF8574, que recebe comandos seriais do Arduino através do protocolo bifilar I2C e os traduz paralelamente para os pinos do LCD:

• Linha SDA (Serial Data): Pino Analógico A4 do Arduino Uno R3.
• Linha SCL (Serial Clock): Pino Analógico A5 do Arduino Uno R3.

O barramento opera a uma taxa de clock de 100 kHz com endereçamento de 7 bits. O endereço padrão de fábrica para módulos com chip PCF8574T é comumente 0x27 (ou 0x3F para variantes PCF8574AT). Um trimpot de ajuste na face traseira permite calibrar a polarização de contraste do cristal líquido.

📦 Bibliotecas desta lição:

• Wire.h (embutida no compilador da Arduino IDE para barramento I2C).
• LiquidCrystal_I2C.h (por Frank de Brabander / John Rickman — versão recomendada 1.1.2).
• Instalação: No Gerenciador de Bibliotecas, pesquise por LiquidCrystal I2C mantida por Frank de Brabander e clique em Instalar, ou utilize o arquivo LiquidCrystal_I2C.zip presente no kit.

Componentes Necessários

Componente	Quantidade	Descrição / Observação
Placa compatível Arduino Uno R3	1	Mestre do barramento I2C
Módulo Display LCD 16x2 com I2C	1	2 linhas de 16 caracteres com backlight azul
Cabos jumper fêmea-macho flexíveis	4	Conexão para VCC, GND, SDA e SCL

Tabela de Conexões Elétricas

Pino do Módulo LCD I2C	Pino no Arduino Uno	Linha do Barramento I2C / Função
Pino GND	Pino GND do Arduino	Referência comum de terra
Pino VCC	Pino 5V do Arduino	Alimentação contínua de 5,0 V do display e backlight
Pino SDA (Serial Data)	Pino Analógico A4 (ou pino SDA superior)	Linha bidirecional serial de dados
Pino SCL (Serial Clock)	Pino Analógico A5 (ou pino SCL superior)	Linha de clock serial síncrono

Código-Fonte Oficial Comentado

// Licao 20: Exibicao alfanumerica em display LCD 16x2 via barramento serial I2C
#include <Wire.h>              // Inclui suporte nativo ao protocolo I2C
#include <LiquidCrystal_I2C.h> // Inclui a biblioteca de controle do LCD com chip PCF8574

// Instancia o objeto do display: endereco 0x27, 16 colunas e 2 linhas de texto
LiquidCrystal_I2C lcd(0x27, 16, 2); 

void setup() {
  // Inicializa o controlador do display LCD
  lcd.init(); 
  // Segunda chamada de seguranca para estabilizacao de comandos internos
  lcd.init();
  
  // Liga a luz de fundo (backlight azul de alto brilho)
  lcd.backlight();
  
  // Posiciona o cursor na coluna 0, linha 0 (primeira linha superior)
  lcd.setCursor(0, 0);
  // Escreve a mensagem de texto
  lcd.print("Hello, world!");
  
  // Posiciona o cursor na coluna 0, linha 1 (segunda linha inferior)
  lcd.setCursor(0, 1);
  // Escreve o nome da fabricante oficial do kit
  lcd.print("KUONGSHUN");
}

void loop() {
  // O texto estatico permanece visivel indefinidamente
}

Gravação e Procedimento de Teste

1. Ligue os 4 pinos do módulo LCD ao Arduino Uno R3: GND em GND, VCC em 5V, SDA em A4 e SCL em A5.
2. Carregue o sketch para a placa.
3. Se a tela acender mas os caracteres não aparecerem ou forem exibidos como blocos brancos sólidos, gire o trimpot azul localizado na parte traseira da placa I2C com uma pequena chave plástica ou de fenda para ajustar a polarização de contraste.
4. Resultado Esperado: A tela azul iluminará com nitidez exibindo Hello, world! na linha superior e KUONGSHUN na linha inferior.

---

Lição 21: Expansão de Saídas com Registrador de Deslocamento 74HC595 e 8 LEDs

A Lição 21 estuda uma das técnicas mais consagradas da engenharia de hardware para ampliação de portas digitais: o circuito integrado 74HC595, um registrador de deslocamento de 8 bits serial-in paralelo-out com trava de saída (Latch), demonstrando como controlar 8 LEDs individuais utilizando apenas 3 pinos digitais do Arduino Uno R3.

Arquitetura Interna do CI 74HC595 e Protocolo de Carga

O chip 74HC595 combina internamente dois blocos funcionais independentes:

1. Registrador de Deslocamento (Shift Register): Uma cadeia de 8 flip-flops do tipo D em cascata sincronizados pelo pino de clock SH_CP (Shift Clock Pulse, pino 11 do chip). A cada borda de subida do clock, o bit presente na linha de dados DS (Data Serial, pino 14 do chip) é empurrado para o primeiro registrador, deslocando todos os outros 7 bits para a direita.
2. Registrador de Armazenamento / Trava (Storage Register / Latch): Um registrador intermediário de 8 bits sincronizado pelo pino ST_CP (Storage Clock Pulse, pino 12 do chip). Enquanto o pino Latch permanece em nível baixo, as saídas externas ($Q_0 \dots Q_7$) permanecem inalteradas, permitindo carregar os novos 8 bits serialmente sem causar cintilação nas saídas. Ao aplicar uma borda de subida no pino Latch, os 8 bits são transferidos instantaneamente para os pinos de saída.

A função nativa do Arduino shiftOut(dataPin, clockPin, bitOrder, value) implementa esse protocolo em nível de bit:

void shiftOut(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder, uint8_t val);

Para atualizar 8 saídas externas, o microcontrolador necessita de apenas:

$$N_{PINOS\_MCU} = 3 \quad (\text{Data, Clock, Latch})$$

Com capacidade de cascateamento infinito unindo o pino $Q_{7S}$ (pino 9 do chip) ao pino DS do próximo registrador, viabilizando o controle de 16, 24, 32 ou mais saídas com os mesmos 3 pinos da CPU.

Componentes Necessários

Componente	Quantidade	Descrição / Observação
Placa compatível Arduino Uno R3	1	Unidade controladora das linhas de deslocamento
Circuito Integrado 74HC595N	1	Registrador de deslocamento de 8 bits (DIP-16)
LEDs difusos vermelhos de 5 mm	8	Dispositivos emissores de luz individuais
Resistores de filme de carbono 220 Ω (1/4W)	8	Limitadores de corrente para cada LED
Matriz de contatos (Breadboard 830 furos)	1	Base para montagem do circuito integrado
Cabos jumper flexíveis	16	Conexões de dados, controle e ânodos

Tabela de Conexões Elétricas

Pino do CI 74HC595	Nome do Pino	Conexão no Circuito	Função Elétrica
Pino 16 ($V_{CC}$)	Tensão de Alimentação	Pino 5V do Arduino	Alimentação lógica contínua
Pino 8 (GND)	Terra	Pino GND do Arduino	Referência de 0V
Pino 10 ($\overline{MR}$)	Reset Mestre	Barramento 5V (+5V)	Mantém o registrador ativo (ativo em nível baixo)
Pino 13 ($\overline{OE}$)	Habilitação de Saída	Barramento GND (0V)	Habilita as saídas de potência tri-state
Pino 14 (DS / Data)	Entrada de Dados Serial	Pino Digital D12 do Arduino	Envio de bits seriais
Pino 11 (SH_CP / Clock)	Pulso de Clock de Deslocamento	Pino Digital D9 do Arduino	Sincroniza cada bit transmitido
Pino 12 (ST_CP / Latch)	Pulso de Trava de Saída	Pino Digital D11 do Arduino	Transfere os 8 bits para as saídas
Pinos 15, 1, 2, 3, 4, 5, 6, 7	Saídas Paralelas $Q_0 \dots Q_7$	Resistores 220 Ω $\to$ ânodos dos LEDs	Saídas independentes para os 8 LEDs
Cátodos dos 8 LEDs	Linha Comum	Barramento GND do Arduino	Retorno ao terra de referência

Código-Fonte Oficial Comentado

// Licao 21: Controle sequencial de 8 LEDs com registrador de deslocamento 74HC595
int tDelay = 100;     // Tempo de retardo em milissegundos entre animacoes
int latchPin = 11;   // Conectado ao pino ST_CP (pino 12) do 74HC595
int clockPin = 9;    // Conectado ao pino SH_CP (pino 11) do 74HC595
int dataPin = 12;    // Conectado ao pino DS (pino 14) do 74HC595

byte leds = 0; // Variavel de 8 bits (byte) contendo o estado binario dos 8 LEDs

// Funcao que transfere a variavel byte para o CI e atualiza os pinos fisicos
void updateShiftRegister() {
  digitalWrite(latchPin, LOW); // Coloca a trava em nivel baixo para liberar a recepcao serial
  shiftOut(dataPin, clockPin, MSBFIRST, leds); // Transmite os 8 bits (do mais significativo ao menos)
  digitalWrite(latchPin, HIGH); // Aplica borda de subida na trava, atualizando os 8 LEDs de uma vez
}

void setup() {
  // Configura os tres pinos de comunicacao serial como saidas digitais
  pinMode(latchPin, OUTPUT);
  pinMode(dataPin, OUTPUT);  
  pinMode(clockPin, OUTPUT);
}

void loop() {
  leds = 0; // Zera todos os bits (apaga todos os LEDs)
  updateShiftRegister();
  delay(500);
  
  // Animacao 1: Efeito sequencial acendendo LED por LED (Barra de progresso)
  for (int i = 0; i < 8; i++) {
    bitSet(leds, i); // Seta o bit i para nivel logico 1
    updateShiftRegister();
    delay(tDelay);
  }
  
  // Animacao 2: Efeito sequencial apagando LED por LED
  for (int i = 0; i < 8; i++) {
    bitClear(leds, i); // Seta o bit i para nivel logico 0
    updateShiftRegister();
    delay(tDelay);
  }
  
  // Animacao 3: Efeito de vai-e-vem ("Knight Rider" / Carro Fantasma)
  for (int i = 0; i < 8; i++) {
    leds = (1 << i); // Desloca um unico bit ativo para a posicao i
    updateShiftRegister();
    delay(tDelay);
  }
  for (int i = 6; i >= 1; i--) {
    leds = (1 << i);
    updateShiftRegister();
    delay(tDelay);
  }
}

Gravação e Procedimento de Teste

1. Encaixe o CI 74HC595 atravessando o canal central divisor da protoboard, atentando para a meia-lua de chanfro indicadora do pino 1 no topo à esquerda.
2. Conecte os 8 resistores de 220 Ω entre as saídas $Q_0 \dots Q_7$ e os ânodos dos 8 LEDs vermelhos, fechando os cátodos no barramento de terra (GND).
3. Ligue as linhas de controle ao Arduino: Latch em D11, Clock em D9 e Data em D12.
4. Carregue o sketch para a placa Arduino Uno R3.
5. Resultado Esperado: Os 8 LEDs executarão uma sequência de efeitos visuais dinâmicos (preenchimento progressivo, esvaziamento e oscilação de corrida tipo vai-e-vem) com sincronismo perfeito e total estabilidade luminosa, demonstrando a versatilidade dos registradores de deslocamento serial-paralelo.

---

Lição 22: Controle Interativo de LEDs pelo Monitor Serial

A Lição 22 estuda a integração bidirecional entre comandos textuais digitados pelo operador no computador e o acionamento físico de atuadores, combinando a leitura de caracteres da interface UART com a expansão de saídas através do registrador 74HC595.

Protocolo de Recepção Serial Assíncrona e Buffer Circular

O microcontrolador ATmega328P possui um registrador de dados USART (UDR0) e um buffer circular de recepção em memória SRAM gerenciado por interrupções com capacidade para 64 bytes. A função Serial.available() retorna a quantidade de bytes pendentes de leitura no buffer:

if (Serial.available() > 0) {
  char ch = Serial.read(); // Extrai o proximo caractere ASCII da fila
}

Na tabela ASCII padrão, os caracteres numéricos '0' a '7' possuem códigos hexadecimais de 0x30 a 0x37. Para converter o caractere recebido no índice numérico inteiro correspondente de 0 a 7, aplica-se a subtração aritmética simples:

$$\text{índice} = ch - \text{'0'}$$

O firmware inverte o estado lógico do bit selecionado utilizando o operador de ou-exclusivo bit a bit (XOR):

$$\text{leds} = \text{leds} \oplus (1 \ll \text{índice})$$

atualizando o registrador de deslocamento imediatamente através da função shiftOut().

Componentes Necessários

Componente	Quantidade	Descrição / Observação
Placa compatível Arduino Uno R3	1	Processa comandos seriais da porta USB
Circuito Integrado 74HC595N	1	Registrador de deslocamento de 8 bits
LEDs difusos vermelhos de 5 mm	8	Matriz de 8 pontos de saída
Resistores de 220 Ω (1/4W)	8	Limitadores de corrente para cada LED
Matriz de contatos (Breadboard 830 furos)	1	Base para fixação do circuito
Cabos jumper flexíveis	16	Conexões de dados, controle e ânodos

Tabela de Conexões Elétricas

Pino do 74HC595	Conexão no Arduino	Função Elétrica
Pino 14 (DS / Data)	Pino Digital D12 do Arduino	Entrada de dados serial
Pino 11 (SH_CP / Clock)	Pino Digital D9 do Arduino	Pulso de clock de deslocamento
Pino 12 (ST_CP / Latch)	Pino Digital D11 do Arduino	Pulso de trava de saída (Latch)
Pino 16 ($V_{CC}$) e Pino 10 ($\overline{MR}$)	Barramento 5V (+5V)	Alimentação lógica e desativação de reset
Pino 8 (GND) e Pino 13 ($\overline{OE}$)	Barramento GND (0V)	Referência de terra e habilitação de saídas
Saídas $Q_0 \dots Q_7$	Resistores 220 Ω $\to$ LEDs 0 a 7	Acionamento independente dos 8 LEDs

Código-Fonte Oficial Comentado

// Licao 22: Controle interativo dos 8 LEDs via comandos no Monitor Serial
int latchPin = 11; // Conectado ao pino ST_CP (pino 12) do 74HC595
int clockPin = 9;  // Conectado ao pino SH_CP (pino 11) do 74HC595
int dataPin = 12;  // Conectado ao pino DS (pino 14) do 74HC595

byte leds = 0; // Armazena o estado binario consolidado dos 8 LEDs (0 = apagado, 1 = aceso)

// Funcao que carrega o byte leds no registrador 74HC595
void updateShiftRegister() {
  digitalWrite(latchPin, LOW); // Libera o registrador para receber bits seriais
  shiftOut(dataPin, clockPin, MSBFIRST, leds); // Envia os 8 bits
  digitalWrite(latchPin, HIGH); // Atualiza os pinos de saida
}

void setup() {
  pinMode(latchPin, OUTPUT);
  pinMode(dataPin, OUTPUT);  
  pinMode(clockPin, OUTPUT);
  
  updateShiftRegister(); // Garante todos os LEDs desligados na inicializacao
  
  Serial.begin(9600); // Inicializa a comunicacao serial na taxa padrao de 9600 bps
  Serial.println("==================================================");
  Serial.println("Licao 22: Controle Interativo dos 8 LEDs via Serial");
  Serial.println("Digite um numero de 0 a 7 para alternar o LED...");
  Serial.println("==================================================");
}

void loop() {
  // Verifica se ha algum caractere recebido da porta USB aguardando processamento
  if (Serial.available()) {
    char ch = Serial.read(); // Extrai o caractere
    
    // Se o caractere digitado for um digito valido entre '0' e '7'
    if (ch >= '0' && ch <= '7') {
      int led = ch - '0'; // Converte o caractere ASCII no indice inteiro (0 a 7)
      
      // Inverte o estado do bit selecionado atraves da operacao XOR (ou-exclusivo)
      bitWrite(leds, led, !bitRead(leds, led));
      
      updateShiftRegister(); // Envia o novo byte atualizado para o 74HC595
      
      // Informa o status da comutacao no Monitor Serial
      Serial.print("LED ");
      Serial.print(led);
      Serial.print(" agora esta: ");
      Serial.println(bitRead(leds, led) ? "LIGADO [ON]" : "DESLIGADO [OFF]");
    }
  }
}

Gravação e Procedimento de Teste

1. Mantenha a mesma montagem física de 8 LEDs com o CI 74HC595 da Lição 21.
2. Carregue o sketch da Lição 22 e abra o Monitor Serial configurado a 9600 baud.
3. Na caixa de texto superior do Monitor Serial, digite 0 e pressione a tecla Enter. O LED 0 acenderá imediatamente e a mensagem LED 0 agora esta: LIGADO [ON] será exibida.
4. Digite sucessivamente 2, 4, 6 para acender os LEDs pares, e em seguida digite 0 novamente para apagar o primeiro LED, validando o controle bidirecional assíncrono.

---

Lição 23: Sensor óptico de Detecção de Chama (Flame Sensor) com Alarme Sonoro

A Lição 23 aborda a instrumentação de segurança contra incêndios através de um sensor óptico de chama baseado em fototransistor de infravermelho de alta sensibilidade, ativando um alarme sonoro de emergência com buzzer quando uma fonte de combustão é detectada.

Espectro óptico da Combustão e Princípio do Fototransistor

A reação química de queima de hidrocarbonetos e compostos orgânicos emite um espectro característico de radiação eletromagnética com pico de emissão na faixa do infravermelho próximo (NIR — Near-Infrared), entre 760 nm e 1100 nm, resultante da transição eletrônica de moléculas excitadas de vapor d’água ($H_2O$) e dióxido de carbono ($CO_2$).

O sensor de chama do kit é um fototransistor semicondutor de silício com filtro de resina preta que bloqueia a maior parte da luz visível e permite a passagem seletiva dos fótons de radiação infravermelha:

• Na escuridão ou ausência de chama, a corrente de fuga do semicondutor é mínima ($I_C \approx 0$).
• Quando fótons infravermelhos da chama atingem a junção base-coletor, elétrons são liberados pelo efeito fotoelétrico, gerando uma corrente fototransistorizada que comuta o dispositivo e derruba sua resistência.

Montado em topologia de divisor de tensão, a leitura no canal analógico A0 cai drasticamente com a proximidade do fogo:

• Sem chama (repouso): leitura analógica alta ($ADC > 800$).
• Presença de chama próxima: leitura analógica baixa ($ADC < 200$).

Componentes Necessários

Componente	Quantidade	Descrição / Observação
Placa compatível Arduino Uno R3	1	Monitora o canal analógico e dispara alarme
Sensor óptico de Chama (Fototransistor IR)	1	Sensível a comprimentos de onda de 760 nm a 1100 nm
Buzzer Piezoelétrico Ativo ou Passivo	1	Emissor sonoro de alerta de incêndio
Resistor de filme de carbono 10 kΩ (1/4W)	1	Resistor de polarização do divisor de tensão
Matriz de contatos e cabos jumper	6	Conexões físicas do circuito

Tabela de Conexões Elétricas

Componente / Terminal	Conexão no Arduino	Função Elétrica
Sensor de Chama (Terminal Curto / Chanfro)	Barramento 5V (+5V)	Conexão positiva de alimentação
Sensor de Chama (Terminal Longo)	Pino Analógico A0 e Resistor 10 kΩ	Ponto central do divisor de tensão
Resistor de Polarização (10 kΩ)	Barramento GND (0V)	Resistor de pull-down para o terra
Buzzer Positivo (+)	Pino Digital D9 do Arduino	Saída digital para disparo do alarme sonoro
Buzzer Negativo (-)	Barramento GND (0V)	Retorno ao terra de referência

Código-Fonte Oficial Comentado

// Licao 23: Sistema de deteccao de chama com sensor optico e alarme sonoro
int flame = 0; // Define o canal analogico A0 conectado ao sensor de chama
int Beep = 9;  // Define o pino digital D9 para acionamento do buzzer de alerta
int val = 0;   // Variavel para armazenar a leitura bruta do ADC (0 a 1023)

void setup() {
  pinMode(Beep, OUTPUT); // Configura o pino do buzzer como saida digital
  pinMode(flame, INPUT);  // Configura a porta A0 como entrada de medicao
  Serial.begin(9600);    // Inicializa comunicacao serial para monitoramento
  Serial.println("Licao 23: Monitor de Seguranca contra Incendio Inicializado!");
}

void loop() {
  // Realiza a leitura analogica de 10 bits da intensidade de radiacao infravermelha
  val = analogRead(flame);
  
  // Imprime o valor bruto lido no Monitor Serial para calibracao do limiar
  Serial.print("Nivel de Radiacao IR (A0): ");
  Serial.println(val);
  
  // Limiar de seguranca: se a leitura cair abaixo de 600, ha deteccao confirmada de chama
  if (val < 600) {
    // Emite tom sonoro continuo de alarme de emergencia
    digitalWrite(Beep, HIGH);
    Serial.println(">>> ALERTA CRITICO: Fogo / Chama Detectada! <<<");
  } else {
    // Mantem o buzzer silencioso sob condicoes normais e seguras
    digitalWrite(Beep, LOW);
  }
  
  // Intervalo de 200 milissegundos entre varreduras
  delay(200);
}

Gravação e Procedimento de Teste

1. Monte o sensor de chama na protoboard com o resistor de pull-down de $10\,\text{k}\Omega$ e conecte o buzzer ao pino D9.
2. Carregue o sketch e abra o Monitor Serial.
3. Sob a luz ambiente normal da sala, a leitura permanecerá alta (entre 800 e 950) e o buzzer ficará em silêncio.
4. Acenda um isqueiro ou fósforo a uma distância segura de cerca de 30 a 50 cm do fototransistor (ou aponte um controle remoto infravermelho diretamente para o sensor pressionando qualquer botão para teste sem fogo).
5. Resultado Esperado: A leitura despencará bruscamente para valores abaixo de 200 e o buzzer disparará um alarme sonoro estridente contínuo até que a fonte de combustão seja afastada.

---

Lição 24: Fotocélula LDR e Barra de LEDs com Registrador 74HC595

A Lição 24 estuda a transdução fotoelétrica da luz ambiente através de um resistor dependente de luz (LDR — Light Dependent Resistor) e a visualização dinâmica do nível de iluminamento em formato de bargraph analógico de 8 LEDs acionado pelo chip 74HC595.

Física do LDR e Efeito Fotocondutivo

O fotorresistor LDR é fabricado com uma fina camada semicondutora de Sulfeto de Cádmio (CdS) disposta em padrão geométrico de serpentina para maximizar a área de contato. Quando fótons de luz visível com energia superior ao bandgap do material ($E_{FOTON} = h u > E_g$) atingem o semicondutor, elétrons saltam da banda de valência para a banda de condução, gerando pares elétron-lacuna livres:

$$R_{LDR} = \frac{A}{E^{\gamma}}$$

onde $E$ é a iluminância em Lux e $\gamma$ é o expoente característico de sensibilidade do CdS (tipicamente $0{,}7 \le \gamma \le 0{,}9$):

• Na escuridão total, $R_{LDR}$ atinge valores superiores a $1{,}0\,\text{M}\Omega$.
• Sob iluminação solar direta ou lâmpada forte, $R_{LDR}$ decai para menos de $100\,\Omega$ a $1\,\text{k}\Omega$.

Montado em série com um resistor de precisão fixo de $10\,\text{k}\Omega$ formando um divisor de tensão conectado ao canal A0, a tensão de saída é linearizada e mapeada pela função map() em uma escala de 0 a 8 segmentos de LED ativos na barra iluminada.

Componentes Necessários

Componente	Quantidade	Descrição / Observação
Placa compatível Arduino Uno R3	1	Unidade de conversão ADC e controle serial
Sensor Fotoelétrico LDR (CdS 5 mm)	1	Resistor dependente de luz de alta sensibilidade
Resistor de filme de carbono 10 kΩ (1/4W)	1	Resistor de referência para o divisor de tensão
Circuito Integrado 74HC595N	1	Expansor de portas serial-paralelo de 8 bits
LEDs difusos vermelhos de 5 mm	8	Formam a escala de bargraph proporcional
Resistores de 220 Ω (1/4W)	8	Limitadores de corrente para os LEDs
Matriz de contatos e jumpers flexíveis	1	Montagem completa do sistema

Tabela de Conexões Elétricas

Componente / Terminal	Conexão no Circuito	Função Elétrica
LDR (Terminal 1)	Barramento 5V (+5V)	Alimentação positiva do sensor fotométrico
LDR (Terminal 2)	Pino Analógico A0 e Resistor 10 kΩ	Tensão analógica proporcional à luz ambiente
Resistor de 10 kΩ	Barramento GND (0V)	Resistor de pull-down para o terra
CI 74HC595 (Pinos 11, 12, 14)	Pinos Digitais D9, D11, D12 do Arduino	Linhas de Clock, Latch e Dados seriais
CI 74HC595 (Saídas $Q_0 \dots Q_7$)	Resistores 220 Ω $\to$ ânodos dos 8 LEDs	Barra visual de 8 níveis luminosos

Código-Fonte Oficial Comentado

// Licao 24: Medicao fotometrica com LDR e exibicao em barra de LEDs via 74HC595
int lightPin = 0;   // Pino analogico A0 conectado ao divisor com sensor LDR
int latchPin = 11;  // Pino ST_CP do 74HC595 conectado ao D11
int clockPin = 9;   // Pino SH_CP do 74HC595 conectado ao D9
int dataPin = 12;   // Pino DS do 74HC595 conectado ao D12

int leds = 0; // Mascara de bits para os 8 LEDs

// Funcao que atualiza o CI registrador com o novo padrao binario
void updateShiftRegister() {
  digitalWrite(latchPin, LOW);
  shiftOut(dataPin, clockPin, MSBFIRST, leds);
  digitalWrite(latchPin, HIGH);
}

void setup() {
  pinMode(latchPin, OUTPUT);
  pinMode(dataPin, OUTPUT);  
  pinMode(clockPin, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  // Realiza a leitura analogica do nivel de iluminacao ambiente (0 a 1023)
  int reading = analogRead(lightPin);
  
  // Mapeia o valor bruto lido na faixa de 0 a 8 LEDs acesos
  int numLEDSLit = map(reading, 200, 800, 0, 8);
  numLEDSLit = constrain(numLEDSLit, 0, 8); // Garante que o valor fique estritamente entre 0 e 8
  
  // Monta a barra progressiva de bits ativos: ex: se numLEDSLit = 3, leds = B00000111
  leds = 0;
  for (int i = 0; i < numLEDSLit; i++) {
    leds |= (1 << i);
  }
  
  updateShiftRegister(); // Atualiza a barra de LEDs imediatamente
  
  Serial.print("Leitura LDR (ADC): ");
  Serial.print(reading);
  Serial.print(" | LEDs Acesos: ");
  Serial.println(numLEDSLit);
  
  delay(100);
}

Gravação e Procedimento de Teste

1. Monte o circuito mantendo a fiação dos 8 LEDs no 74HC595 e inserindo o LDR com resistor de $10\,\text{k}\Omega$ no canal A0.
2. Carregue o sketch para a placa Arduino Uno R3.
3. Cubra o sensor LDR completamente com a ponta do dedo para simular escuridão total. Todos os 8 LEDs da barra se apagarão.
4. Retire o dedo gradualmente e aponte a lanterna do celular em direção ao LDR.
5. Resultado Esperado: Os 8 LEDs acenderão progressivamente um a um como um medidor de potência ótica (vu-meter luminoso), proporcionalmente à intensidade de fótons incidentes na célula de CdS.

---

Lição 25: Display de 7 Segmentos de 1 Dígito com Registrador 74HC595

A Lição 25 aborda a síntese de algarismos numéricos decimais através de um display de 7 segmentos de 1 dígito operando em conjunto com o registrador de deslocamento 74HC595, demonstrando como renderizar caracteres sem consumir 8 portas digitais diretas do microcontrolador.

Estrutura Topológica do Display e Mapeamento Binário

Um display numérico de 7 segmentos reúne internamente 8 diodos emissores de luz individuais encapsulados em formato de barras: sete segmentos identificados convencionalmente pelas letras minúsculas a, b, c, d, e, f, g e um ponto decimal (DP — Decimal Point).

No display de Cátodo Comum (padrão utilizado no kit):

• Todos os cátodos de todos os 8 LEDs internos são unidos eletricamente em um pino comum aterrado no GND.
• Para acender qualquer segmento, basta aplicar nível lógico alto (+5 V) no Ânodo individual correspondente através de um resistor limitador de corrente.

As saídas $Q_0 \dots Q_7$ do CI 74HC595 são conectadas aos segmentos $a, b, c, d, e, f, g$ e $DP$. O padrão em bytes para cada algarismo de 0 a 9 é consolidado em uma tabela constante:

Algarismo	Segmentos Acesos	Representação Binária (MSB: a, b, c, d, e, f, g, DP)	Valor Hexadecimal
0	a, b, c, d, e, f	B11111100	0xFC
1	b, c	B01100000	0x60
2	a, b, d, e, g	B11011010	0xDA
3	a, b, c, d, g	B11110010	0xF2
4	b, c, f, g	B01100110	0x66
5	a, c, d, f, g	B10110110	0xB6
6	a, c, d, e, f, g	B10111110	0xBE
7	a, b, c	B11100000	0xE0
8	a, b, c, d, e, f, g	B11111110	0xFE
9	a, b, c, d, f, g	B11110110	0xF6

Componentes Necessários

Componente	Quantidade	Descrição / Observação
Placa compatível Arduino Uno R3	1	Gera os trens de clock e dados seriais
Circuito Integrado 74HC595N	1	Registrador serial-paralelo de 8 bits
Display de 7 segmentos de 1 dígito	1	Modelo Cátodo Comum com ponto decimal
Resistores de filme de carbono 220 Ω (1/4W)	8	Limitadores de corrente para cada segmento
Matriz de contatos e cabos jumper flexíveis	1	Interligação da bancada de testes

Tabela de Conexões Elétricas

Pino do 74HC595	Segmento do Display	Pino Físico do Display	Corrente Limitada
Saída $Q_0$ (Pino 15)	Segmento a (barra superior)	Pino 7	Resistor 220 Ω em série
Saída $Q_1$ (Pino 1)	Segmento b (superior direito)	Pino 6	Resistor 220 Ω em série
Saída $Q_2$ (Pino 2)	Segmento c (inferior direito)	Pino 4	Resistor 220 Ω em série
Saída $Q_3$ (Pino 3)	Segmento d (barra inferior)	Pino 2	Resistor 220 Ω em série
Saída $Q_4$ (Pino 4)	Segmento e (inferior esquerdo)	Pino 1	Resistor 220 Ω em série
Saída $Q_5$ (Pino 5)	Segmento f (superior esquerdo)	Pino 9	Resistor 220 Ω em série
Saída $Q_6$ (Pino 6)	Segmento g (barra central)	Pino 10	Resistor 220 Ω em série
Saída $Q_7$ (Pino 7)	Ponto Decimal (DP)	Pino 5	Resistor 220 Ω em série
Pinos 3 e 8 do Display	Cátodo Comum (COM)	Pino GND do Arduino	Retorno ao terra de referência

Código-Fonte Oficial Comentado

// Licao 25: Contador decimal de 0 a 9 em display de 7 segmentos com 74HC595
int latchPin = 11; // Conectado ao pino ST_CP do 74HC595
int clockPin = 9;  // Conectado ao pino SH_CP do 74HC595
int dataPin = 12;  // Conectado ao pino DS do 74HC595

// Vetor com os 10 padroes binarios para os algarismos de 0 a 9 (catodo comum)
byte seven_seg_digits[10] = {
  B11111100,  // Algarismo 0
  B01100000,  // Algarismo 1
  B11011010,  // Algarismo 2
  B11110010,  // Algarismo 3
  B01100110,  // Algarismo 4
  B10110110,  // Algarismo 5
  B10111110,  // Algarismo 6
  B11100000,  // Algarismo 7
  B11111110,  // Algarismo 8
  B11110110   // Algarismo 9
};

// Funcao auxiliar para gravacao do padrao no display
void postNumber(byte number) {
  digitalWrite(latchPin, LOW);
  shiftOut(dataPin, clockPin, MSBFIRST, number);
  digitalWrite(latchPin, HIGH);
}

void setup() {
  pinMode(latchPin, OUTPUT);
  pinMode(dataPin, OUTPUT);  
  pinMode(clockPin, OUTPUT);
}

void loop() {
  // Conta sequencialmente de 0 ate 9 em passos de 1 segundo
  for (byte digit = 0; digit < 10; digit++) {
    postNumber(seven_seg_digits[digit]); // Envia o padrao binario correspondente
    delay(1000);                         // Mantem o digito estavel por 1 segundo
  }
}

Gravação e Procedimento de Teste

1. Encaixe o display de 7 segmentos de 1 dígito na protoboard e ligue seus pinos de cátodo comum (pinos centrais 3 e 8) ao GND.
2. Interligue as saídas $Q_0 \dots Q_7$ do 74HC595 aos segmentos com resistores limitadores de 220 Ω.
3. Carregue o sketch para o Arduino Uno R3.
4. Resultado Esperado: O display iniciará a contagem progressiva exibindo os dígitos 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 com cadência de exatamente 1 segundo por número, repetindo o ciclo continuamente.

---

Lição 26: Display de 7 Segmentos de 4 Dígitos Multiplexado com 74HC595

A Lição 26 eleva a densidade de informação visual demonstrando o acionamento de um display numérico de 7 segmentos de 4 dígitos multiplexados por divisão temporal, integrando a decodificação hexadecimal através do registrador de deslocamento 74HC595.

Princípio de Multiplexação de Dígitos por Ânodo/Cátodo Comum

Um display de 4 dígitos possui $4 \times 8 = 32$ diodos emissores de luz internos. Para evitar um componente com 32 pinos, o fabricante interliga internamente todos os segmentos homólogos de todos os dígitos em paralelo (todos os segmentos ‘a’ juntos, todos os ‘b’ juntos, etc.), disponibilizando apenas 12 terminais no encapsulamento: 8 linhas de segmentos ($a, b, c, d, e, f, g, DP$) e 4 linhas de seleção de dígitos ($D_1, D_2, D_3, D_4$).

O CI 74HC595 atua como o decodificador de barramento de dados dos 8 segmentos. O algoritmo permite exibir contadores ou números de múltiplos dígitos multiplexando a habilitação dos cátodos de cada dígito em alta velocidade ($f > 60\,\text{Hz}$):

1. O microcontrolador envia para o 74HC595 o padrão do primeiro dígito e ativa o pino $D_1$.
2. Aguarda-se um intervalo infinitesimal ($t \approx 2\,\text{ms}$).
3. Desativa-se $D_1$, carrega-se o padrão do segundo dígito e ativa-se $D_2$.
4. Repete-se o processo para $D_3$ e $D_4$. Graças à persistência visual humana, os 4 algarismos parecem estar acesos simultaneamente sem cintilação.

O vetor de dados da fabricante expande a contagem para além do sistema decimal, abrangendo toda a base hexadecimal de 0 a F:

0x3f (0), 0x06 (1), 0x5b (2), 0x4f (3), 0x66 (4), 0x6d (5), 0x7d (6), 0x07 (7),
0x7f (8), 0x6f (9), 0x77 (A), 0x7c (b), 0x39 (C), 0x5e (d), 0x79 (E), 0x71 (F)

Componentes Necessários

Componente	Quantidade	Descrição / Observação
Placa compatível Arduino Uno R3	1	Unidade geradora de clock e sinais de controle
Display de 7 segmentos de 4 dígitos	1	Modelo multiplexado com 12 terminais
Circuito Integrado 74HC595N	1	Registrador de deslocamento de 8 bits
Resistores de filme de carbono 220 Ω (1/4W)	8	Limitadores de corrente para os segmentos
Matriz de contatos e jumpers flexíveis	1	Base e fiação para interconexão

Tabela de Conexões Elétricas

Terminal do Circuito	Pino no 74HC595 / Arduino	Função Elétrica
Linha de Dados (DS / Data)	Pino Digital D8 do Arduino	Envia o byte com a forma do algarismo
Linha de Latch (ST_CP / Latch)	Pino Digital D9 do Arduino	Atualiza as saídas paralelas do registrador
Linha de Clock (SH_CP / Clock)	Pino Digital D10 do Arduino	Sincroniza cada bit de deslocamento
Saídas $Q_0 \dots Q_7$ do 74HC595	Resistores 220 Ω $\to$ Segmentos a-g + DP	Fornece corrente positiva aos ânodos dos segmentos
Seletores de Dígitos ($D_1 \dots D_4$)	Barramento GND (ou pinos de controle)	Habilita os cátodos dos dígitos ativos

Código-Fonte Oficial Comentado

// Licao 26: Exibicao hexadecimal completa (0 a F) em display multiplexado com 74HC595
int data = 8;   // Pino DS (Data Serial, pino 14 do 74HC595) conectado ao D8
int latch = 9;  // Pino ST_CP (Storage Clock / Latch, pino 12) conectado ao D9
int clock = 10; // Pino SH_CP (Shift Clock, pino 11) conectado ao D10

// Tabela constante em memoria contendo os padroes binarios para 0 a F e tela apagada
unsigned char table[] = {
  0x3f, // Caractere '0'
  0x06, // Caractere '1'
  0x5b, // Caractere '2'
  0x4f, // Caractere '3'
  0x66, // Caractere '4'
  0x6d, // Caractere '5'
  0x7d, // Caractere '6'
  0x07, // Caractere '7'
  0x7f, // Caractere '8'
  0x6f, // Caractere '9'
  0x77, // Caractere 'A'
  0x7c, // Caractere 'b'
  0x39, // Caractere 'C'
  0x5e, // Caractere 'd'
  0x79, // Caractere 'E'
  0x71, // Caractere 'F'
  0x00  // Display apagado
};

// Funcao que carrega o codigo do caractere no registrador 74HC595
void Display(unsigned char num) {
  digitalWrite(latch, LOW); // Libera o buffer para novos dados
  shiftOut(data, clock, MSBFIRST, table[num]); // Envia o byte da tabela
  digitalWrite(latch, HIGH); // Atualiza os segmentos fisicos
}

void setup() {
  pinMode(latch, OUTPUT);
  pinMode(clock, OUTPUT);
  pinMode(data, OUTPUT);
}

void loop() {
  // Percorre sequencialmente todos os 15 simbolos hexadecimais (1 a 15)
  for (int i = 1; i <= 15; i++) {
    Display(i); // Exibe o caractere atual
    delay(500); // Mantem estavel por 500 milissegundos
  }
}

Gravação e Procedimento de Teste

1. Conecte o display de 4 dígitos na protoboard interligando os segmentos às saídas do 74HC595 com resistores de 220 Ω e aterre os pinos dos dígitos comuns que deseja ativar.
2. Ligue as linhas de controle ao Arduino: Data em D8, Latch em D9 e Clock em D10.
3. Carregue o sketch para a placa Arduino Uno R3.
4. Resultado Esperado: O display iniciará uma contagem contínua e límpida apresentando todos os algarismos da base hexadecimal (1, 2, 3, 4, 5, 6, 7, 8, 9, A, b, C, d, E, F) a cada meio segundo.

---

Lição 27: Módulo Relé de 1 Canal para Comutação de Cargas de Potência

A Lição 27 estuda o isolamento galvânico e a interface de potência entre circuitos digitais de controle de baixa tensão (5V/microamperes) e cargas industriais de alta tensão ou corrente contínua/alternada (12V, 24V ou rede elétrica CA), utilizando o Módulo Relé Eletromecânico de 1 Canal.

Eletromagnetismo, Isolamento óptico e Diodo Flyback

Um microcontrolador ATmega328P é incapaz de acionar diretamente a bobina indutiva de um relé mecânico, pois a bobina drena entre 70 mA e 100 mA de corrente (muito acima do limite seguro de 20 mA de um pino GPIO) e gera tensões reversas destrutivas por indução ao ser desligada.

O módulo relé resolve esse desafio integrando três proteções fundamentais:

1. Isolamento Galvânico por Optoacoplador: O sinal do Arduino aciona apenas um diodo emissor infravermelho interno selado em uma cápsula óptica. Não há contato elétrico direto entre a terra lógica do microcontrolador e o circuito da carga externa, blindando o Arduino contra picos de surto e ruídos transientes.
2. Transistor Driver de Corrente: O fototransistor receptor polariza um transistor bipolar de potência que chaveia a corrente de 70 mA necessária para a bobina de 5 V.
3. Diodo de Roda-Livre (Flyback Diode): Conectado em antiparalelo com a bobina. Conforme a Lei de Lenz-Faraday, no instante exato em que a corrente da bobina é cortada bruscamente, o colapso do campo magnético gera um pico indutivo reverso:

$$V_L = -L \frac{di}{dt}$$

Sem o diodo flyback, esse pico de tensão poderia ultrapassar centenas de volts e queimar os transistores. O diodo conduz e dissipa essa energia magneticamente recirculando a corrente com segurança.

Os terminais de saída a parafuso oferecem três contatos:

• COM (Comum): Ponto de entrada de alimentação da carga.
• NA / NO (Normalmente Aberto): Aberto em repouso; fecha quando o relé é acionado.
• NF / NC (Normalmente Fechado): Fechado em repouso; abre quando o relé é acionado.

Componentes Necessários

Componente	Quantidade	Descrição / Observação
Placa compatível Arduino Uno R3	1	Gera o sinal lógico de comando
Módulo Relé de 1 Canal (5V com optoacoplador)	1	Capacidade de chaveamento: até 10A / 250VAC ou 10A / 30VDC
Cabos jumper flexíveis	3	Conexão para VCC, GND e IN

Tabela de Conexões Elétricas

Pino do Módulo Relé	Conexão no Arduino Uno	Função Elétrica
Pino VCC (+)	Pino 5V do Arduino	Alimentação contínua da bobina e do circuito óptico
Pino GND (-)	Pino GND do Arduino	Referência de terra
Pino IN (Sinal de Disparo)	Pino Digital D7	Nível lógico de acionamento do optoacoplador

Código-Fonte Oficial Comentado

// Licao 27: Comutacao eletromecanica periodica com Modulo Rele de 1 canal
const int pinoRele = 7; // Pino digital 7 conectado a entrada de comando IN do rele

void setup() {
  // Configura a porta digital 7 como saida digital de controle
  pinMode(pinoRele, OUTPUT);
}

void loop() {
  // Aciona a bobina eletromagnetica do rele
  digitalWrite(pinoRele, HIGH);
  // Mantem a carga comutada (contato NA fechado) durante 1000 milissegundos (1 segundo)
  delay(1000);
  
  // Desenergiza a bobina eletromagnetica do rele
  digitalWrite(pinoRele, LOW);
  // Mantem a carga desativada (contato NA aberto) durante 1000 milissegundos (1 segundo)
  delay(1000);
}

Gravação e Procedimento de Teste

1. Ligue os pinos do módulo relé ao Arduino Uno R3: VCC em 5V, GND em GND e IN em D7.
2. Carregue o sketch para a placa.
3. Observe e ouça o comportamento físico do módulo.
4. Resultado Esperado: O relé emitirá um clique mecânico seco característico a cada 1 segundo em perfeita sincronia com o LED indicador SMD presente na placa do módulo, confirmando o fechamento mecânico e a abertura cíclica dos contatos de potência.

---

Lição 28: Motor de Passo 28BYJ-48 com Driver Darlington ULN2003

A Lição 28 encerra as lições práticas com o projeto de maior complexidade eletromecânica do kit: o controle de posição angular absoluta, velocidade e sentido de rotação de um motor de passo unipolar de 4 fases modelo 28BYJ-48, acionado através de uma placa de potência baseada na matriz de transistores Darlington ULN2003.

Eletromecânica do Motor Unipolar e Redução por Engrenagens

Diferente de um motor DC convencional que gira livremente sem controle de posição, o motor de passo converte pulsos digitais discretos em incrementos angulares mecânicos rigorosamente exatos.

O modelo 28BYJ-48 possui 4 fases magnéticas distribuídas em estator unipolar acionadas em sequência:

• Possui internamente 32 passos elétricos completos por rotação do rotor primário ($11{,}25^{\circ}$ por passo elétrico).
• Possui acoplada uma caixa redutora mecânica de engrenagens de precisão com relação de transmissão nominal de 64:1 (relação real de dentes: $\frac{64}{1} \times \frac{32}{1} = 2048$ passos por volta completa do eixo de saída externo).

O número de passos de comando para completar uma volta de $360^{\circ}$ no eixo de saída é calculado por:

$$\text{Passos por Revolucao} = 32 \times 64 = 2048 \text{ passos}$$ $$\Delta\theta_{PASSO} = \frac{360^{\circ}}{2048} \approx 0{,}17578^{\circ} \text{ por passo}$$

O circuito integrado ULN2003 reúne sete pares de transistores Darlington de alta corrente ($500\,\text{mA}$) e diodos supressores integrados. Quatro LEDs indicadores na placa driver iluminam em tempo real indicando qual das 4 fases ($A, B, C, D$) está energizada a cada instante.

A biblioteca nativa do Arduino Stepper.h inicializa a sequência nas portas digitais na ordem correta de comutação das bobinas:

Stepper myStepper(2048, 8, 10, 9, 11);

📦 Bibliotecas desta lição:

• Stepper.h (Biblioteca nativa do compilador AVR da Arduino IDE).
• Nada a baixar: já vem embutida na instalação padrão do sistema.

Componentes Necessários

Componente	Quantidade	Descrição / Observação
Placa compatível Arduino Uno R3	1	Gera os trens de pulsos de comutação
Motor de Passo Unipolar 28BYJ-48 (5V)	1	Redução interna 64:1, 2048 passos por volta
Placa Driver ULN2003 com 4 LEDs de Fase	1	Matriz Darlington de potência para as bobinas
Cabos jumper flexíveis	6	Conexão de alimentação (5V, GND) e 4 fases lógicas

Tabela de Conexões Elétricas

Entrada da Placa ULN2003	Pino no Arduino Uno	Fase do Motor / LED Indicador
Pino IN1	Pino Digital D8 do Arduino	Fase A do motor de passo (LED A acende)
Pino IN2	Pino Digital D9 do Arduino	Fase B do motor de passo (LED B acende)
Pino IN3	Pino Digital D10 do Arduino	Fase C do motor de passo (LED C acende)
Pino IN4	Pino Digital D11 do Arduino	Fase D do motor de passo (LED D acende)
Pino (+) / VCC da Placa Driver	Pino 5V do Arduino	Alimentação de corrente das bobinas
Pino (-) / GND da Placa Driver	Pino GND do Arduino	Referência comum de terra
Conector Plástico Fêmea de 5 Vias	Encaixe no soquete branco do driver	Conexão mecânica com chave polarizadora

Código-Fonte Oficial Comentado

// Licao 28: Controle angular de precisao com motor de passo 28BYJ-48 e ULN2003
#include <Stepper.h> // Inclui a biblioteca oficial de motores de passo do Arduino

// Define a resolucao total do conjunto motor + caixa de engrenagens
const int stepsPerRevolution = 2048; // 2048 passos necessarios para completar exatamente 360 graus

// Velocidade de rotacao desejada em rotacoes por minuto (RPM)
// Para o 28BYJ-48 a 5V, a faixa estavel e viavel situa-se entre 1 e 17 RPM
const int rolePerMinute = 15; 

// Inicializa a classe Stepper associando os pinos na ordem correta de chaveamento (8, 10, 9, 11)
Stepper myStepper(stepsPerRevolution, 8, 10, 9, 11);

void setup() {
  // Configura a velocidade angular nominal do motor em RPM
  myStepper.setSpeed(rolePerMinute);
  
  // Inicializa a comunicacao serial a 9600 bps para telemetria
  Serial.begin(9600);
  Serial.println("==================================================");
  Serial.println("Licao 28: Motor de Passo 28BYJ-48 Inicializado!");
  Serial.println("Executando ciclos de uma volta completa nos dois sentidos");
  Serial.println("==================================================");
}

void loop() {  
  // Gira o eixo exatamente uma revolucao completa (360 graus) no sentido horario
  Serial.println(">> Movimento: Rotacao de 360 graus no Sentido Horario [CW]");
  myStepper.step(stepsPerRevolution); // Envia 2048 pulsos positivos
  delay(500); // Pausa de meio segundo para estabilizacao inercial mecanica

  // Gira o eixo exatamente uma revolucao completa (360 graus) no sentido anti-horario
  Serial.println(">> Movimento: Rotacao de 360 graus no Sentido Anti-Horario [CCW]");
  myStepper.step(-stepsPerRevolution); // Envia 2048 pulsos com sinal invertido
  delay(500); // Pausa antes de repetir o ciclo
}

Gravação e Procedimento de Teste

1. Encaixe o conector de 5 fios do motor 28BYJ-48 no soquete branco com trava mecânica da placa driver ULN2003.
2. Interligue os pinos lógicos conforme a tabela: IN1 em D8, IN2 em D9, IN3 em D10 e IN4 em D11, além de alimentar VCC em 5V e GND em GND.
3. Fixe uma pequena fita adesiva colorida na ponta chanfrada do eixo do motor para acompanhar visualmente a rotação angular.
4. Carregue o sketch para a placa Arduino Uno R3.
5. Resultado Esperado: Os 4 LEDs vermelhos da placa driver piscarão rapidamente em sequência de onda rotativa. O eixo do motor de passo girará suavemente com torque constante completando uma volta exata de $360^{\circ}$ em sentido horário, fará uma pausa de meio segundo e girará uma volta completa exata de $360^{\circ}$ em sentido anti-horário, demonstrando repetibilidade micrométrica sem perda de passos.

---

Guia Diagnóstico e Resolução de Problemas (Troubleshooting)

Durante a montagem dos circuitos, carregamento de sketches ou testes de bancada com o Kit Avançado de Componentes Eletrônicos Caixa AE001, erros operacionais e anomalias de hardware podem ocorrer. A tabela sistemática a seguir cataloga as 18 principais falhas encontradas em projetos práticos com Arduino Uno R3, detalhando a causa física ou lógica subjacente e o procedimento técnico corretivo passo a passo.

#	Sintoma Observado	Causa Raiz Provável	Procedimento de Ação Corretiva
1	Erro ao carregar sketch: avrdude: stk500_recv(): programmer is not responding	Porta serial COM incorreta, cabo USB apenas de carga ou dispositivos conectados aos pinos D0/D1	1. Verifique se o cabo USB possui linhas de dados (tente outro cabo). 2. Acesse Ferramentas > Porta e confirme a COM da placa. 3. Desconecte temporariamente qualquer cabo ou módulo ligado aos pinos D0 (RX) e D1 (TX) durante o upload.
2	Placa Uno não é reconhecida no Windows (nenhuma porta COM listada)	Ausência do driver USB-Serial CH340G ou cabo USB desconectado	1. Abra o Gerenciador de Dispositivos e procure por um item com exclamação amarela sob Portas ou Outros Dispositivos. 2. Execute o instalador CH341SER.EXE da pasta do kit com privilégios de administrador e clique em INSTALL. 3. Conecte em outra porta USB traseira do computador.
3	Erro de compilação: 'IRrecv' does not name a type na Lição 13	Biblioteca IRremote instalada em versão 3.x ou 4.x incompatível	A versão 3.x/4.x alterou completamente a arquitetura da biblioteca. Abra o Gerenciador de Bibliotecas (Ctrl + Shift + I), busque por IRremote, selecione no menu suspenso a versão 2.8.0 e clique em Instalar, ou instale manualmente o arquivo IRremote.zip fornecido no kit.
4	Erro de compilação: dht_nonblocking.h: No such file or directory na Lição 11	Biblioteca do sensor DHT11 não instalada na pasta de bibliotecas da IDE	Acesse Sketch > Incluir Biblioteca > Gerenciar Bibliotecas..., pesquise por dht_nonblocking de Ole Wolf e clique em Instalar, ou copie a pasta da biblioteca para Documentos/Arduino/libraries/. Reinicie a IDE em seguida.
5	Monitor Serial exibe caracteres ilegíveis, pontos de interrogação ou ruído	Discrepância na taxa de transmissão (baud rate) entre o código e a interface serial	Abra o Monitor Serial e altere o seletor no canto inferior direito para 9600 baud (ou o valor configurado no comando Serial.begin(...) do sketch).
6	LED externo não acende em nenhum momento ao carregar a Lição 3 ou 4	Polaridade invertida do LED ou ausência de resistor limitador	Identifique o terminal longo do LED (Ânodo, positivo) e o terminal curto com chanfro achatado na base plástica (cátodo, negativo/GND). Inverta a posição do componente na protoboard.
7	Display LCD 16x2 I2C acende a luz de fundo azul, mas não exibe nenhum texto	Potenciômetro de contraste traseiro descalibrado ou endereço I2C incorreto	1. Gire vagarosamente o parafuso do trimpot azul localizado na face traseira da placa I2C com uma pequena chave até que as letras brancas apareçam nítidas. 2. Se a tela continuar vazia, altere o endereço de 0x27 para 0x3F no sketch (LiquidCrystal_I2C lcd(0x3F, 16, 2);).
8	Leitor RFID RC522 não detecta nenhuma tag ao aproximar cartões na Lição 19	Módulo conectado erroneamente no pino 5V, pinos SPI trocados ou solda fria	1. Verifique se o VCC está ligado impreterivelmente no pino 3.3V (o chip queima se for ligado em 5V). 2. Confira se MOSI está em D11, MISO em D12, SCK em D13 e SDA em D10. 3. Certifique-se de que a barra de pinos do módulo esteja devidamente soldada à placa.
9	Servomotor SG90 vibra freneticamente, reinicia a placa Uno ou trava no extremo	Queda de tensão (Brownout Reset) causada por pico de corrente do motor na linha USB	Servomotores podem puxar picos de corrente superiores a 500 mA ao acelerar. Conecte um capacitor eletrolítico de $100\,\mu\text{F}$ a $470\,\mu\text{F}$ entre os pinos 5V e GND da protoboard, ou utilize uma fonte de alimentação externa de 5V dedicada com terras (GND) interligados.
10	Motor de passo 28BYJ-48 apenas zune ou vibra sem girar o eixo na Lição 28	Ordem incorreta dos fios de fase na função Stepper ou alimentação insuficiente	Na biblioteca Stepper oficial, os pinos devem ser instanciados na ordem de chaveamento magnético: Stepper myStepper(2048, 8, 10, 9, 11); (note a troca dos pinos centrais 10 e 9). Verifique também se a chave de alimentação do driver ULN2003 está ligada e se os 4 LEDs acendem sequencialmente.
11	Sensor LM35 aquece bruscamente até queimar os dedos ao energizar a Lição 15	Ligação invertida dos pinos de alimentação VCC e GND	Desconecte o cabo USB imediatamente! Olhando o LM35 de frente para a face plana com as gravações de fábrica: Pino 1 (esquerda) = +5V, Pino 2 (centro) = Sinal Analógico A0, Pino 3 (direita) = GND. Deixar o sensor invertido queima a pastilha interna em poucos segundos.
12	Saídas do registrador 74HC595 apresentam comportamento aleatório ou piscam rápido	Pinos de controle $\overline{MR}$ e $\overline{OE}$ flutuando sem nível lógico definido	O pino 10 ($\overline{MR}$) do 74HC595 deve estar obrigatoriamente conectado ao barramento 5V, e o pino 13 ($\overline{OE}$) deve estar conectado ao GND. Pinos de habilitação desconectados deixam as saídas em alta impedância oscilante.
13	Botões push-button geram acionamentos múltiplos ao serem pressionados uma vez	Efeito de repique mecânico das lâminas condutoras internas (Contact Bouncing)	No momento do fechamento, as lâminas metálicas vibram por 5 a 20 ms gerando pulsos repetidos. Adicione um pequeno delay(20); após a detecção de leitura para filtrar o ruído mecânico por software (Debounce).
14	Teclado matricial 4x4 não registra algumas teclas (especialmente colunas externas)	Fita flexível mal inserida ou pinos de linha e coluna invertidos	Verifique se a ordem das 8 vias respeita rigorosamente a sequência de D9 a D2 conforme a tabela de conexões. Certifique-se de que os terminais do conector flat estejam bem encaixados na barra de pinos macho-macho.
15	Sensor de Chama aciona o alarme falso continuamente mesmo no escuro	Limiar de disparo de tensão analógica muito elevado no código	Iluminação fluorescente, telas de TV e lâmpadas incandescentes emitem radiação infravermelha residual. Abra o Monitor Serial para monitorar o valor de repouso em sua sala e ajuste a condição no código (ex.: reduza o limiar de val < 600 para val < 300).
16	Sensor de Nível de água apresenta leituras flutuantes com o recipiente vazio	Umidade residual superficial entre as trilhas de cobre ou trilho flutuante	Seque a lâmina do sensor com papel toalha absorvente. Certifique-se de que o pino GND do módulo esteja solidamente aterrado ao GND do Arduino para fechar o circuito do divisor de tensão.
17	Relógio RTC DS1302 perde a hora ou exibe data 00/00/2000 00:00:00	Bateria tipo moeda ausente, descarregada ou oscilador do cristal desativado	1. Insira uma bateria de lítio CR2025/CR2032 de 3V no soquete. 2. Verifique se o código executa os comandos de destravamento de escrita e habilitação do cristal: Rtc.SetIsWriteProtected(false); e Rtc.SetIsRunning(true);.
18	Módulo Relé não atraca ao enviar nível HIGH pelo pino digital D7	Módulo configurado com acionamento por nível lógico baixo (Active LOW)	Muitos módulos relé comerciais possuem acionamento invertido: atracam com nível lógico LOW (0V) e desligam com HIGH (+5V). Se o seu módulo relé for do tipo Active-LOW, inverta os comandos no código (digitalWrite(pinoRele, LOW); para ligar e HIGH para desligar).

Solução de problemas

Olá! Sou o assistente técnico da RoboBuilders. Descreva seu problema com o Kit Avançado Componentes Eletrônicos Para Arduino Caixa AE001 e eu ajudarei a encontrar a solução.

Enviar

O assistente usa IA e pode errar. Confirme informações críticas no datasheet oficial do fabricante.