Kit Avançado Componentes Eletrônicos Para Arduino Caixa AE086 RB2051 – Curso Completo

Introdução

Este curso apresenta uma formação técnica aprofundada em computação física, sistemas embarcados e instrumentação eletrônica aplicada utilizando a placa microcontroladora Uno DIP 16u2 compatível com Arduino (microcontrolador de 8 bits ATmega328P) e o conjunto oficial KUONGSHUN AE086 — The Most Complete Starter Kit for UNO, distribuído no Brasil pela RoboBuilders sob o modelo RB2051. Ao longo de 34 lições práticas numeradas rigorosamente de 0 a 33, exatamente na ordem estabelecida na documentação técnica do fabricante, o estudante é conduzido desde os fundamentos da lógica digital e montagem em matriz de contatos (breadboard) até subsistemas complexos de automação. São explorados o chaveamento semicondutor, conversores analógico-digitais (ADC — Analog-to-Digital Converter), modulação por largura de pulso (PWM — Pulse Width Modulation), expansores seriais com registradores de deslocamento, barramentos síncronos e assíncronos como UART (Universal Asynchronous Receiver-Transmitter), I2C (Inter-Integrated Circuit) e SPI (Serial Peripheral Interface), transdutores acústicos, sensoriamento ambiental de temperatura e umidade, radiofrequência a 13,56 MHz (RFID — Radio-Frequency Identification), pontes H bipolares para motores de corrente contínua e drivers Darlington para controle vetorial de motores de passo.

Desenvolvido para atender tanto a iniciantes quanto a técnicos, estudantes de engenharia e desenvolvedores de automação, o material adota uma abordagem estritamente experimental baseada em projetos. Cada lição constitui uma unidade didática auto-contida, estruturada segundo o mesmo rigor técnico: fundamentação física do componente e modelagem matemática, tabela de materiais necessários, diagramas esquemáticos e fotos da montagem real em protoboard, mapeamento pino a pino com especificações operacionais, código-fonte em C++ para Arduino comentado linha a linha em português, procedimento sistemático de compilação, carga via bootloader Optiboot e validação de funcionamento, além de alertas de segurança para proteção contra sobrecorrente e inversão de polaridade.

O que você vai aprender:

• Compreender a arquitetura interna do microcontrolador ATmega328P, registradores de porta, temporizadores (Timers 0, 1 e 2) e interfaces seriais UART, I2C e SPI.
• Aplicar a Lei de Ohm e as Leis de Kirchhoff no dimensionamento de resistores limitadores para diodos emissores de luz (LEDs) monocromáticos e RGB.
• Tratar entradas digitais com chaves táteis utilizando circuitos pull-up internos e prevenir instabilidades causadas por ruído mecânico (debouncing).
• Gerar ondas acústicas com buzzers ativos e passivos, manipulando frequências sonoras e ciclos de trabalho via funções nativas e bibliotecas de escala musical.
• Medir distâncias milimétricas com ondas ultrassônicas de 40 kHz através do sensor HC-SR04 e equações de tempo de voo acústico.
• Decodificar pulsos infravermelhos modulados a 38 kHz no protocolo NEC para recepção de comandos a partir de teclados remotos portáteis.
• Expandir as portas de saída do microcontrolador utilizando registradores de deslocamento serial-para-paralelo de 8 bits (74HC595) em cascatas de LEDs e displays numéricos.
• Monitorar e exibir grandezas físicas em tempo real em displays alfanuméricos LCD 1602 em modo paralelo de 4 bits e matrizes de LED 8x8 comandadas pelo CI MAX7219.
• Coletar dados ambientais e inerciais de múltiplos transdutores: temperatura e umidade com DHT11, inclinação mecânica, nível condutivo de água, ruído acústico, termistor NTC e aceleração angular de 6 eixos com o giroscópio MPU6050.
• Autenticar crachás e chaveiros passivos de 13,56 MHz utilizando o transceptor de identificação por radiofrequência MFRC522 no protocolo SPI.
• Controlar atuadores eletromecânicos de precisão: servomotores angulares SG90, motores de corrente contínua com controle bidirecional via ponte H L293D, módulos de relé isolados e motores de passo bipolares com drivers Darlington ULN2003.
• Diagnosticar sistematicamente falhas de comunicação USB, gravação de bootloader, conflitos de barramento I2C/SPI e quedas de tensão no Guia Diagnóstico de Falhas.

Material utilizado: Kit Avançado Componentes Eletrônicos Para Arduino Caixa NFe na loja RoboBuilders

---

Visão Geral do Kit e Arquitetura de Hardware

O kit KUONGSHUN AE086 / RB2051 adota como unidade central de processamento a placa microcontroladora Uno DIP 16u2 compatível com Arduino. Esta plataforma utiliza o microcontrolador ATmega328P da Microchip/Atmel montado em soquete DIP-28 de 28 pinos removível, operando com frequência de clock principal de 16 MHz estabilizada por cristal de quartzo externo. Diferente de versões econômicas que empregam conversores seriais CH340 ou CP2102, a placa Uno DIP 16u2 deste kit integra um microcontrolador secundário ATmega16U2 programado com firmware USB CDC (Communications Device Class), o que garante reconhecimento nativo de alta velocidade no Windows, Linux e macOS sem necessidade de drivers externos não assinados, além de oferecer baixíssima latência de sincronismo DTR para reset automático no processo de upload via bootloader Optiboot.

Especificações Técnicas da Placa Uno DIP 16u2

A tabela abaixo resume os parâmetros elétricos e arquiteturais fundamentais da placa, servindo como referência de projeto para dimensionamento de circuitos de carga e periféricos nas 34 lições:

Parâmetro de Engenharia	Especificação Técnica	Diretrizes Operacionais e Limites Seguros
Microcontrolador Principal	ATmega328P (Arquitetura Harvard AVR RISC 8 bits)	Encapsulamento DIP-28 intercambiável em soquete de precisão
Frequência de Operação (Clock)	16,0 MHz	Gerada por cristal de quartzo externo com tolerância de ±30 ppm
Tensão Lógica de Operação	5,0 VDC (Padrão TTL / CMOS)	Nível lógico HIGH: 4,2 V a 5,0 V; Nível lógico LOW: 0,0 V a 0,8 V
Tensão de Alimentação Recomendada (VIN / Jack P4)	7,0 V a 12,0 VDC	Regulada pelo circuito LDO integrado NCP1117ST50 / AMS1117
Limites Absolutos de Alimentação Externa	6,0 V a 20,0 VDC	Tensões acima de 12 V causam aquecimento térmico acentuado no LDO
Portas de Entrada/Saída Digital (GPIO)	14 pinos (D0 a D13)	Podem ser configuradas como INPUT, OUTPUT ou INPUT_PULLUP
Canais PWM por Hardware	6 pinos (D3, D5, D6, D9, D10 e D11)	Resolução de 8 bits (0 a 255 passos), marcados com símbolo til (~)
Entradas Analógicas com ADC	6 canais dedicados (A0 a A5)	Conversor de aproximações sucessivas de 10 bits (0 a 1023 passos)
Corrente Máxima Contínua por Pino GPIO	20 mA típico (40 mA limite absoluto)	Nunca acionar bobinas de relé ou motores DC diretamente do pino
Corrente Máxima Combinada no VCC / GND	200 mA contínuos	Somatório de todas as portas acionadas simultaneamente
Capacidade da Linha Regulada de 3,3 V	150 mA	Alimentação direta para transceptores como RFID RC522 e MPU6050
Memória de Programa (Flash)	32 KB	0,5 KB ocupados pelo bootloader Optiboot de 115200 bps
Memória Volátil de Dados (SRAM)	2 KB (2048 bytes)	Armazena variáveis globais, pilha de execução e alocação dinâmica
Memória Não-Volátil (EEPROM)	1 KB (1024 bytes)	Retenção permanente de parâmetros e calibrações de sensores
Interface USB-Serial de Comunicação	Microcontrolador ATmega16U2 dedicado	Suporta emulação DFU, porta COM nativa e reprogramação de firmware

Modelagem Matemática Fundamental dos Circuitos

A interpretação precisa de grandezas físicas e a temporização de sinais no curso dependem de relações eletroeletrônicas clássicas. O conversor analógico-digital (ADC) do microcontrolador converte a tensão analógica aplicada a um canal de entrada ($0{,}0\,\text{V} \le V_{IN} \le 5{,}0\,\text{V}$) em uma representação quantizada inteira de 10 bits ($0 \le ADC \le 1023$):

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

Para resistores limitadores de corrente em diodos emissores de luz (LEDs), a tensão nominal da fonte $V_{CC}$ (5,0 V) deve superar a queda de tensão direta de condução da junção semicondutora $V_F$ (aproximadamente 1,8 V a 2,2 V para LEDs vermelhos e amarelos, e 3,0 V a 3,3 V para azuis, verdes e brancos). O resistor $R$ para uma corrente de operação segura $I_F$ (10 mA a 15 mA) é determinado pela Lei de Ohm:

$$R = \frac{V_{CC} - V_F}{I_F}$$

A potência elétrica dissipada no resistor obedece à equação:

$$P_R = (V_{CC} - V_F) \times I_F = \frac{(V_{CC} - V_F)^2}{R}$$

Nas saídas PWM de 8 bits, o microcontrolador gera uma onda quadrada periódica de frequência constante (~490 Hz nos pinos D3, D9, D10 e D11; ~980 Hz nos pinos D5 e D6 via Timer 0). A tensão média eficaz $V_{MED}$ entregue à carga é proporcional à razão de ciclo de trabalho (duty cycle $D$), controlada pelo argumento inteiro de 0 a 255 passado à função analogWrite():

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

Na medição ultrassônica de distância (Lição 10), o sensor HC-SR04 emite uma rajada acústica de 8 pulsos a 40 kHz e mede o intervalo temporal $\Delta t$ (em microssegundos) decorrido até a recepção do eco refletido pelo obstáculo. Considerando a velocidade de propagação do som no ar seco a 20 °C ($v_{som} \approx 343\,\text{m/s} = 0{,}0343\,\text{cm/\mu s}$), a distância unidirecional $d$ ao objeto é dada por:

$$d = \frac{\Delta t \times v_{som}}{2} = \frac{\Delta t \times 0{,}0343}{2} = \frac{\Delta t}{58{,}3}$$

Na instrumentação térmica com termistor NTC de 10 kΩ (Lição 23), a resistência ôhmica diminui de modo não-linear com a elevação da temperatura absoluta, modelada pela aproximação do parâmetro $B$ da equação de Steinhart-Hart:

$$\frac{1}{T_K} = \frac{1}{T_0} + \frac{1}{B} \ln\left(\frac{R_T}{R_0}\right)$$

onde $T_K$ é a temperatura medida em Kelvin, $T_0 = 298{,}15\,\text{K}$ (25 °C), $R_0 = 10000\,\Omega$ é a resistência nominal do termistor a 25 °C, e $B \approx 3950\,\text{K}$ é a constante de sensibilidade térmica do material semicondutor de óxido metálico.

Mapeamento de Pinos e Barramentos Especiais

Pino Arduino	Nome / Função Primária	Protocolo / Barramento Hardware	Observações Críticas de Aplicação
D0	RX (Recepção Serial)	UART Hardware	Conectado internamente ao ATmega16U2. Não usar durante uploads
D1	TX (Transmissão Serial)	UART Hardware	Conectado internamente ao ATmega16U2. Não usar durante uploads
D2	GPIO / INT0	Interrupção Externa 0	Acionamento sensível a bordas de subida, descida ou nível LOW
D3	GPIO / INT1 / PWM	Timer 2 / Interrupção 1	Saída PWM de 490 Hz ou disparo de interrupção externa
D4	GPIO	Porta Digital	Utilizado para sinais de controle em displays e microfone
D5	GPIO / PWM	Timer 0	Frequência de PWM de 980 Hz (compartilhada com função millis)
D6	GPIO / PWM	Timer 0	Frequência de PWM de 980 Hz (compartilhada com função millis)
D7	GPIO	Porta Digital	Linha de leitura para sensor piroelétrico de presença PIR
D8	GPIO	Porta Digital	Usado como linha de disparo Trigger no HC-SR04
D9	GPIO / PWM	Timer 1	PWM de 490 Hz / Pino de Eco no HC-SR04 e Reset no RC522
D10	GPIO / PWM / SS	Timer 1 / SPI Slave Select	Linha de habilitação de escravo no barramento SPI (RC522)
D11	GPIO / PWM / MOSI	SPI Master Out Slave In	Saída de dados mestre no barramento SPI de alta velocidade
D12	GPIO / MISO	SPI Master In Slave Out	Entrada de dados mestre no barramento SPI
D13	GPIO / SCK / LED L	SPI Serial Clock / LED onboard	Relógio do barramento SPI e LED SMD integrado no circuito
A0	Entrada Analógica 0	ADC Canal 0	Leitura de termistor, sensor de água, microfone e fotocélula LDR
A1	Entrada Analógica 1	ADC Canal 1	Canal de eixo vertical Y do módulo joystick analógico
A2	Entrada Analógica 2	ADC Canal 2	Entrada de propósito geral para condicionamento analógico
A3	Entrada Analógica 3	ADC Canal 3	Entrada de propósito geral para transdutores resistivos
A4	Entrada Analógica 4 / SDA	I2C Serial Data	Linha bidirecional de dados do barramento I2C (RTC, MPU6050)
A5	Entrada Analógica 5 / SCL	I2C Serial Clock	Linha de relógio síncrono do barramento I2C (máximo 400 kHz)

Inventário Completo do Kit AE086 RB2051 (Packing List Oficial)

A relação abaixo lista todos os 52 itens e subsistemas fornecidos no estojo organizador do produto oficial Kit Avançado Componentes Eletrônicos Para Arduino Caixa NFe (RB2051), com descrição detalhada de componentes:

• Placa microcontroladora Uno DIP com conversor USB ATmega16U2 e microcontrolador ATmega328P em soquete DIP-28 removível (1 unidade)
• Módulo de display de cristal líquido alfanumérico LCD 1602 com backlight azul e barramento paralelo de 16 pinos (1 unidade)
• Módulo giroscópio e acelerômetro de 6 eixos GY-521 com transdutor inercial MPU-6050 e interface I2C (1 unidade)
• Conjunto transceptor RFID RC522 operando em 13,56 MHz, acompanhado de 1 cartão Mifare S50 em formato PVC e 1 chaveiro tag Mifare S50 azul (3 itens combinados)
• Motor de passo unipolar de 4 fases 28BYJ-48 de 5 V com redução de engrenagens de 1:64 (1 unidade)
• Placa de acionamento de motor de passo baseada no circuito integrado de transistores Darlington ULN2003 com 4 LEDs indicadores (1 unidade)
• Módulo joystick analógico de 2 eixos ortogonais potenciométricos de 10 kΩ com botão pulsador integrado no eixo Z (1 unidade)
• Sensor piroelétrico infravermelho passivo de presença AM312 com lente Fresnel miniatura integrada (1 unidade)
• Módulo sensor de som ambiente e detecção de ruído acústico com cápsula de microfone de eletreto e amplificador (1 unidade)
• Módulo sensor condutivo de nível de líquido e detecção de presença de água com trilhas banhadas (1 unidade)
• Sensor ultrassônico de medição de distância HC-SR04 com transdutores piezoelétricos emissores e receptores de 40 kHz (1 unidade)
• Micro servomotor analógico SG90 de 9 g com curso de 180 graus, engrenagens plásticas, parafusos e braços plásticos de acionamento (1 unidade)
• Módulo relógio de tempo real RTC DS1307 com oscilador de cristal de quartzo de 32,768 kHz e soquete para bateria de lítio CR2032 (1 unidade)
• Módulo receptor infravermelho de três terminais AX-1838HS com demodulador de portadora de 38 kHz (1 unidade)
• Módulo encoder rotativo incremental KY-040 com chave tátil central integrada e resistores de polarização (1 unidade)
• Módulo digital de sensoriamento de temperatura e umidade relativa do ar DHT11 com encapsulamento plástico perfurado (1 unidade)
• Módulo matriz de LEDs 8x8 monocromática vermelha controlada pelo circuito integrado de varredura MAX7219 (1 unidade)
• Placa ProtoShield de prototipagem rápida para Arduino Uno com mini matriz de contatos autoadesiva de 170 pontos (1 unidade)
• Mini controle remoto infravermelho de 21 teclas de membrana emborrachada com emissor de 38 kHz (1 unidade)
• Circuito integrado driver quadruplo de meia-ponte H bipolar L293D em encapsulamento DIP-16 para motores DC (1 unidade)
• Display numérico de 7 segmentos de 1 dígito de 0,56 polegadas com ponto decimal em encapsulamento de 10 pinos (1 unidade)
• Display numérico de 7 segmentos de 4 dígitos multiplexados no tempo de 0,36 polegadas com dois pontos horários (1 unidade)
• Transdutor sonoro piezoelétrico passivo sem oscilador interno para síntese musical via sinal alternado (1 unidade)
• Circuito integrado registrador de deslocamento serial-para-paralelo de 8 bits 74HC595 em encapsulamento DIP-16 (1 unidade)
• Transdutor sonoro eletromagnético tipo buzzer ativo com circuito oscilador integrado para emissão em 2,3 kHz sob corrente contínua (1 unidade)
• Micro motor elétrico de corrente contínua tipo 130 de 3 V a 6 VDC com eixo de 2 mm e hélice plástica ventiladora de quatro pás (1 unidade)
• Cabo de interface e comunicação USB tipo A macho para USB tipo B macho de alta blindagem com comprimento de 50 cm (1 unidade)
• Módulo relé de 1 canal de 5 VDC com isolamento por optoacoplador, diodo de proteção flyback e contatos reversíveis NA/NF para 10 A em 250 VAC (1 unidade)
• Teclado matricial de membrana flexível 4x4 contendo 16 teclas alfanuméricas com conector fêmea de 8 vias (1 unidade)
• Fonte de alimentação chaveada de parede estabilizada com entrada bivolt 100-240 VAC e saída regulada de 9 VDC a 1 A com conector jack P4 (1 unidade)
• Matriz de contatos experimental (protoboard) de 830 pontos de conexão com duas colunas centrais e quatro barramentos laterais de alimentação (1 unidade)
• Cabo adaptador de conexão para bateria de 9 V (6F22) com conector clip reforçado e plugue P4 macho com centro positivo (1 unidade)
• Chaves táteis de pulso tipo push-button de 4 terminais com capas plásticas removíveis coloridas para acionamento mecânico (5 unidades)
• Pacote de jumpers condutores flexíveis macho-macho para protoboard com comprimentos e cores variadas (65 unidades)
• Barra de jumpers de fita destacável com conectores tipo macho-fêmea de 20 vias (20 condutores)
• Sensor mecânico de inclinação esférico tipo interruptor de mercúrio seguro SW-520D com contatos internos banhados a ouro (1 unidade)
• Potenciômetros rotativos de precisão com variação linear de resistência de 10 kΩ e haste estriada de 6 mm (2 unidades)
• Resistores de precisão de filme metálico de 1/4W e tolerância de ±1%, distribuídos em 12 valores comerciais: 10 Ω, 100 Ω, 220 Ω, 330 Ω, 1 kΩ, 2 kΩ, 5,1 kΩ, 10 kΩ, 100 kΩ e 1 MΩ (120 unidades no total)
• Capacitores eletrolíticos de alumínio polarizados com capacitância de 10 µF e tensão de isolamento de 50 V (2 unidades)
• Capacitores eletrolíticos de alumínio polarizados com capacitância de 100 µF e tensão de isolamento de 50 V (2 unidades)
• Transistores bipolares de junção NPN de alta corrente tipo S8050 em encapsulamento plástico TO-92 (5 unidades)
• Transistores bipolares de junção NPN de chaveamento rápido tipo PN2222 em encapsulamento plástico TO-92 (5 unidades)
• Capacitores cerâmicos multicamada de desacoplamento com capacitância nominal de 100 nF (código serigráfico 104) (5 unidades)
• Capacitores cerâmicos de disco para osciladores de cristal com capacitância de 22 pF (5 unidades)
• Termistor resistivo de coeficiente térmico negativo tipo NTC de 10 kΩ a 25 °C série MF52D-103F-3950 (1 unidade)
• Diodos retificadores de silício de junção PN de uso geral série 1N4007 para 1000 V de tensão reversa e 1 A de corrente média (5 unidades)
• Sensores fotoresistores analógicos baseados em sulfeto de cádmio LDR de 5 mm série CDS-55 (2 unidades)
• Diodo emissor de luz tricolor tipo LED RGB difuso de 5 mm com terminal catodo comum e lentes foscas (1 unidade)
• Diodos emissores de luz monocromáticos difusos de 5 mm na cor vermelha (5 unidades)
• Diodos emissores de luz monocromáticos difusos de 5 mm na cor amarela (5 unidades)
• Diodos emissores de luz monocromáticos difusos de 5 mm na cor azul (5 unidades)
• Diodos emissores de luz monocromáticos difusos de 5 mm na cor verde (5 unidades)
• Diodos emissores de luz monocromáticos difusos de 5 mm na cor branca de alto brilho (5 unidades)
• Caixa plástica transparente organizadora de alto impacto com travas laterais e divisórias internas sob medida (1 unidade)

A somatória total contabiliza rigorosamente 280 elementos individuais e subsistemas integrados, compondo uma bancada completa de experimentação capaz de suprir integralmente todas as demandas das 34 lições práticas deste curso.

---

Módulo 0 — Preparação do Ambiente e Ferramentas (Lições 0 e 1)

O Módulo 0 estabelece as bases de software, configuração de drivers e gerenciamento de ecossistema necessários para a comunicação confiável entre a estação de trabalho e a placa Uno DIP 16u2. A conformidade rigorosa destas etapas iniciais evita falhas posteriores de compilação, problemas de bloqueio de porta COM e erros de inclusão de cabeçalhos de bibliotecas.

Lição 0: Instalação da IDE Arduino e Configuração do Driver USB-Serial

A Lição 0 aborda o procedimento oficial de download, instalação e provisionamento de portas de comunicação no ambiente Arduino IDE (versão 2.x ou clássica 1.8.x). A placa Uno DIP 16u2 utiliza o chip dedicado ATmega16U2 como ponte entre o protocolo USB do computador host e os pinos de transmissão/recepção assíncrona da UART (D0 e D1) do microcontrolador principal ATmega328P.

Ao conectar o cabo USB à porta de seu computador com sistema operacional Windows, o sistema operacional reconhece o dispositivo através de sua tabela VID/PID oficial (Vendor ID 0x2341 e Product ID 0x0043). Diferente dos conversores baseados em CH340 que exigem a instalação manual do executável CH341SER.EXE, a ponte ATmega16U2 da placa deste kit é reconhecida de forma transparente pelo driver certificado incluso no próprio pacote de instalação da IDE Arduino (arduino.inf), localizado no diretório padrão C:\Program Files (x86)\Arduino\drivers.

Roteiro Passo a Passo de Instalação e Teste de Conectividade:

1. Obtenção do Software: Acesse o portal oficial arduino.cc/en/software e realize o download do instalador correspondente ao seu sistema operacional (recomendado: instalador .exe para Windows 10/11 de 64 bits).
2. Execução do Instalador: Execute o instalador com privilégios de administrador. Certifique-se de manter marcadas todas as caixas de seleção adicionais que autorizam a instalação dos drivers USB periféricos da Adafruit e Arduino LLC.
3. Conexão Física: Conecte o conector USB tipo B quadrado à placa Uno e a ponta tipo A retangular a uma porta USB 2.0 ou 3.0 direta de seu computador (evite o uso de concentradores USB passivos sem alimentação externa durante uploads de firmware).
4. Verificação no Gerenciador de Dispositivos: No Windows, pressione o atalho Win + X e selecione Gerenciador de Dispositivos. Expanda a seção intitulada Portas (COM e LPT). Você deverá observar uma linha explícita: Arduino Uno (COMx), onde x representa o número ordinal alocado pelo sistema (por exemplo, COM3, COM5 ou COM8).
5. Configuração na IDE: Abra o software Arduino IDE. Navegue até o menu superior Ferramentas > Placa > Arduino AVR Boards e clique em Arduino Uno. Em seguida, vá ao menu Ferramentas > Porta e selecione a porta serial identificada no passo anterior.

💡 Dica de Engenharia: Se ao conectar o cabo USB o Gerenciador de Dispositivos listar um dispositivo com triângulo amarelo rotulado como Dispositivo Desconhecido ou USB-Serial, clique com o botão direito sobre ele, selecione Atualizar Driver, escolha Procurar drivers no meu computador e aponte para a pasta C:\Program Files\Arduino\drivers.

---

Lição 1: Adicionar Bibliotecas e Abrir o Monitor Serial

A Lição 1 ensina como incorporar módulos de código de terceiros (bibliotecas C/C++) à pasta de desenvolvimento e como operar o Monitor Serial integrado, a principal ferramenta de instrumentação e depuração em tempo real para projetos de computação física.

Uma biblioteca no ecossistema Arduino consiste em um pacote estruturado contendo arquivos de cabeçalho (.h), arquivos de implementação (.cpp), arquivos de documentação (keywords.txt) e exemplos demonstrativos (.ino). Existem três formas oficiais de integrar essas bibliotecas ao compilador AVR-GCC:

1. Gerenciador Oficial de Bibliotecas (Library Manager): Acesso pelo menu Sketch > Incluir Biblioteca > Gerenciar Bibliotecas… (ou atalho Ctrl + Shift + I). Permite buscar por nome e instalar com um único clique repositórios oficiais mantidos pela comunidade.
2. Inclusão por Arquivo Compactado (.ZIP): Menu Sketch > Incluir Biblioteca > Adicionar Biblioteca .ZIP…. Este método é obrigatório para as bibliotecas customizadas inclusas no kit AE086 (como os arquivos presentes na pasta 3.Libraries: SR04.zip, DS1307.zip, LedControl.zip, Keypad.zip e MPU6050.zip).
3. Instalação Manual na Pasta do Usuário: Descompactar os diretórios de código diretamente no caminho do usuário: Documents/Arduino/libraries/.

O Monitor Serial opera através dos circuitos de hardware UART do ATmega328P. Para estabelecer uma sessão de comunicação sem corrupção de caracteres, ambos os extremos (o microcontrolador e o software no PC) devem operar estritamente na mesma taxa de transmissão em símbolos por segundo (baud rate). O padrão pedagógico adotado neste curso é de 9600 baud, com quadro de 8 bits de dados, sem paridade e 1 bit de parada (formato 8N1).

⚠️ Atenção aos Finalizadores de Linha: No canto inferior direito da janela do Monitor Serial, configure o seletor de final de linha para Ambos NL & CR (Both Newline & Carriage Return). Essa configuração é imprescindível para o envio de comandos interativos nas lições de expansão com registrador 74HC595 (Lição 25) e controle serial.

Tabela-mestre de bibliotecas do curso

A tabela abaixo compila todas as bibliotecas externas manipuladas ao longo do curso, com suas respectivas versões testadas, método de instalação e lições de aplicação:

Biblioteca	Versão Testada	Origem / Método de Instalação	Lições de Aplicação	Propósito Funcional
SR04.h	1.0.0	Arquivo ZIP do Kit (3.Libraries/HC-SR04.zip)	Lição 10	Temporização de pulsos de disparo e eco do sensor ultrassônico
Keypad.h	3.1.1	Library Manager ou ZIP (3.Libraries/Keypad.zip)	Lição 11	Varredura e tratamento de debounce para teclados matriciais
dht_nonblocking.h	1.0.0	Arquivo ZIP do Kit (3.Libraries/DHT.zip)	Lição 12	Leitura não-bloqueante de temperatura e umidade com DHT11
IRremote.h	2.8.x Pinada	Arquivo ZIP do Kit (3.Libraries/IRremote.zip)	Lições 14 e 32	Decodificação de pacotes infravermelhos NEC de 38 kHz
LedControl.h	1.0.6	Arquivo ZIP do Kit (3.Libraries/LedControl.zip)	Lição 15	Multiplexação serial SPI de matrizes de LED com CI MAX7219
Wire.h	1.0 (Nativa)	Integrada ao núcleo oficial Arduino AVR Core	Lições 16 e 19	Comunicação mestre-escravo I2C de dois fios (pinos A4/A5)
MPU6050.h	1.0.0	Arquivo ZIP do Kit (3.Libraries/MPU6050.zip)	Lição 16	Leitura de registradores de aceleração e rotação do GY-521
DS3231.h / DS1307.h	1.0.1	Arquivo ZIP do Kit (3.Libraries/DS1307.zip)	Lição 19	Gestão de calendário, horas, minutos e segundos no RTC I2C
MFRC522.h / rfid.h	1.4.10	Arquivo ZIP do Kit (3.Libraries/rfid.zip)	Lição 21	Transcepção em protocolo SPI com transponder Mifare 13,56 MHz
LiquidCrystal.h	1.0.7	Integrada à IDE ou ZIP (3.Libraries/LiquidCrystal.zip)	Lições 22 e 23	Controle de display alfanumérico HD44780 em modo paralelo de 4 bits
pitches.h	1.0.0	Arquivo ZIP do Kit (3.Libraries/pitches.zip)	Lição 7	Definição de frequências fundamentais em Hertz da escala musical
Servo.h	1.2.1	Integrada ao núcleo oficial Arduino AVR Core	Lição 9	Geração de pulsos de precisão de 1 ms a 2 ms para servomotores
Stepper.h	1.1.3	Integrada ao núcleo oficial Arduino AVR Core	Lições 31, 32 e 33	Sequenciamento de fases de 4 passos para motores 28BYJ-48

---

Módulo 1 — Fundamentos Digitais, Som e Movimento Inicial (Lições 2 a 9)

O Módulo 1 introduz os conceitos centrais da eletrônica digital e analógica prática: controle de saídas discretas, limitação de corrente por resistores, modulação PWM para mistura cromática, leitura de entradas digitais com chaveamento sem ruído, geração de sinais acústicos por transdutores eletromecânicos e piezoelétricos, sensoriamento mecânico de inclinação e controle angular de precisão com servomotores.

---

Lição 2: Blink — Testando o Microcontrolador e o LED Integrado (D13)

A Lição 2 tem como objetivo validar o ciclo completo de desenvolvimento (edição de código, compilação cruzada pelo compilador AVR-GCC e gravação na memória Flash via bootloader Optiboot) utilizando o LED de teste integrado na própria placa Uno, conectado internamente ao pino digital 13 (D13) através de um amplificador operacional ou circuito buffer de alta impedância para não sobrecarregar a porta.

Na arquitetura do ATmega328P, o pino D13 corresponde fisicamente ao bit 5 do registrador de porta B (PORTB5). Quando a função pinMode(13, OUTPUT) é executada, o bit correspondente no registrador de direção de dados (DDRB5) é configurado em nível lógico alto (1), comutando os circuitos de saída push-pull internos. Ao aplicar nível lógico HIGH com digitalWrite(13, HIGH), a porta fornece aproximadamente 5,0 V nominais, polarizando diretamente o diodo emissor de luz montado na placa.

Materiais Necessários:

Componente	Quantidade	Especificação Técnica / Observações
Placa Uno DIP 16u2	1	Unidade central com cabo USB tipo A-B incluso
Computador Pessoal	1	Com Arduino IDE 2.x ou 1.8.x previamente instalada

Conexões e Interface de Hardware:

Nenhum componente externo ou matriz de contatos é exigido nesta lição inicial. O circuito do LED indicador (rotulado como L na serigrafia da placa) já está soldado na placa de circuito impresso:

Elemento na Placa	Pino Interno ATmega328P	Função Elétrica
LED SMD L (Amarelo)	Pino Digital 13 (PB5)	Cátodo ao GND via resistor limitador SMD interno de 1 kΩ

📦 Bibliotecas desta lição: Nenhuma biblioteca externa é necessária (utiliza apenas funções nativas do núcleo AVR Arduino: pinMode, digitalWrite, delay).

Código-Fonte Completo Comentado (Blink.ino):

// Lição 2: Blink - Piscar o LED Integrado D13
// Kit Avançado AE086 RB2051 - RoboBuilders

// Definição da constante que identifica o pino do LED integrado
const int ledPin = 13;

void setup() {
  // Configura o pino digital 13 como saída digital (OUTPUT)
  // Isso habilita os transistores internos de acionamento push-pull do microcontrolador
  pinMode(ledPin, OUTPUT);
}

void loop() {
  // Coloca o pino digital 13 em nível lógico alto (5,0 V nominais)
  // Isso polariza diretamente o LED SMD integrado, fazendo-o acender
  digitalWrite(ledPin, HIGH);

  // Pausa a execução do processador por um intervalo de 1000 milissegundos (1 segundo)
  delay(1000);

  // Coloca o pino digital 13 em nível lógico baixo (0,0 V / GND)
  // O circuito do LED é despolarizado, fazendo-o apagar
  digitalWrite(ledPin, LOW);

  // Pausa a execução do processador por mais 1000 milissegundos (1 segundo)
  delay(1000);
}

Procedimento de Carga e Resultado Esperado:

1. Conecte a placa Uno ao computador através do cabo USB.
2. Na IDE, verifique se a placa selecionada é Arduino Uno e a porta COM correta está ativa.
3. Clique no ícone de seta Carregar (Upload). Os LEDs indicadores TX e RX piscarão rapidamente durante a transferência dos pacotes de gravação.
4. Ao término da mensagem Carregado, o LED L começará a piscar ritmicamente em intervalos exatos de 1 segundo aceso e 1 segundo apagado (frequência de 0,5 Hz com duty cycle de 50%).

💡 Dica: Para experimentar diferentes cadências visuais, altere o valor do argumento de delay() para 200 ms (piscar rápido) ou adote tempos assimétricos (ex: 100 ms aceso e 900 ms apagado) para simular um sinalizador estroboscópico de advertência.

---

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

A Lição 3 explora a montagem de circuitos externos em matriz de contatos (protoboard), analisando a relação entre resistência ôhmica, fluxo de corrente elétrica e intensidade luminosa produzida por um diodo semicondutor emissor de luz (LED de 5 mm).

Um LED opera como uma junção semicondutora PN que emite fótons por eletroluminescência quando diretamente polarizada. Diferente de uma lâmpada resistiva incandescente, o diodo apresenta uma característica tensão-corrente exponencial acentuada: uma vez atingida a tensão de condução direta ($V_F \approx 1{,}8\,\text{V}$ a $2{,}0\,\text{V}$ para o LED vermelho), qualquer pequeno acréscimo de tensão resulta em uma elevação exponencial de corrente. Se conectado diretamente a uma fonte de 5,0 V sem resistor limitador em série, a corrente ultrapassa a capacidade máxima de dissipação térmica do componente ($\approx 30\,\text{mA}$), fundindo a junção semicondutora em frações de segundo.

Para dimensionar o resistor ideal aplicando a Lei de Ohm com alimentação de 5 V e corrente nominal de 15 mA ($0{,}015\,\text{A}$):

$$R = \frac{V_{CC} - V_F}{I_F} = \frac{5{,}0\,\text{V} - 1{,}8\,\text{V}}{0{,}015\,\text{A}} = \frac{3{,}2\,\text{V}}{0{,}015\,\text{A}} \approx 213{,}3\,\Omega \implies \text{Valor comercial: } 220\,\Omega$$

Nesta lição, você comparará o brilho emitido pelo LED ao alternar três valores de resistores fornecidos no kit: 220 Ω (vermelho-vermelho-marrom), 1 kΩ (marrom-preto-vermelho) e 10 kΩ (marrom-preto-laranja).

Materiais Necessários:

Componente	Quantidade	Especificação Técnica / Observações
Placa Uno DIP 16u2	1	Unidade de alimentação e controle
Matriz de Contatos (Protoboard)	1	Modelo de 830 pontos com canal central
LED Difuso Vermelho 5 mm	1	Tensão direta $V_F \approx 1{,}8\,\text{V}$
Resistor de Filme Metálico 220 Ω (1/4W)	1	Código de cores: Vermelho, Vermelho, Marrom, Ouro
Resistor de Filme Metálico 1 kΩ (1/4W)	1	Código de cores: Marrom, Preto, Vermelho, Ouro
Resistor de Filme Metálico 10 kΩ (1/4W)	1	Código de cores: Marrom, Preto, Laranja, Ouro
Jumpers Macho-Macho	2	Fios rígidos flexíveis para protoboard

Mapeamento de Conexões Pino a Pino:

Terminal do Componente	Conexão na Protoboard / Arduino	Função Elétrica
LED Ânodo (terminal longo)	Linha de sinal conectada ao Resistor	Entrada de corrente positiva polarizada
Resistor Limitador (outro lado)	Pino Digital D8 (ou 5V para teste estático)	Linha de controle / alimentação positiva
LED Cátodo (terminal curto / chanfro)	Barramento GND do Arduino	Retorno de corrente para terra de referência

📦 Bibliotecas desta lição: Nenhuma biblioteca externa é necessária.

Código-Fonte Completo Comentado (LED_Blink_D8.ino):

// Lição 3: Controle de LED Externo com Diferentes Resistores
// Kit Avançado AE086 RB2051 - RoboBuilders

// Declaração do pino digital associado ao ânodo do LED através do resistor
const int ledPin = 8;

void setup() {
  // Define o pino digital D8 como saída de sinal
  pinMode(ledPin, OUTPUT);
}

void loop() {
  // Envia nível lógico ALTO (5V) para acender o LED externo
  digitalWrite(ledPin, HIGH);
  delay(1000); // Mantém aceso por 1 segundo

  // Envia nível lógico BAIXO (0V) para desenergizar o LED
  digitalWrite(ledPin, LOW);
  delay(1000); // Mantém apagado por 1 segundo
}

Teste Prático e Comparação de Resistores:

1. Monte o circuito na protoboard inicialmente com o resistor de 220 Ω. Carregue o programa e observe a intensidade luminosa plena do LED vermelho.
2. Desconecte o cabo USB por segurança. Substitua o resistor de 220 Ω pelo de 1 kΩ. Reconecte o USB: o brilho será visivelmente mais atenuado, pois a corrente caiu para aproximadamente 3,2 mA.
3. Substitua agora pelo resistor de 10 kΩ: a corrente é reduzida para apenas ~0,32 mA e o LED emitirá apenas um ponto de luz tênue, mal perceptível em ambientes iluminados.

⛔ Perigo de Danos ao Hardware: Jamais ligue o LED diretamente entre os pinos 5V e GND sem nenhum resistor em série. Isso provoca sobrecorrente imediata, podendo danificar permanentemente o LED ou queimar a porta de saída do microcontrolador.

---

Lição 4: LED RGB — Modulação PWM e Mistura de Cores

A Lição 4 demonstra o princípio da síntese aditiva de cores utilizando um LED RGB difuso de 5 mm com cátodo comum controlado por três saídas digitais com modulação por largura de pulso (PWM — Pulse Width Modulation).

Um LED RGB encapsula três pastilhas semicondutoras distintas em um único invólucro de resina epóxi: uma vermelha (Red), uma verde (Green) e uma azul (Blue). No modelo de cátodo comum, o terminal mais longo entre os quatro corresponde ao terra compartilhado dos três emissores. Para controlar a luminosidade relativa de cada cor primária independentemente, a função analogWrite(pino, valor) altera o ciclo de trabalho (duty cycle) de 0 a 255 passos:

$$D_{\%} = \frac{\text{valor}}{255} \times 100\%$$

Ao variar simultaneamente as razões de ciclo de trabalho nos três canais PWM, é possível sintetizar milhões de tonalidades cromáticas, como amarelo (vermelho + verde), ciano (verde + azul), magenta (vermelho + azul) e branco puro (vermelho + verde + azul em proporções equilibradas).

Materiais Necessários:

Componente	Quantidade	Especificação Técnica / Observações
Placa Uno DIP 16u2	1	Unidade microcontroladora
Matriz de Contatos (Protoboard)	1	Para montagem do circuito
LED RGB Difuso 5 mm	1	Cátodo Comum (terminal mais longo = GND)
Resistores de 220 Ω (1/4W)	3	Um resistor dedicado em série para cada canal de cor
Jumpers Macho-Macho	5	Condutores de ligação

Identificação de Terminais e Pinagem:

Com os terminais do LED RGB voltados para baixo e o terminal mais longo posicionado na segunda posição a partir da esquerda:

• Terminal 1 (extrema esquerda): Ânodo Vermelho (Red)
• Terminal 2 (mais longo): Cátodo Comum (GND)
• Terminal 3: Ânodo Verde (Green)
• Terminal 4 (extrema direita): Ânodo Azul (Blue)

Terminal LED RGB	Conexão via Resistor 220 Ω	Pino Arduino Uno	Função
Ânodo Vermelho (R)	Resistor 220 Ω em série	Pino Digital ~6	Canal PWM Vermelho
Cátodo Comum (-)	Conexão direta ao GND	Barramento GND	Terra compartilhado
Ânodo Verde (G)	Resistor 220 Ω em série	Pino Digital ~5	Canal PWM Verde
Ânodo Azul (B)	Resistor 220 Ω em série	Pino Digital ~3	Canal PWM Azul

📦 Bibliotecas desta lição: Nenhuma biblioteca externa é necessária (utiliza analogWrite nativo).

Código-Fonte Completo Comentado (RGB_LED.ino):

// Lição 4: LED RGB com Mistura de Cores PWM
// Kit Avançado AE086 RB2051 - RoboBuilders

// Definição dos pinos de hardware associados aos canais PWM
#define RED_PIN   6   // Canal PWM associado ao filamento vermelho
#define GREEN_PIN 5   // Canal PWM associado ao filamento verde
#define BLUE_PIN  3   // Canal PWM associado ao filamento azul

// Função auxiliar para aplicar os três valores de cor simultaneamente (0 a 255)
void setColor(int redValue, int greenValue, int blueValue) {
  analogWrite(RED_PIN, redValue);     // Aplica duty cycle no pino do canal vermelho
  analogWrite(GREEN_PIN, greenValue); // Aplica duty cycle no pino do canal verde
  analogWrite(BLUE_PIN, blueValue);   // Aplica duty cycle no pino do canal azul
}

void setup() {
  // Configura os três pinos PWM como saídas digitais
  pinMode(RED_PIN, OUTPUT);
  pinMode(GREEN_PIN, OUTPUT);
  pinMode(BLUE_PIN, OUTPUT);
}

void loop() {
  // 1. Vermelho puro (Full Red)
  setColor(255, 0, 0);
  delay(1000);

  // 2. Verde puro (Full Green)
  setColor(0, 255, 0);
  delay(1000);

  // 3. Azul puro (Full Blue)
  setColor(0, 0, 255);
  delay(1000);

  // 4. Amarelo (Vermelho + Verde)
  setColor(255, 255, 0);
  delay(1000);

  // 5. Roxo / Magenta (Vermelho + Azul)
  setColor(255, 0, 255);
  delay(1000);

  // 6. Ciano / Azul piscina (Verde + Azul)
  setColor(0, 255, 255);
  delay(1000);

  // 7. Branco sintético (Todas as cores balanceadas)
  setColor(255, 255, 255);
  delay(1000);

  // 8. Apagado total
  setColor(0, 0, 0);
  delay(1000);
}

Procedimento de Gravação e Teste:

1. Carregue o programa e confira a sequência de cores alternando a cada segundo.
2. Certifique-se de que os três resistores de 220 Ω foram inseridos individualmente nos canais R, G e B. Nunca coloque um resistor único no terminal de cátodo comum, pois quando duas ou três cores acenderem simultaneamente a queda de tensão mudará e descalibrará as tonalidades.

---

Lição 5: Entradas Digitais — Leitura de Botões Táteis (Push-Button)

A Lição 5 aborda a aquisição de sinais digitais binários a partir de chaves de pressão táteis tipo push-button, apresentando o conceito elétrico de pull-up interno e a mitigação de estados de alta impedância (flutuação de entrada).

Uma porta de entrada digital do microcontrolador ATmega328P configurada via pinMode(pino, INPUT) apresenta impedância de entrada elevadíssima ($\approx 100\,\text{M}\Omega$). Se um botão estiver aberto sem resistores de polarização associados, o pino capta campos eletromagnéticos espúrios do ambiente, oscilando imprevisivelmente entre 0 e 1. Para resolver este problema sem componentes externos adicionais, o microcontrolador integra resistores de pull-up internos com valor entre $20\,\text{k}\Omega$ e $50\,\text{k}\Omega$, ativados por software através de pinMode(pino, INPUT_PULLUP).

Sob essa configuração de lógica negativa ou invertida:

• Botão em repouso (despressionado): a entrada é puxada para $V_{CC}$ (nível lógico HIGH).
• Botão pressionado: o contato aterra o pino diretamente ao GND (nível lógico LOW).

Neste projeto da documentação oficial, dois botões são implementados: o Botão A acende um LED e o Botão B o desliga.

Materiais Necessários:

Componente	Quantidade	Especificação Técnica / Observações
Placa Uno DIP 16u2	1	Unidade de processamento
Matriz de Contatos (Protoboard)	1	Para montagem dos botões e LED
Chaves Táteis de 4 Terminais (Push-Button)	2	Botão A (liga) e Botão B (desliga)
LED Difuso Vermelho 5 mm	1	Indicador luminoso de estado
Resistor de 220 Ω (1/4W)	1	Limitador de corrente do LED
Jumpers Macho-Macho	6	Condutores flexíveis

Conexões Elétricas:

As chaves de 4 terminais possuem pares de pernas opostas permanentemente interligadas internamente. Posicione os botões transpondo o canal central da protoboard:

Componente	Conexão de Origem	Pino Arduino Uno	Lógica / Comportamento
LED Ânodo	Via Resistor 220 Ω	Pino Digital D5	Saída de controle do LED
LED Cátodo	Terminal curto	Barramento GND	Retorno de terra
Botão A (Liga)	Terminal A	Pino Digital D9	Entrada com pull-up (LOW = pressionado)
Botão A (Liga)	Terminal B oposto	Barramento GND	Conexão para aterramento
Botão B (Desliga)	Terminal A	Pino Digital D8	Entrada com pull-up (LOW = pressionado)
Botão B (Desliga)	Terminal B oposto	Barramento GND	Conexão para aterramento

📦 Bibliotecas desta lição: Nenhuma biblioteca externa é necessária.

Código-Fonte Completo Comentado (Digital_Inputs.ino):

// Lição 5: Entradas Digitais com Botões Táteis e Pull-up Interno
// Kit Avançado AE086 RB2051 - RoboBuilders

// Definição dos pinos do circuito
const int ledPin = 5;       // Pino digital conectado ao LED através de resistor de 220 ohms
const int buttonApin = 9;   // Pino digital conectado ao Botão A (comando de Ligar)
const int buttonBpin = 8;   // Pino digital conectado ao Botão B (comando de Desligar)

void setup() {
  // Configura o pino do LED como saída digital
  pinMode(ledPin, OUTPUT);

  // Configura os pinos dos botões como entradas com resistor de pull-up interno ativado
  // O pino permanece em nível HIGH em repouso e vai para LOW quando o botão é pressionado
  pinMode(buttonApin, INPUT_PULLUP);
  pinMode(buttonBpin, INPUT_PULLUP);
}

void loop() {
  // Realiza a leitura do Botão A; se o estado for LOW, significa que foi pressionado
  if (digitalRead(buttonApin) == LOW) {
    digitalWrite(ledPin, HIGH); // Acende o LED e mantém ligado
  }

  // Realiza a leitura do Botão B; se o estado for LOW, significa que foi pressionado
  if (digitalRead(buttonBpin) == LOW) {
    digitalWrite(ledPin, LOW);  // Desliga o LED e mantém apagado
  }
}

Validação Funcional:

1. Carregue o firmware e observe que o LED permanece inicialmente apagado.
2. Pressione o Botão A: o pino 9 é aterrado e o microcontrolador aciona o pino 5, ligando o LED. Solte o botão: o LED continua aceso.
3. Pressione o Botão B: o pino 8 é aterrado e o programa desativa a saída do LED, apagando-o.

---

Lição 6: Buzzer Ativo — Emissão Sonora e Sinais de Alarme

A Lição 6 estuda o acionamento de um buzzer eletromagnético ativo, um transdutor sonoro projetado para emitir sinais acústicos monotônicos contínuos ou intermitentes sem demandar processamento de forma de onda pelo microcontrolador.

A distinção fundamental entre um buzzer ativo e um buzzer passivo reside na presença de um circuito oscilador ressonante interno embutido no encapsulamento do modelo ativo. Ao receber uma tensão contínua fixa de 5,0 VDC em seus terminais polarizados, o oscilador interno entra em auto-oscilação a uma frequência fixa em torno de 2,3 kHz a 2,5 kHz, acionando a membrana metálica flexível. Consequentemente, para fazê-lo apitar, basta enviar digitalWrite(pino, HIGH).

O buzzer ativo pode ser identificado visualmente no kit por possuir a parte inferior selada com resina epóxi preta uniforme (escondendo os circuitos) e, tipicamente, por vir de fábrica com uma etiqueta adesiva de proteção cobrindo o orifício ressonador acústico superior, que deve ser removida para obter máximo volume sonoro.

Materiais Necessários:

Componente	Quantidade	Especificação Técnica / Observações
Placa Uno DIP 16u2	1	Unidade de acionamento
Matriz de Contatos (Protoboard)	1	Suporte mecânico para conexões
Buzzer Ativo de 5 V	1	Frequência nominal de ~2,3 kHz com oscilador interno
Jumpers Macho-Macho	2	Fios de ligação

Mapeamento de Conexões:

Terminal do Buzzer	Indicação Física	Pino no Arduino Uno	Função
Terminal Positivo (+)	Perna mais longa / Símbolo + na carcaça	Pino Digital D12	Sinal de acionamento DC (HIGH = som)
Terminal Negativo (-)	Perna mais curta	Barramento GND	Referência de retorno de corrente

📦 Bibliotecas desta lição: Nenhuma biblioteca externa necessária.

Código-Fonte Completo Comentado (active.ino):

// Lição 6: Acionamento de Buzzer Ativo para Alarmes
// Kit Avançado AE086 RB2051 - RoboBuilders

// Definição da porta digital conectada ao pino positivo do buzzer ativo
int buzzer = 12;

void setup() {
  // Configura a porta digital D12 como saída de sinal
  pinMode(buzzer, OUTPUT);
}

void loop() {
  unsigned char i;

  // Primeiro ciclo de alarme: pulsos rápidos de alta frequência auditiva
  for (i = 0; i < 80; i++) {
    digitalWrite(buzzer, HIGH); // Ativa o buzzer fornecendo 5V nominais
    delay(1);                   // Mantém acionado por 1 milissegundo
    digitalWrite(buzzer, LOW);  // Corta a alimentação do buzzer
    delay(1);                   // Mantém desativado por 1 milissegundo
  }

  // Segundo ciclo de alarme: cadência mais lenta para distinção de tom
  for (i = 0; i < 100; i++) {
    digitalWrite(buzzer, HIGH); // Liga o buzzer
    delay(2);                   // Mantém acionado por 2 milissegundos
    digitalWrite(buzzer, LOW);  // Desliga o buzzer
    delay(2);                   // Mantém desativado por 2 milissegundos
  }
}

Teste e Verificação Auditiva:

1. Carregue o código para a placa Uno.
2. Ao iniciar o loop, o buzzer emitirá um padrão de bipe oscilante contínuo em duas frequências perceptíveis, demonstrando sua aplicação prática típica em sinalizadores sonoros industriais, alarmes de intrusão e alertas de teclado.

---

Lição 7: Buzzer Passivo — Frequências Sonoras e Escala Musical com pitches.h

A Lição 7 explora a síntese de frequências acústicas analógicas por meio de um buzzer piezoelétrico passivo, permitindo a execução de notas musicais, melodias complexas e efeitos sonoros customizados.

Diferente do modelo ativo, o buzzer passivo não possui oscilador interno. Sua base revela uma pequena placa de circuito impresso com trilhas de cobre visíveis. Se alimentado com tensão contínua pura de 5 V, o elemento piezoelétrico apenas sofre uma deflexão mecânica momentânea produzindo um estalido (click) inaudível. Para emitir som audível contínuo, o microcontrolador deve enviar um sinal de onda quadrada alternada na frequência exata da nota desejada:

$$f = \frac{1}{T} \implies T = \frac{1}{f}$$

A função nativa tone(pino, frequencia, duracao) do Arduino utiliza os temporizadores internos por hardware para comutar a porta na frequência configurada em Hertz (Hz). A biblioteca auxiliar pitches.h mapeia as notas musicais universais da escala temperada ocidental em constantes numéricas (por exemplo, NOTE_C4 = 262 Hz [Dó], NOTE_D4 = 294 Hz [Ré], NOTE_E4 = 330 Hz [Mi], NOTE_G4 = 392 Hz [Sol]).

Materiais Necessários:

Componente	Quantidade	Especificação Técnica / Observações
Placa Uno DIP 16u2	1	Unidade geradora de frequências PWM
Matriz de Contatos (Protoboard)	1	Para fixação dos componentes
Buzzer Piezoelétrico Passivo	1	Base aberta sem resina, sem oscilador interno
Jumpers Macho-Macho	2	Conexões de sinal e terra

Conexões Elétricas:

Terminal do Buzzer Passivo	Pino no Arduino Uno	Função Operacional
Terminal Positivo (+)	Pino Digital D8	Linha de onda quadrada com frequência variável via tone()
Terminal Negativo (-)	Barramento GND	Retorno para terra de referência

📦 Bibliotecas desta lição:

• pitches.h (versão 1.0.0, inclusa no kit na pasta 3.Libraries/pitches.zip ou copiada no mesmo diretório do sketch) — Contém a tabela de frequências das notas musicais em Hertz.

Código-Fonte Completo Comentado (passive_buzzer.ino):

// Lição 7: Síntese Sonora de Escala Musical com Buzzer Passivo
// Kit Avançado AE086 RB2051 - RoboBuilders

// Inclusão do cabeçalho com a definição das frequências em Hertz das notas musicais
#include "pitches.h"

// Vetor com a sequência de notas musicais que formam a melodia:
// C4 (Dó), G3 (Sol grave), G3 (Sol grave), A3 (Lá grave), G3 (Sol grave), pausa (0), B3 (Si grave), C4 (Dó)
int melody[] = {
  NOTE_C4, NOTE_G3, NOTE_G3, NOTE_A3, NOTE_G3, 0, NOTE_B3, NOTE_C4
};

// Vetor correspondente com as durações relativas de cada nota:
// 4 = semínima (quarto de tempo), 8 = colcheia (oitavo de tempo)
int noteDurations[] = {
  4, 8, 8, 4, 4, 4, 4, 4
};

void setup() {
  // Itera sobre as 8 notas da partitura
  for (int thisNote = 0; thisNote < 8; thisNote++) {

    // Calcula a duração da nota em milissegundos dividindo 1000 ms pelo tipo de nota
    // Uma semínima (4) dura 1000 / 4 = 250 ms
    int noteDuration = 1000 / noteDurations[thisNote];

    // Emite o tom sonoro no pino digital 8 com a frequência e duração calculadas
    tone(8, melody[thisNote], noteDuration);

    // Para distinguir notas consecutivas de mesma altura, estabelece-se uma breve pausa
    // Adota-se classicamente um tempo 30% superior à duração da nota executada
    int pauseBetweenNotes = noteDuration * 1.30;
    delay(pauseBetweenNotes);

    // Interrompe explicitamente a geração da forma de onda no pino 8
    noTone(8);
  }
}

void loop() {
  // A execução da melodia ocorre uma única vez no setup(); o loop permanece ocioso
}

Teste Prático:

1. Descompacte o arquivo pitches.zip ou coloque o arquivo pitches.h na mesma pasta do seu arquivo .ino.
2. Carregue o sketch para a placa Uno.
3. Você ouvirá nitidamente os oito compassos da melodia clássica sendo sintetizados com notas limpas e perfeitamente afinadas, demonstrando a superioridade do buzzer passivo para interface musical.

---

Lição 8: Sensor de Inclinação Esférico (Ball Tilt Switch)

A Lição 8 estuda o sensor de inclinação mecânico baseado em esfera condutiva interna (modelo SW-520D), demonstrando sua aplicação no acionamento de segurança em quedas, verticalidade de equipamentos e alarmes de capotamento veicular.

O sensor SW-520D consiste em um pequeno cilindro metálico hermético contendo duas esferas condutivas banhadas a ouro em seu interior. Quando o sensor é posicionado na vertical com os terminais apontando para baixo, as esferas descem por gravidade e curto-circuitam dois pinos de contato fixos na base, fechando o circuito (baixa resistência, $R < 10\,\Omega$). Quando o componente é inclinado acima de um ângulo crítico de transição (tipicamente $> 15^\circ$ a $45^\circ$) ou invertido de cabeça para baixo, as esferas rolam para a extremidade oposta do invólucro, interrompendo o contato elétrico (circuito aberto, $R > 10\,\text{M}\Omega$).

Para monitorar este estado pelo microcontrolador, utiliza-se a técnica de divisor resistivo com resistor externo de pull-up ou a configuração interna INPUT_PULLUP.

Materiais Necessários:

Componente	Quantidade	Especificação Técnica / Observações
Placa Uno DIP 16u2	1	Processamento de sinal
Matriz de Contatos (Protoboard)	1	Para montagem
Sensor de Inclinação SW-520D	1	Cápsula metálica cilíndrica com esfera móvel
Resistor de 220 Ω (1/4W)	1	Resistor limitador para LED externo
LED Difuso Vermelho 5 mm	1	Sinalizador visual de inclinação
Jumpers Macho-Macho	4	Condutores de montagem

Conexões Pino a Pino:

Componente	Terminal	Pino no Arduino Uno	Observação
Sensor SW-520D	Terminal 1	Pino Digital D2	Linha de leitura com pull-up
Sensor SW-520D	Terminal 2	Barramento GND	Linha de terra
LED Vermelho	Ânodo via 220 Ω	Pino Digital D13 (ou LED L nativo)	Sinalizador de alarme
LED Vermelho	Cátodo	Barramento GND	Terra de referência

📦 Bibliotecas desta lição: Nenhuma biblioteca externa necessária.

Código-Fonte Completo Comentado (Ball_Switch.ino):

// Lição 8: Detecção de Ângulo e Queda com Sensor de Inclinação Esférico
// Kit Avançado AE086 RB2051 - RoboBuilders

const int ledPin = 13;   // Pino do LED indicador de inclinação (D13)
const int tiltPin = 2;   // Pino de entrada conectado ao sensor de esfera SW-520D

void setup() {
  // Configura o LED como saída digital
  pinMode(ledPin, OUTPUT);

  // Configura o sensor de inclinação como entrada com resistor de pull-up interno
  // Sensor vertical (fechado) = nível LOW; Sensor inclinado (aberto) = nível HIGH
  pinMode(tiltPin, INPUT_PULLUP);
}

void loop() {
  // Realiza a leitura do estado lógico do sensor
  int tiltState = digitalRead(tiltPin);

  // Se o sensor foi inclinado além do ângulo limite, o contato abre e a leitura vai a HIGH
  if (tiltState == HIGH) {
    digitalWrite(ledPin, HIGH); // Acende o LED alertando inclinação / queda
  } else {
    digitalWrite(ledPin, LOW);  // Mantém apagado na posição vertical normal
  }
}

Teste e Validação:

1. Carregue o programa e mantenha a protoboard perfeitamente apoiada e nivelada sobre a bancada: o LED permanece apagado.
2. Incline levemente a protoboard em cerca de 30 graus: você ouvirá o som sutil das esferas deslizando no tubo metálico e o LED acenderá instantaneamente, validando o circuito detector.

---

Lição 9: Micro Servo Motor SG90 — Controle Angular de Precisão

A Lição 9 apresenta o funcionamento eletromecânico e o controle de malha fechada do micro servomotor analógico SG90, um atuador fundamental em robótica articulada, braços manipuladores, direções de veículos e posicionamento de radares.

O servomotor SG90 integra quatro subsistemas essenciais em um corpo plástico de apenas 9 gramas:

1. Um pequeno motor de corrente contínua de alta rotação;
2. Um trem de engrenagens redutoras que amplia o torque mecânico para cerca de 1,6 kgf·cm a 4,8 V;
3. Um potenciômetro solidário ao eixo de saída final que atua como sensor de posição angular (feedback);
4. Uma placa de controle eletrônico proporcional analógica.

O controle de posição é realizado através de um protocolo PWM específico de trem de pulsos com período fixo de 20 milissegundos (frequência de 50 Hz). A largura do pulso em nível alto ($t_{ON}$) comanda diretamente o ângulo do eixo:

• Pulso de 1,0 ms: posiciona o eixo no batente esquerdo de 0°;
• Pulso de 1,5 ms: posiciona o eixo no centro exato de 90°;
• Pulso de 2,0 ms: posiciona o eixo no batente direito de 180°.

A biblioteca oficial Servo.h abstrai essas temporizações em microssegundos através da função myservo.write(angulo), que aceita ângulos inteiros diretamente de 0 a 180 graus.

Materiais Necessários:

Componente	Quantidade	Especificação Técnica / Observações
Placa Uno DIP 16u2	1	Geração de pulsos de temporização por hardware
Micro Servomotor SG90 (9g)	1	Curso de 180°, torque de 1,6 kgf·cm
Braço / Hélice Plástica de Acionamento	1	Para visualização do ângulo de rotação
Jumpers Macho-Macho	3	Cabos de sinal, alimentação e terra

Mapeamento de Cores do Chicote do SG90:

Cor do Fio do Servomotor	Função	Pino de Conexão no Arduino Uno
Marrom / Preto	Terra elétrico (GND)	Barramento GND
Vermelho	Tensão contínua de alimentação (+5V)	Terminal 5V do Arduino
Laranja / Amarelo	Linha de sinal PWM de controle	Pino Digital ~9

📦 Bibliotecas desta lição:

• Servo.h (versão 1.2.1, incluída nativamente no núcleo oficial Arduino AVR Core) — Controla servomotores via temporizadores por hardware sem interferir na função delay().

Código-Fonte Completo Comentado (servo.ino):

// Lição 9: Posicionamento Angular com Micro Servomotor SG90
// Kit Avançado AE086 RB2051 - RoboBuilders

// Inclusão da biblioteca de controle de servomotores padrão Arduino
#include <Servo.h>

// Instanciação do objeto de controle do servo motor
Servo myservo;

// Variável para armazenar a posição angular do eixo em graus (0 a 180)
int pos = 0;

void setup() {
  // Vincula o objeto myservo ao pino digital 9 do Arduino Uno
  myservo.attach(9);
}

void loop() {
  // Varredura progressiva do ângulo de 0 graus até 180 graus em passos de 1 grau
  for (pos = 0; pos <= 180; pos += 1) {
    // Comanda o servomotor a assumir a posição angular calculada
    myservo.write(pos);
    // Aguarda 15 milissegundos para que a engrenagem física alcance a nova posição
    delay(15);
  }

  // Varredura reversa retornando de 180 graus até 0 graus
  for (pos = 180; pos >= 0; pos -= 1) {
    myservo.write(pos);
    delay(15);
  }
}

Teste e Recomendações de Potência:

1. Encaixe um dos braços plásticos fornecidos no eixo estriado do motor SG90 para visualizar a rotação.
2. Carregue o programa: o braço realizará um movimento contínuo e suave de vaivém de 0 a 180 graus como um limpador de para-brisa.

⚠️ Atenção aos Picos de Corrente: Durante a partida brusca ou sob carga mecânica pesada, o servomotor SG90 pode consumir transientes de corrente superiores a 500 mA, o que pode causar reset na placa Uno se alimentada exclusivamente pela porta USB do computador. Para acionar múltiplos servomotores simultaneamente, utilize sempre uma fonte externa dedicada de 5 V com o terra unificado ao GND do Arduino.

---

Módulo 2 — Sensores de Proximidade, Interface Humana e Ambiente (Lições 10 a 17)

O Módulo 2 aprofunda o sensoriamento físico de precisão e a interação humano-máquina: medição de distância por ultrassom, leitura de teclados de membrana por varredura matricial, psicrometria digital com DHT11, controle vetorial analógico com joystick, telecomando infravermelho modulado a 38 kHz, visualização gráfica em matrizes de LED 8x8 via MAX7219, orientação espacial inercial de 6 eixos (aceleração e rotação) com o sensor MPU6050 e monitoramento de presença biológica com detector piroelétrico passivo PIR AM312.

---

Lição 10: Módulo Sensor Ultrassônico HC-SR04 — Medição de Distância por Eco

A Lição 10 aborda o princípio de ecolocalização e tempo de voo acústico (Time-of-Flight — ToF) utilizando o sensor ultrassônico HC-SR04, largamente empregado em robôs móveis para prevenção autônoma de colisões, sonares e medição de nível de reservatórios.

O módulo HC-SR04 opera com dois transdutores piezoelétricos sintonizados: o transmissor T (Transmitter) e o receptor R (Receiver). O ciclo de medição transcorre segundo o seguinte cronograma elétrico:

1. O microcontrolador envia um pulso em nível alto de no mínimo $10\,\mu\text{s}$ no pino Trig (Trigger);
2. Ao receber o disparo, o circuito interno do sensor gera automaticamente uma rajada de 8 pulsos ultrassônicos em onda quadrada na frequência de $40\,\text{kHz}$;
3. O pino Echo é levado a nível alto no exato instante do disparo da rajada e assim permanece até que o circuito receptor capte o eco de retorno refletido pelo obstáculo;
4. A largura temporal do pulso em nível alto no pino Echo ($\Delta t$, medida em microssegundos) é diretamente proporcional à distância percorrida pela onda.

Considerando a velocidade do som no ar a 20 °C ($v_{som} = 343\,\text{m/s} = 0{,}0343\,\text{cm/\mu s}$), e sabendo que a onda sonora viaja até o obstáculo e retorna (trajeto duplo), a distância unidirecional $d$ em centímetros é expressa por:

$$d = \frac{\Delta t \times 0{,}0343}{2} = \frac{\Delta t}{58{,}3}$$

A biblioteca dedicada SR04.h gerencia automaticamente os pulsos de trigger e a captura de eco através das funções de temporização do hardware.

Materiais Necessários:

Componente	Quantidade	Especificação Técnica / Observações
Placa Uno DIP 16u2	1	Temporização de microsegundos
Sensor Ultrassônico HC-SR04	1	Alcance de 2 cm a 400 cm com resolução de 3 mm
Matriz de Contatos (Protoboard)	1	Para suporte do sensor
Jumpers Fêmea-Macho / Macho-Macho	4	Conexões de 5V, GND, Trig e Echo

Tabela de Pinagem do HC-SR04:

Pino no HC-SR04	Pino no Arduino Uno	Função Operacional
VCC	5V	Alimentação positiva contínua de 5,0 VDC
Trig (Trigger)	Pino Digital D8	Pulso de disparo de $10\,\mu\text{s}$ para iniciar o ciclo
Echo	Pino Digital D9	Sinal de retorno cuja largura do pulso representa o tempo de voo
GND	Barramento GND	Terra elétrico compartilhado

📦 Bibliotecas desta lição:

• SR04.h (versão 1.0.0, inclusa no arquivo 3.Libraries/HC-SR04.zip do kit) — Abstrai os pulsos de disparo e calcula a distância diretamente em centímetros através do método .Distance().

Código-Fonte Completo Comentado (SR04_Example.ino):

// Lição 10: Medição de Distância com Sensor Ultrassônico HC-SR04
// Kit Avançado AE086 RB2051 - RoboBuilders

// Inclusão da biblioteca oficial do sensor HC-SR04 fornecida no kit
#include "SR04.h"

// Definição das portas digitais conectadas aos terminais do sensor
#define TRIG_PIN 8   // Pino de Trigger (disparo acústico)
#define ECHO_PIN 9   // Pino de Echo (captura do tempo de voo)

// Instanciação do objeto sensor passando os pinos de Trigger e Echo
SR04 sr04 = SR04(ECHO_PIN, TRIG_PIN);

// Variável para armazenar a distância calculada em centímetros
long distance;

void setup() {
  // Inicializa a comunicação serial na velocidade padrão de 9600 baud
  Serial.begin(9600);
  // Aguarda 1 segundo para estabilização das linhas de alimentação
  delay(1000);
}

void loop() {
  // Executa o método de disparo e cálculo de distância em centímetros
  distance = sr04.Distance();

  // Imprime a grandeza medida no Monitor Serial
  Serial.print(distance);
  Serial.println(" cm");

  // Intervalo de amostragem de 1000 ms para não sobrepor reflexões acústicas em ambientes fechados
  delay(1000);
}

Teste e Validação:

1. Instale a biblioteca HC-SR04.zip na IDE via menu Sketch > Incluir Biblioteca > Adicionar Biblioteca .ZIP….
2. Carregue o código e abra o Monitor Serial configurado em 9600 baud.
3. Aproxime a mão ou uma cartolina plana perpendicularmente aos tubos do sensor: as leituras de distância responderão em tempo real de 3 cm até mais de 300 cm com precisão milimétrica.

💡 Dica: Superfícies macias e porosas como tecidos, espumas ou bichos de pelúcia absorvem ondas acústicas de 40 kHz em vez de refleti-las, reduzindo o alcance efetivo do sensor. Para calibração precisa, utilize anteparos planos rígidos (madeira, plástico ou acrílico).

---

Lição 11: Teclado Matricial de Membrana 4x4 — Varredura Matricial com Keypad

A Lição 11 estuda a técnica de multiplexação espacial através de um teclado de membrana matricial 4x4, capaz de ler 16 teclas distintas utilizando apenas 8 pinos digitais do microcontrolador em vez de 16 conexões individuais.

O teclado 4x4 organiza suas 16 chaves momentâneas na interseção de uma grade de 4 Linhas (Rows) e 4 Colunas (Columns). Sob a biblioteca Keypad.h, o algoritmo de varredura (matrix scanning) opera de maneira contínua e ultrarrápida:

1. As 4 linhas são configuradas como saídas e as 4 colunas como entradas com resistores de pull-up internos ativados;
2. O microcontrolador coloca uma linha por vez em nível baixo (LOW), mantendo as demais em nível alto (HIGH);
3. Em seguida, lê sequencialmente o estado lógico das 4 colunas. Se uma tecla for pressionada, a linha em LOW fechará contato elétrico com a respectiva coluna, fazendo a leitura daquela entrada cair para LOW;
4. Por combinação biunívoca da linha ativa com a coluna em nível baixo, o sistema identifica de forma inequívoca qual das 16 teclas foi acionada, aplicando ainda rotinas internas de compensação de repique mecânico (debouncing).

Materiais Necessários:

Componente	Quantidade	Especificação Técnica / Observações
Placa Uno DIP 16u2	1	Unidade de varredura matricial
Teclado de Membrana 4x4	1	16 teclas (0–9, A–D, *, #) com flat cable de 8 vias
Barra de Jumpers Macho-Macho	8	Para conexão do soquete fêmea do flat cable aos pinos da Uno

Conexão do Flat Cable de 8 Vias:

Seguindo a ordem dos 8 pinos do conector do flat cable da esquerda para a direita (com a superfície frontal do teclado voltada para você):

Terminal do Flat Cable	Identificação	Pino no Arduino Uno
Pino 1 (Extrema Esquerda)	Linha 1 (Row 0)	Pino Digital D9
Pino 2	Linha 2 (Row 1)	Pino Digital D8
Pino 3	Linha 3 (Row 2)	Pino Digital D7
Pino 4	Linha 4 (Row 3)	Pino Digital D6
Pino 5	Coluna 1 (Col 0)	Pino Digital D5
Pino 6	Coluna 2 (Col 1)	Pino Digital D4
Pino 7	Coluna 3 (Col 2)	Pino Digital D3
Pino 8 (Extrema Direita)	Coluna 4 (Col 3)	Pino Digital D2

📦 Bibliotecas desta lição:

• Keypad.h (versão 3.1.1, inclusa no arquivo 3.Libraries/Keypad.zip ou instalável pelo Library Manager) — Realiza a varredura matricial em background e filtra ruídos transitórios de contato mecânico.

Código-Fonte Completo Comentado (custom_keypad.ino):

// Lição 11: Leitura de Teclado Matricial 4x4
// Kit Avançado AE086 RB2051 - RoboBuilders

// Inclusão da biblioteca oficial de gerenciamento de teclados matriciais
#include <Keypad.h>

// Definição da matriz de 4 linhas e 4 colunas
const byte ROWS = 4; // Quatro linhas
const byte COLS = 4; // Quatro colunas

// Mapa de caracteres correspondente à serigrafia visual do teclado
char hexaKeys[ROWS][COLS] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};

// Mapeamento dos pinos do microcontrolador conectados às 4 linhas
byte rowPins[ROWS] = {9, 8, 7, 6};

// Mapeamento dos pinos do microcontrolador conectados às 4 colunas
byte colPins[COLS] = {5, 4, 3, 2};

// Inicialização e criação do objeto customKeypad com as configurações de pinagem
Keypad customKeypad = Keypad(makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS);

void setup() {
  // Inicia a porta serial com velocidade de 9600 bps para exibição de caracteres digitados
  Serial.begin(9600);
}

void loop() {
  // Realiza a varredura e retorna o caractere pressionado (ou NO_KEY se nenhuma tecla for acionada)
  char customKey = customKeypad.getKey();

  // Se uma tecla válida for detectada, imprime-a imediatamente no console
  if (customKey) {
    Serial.println(customKey);
  }
}

Teste e Validação:

1. Carregue o sketch e abra o Monitor Serial a 9600 baud.
2. Pressione qualquer tecla numérica (0 a 9), letra (A, B, C, D) ou símbolo (*, #): o caractere correspondente será exibido instantaneamente no console, pronto para ser integrado a fechaduras eletrônicas ou sistemas de senha.

---

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

A Lição 12 aborda a medição simultânea de temperatura ambiente e umidade relativa do ar utilizando o transdutor integrado DHT11, analisando seu protocolo proprietário digital de barramento unifilar (one-wire assíncrono).

O DHT11 encapsula internamente um elemento resistivo sensor de umidade relativa (filme de polímero higroscópico), um termistor NTC para medição térmica e um microcontrolador de 8 bits dedicado que calibra e serializa os dados. Todo o pacote de medição é transmitido por uma única linha de dados através de um trem de 40 bits estruturado em 5 bytes:

• Byte 0: Parte inteira da umidade relativa (% RH);
• Byte 1: Parte decimal da umidade;
• Byte 2: Parte inteira da temperatura (°C);
• Byte 3: Parte decimal da temperatura;
• Byte 4: Soma de verificação (checksum = Byte 0 + Byte 1 + Byte 2 + Byte 3).

A biblioteca inclusa no kit (dht_nonblocking.h) adota uma arquitetura orientada a máquinas de estado não-bloqueantes: em vez de congelar a execução do processador com chamadas bloqueantes de delay(), ela faz amostragens temporizadas a cada 2 segundos respeitando os limites físicos de estabilização do elemento químico higroscópico.

Materiais Necessários:

Componente	Quantidade	Especificação Técnica / Observações
Placa Uno DIP 16u2	1	Unidade de leitura
Módulo Sensor DHT11	1	Faixa: 20–90% RH (±5%) e 0–50 °C (±2 °C) com placa integrada
Jumpers Fêmea-Macho	3	VCC, GND e Dados

Pinagem do Módulo DHT11:

O módulo de 3 pinos fornecido no kit já conta com resistor de pull-up soldado internamente:

Pino no Módulo DHT11	Pino no Arduino Uno	Função Elétrica
Pino + (VCC)	5V	Alimentação contínua de 3,3 V a 5,5 VDC
Pino Out / S (Dados)	Pino Digital D2	Linha de comunicação serial unifilar
Pino - (GND)	Barramento GND	Retorno de terra

📦 Bibliotecas desta lição:

• dht_nonblocking.h (versão 1.0.0, inclusa no arquivo 3.Libraries/DHT.zip do kit) — Gerencia a captura dos 40 bits por temporização em microsegundos sem bloquear o laço principal.

Código-Fonte Completo Comentado (DHT11_Example.ino):

// Lição 12: Sensoriamento Termo-higrométrico Digital com DHT11
// Kit Avançado AE086 RB2051 - RoboBuilders

// Inclusão da biblioteca de leitura não-bloqueante do DHT11
#include <dht_nonblocking.h>

// Definição do modelo de transdutor e do pino de dados conectado
#define DHT_SENSOR_TYPE DHT_TYPE_11
static const int DHT_SENSOR_PIN = 2;

// Instanciação do objeto sensor
DHT_nonblocking dht_sensor(DHT_SENSOR_PIN, DHT_SENSOR_TYPE);

void setup() {
  // Inicializa a interface de comunicação serial a 9600 bps
  Serial.begin(9600);
}

// Função auxiliar que gerencia a periodicidade de leitura a cada 2,5 segundos
static bool measure_environment(float *temperature, float *humidity) {
  static unsigned long measurement_timestamp = millis();

  // O DHT11 requer no mínimo 2000 ms entre amostragens consecutivas para estabilização térmica
  if (millis() - measurement_timestamp > 2500ul) {
    if (dht_sensor.measure(temperature, humidity) == true) {
      measurement_timestamp = millis();
      return true; // Leitura bem-sucedida e validada pelo checksum
    }
  }
  return false;
}

void loop() {
  float temperature;
  float humidity;

  // Realiza a chamada não-bloqueante; se uma nova leitura estiver pronta, exibe os valores
  if (measure_environment(&temperature, &humidity) == true) {
    Serial.print("T = ");
    Serial.print(temperature, 1);
    Serial.print(" °C | H = ");
    Serial.print(humidity, 1);
    Serial.println(" %");
  }
}

Teste e Validação:

1. Carregue o programa e abra o Monitor Serial a 9600 baud.
2. A cada 2,5 segundos, a linha de telemetria informará a temperatura e a umidade. Sopre suavemente sobre a carcaça azul do sensor: o ar úmido exalado provocará uma elevação imediata na leitura de umidade para mais de 70% ou 80%, comprovando a reatividade do transdutor.

---

Lição 13: Módulo Joystick Analógico de 2 Eixos com Botão Integrado

A Lição 13 explora o controle proporcional bidimensional através de um módulo joystick analógico de 2 eixos, equivalente aos controladores utilizados em manetes de aeronaves, drones e videogames.

O módulo joystick é composto por dois potenciômetros mecânicos independentes de $10\,\text{k}\Omega$ montados perpendicularmente em um arranjo cartesiano a 90 graus (eixos X e Y). Uma haste central com mola de retorno força ambos os potenciômetros para a posição central de repouso. Além disso, a haste atua sobre uma microchave tátil interna no sentido vertical (eixo Z / botão SW):

• Posição central de repouso: os cursores móveis encontram-se na metade da pista resistiva, fornecendo uma tensão próxima de $2{,}5\,\text{V}$ nos terminais de saída analógica, que o ADC de 10 bits do Arduino quantiza em valores próximos de $512$ ($\pm 30$ de banda morta por tolerância mecânica);
• Deslocamento total para um extremo: a tensão varia até $0{,}0\,\text{V}$ (valor digital $0$);
• Deslocamento para o extremo oposto: a tensão alcança $5{,}0\,\text{V}$ (valor digital $1023$);
• Botão SW: opera como uma chave momentânea que aterra o pino quando a alavanca é pressionada para baixo.

Materiais Necessários:

Componente	Quantidade	Especificação Técnica / Observações
Placa Uno DIP 16u2	1	Conversão analógica nos canais A0 e A1
Módulo Joystick Analógico	1	Potenciômetros duplos de 10 kΩ com botão de clique
Jumpers Fêmea-Macho	5	VCC, GND, VRX, VRY e SW

Mapeamento Pino a Pino:

Pino no Joystick	Identificação	Pino no Arduino Uno	Tipo de Sinal
GND	Terra comum	Barramento GND	0 VDC
+5V	Alimentação positiva	Terminal 5V	+5 VDC contínuos
VRX	Tensão analógica do eixo X	Entrada Analógica A0	0 a 1023 (Centro ~512)
VRY	Tensão analógica do eixo Y	Entrada Analógica A1	0 a 1023 (Centro ~512)
SW	Chave digital de pressão	Pino Digital D2	Pull-up ativado (LOW = clicado)

📦 Bibliotecas desta lição: Nenhuma biblioteca externa necessária.

Código-Fonte Completo Comentado (Analog_Joystick.ino):

// Lição 13: Aquisição Analógica de Joystick Biaxial com Botão
// Kit Avançado AE086 RB2051 - RoboBuilders

// Definição dos pinos de interface
const int SW_pin = 2; // Pino digital conectado ao botão de clique SW
const int X_pin = 0;  // Pino analógico A0 conectado ao cursor do eixo horizontal VRX
const int Y_pin = 1;  // Pino analógico A1 conectado ao cursor do eixo vertical VRY

void setup() {
  // Configura a entrada digital do botão com pull-up interno ativado
  // Em repouso lê HIGH (1); ao ser pressionado pelo clique, aterra para LOW (0)
  pinMode(SW_pin, INPUT_PULLUP);

  // Inicia a transmissão serial a 9600 baud para telemetria
  Serial.begin(9600);
}

void loop() {
  // Realiza a leitura digital do botão
  int swState = digitalRead(SW_pin);

  // Realiza as conversões analógicas dos eixos X e Y (0 a 1023 passos)
  int xVal = analogRead(X_pin);
  int yVal = analogRead(Y_pin);

  // Envia as leituras formatadas via console serial
  Serial.print("Botao: ");
  Serial.print(swState);
  Serial.print(" | Eixo X: ");
  Serial.print(xVal);
  Serial.print(" | Eixo Y: ");
  Serial.println(yVal);

  // Pausa de 200 ms para facilitar a leitura no console
  delay(200);
}

Teste e Validação:

1. Carregue o programa e abra o Monitor Serial a 9600 baud.
2. Em repouso, observe os valores de X e Y situados próximos a 512 com botão em 1.
3. Empurre a alavanca para a esquerda/direita e para cima/baixo: os números variarão fluidamente de 0 a 1023. Pressione o centro da alavanca com o polegar: o valor de Botão comutará instantaneamente para 0.

---

Lição 14: Receptor Infravermelho (IR) e Controle Remoto — Decodificação NEC

A Lição 14 aborda a recepção e demodulação óptica de comandos codificados pelo protocolo infravermelho NEC a 38 kHz, decodificando as teclas de um controle remoto portátil.

A comunicação infravermelha comercial não transmite pulsos contínuos de luz invisível, pois lâmpadas e a luz solar causariam saturação e ruído imediato no fotodiodo. Para superar isso, o emissor no controle remoto chaveia o feixe óptico infravermelho (comprimento de onda de 940 nm) em uma frequência de portadora de 38 kHz.

O sensor AX-1838HS do kit possui em seu corpo um filtro óptico para luz visível, um circuito amplificador com ganho automático (AGC) e um demodulador de 38 kHz. Sua saída entrega um trem de pulsos em banda base limpo em nível TTL. No protocolo NEC, uma transmissão consiste em:

• Pulso de cabeçalho inicial (burst) de 9 ms seguido de uma pausa de 4,5 ms;
• 8 bits de endereço do dispositivo seguidos de 8 bits de endereço invertido para validação;
• 8 bits de código de comando da tecla seguidos de 8 bits de comando invertido;
• Codificação dos bits por distância de pulso: um bit 0 lógico dura 1,12 ms total, enquanto um bit 1 lógico dura 2,25 ms.

Materiais Necessários:

Componente	Quantidade	Especificação Técnica / Observações
Placa Uno DIP 16u2	1	Processamento de temporização de bordas
Módulo Receptor IR (AX-1838HS)	1	Demodulador integrado de 38 kHz
Mini Controle Remoto IR	1	21 teclas de membrana com bateria CR2025/CR2032
Jumpers Fêmea-Macho	3	VCC, GND e Sinal de Dados

Pinagem do Módulo Receptor IR:

Identificação no Módulo	Pino no Arduino Uno	Observações
VCC / +	Terminal 5V	Alimentação contínua de 5 V
GND / -	Barramento GND	Linha de terra
IN / S / DAT	Pino Digital D11	Sinal demodulado em nível lógico TTL

📦 Bibliotecas desta lição:

• IRremote.h (versão 2.8.x inclusa na pasta 3.Libraries/IRremote.zip do kit) — Trata interrupções de hardware para captura de bordas e decodificação do protocolo NEC.

Código-Fonte Completo Comentado (IR_Receiver_Module.ino):

// Lição 14: Decodificação de Controle Remoto Infravermelho NEC
// Kit Avançado AE086 RB2051 - RoboBuilders

// Inclusão da biblioteca de captura e demodulação de infravermelho
#include <IRremote.h>

// Definição do pino digital receptor
int receiver = 11;

// Instanciação dos objetos da biblioteca IRremote
IRrecv irrecv(receiver);     // Criação da instância receptora no pino 11
decode_results results;      // Estrutura de dados para armazenar o código hexadecimal recebido

void setup() {
  // Inicialização do canal de comunicação serial a 9600 baud
  Serial.begin(9600);
  Serial.println("Receptor Infravermelho Inicializado...");

  // Inicializa o circuito receptor e o timer de captura por interrupção
  irrecv.enableIRIn();
}

void loop() {
  // Verifica se um pacote infravermelho foi capturado e decodificado com sucesso
  if (irrecv.decode(&results)) {
    // Imprime o código hexadecimal de 32 bits correspondente à tecla pressionada
    Serial.print("Codigo Hex: 0x");
    Serial.println(results.value, HEX);

    // Reinicializa o receptor para habilitar a captura do próximo pacote de sinal
    irrecv.resume();
  }
  // Pequeno delay para aliviar o laço principal
  delay(100);
}

Teste e Identificação de Teclas:

1. Retire a fita plástica protetora da bateria na parte inferior do controle remoto.
2. Carregue o programa e abra o Monitor Serial a 9600 baud.
3. Aponte o controle remoto para o receptor e pressione as teclas: cada botão enviará um identificador hexadecimal exclusivo e consistente (por exemplo: tecla POWER = 0xFFA25D, tecla 1 = 0xFF30CF, tecla + = 0xFFA857). Se uma tecla for mantida pressionada continuamente, o protocolo NEC emitirá o código de repetição 0xFFFFFFFF.

---

Lição 15: Módulo Matriz de LED 8x8 com Driver MAX7219

A Lição 15 ensina a comandar um display gráfico monocromático de 64 LEDs (matriz 8x8) através do circuito integrado especializado de varredura multiplexada MAX7219.

Acionar 64 diodos emissores de luz de forma matricial convencional exigiria 16 portas de saída do microcontrolador (8 ânodos de linha e 8 cátodos de coluna) e código de temporização por interrupção contínua. O circuito integrado MAX7219 soluciona este desafio incorporando:

• Registradores de memória estática de 8x8 bits (um byte para cada linha da matriz);
• Circuitos internos de varredura por multiplexação no tempo na frequência de 800 Hz (completamente livre de oscilações ou flicker);
• Fonte de corrente constante controlada por resistor único, garantindo brilho perfeitamente uniforme entre os LEDs sem a necessidade de 64 resistores externos;
• Interface serial síncrona tipo SPI de 3 fios: DIN (Data In), CLK (Clock) e CS / LOAD (Chip Select).

A biblioteca LedControl.h permite controlar individualmente qualquer LED pela coordenada cartesiana setLed(modulo, linha, coluna, estado) ou carregar linhas inteiras através de bytes em binário com setRow(modulo, linha, byte).

Materiais Necessários:

Componente	Quantidade	Especificação Técnica / Observações
Placa Uno DIP 16u2	1	Unidade de comando SPI
Módulo Matriz de LED 8x8 MAX7219	1	Matriz vermelha de 32 mm com placa integrada
Jumpers Fêmea-Macho	5	VCC, GND, DIN, CS e CLK

Tabela de Pinagem:

Pino no Módulo MAX7219	Pino no Arduino Uno	Descrição Funcional
VCC	5V	Alimentação contínua de 5,0 VDC
GND	Barramento GND	Terra elétrico compartilhado
DIN (Data In)	Pino Digital D12	Linha de transmissão serial de dados síncronos
CS (Chip Select)	Pino Digital D10	Habilitação e travamento de dados (Latch)
CLK (Clock)	Pino Digital D11	Sinal de relógio síncrono para deslocamento de bits

📦 Bibliotecas desta lição:

• LedControl.h (versão 1.0.6, inclusa no arquivo 3.Libraries/LedControl.zip do kit) — Gerencia a comunicação SPI e oferece primitivas de acendimento de pixels e caracteres.

Código-Fonte Completo Comentado (MAX7219.ino):

// Lição 15: Controle de Matriz de LEDs 8x8 com Driver MAX7219
// Kit Avançado AE086 RB2051 - RoboBuilders

// Inclusão da biblioteca de controle do driver MAX7219
#include "LedControl.h"

// Definição das portas seriais de comunicação:
// Pino 12 = DIN, Pino 11 = CLK, Pino 10 = CS/Load, 1 = número de módulos MAX7219 em cascata
LedControl lc = LedControl(12, 11, 10, 1);

// Mapa binário de caracteres: Desenho de um "Coração" em 8 linhas de 8 bits
// Cada bit '1' representa um LED aceso; '0' representa LED apagado
const byte heartShape[8] = {
  B00000000,
  B01100110,
  B11111111,
  B11111111,
  B11111111,
  B01111110,
  B00111100,
  B00011000
};

// Mapa de uma "Carinha Feliz" (Smiley Face)
const byte smileShape[8] = {
  B00111100,
  B01000010,
  B10100101,
  B10000001,
  B10100101,
  B10011001,
  B01000010,
  B00111100
};

void setup() {
  // O MAX7219 inicializa em modo de economia de energia (Power-Saving / Shutdown)
  // É necessário retirá-lo do modo de suspensão no primeiro argumento (módulo 0)
  lc.shutdown(0, false);

  // Configura a intensidade de brilho do display (valores de 0 a 15)
  // Adotamos brilho intermediário 8 para evitar consumo excessivo de corrente
  lc.setIntensity(0, 8);

  // Limpa todos os 64 LEDs da matriz do módulo 0
  lc.clearDisplay(0);
}

void loop() {
  // 1. Exibe o desenho do Coração linha por linha
  for (int row = 0; row < 8; row++) {
    lc.setRow(0, row, heartShape[row]);
  }
  delay(2000); // Exibe por 2 segundos

  // 2. Exibe o desenho da Carinha Feliz
  for (int row = 0; row < 8; row++) {
    lc.setRow(0, row, smileShape[row]);
  }
  delay(2000); // Exibe por 2 segundos

  // 3. Efeito estroboscópico de varredura individual de LEDs
  lc.clearDisplay(0);
  for (int r = 0; r < 8; r++) {
    for (int c = 0; c < 8; c++) {
      lc.setLed(0, r, c, true); // Acende o pixel na coordenada (r, c)
      delay(20);
      lc.setLed(0, r, c, false); // Apaga o pixel
    }
  }
}

Teste e Validação:

1. Instale a biblioteca LedControl.zip na IDE.
2. Carregue o programa: a matriz de 8x8 LEDs alternará entre os ícones gráficos nítidos com excelente uniformidade óptica de brilho.

---

Lição 16: Módulo Acelerômetro e Giroscópio de 6 Eixos GY-521 (MPU6050)

A Lição 16 explora a instrumentação inercial de ponta utilizando o módulo GY-521, baseado no circuito integrado microeletromecânico (MEMS — Micro-Electro-Mechanical Systems) MPU-6050, que combina um acelerômetro triaxial e um giroscópio triaxial com barramento de comunicação I2C.

O MPU-6050 possui 6 conversores analógico-digitais de 16 bits integrados que digitalizam continuamente forças inerciais e velocidades angulares ao longo dos três eixos espaciais ortogonais ($X, Y, Z$):

1. Acelerômetro Triaxial: Mede acelerações estáticas da gravidade ($1g = 9{,}81\,\text{m/s}^2$) e acelerações dinâmicas resultantes de choques e movimento. Na escala configurada de $\pm 2g$, o fator de sensibilidade é de $16384\,\text{LSB}/g$;
2. Giroscópio Triaxial: Mede a velocidade angular de rotação em torno dos eixos ($Roll$, $Pitch$ e $Yaw$). Na escala de $\pm 250^\circ/\text{s}$, a sensibilidade é de $131\,\text{LSB}/(^\circ/\text{s})$;
3. Sensor de Temperatura Integrado: Monitora o calor interno do silício para correção de desvios térmicos (bias drift).

O protocolo I2C utiliza o endereço de 7 bits 0x68 (quando o pino AD0 é mantido em nível baixo) e opera através de apenas dois fios condutores: SDA (Serial Data) no pino A4 e SCL (Serial Clock) no pino A5 do Arduino Uno.

Materiais Necessários:

Componente	Quantidade	Especificação Técnica / Observações
Placa Uno DIP 16u2	1	Mestre I2C no barramento de dois fios
Módulo Inercial GY-521 (MPU6050)	1	Transdutor inercial de 6 graus de liberdade (6-DoF)
Jumpers Fêmea-Macho	4	VCC, GND, SCL e SDA

Conexões do Barramento I2C:

Pino no GY-521	Pino no Arduino Uno	Descrição Elétrica
VCC	5V	O módulo GY-521 inclui regulador LDO de 3,3V interno (aceita 5V)
GND	Barramento GND	Referência de terra compartilhada
SCL	Entrada Analógica A5	Relógio síncrono I2C (Serial Clock)
SDA	Entrada Analógica A4	Linha bidirecional de dados I2C (Serial Data)

📦 Bibliotecas desta lição:

• Wire.h (nativa do Arduino AVR Core) — Gerencia as condições de START, STOP e ACK do barramento I2C.

Código-Fonte Completo Comentado (MPU-6050.ino):

// Lição 16: Aquisição Inercial de 6 Eixos com MPU-6050 via I2C
// Kit Avançado AE086 RB2051 - RoboBuilders

// Inclusão da biblioteca nativa para comunicação com barramentos I2C
#include <Wire.h>

// Endereço I2C de 7 bits do transdutor MPU-6050 (quando pino AD0 está aterrado)
const int MPU_ADDR = 0x68;

// Variáveis de 16 bits para armazenar as leituras brutas dos sensores
int16_t AcX, AcY, AcZ; // Componentes de aceleração nos eixos X, Y e Z
int16_t Tmp;           // Dado bruto do sensor térmico interno do chip
int16_t GyX, GyY, GyZ; // Velocidades angulares nos eixos X, Y e Z

void setup() {
  // Inicializa a interface mestre I2C
  Wire.begin();

  // Inicia a transmissão para o endereço do MPU-6050
  Wire.beginTransmission(MPU_ADDR);
  // Aponta para o registrador de gerenciamento de energia PWR_MGMT_1 (endereço 0x6B)
  Wire.write(0x6B);
  // Escreve 0 no registrador para 'acordar' o sensor retirando-o do modo Sleep
  Wire.write(0);
  Wire.endTransmission(true);

  // Inicializa o Monitor Serial para saída dos dados a 9600 bps
  Serial.begin(9600);
  Serial.println("MPU-6050 Ativo e Operacional!");
}

void loop() {
  // Configura a leitura a partir do primeiro registrador de aceleração (ACCEL_XOUT_H = 0x3B)
  Wire.beginTransmission(MPU_ADDR);
  Wire.write(0x3B);
  Wire.endTransmission(false);

  // Solicita 14 bytes consecutivos de dados inerciais em sequência contínua:
  // 6 bytes de aceleração + 2 bytes de temperatura + 6 bytes de rotação
  Wire.requestFrom(MPU_ADDR, 14, true);

  // Concatena pares de bytes (High Byte e Low Byte) através de deslocamento e OU bit a bit
  AcX = Wire.read() << 8 | Wire.read(); // Aceleração X
  AcY = Wire.read() << 8 | Wire.read(); // Aceleração Y
  AcZ = Wire.read() << 8 | Wire.read(); // Aceleração Z
  Tmp = Wire.read() << 8 | Wire.read(); // Temperatura
  GyX = Wire.read() << 8 | Wire.read(); // Giroscópio X
  GyY = Wire.read() << 8 | Wire.read(); // Giroscópio Y
  GyZ = Wire.read() << 8 | Wire.read(); // Giroscópio Z

  // Converte a leitura bruta do sensor de temperatura para graus Celsius conforme datasheet oficial:
  // Formula: Temp_C = (Tmp / 340.0) + 36.53
  float tempCelsius = (Tmp / 340.0) + 36.53;

  // Imprime os valores inerciais no Monitor Serial
  Serial.print("AcX: "); Serial.print(AcX);
  Serial.print(" | AcY: "); Serial.print(AcY);
  Serial.print(" | AcZ: "); Serial.print(AcZ);
  Serial.print(" | Temp: "); Serial.print(tempCelsius, 1); Serial.print(" C");
  Serial.print(" | GyX: "); Serial.print(GyX);
  Serial.print(" | GyY: "); Serial.print(GyY);
  Serial.print(" | GyZ: "); Serial.println(GyZ);

  // Intervalo de amostragem de 300 ms
  delay(300);
}

Teste e Validação:

1. Carregue o programa e abra o Monitor Serial a 9600 baud.
2. Com a placa em repouso nivelada sobre a mesa, o eixo $Z$ registrará aproximadamente $+16384$ (indicando a força da gravidade normal de $1g$ atuando para baixo), enquanto $X$ e $Y$ ficarão próximos a zero.
3. Ao inclinar ou girar o módulo na mão, os valores de giroscópio e aceleração responderão dinamicamente em tempo real.

---

Lição 17: Sensor de Presença Infravermelho Passivo (PIR) AM312

A Lição 17 estuda a detecção volumétrica de presença humana utilizando o sensor piroelétrico passivo miniatura AM312, empregado em sistemas de iluminação inteligente, automação predial e alarmes antifurto.

O corpo humano emite calor continuamente sob a forma de radiação eletromagnética infravermelha com comprimento de onda entre $9\,\mu\text{m}$ e $10\,\mu\text{m}$. O sensor AM312 integra uma pastilha de cristal piroelétrico sensível a essa faixa térmica, recoberta por uma lente multifacetada de Fresnel. Essa lente fraciona o campo de visão em múltiplos feixes cônicos alternados:

• Quando o ambiente está estático, a radiação incidente sobre as duas metades balanceadas da pastilha piroelétrica é idêntica, mantendo a saída em nível baixo (0V);
• Quando um corpo com temperatura biológica (pessoa ou animal) se desloca cruzando as zonas de foco da lente de Fresnel, as metades da pastilha experimentam um desequilíbrio térmico diferencial transitório;
• O circuito eletrônico interno integrado processa esse sinal e eleva seu pino de saída para nível lógico alto (HIGH / 3,3 V) por um período temporizado de aproximadamente 2 a 3 segundos.

Materiais Necessários:

Componente	Quantidade	Especificação Técnica / Observações
Placa Uno DIP 16u2	1	Aquisição digital de eventos
Módulo Sensor PIR AM312	1	Ângulo de detecção de 100°, alcance de até 3 a 5 metros
LED Difuso Vermelho 5 mm	1	Indicador luminoso de presença
Resistor de 220 Ω (1/4W)	1	Limitador de corrente do LED
Jumpers Fêmea-Macho / Macho-Macho	5	Condutores de ligação

Pinagem do Sensor AM312:

Com a cúpula da lente voltada para cima e os pinos apontados em sua direção:

Terminal do AM312	Indicação	Pino no Arduino Uno	Função Elétrica
Terminal Esquerdo	VCC	Terminal 5V	Alimentação de 2,7 V a 12 VDC
Terminal Central	OUT	Pino Digital D7	Saída digital (HIGH = movimento detectado)
Terminal Direito	GND	Barramento GND	Linha de terra

📦 Bibliotecas desta lição: Nenhuma biblioteca externa necessária.

Código-Fonte Completo Comentado (AM312.ino):

// Lição 17: Detecção de Presença e Movimento com PIR AM312
// Kit Avançado AE086 RB2051 - RoboBuilders

const int pirPin = 7;    // Pino digital conectado à saída de sinal do sensor AM312
const int ledPin = 13;   // Pino do LED indicador de alarme (LED D13 integrado na Uno)

void setup() {
  // Configura o pino do LED indicador como saída
  pinMode(ledPin, OUTPUT);

  // Configura o pino do sensor PIR como entrada digital
  pinMode(pirPin, INPUT);

  // Inicializa o Monitor Serial para depuração
  Serial.begin(9600);
  Serial.println("Calibrando sensor PIR AM312 (aguarde 5 segundos)...");

  // Período de warm-up térmico para o sensor estabilizar o nível de repouso
  delay(5000);
  Serial.println("Sensor Pronto para Deteccao!");
}

void loop() {
  // Realiza a leitura do estado lógico emitido pelo transdutor piroelétrico
  int motionDetected = digitalRead(pirPin);

  if (motionDetected == HIGH) {
    digitalWrite(ledPin, HIGH); // Acende o LED alertando presença humana
    Serial.println("ALERTA: Movimento Humano Detectado!");
  } else {
    digitalWrite(ledPin, LOW);  // Desliga o LED quando não há deslocamento
  }

  // Amostragem a cada 200 ms
  delay(200);
}

Teste e Validação:

1. Carregue o programa e afaste as mãos do sensor durante os 5 segundos iniciais de calibração térmica.
2. Mova a mão a cerca de 1 metro de distância do sensor: o LED no pino 13 acenderá instantaneamente e o alerta surgirá no console, retornando ao estado de repouso após alguns segundos de imobilidade.

---

Módulo 3 — Sensoriamento Especializado, Tempo, Som, RFID e Displays (Lições 18 a 23)

O Módulo 3 aborda subsistemas eletrônicos especializados para aplicações industriais e residenciais: detecção condutiva de nível de líquidos, cronometria de alta precisão com relógio de tempo real em barramento I2C, transdução eletroacústica de ruído ambiente, controle de acesso seguro por radiofrequência a 13,56 MHz em barramento SPI, inicialização e escrita de displays LCD alfanuméricos em barramento paralelo de 4 bits e instrumentação térmica de alta precisão com termistor NTC combinada à exibição em tempo real no display.

---

Lição 18: Módulo Sensor de Nível e Presença de Água

A Lição 18 aborda a quantificação analógica de volume de líquido através de um sensor condutivo de nível de água, amplamente utilizado em reservatórios, caixas d’água, sistemas de irrigação automatizada e detecção preventiva de inundações.

O sensor de nível é construído com uma série de dez trilhas condutivas expostas paralelas dispostas sobre uma placa de circuito impresso. Cinco dessas trilhas são conectadas à linha de alimentação positiva (+5V) e as cinco intercaladas são interligadas à linha de saída analógica através de um circuito transistorizado ou divisor resistivo de polarização.

• Quando o sensor está completamente seco no ar, a resistência entre as trilhas é quase infinita ($R > 20\,\text{M}\Omega$), resultando em uma leitura de tensão nula ou próxima de 0 V (valor quantizado $ADC \approx 0$ a $50$);
• Conforme a água com eletrólitos e sais minerais entra em contato com a superfície da placa, o líquido atua como um condutor ôhmico paralelo que fecha o circuito entre as trilhas polarizadas;
• Quanto maior a profundidade de imersão do sensor na lâmina d’água, maior será a área molhada e o número de trilhas interligadas, reduzindo a resistência equivalente do circuito e elevando proporcionalmente a tensão entregue à entrada analógica A0.

Materiais Necessários:

Componente	Quantidade	Especificação Técnica / Observações
Placa Uno DIP 16u2	1	Aquisição de conversão A/D
Módulo Sensor de Nível de Água	1	Trilhas banhadas com saída analógica
Copo ou Recipiente com Água	1	Para teste prático de imersão gradual
Jumpers Fêmea-Macho	3	VCC, GND e Sinal Analógico (S)

Pinagem do Sensor de Água:

Pino no Módulo	Serigrafia	Pino no Arduino Uno	Função
+ / VCC	Linha Positiva	Terminal 5V	Alimentação de 3,3 V a 5,0 VDC
- / GND	Terra	Barramento GND	Linha de referência
S / OUT	Sinal	Entrada Analógica A0	Saída de tensão analógica proporcional

📦 Bibliotecas desta lição: Nenhuma biblioteca externa necessária.

Código-Fonte Completo Comentado (Water_level.ino):

// Lição 18: Medição de Nível e Presença de Líquido por Condutância
// Kit Avançado AE086 RB2051 - RoboBuilders

// Definição do pino do conversor analógico-digital conectado ao sinal do sensor
const int waterSensorPin = A0;

// Variável para armazenar a leitura do conversor de 10 bits (0 a 1023)
int sensorValue = 0;

void setup() {
  // Inicializa a interface serial na velocidade de 9600 bps para telemetria
  Serial.begin(9600);
  Serial.println("Sensor de Nivel de Agua Iniciado...");
}

void loop() {
  // Realiza a leitura da grandeza analógica de tensão no pino A0
  sensorValue = analogRead(waterSensorPin);

  // Exibe a leitura bruta do conversor analógico-digital no console
  Serial.print("Leitura Analogica de Nivel: ");
  Serial.print(sensorValue);

  // Classificação lógica da intensidade de imersão
  if (sensorValue < 50) {
    Serial.println(" -> Estado: Totalmente Seco");
  } else if (sensorValue < 300) {
    Serial.println(" -> Estado: Nivel Baixo");
  } else if (sensorValue < 500) {
    Serial.println(" -> Estado: Nivel Medio");
  } else {
    Serial.println(" -> Estado: Nivel Alto / Alerta de Transbordamento");
  }

  // Amostragem temporizada a cada 500 milissegundos
  delay(500);
}

Teste e Validação:

1. Carregue o sketch e abra o Monitor Serial a 9600 baud.
2. Com o sensor seco sobre a bancada, o valor reportado ficará abaixo de 50.
3. Mergulhe lentamente a ponta inferior do sensor em um copo com água: observe o incremento proporcional dos valores para 200, 350 e até mais de 600 conforme a linha d’água sobe pelas trilhas metálicas.

---

Lição 19: Módulo Relógio de Tempo Real (RTC) DS1307 via Barramento I2C

A Lição 19 aborda a gestão de calendário e tempo real utilizando o circuito integrado DS1307 ou DS3231, essencial para dataloggers, automação de iluminação residencial, alimentadores automáticos e registros com carimbo de data e hora (timestamp).

Quando o microcontrolador ATmega328P é desligado ou reiniciado, suas variáveis internas de tempo e contagem de ciclos voltam a zero. O circuito de Relógio de Tempo Real (RTC — Real Time Clock) contorna isso mantendo um oscilador dedicado operando com um cristal de quartzo de frequência padrão de relógio de $32{,}768\,\text{kHz}$ ($2^{15}\,\text{Hz}$). Alimentado por uma bateria de botão de lítio de 3 V (CR2032), o chip continua contando segundos, minutos, horas, dia da semana, dia do mês, mês e ano (com compensação de anos bissextos) de forma autônoma por vários anos ininterruptos, mesmo sem energia na placa Arduino.

A troca de dados ocorre pelo barramento I2C no endereço hexadecimal fixo 0x68, utilizando os pinos analógicos A4 (SDA) e A5 (SCL).

Materiais Necessários:

Componente	Quantidade	Especificação Técnica / Observações
Placa Uno DIP 16u2	1	Mestre I2C
Módulo RTC DS1307 / DS3231	1	Com soquete e bateria de lítio de 3V CR2032 instalada
Jumpers Fêmea-Macho	4	VCC, GND, SDA e SCL

Pinagem do Módulo RTC:

Pino no Módulo RTC	Pino no Arduino Uno	Função Elétrica
VCC	5V	Alimentação primária contínua de 5,0 VDC
GND	Barramento GND	Terra de referência
SDA	Entrada Analógica A4	Linha bidirecional de dados I2C
SCL	Entrada Analógica A5	Relógio síncrono I2C

📦 Bibliotecas desta lição:

• Wire.h (nativa do Arduino AVR Core) — Gerenciamento do barramento I2C.
• DS1307.h ou DS3231.h (versão 1.0.1 inclusa na pasta 3.Libraries/DS1307.zip do kit) — Funções para ajuste e formatação de datas e horários em formato BCD (Binary-Coded Decimal).

Código-Fonte Completo Comentado (DS1307_Example.ino):

// Lição 19: Relógio de Tempo Real (RTC) DS1307 via Barramento I2C
// Kit Avançado AE086 RB2051 - RoboBuilders

// Inclusão das bibliotecas de barramento e manipulação de relógio
#include <Wire.h>
#include "DS1307.h"

// Instanciação do objeto de controle do RTC
DS1307 clock;

void setup() {
  // Inicialização do canal de depuração serial a 9600 baud
  Serial.begin(9600);

  // Inicialização do módulo de relógio de tempo real
  clock.begin();

  // ATENÇÃO: As linhas abaixo definem a data e hora iniciais do chip.
  // Execute-as uma primeira vez para calibrar o relógio e depois comente-as:
  clock.fillByYMD(2026, 9, 14); // Ano: 2026, Mês: 09 (Setembro), Dia: 14
  clock.fillByHMS(12, 0, 0);    // Horas: 12, Minutos: 00, Segundos: 00
  clock.fillDayOfWeek(MON);     // Dia da semana: Segunda-feira (Monday)
  clock.setTime();              // Grava os parâmetros nos registradores BCD do chip
}

void printTime() {
  // Requisita a atualização dos registradores internos do RTC
  clock.getTime();

  // Imprime no console a data formatada DD/MM/AAAA
  if (clock.dayOfMonth < 10) Serial.print("0");
  Serial.print(clock.dayOfMonth, DEC);
  Serial.print("/");
  if (clock.month < 10) Serial.print("0");
  Serial.print(clock.month, DEC);
  Serial.print("/");
  Serial.print(clock.year + 2000, DEC);
  Serial.print(" ");

  // Imprime a hora formatada HH:MM:SS
  if (clock.hour < 10) Serial.print("0");
  Serial.print(clock.hour, DEC);
  Serial.print(":");
  if (clock.minute < 10) Serial.print("0");
  Serial.print(clock.minute, DEC);
  Serial.print(":");
  if (clock.second < 10) Serial.print("0");
  Serial.println(clock.second, DEC);
}

void loop() {
  // Imprime o horário atualizado
  printTime();

  // Aguarda exatamente 1 segundo para a próxima amostragem temporal
  delay(1000);
}

Teste e Verificação:

1. Instale a biblioteca DS1307.zip na IDE.
2. Carregue o programa e abra o Monitor Serial: o relógio exibirá a contagem rigorosa de segundos a cada ciclo.
3. Desconecte a placa Uno da porta USB, aguarde alguns minutos e reconecte-a: graças à bateria de lítio, o relógio não terá se atrasado nem um único segundo.

---

Lição 20: Módulo Sensor de Som e Ruído com Microfone de Eletreto

A Lição 20 estuda a captação de ondas sonoras mecânicas através de um módulo sensor de som com microfone de eletreto, ensinando a processar tanto sinais analógicos brutos quanto gatilhos digitais ajustáveis por potenciômetro trimpot.

A cápsula do microfone de eletreto contém uma membrana flexível com carga eletrostática permanente e uma placa traseira rígida, formando um capacitor cuja capacitância varia com a pressão das ondas sonoras acústicas. Esse sinal em nível de milivolts é injetado em um circuito integrado amplificador operacional comparador (como o LM393):

1. Saída Analógica (AO): Disponibiliza diretamente o sinal elétrico contínuo proporcional à amplitude das vibrações acústicas captadas em tempo real;
2. Saída Digital (DO): Compara a amplitude com um limiar de tensão ajustável por um pequeno parafuso de trimpot na placa. Quando o nível de ruído ultrapassa o limiar estipulado (ex: uma palma de mão ou um estalo de dedos), a saída DO comuta de nível alto para nível baixo (LOW), disparando um gatilho digital imediato.

Materiais Necessários:

Componente	Quantidade	Especificação Técnica / Observações
Placa Uno DIP 16u2	1	Aquisição simultânea analógica e digital
Módulo Sensor de Som (Microfone de Eletreto)	1	Com 4 pinos (VCC, GND, DO, AO) e trimpot
Jumpers Fêmea-Macho	4	Conexões de alimentação e dois canais de sinal

Tabela de Pinagem:

Pino no Módulo de Som	Pino no Arduino Uno	Função
VCC	5V	Alimentação contínua de 5 VDC
GND	Barramento GND	Linha de terra
DO (Digital Out)	Pino Digital D4	Saída digital de gatilho com limiar
AO (Analog Out)	Entrada Analógica A0	Onda de áudio contínua (0 a 1023 passos)

📦 Bibliotecas desta lição: Nenhuma biblioteca externa necessária.

Código-Fonte Completo Comentado (Sound_Sensor_Example.ino):

// Lição 20: Detecção de Ruído e Palmas com Módulo de Som
// Kit Avançado AE086 RB2051 - RoboBuilders

const int soundAnalogPin = A0;  // Pino analógico conectado à saída AO do sensor
const int soundDigitalPin = 4;  // Pino digital conectado à saída DO do comparador
const int ledIndicator = 13;    // LED SMD interno para feedback visual imediato

void setup() {
  // Configura os modos de operação das portas
  pinMode(soundDigitalPin, INPUT);
  pinMode(ledIndicator, OUTPUT);

  // Inicia a comunicação serial para observação gráfica no Serial Plotter
  Serial.begin(9600);
}

void loop() {
  // Realiza a leitura da amplitude de onda instantânea no canal analógico
  int analogVal = analogRead(soundAnalogPin);

  // Realiza a leitura do gatilho digital do comparador LM393
  int digitalVal = digitalRead(soundDigitalPin);

  // Se a saída digital detectar um pico que supere o trimpot (nível LOW)
  if (digitalVal == LOW) {
    digitalWrite(ledIndicator, HIGH); // Acende o LED acusando pico acústico
    Serial.println("PICO ACUSTICO DETECTADO (Palma / Batida)!");
  } else {
    digitalWrite(ledIndicator, LOW);  // Apaga o LED no silêncio
  }

  // Imprime também o valor analógico contínuo para plotagem
  Serial.print("Nivel_Audio:");
  Serial.println(analogVal);

  delay(20); // Amostragem rápida de 50 Hz para capturar transientes sonoros
}

Teste e Ajuste de Sensibilidade:

1. Carregue o programa e abra a ferramenta Menu Ferramentas > Plotter Serial na IDE Arduino.
2. Com um pequeno chaveador plástico ou de fenda fina, gire o parafuso do trimpot no módulo até que o LED integrado apague no silêncio ambiente e pisque apenas quando você bater palmas a um metro de distância.

---

Lição 21: Módulo Leitor RFID RC522 (13,56 MHz) via Barramento SPI

A Lição 21 aborda a identificação por radiofrequência sem contato utilizando o módulo transceptor MFRC522 na frequência universal de 13,56 MHz, analisando a leitura e autenticação de chaves digitais e cartões inteligentes passivos do padrão Mifare no barramento SPI (Serial Peripheral Interface).

A tecnologia RFID opera pelo princípio do acoplamento indutivo em campo próximo (NFC — Near Field Communication). A antena serigrafada na placa do RC522 emite um campo magnético de alta frequência a 13,56 MHz. Quando um cartão ou chaveiro tag Mifare S50 passivo entra no campo de detecção (a até 3 a 5 cm de distância), a bobina interna da etiqueta absorve essa energia por indução eletromagnética para carregar um microcapacitor interno, alimentando momentaneamente seu chip sem precisar de bateria própria. O chip responde modulando a carga no campo magnético, transmitindo seu número de identificação único (UID — Unique Identifier).

O circuito MFRC522 comunica-se com a placa Uno através de um barramento SPI síncrono de alta velocidade:

• MOSI (Pino 11): Master Out Slave In — Linha de envio de comandos do Arduino para o leitor;
• MISO (Pino 12): Master In Slave Out — Linha de recepção de dados do leitor para o Arduino;
• SCK (Pino 13): Serial Clock — Relógio síncrono compartilhado;
• SDA / SS (Pino 10): Slave Select — Habilitação do chip escravo ativo;
• RST (Pino 9): Linha de hardware para reset forçado do leitor.

Materiais Necessários:

Componente	Quantidade	Especificação Técnica / Observações
Placa Uno DIP 16u2	1	Mestre SPI de comunicação
Módulo RFID-RC522 (13,56 MHz)	1	Com antena impressa e pinos soldados
Cartão RFID Mifare 1K (PVC Branco)	1	Etiqueta passiva com UID exclusivo gravado de fábrica
Chaveiro Tag RFID Mifare (Azul)	1	Etiqueta passiva em formato de chaveiro de bolso
Jumpers Fêmea-Macho	7	Barramento SPI e alimentação

Tabela de Pinagem SPI:

Pino no Módulo RC522	Pino no Arduino Uno	Especificação e Cuidados
3.3V	Terminal 3.3V	⚠️ NUNCA ligue no 5V! O chip MFRC522 opera estritamente a 3,3 V
RST	Pino Digital D9	Linha de Reset de hardware
GND	Barramento GND	Terra de referência compartilhado
MISO	Pino Digital D12	Linha MISO do barramento SPI do ATmega328P
MOSI	Pino Digital D11	Linha MOSI do barramento SPI do ATmega328P
SCK	Pino Digital D13	Linha de Clock síncrono do barramento SPI
SDA (SS)	Pino Digital D10	Linha Slave Select (habilitação em nível LOW)

📦 Bibliotecas desta lição:

• SPI.h (nativa do Arduino AVR Core) — Gerenciamento do periférico SPI em nível de hardware.
• MFRC522.h ou rfid.h (versão 1.4.10, inclusa na pasta 3.Libraries/rfid.zip do kit) — Abstrai a autenticação criptográfica e leitura de blocos de memória Mifare.

Código-Fonte Completo Comentado (MF-RC522_RFID.ino):

// Lição 21: Leitura e Autenticação de Tags RFID RC522 via SPI
// Kit Avançado AE086 RB2051 - RoboBuilders

// Inclusão das bibliotecas de barramento SPI e controle do RC522
#include <SPI.h>
#include <MFRC522.h>

// Definição dos pinos de controle de hardware
#define RST_PIN 9   // Pino de reset do módulo
#define SS_PIN  10  // Pino de seleção de escravo (SDA/SS)

// Instanciação do objeto do leitor RFID passando os pinos de controle
MFRC522 mfrc522(SS_PIN, RST_PIN);

void setup() {
  // Inicia a transmissão serial a 9600 baud para leitura dos UIDs
  Serial.begin(9600);
  while (!Serial); // Aguarda abertura do console serial

  // Inicia o barramento SPI do microcontrolador
  SPI.begin();

  // Inicializa o circuito integrado MFRC522
  mfrc522.PCD_Init();

  Serial.println("Aproxime um cartao ou chaveiro RFID de 13.56 MHz...");
}

void loop() {
  // Verifica se há uma nova etiqueta RFID presente no campo magnético da antena
  if (!mfrc522.PICC_IsNewCardPresent()) {
    return; // Se nenhum cartão estiver presente, reinicia o loop
  }

  // Realiza a leitura do número de identificação serial (UID) da etiqueta
  if (!mfrc522.PICC_ReadCardSerial()) {
    return; // Se houver falha na leitura dos bytes, reinicia o loop
  }

  // Imprime o cabeçalho no Monitor Serial
  Serial.print("Cartao Identificado! UID (Hexadecimal): ");

  // O UID da tecnologia Mifare S50 é composto por 4 bytes (32 bits)
  for (byte i = 0; i < mfrc522.uid.size; i++) {
    // Exibe um zero à esquerda para formatação de valores menores que 0x10
    if (mfrc522.uid.uidByte[i] < 0x10) {
      Serial.print(" 0");
    } else {
      Serial.print(" ");
    }
    Serial.print(mfrc522.uid.uidByte[i], HEX);
  }
  Serial.println();

  // Encerra a sessão criptográfica com o cartão para permitir nova leitura
  mfrc522.PICC_HaltA();
}

Teste e Validação:

1. Instale a biblioteca rfid.zip na IDE.
2. Carregue o programa e abra o Monitor Serial a 9600 baud.
3. Aproxime o cartão branco e, em seguida, o chaveiro azul: você verá os códigos UIDs hexadecimais exclusivos de cada um deles sendo impressos na tela. Anote esses códigos, pois são a chave de acesso para cadastrar usuários em sistemas de controle de portaria e travas biométricas.

---

Lição 22: Display LCD Alfanumérico 16x2 em Modo Paralelo de 4 Bits

A Lição 22 aborda a interface de comunicação com um display de cristal líquido alfanumérico padrão LCD 1602 (16 colunas por 2 linhas com retroiluminação azul), operando através do controlador padrão industrial Hitachi HD44780 em modo paralelo de 4 bits.

O display LCD 1602 possui uma matriz de 16 pinos de controle e dados. Para economizar portas no microcontrolador Uno, o padrão da biblioteca LiquidCrystal.h utiliza o modo de 4 bits: em vez de enviar os bytes de caracteres de uma só vez usando 8 pinos de dados (D0 a D7), o microcontrolador divide cada byte em dois pacotes de 4 bits (nibbles: os 4 bits mais significativos seguidos dos 4 bits menos significativos), transmitindo-os pelos pinos D4, D5, D6 e D7.

O circuito requer também o controle das linhas:

• RS (Register Select): seleciona entre o envio de comandos de configuração (RS = LOW) ou caracteres de texto (RS = HIGH);
• EN (Enable): pulso de habilitação que efetiva a escrita do nibble no registrador do display;
• V0 (Contraste): pino analógico ligado a um potenciômetro de $10\,\text{k}\Omega$ para ajustar o contraste óptico dos blocos de cristal líquido.

Materiais Necessários:

Componente	Quantidade	Especificação Técnica / Observações
Placa Uno DIP 16u2	1	Unidade mestre de controle
Display LCD Alfanumérico 1602	1	16 caracteres x 2 linhas com backlight azul
Potenciômetro Rotativo de 10 kΩ	1	Ajuste fino de contraste analógico (V0)
Resistor de 220 Ω (1/4W)	1	Resistor limitador para o LED de backlight (pino 15 A)
Matriz de Contatos (Protoboard)	1	Para posicionamento do display
Jumpers Macho-Macho	16	Conexões de dados, controle e energia

Tabela Completa de Conexões do Display LCD 1602:

Pino no LCD	Nome / Função	Conexão no Circuito / Arduino Uno
Pino 1	VSS (Terra)	Barramento GND da protoboard
Pino 2	VDD (+5V)	Barramento 5V da protoboard
Pino 3	V0 (Contraste)	Terminal central (cursor) do potenciômetro de 10 kΩ
Pino 4	RS (Register Select)	Pino Digital D12 do Arduino Uno
Pino 5	RW (Read/Write)	Barramento GND (operação estrita em modo escrita)
Pino 6	E (Enable)	Pino Digital D11 do Arduino Uno
Pinos 7 a 10	D0 a D3	Não conectados (modo 4 bits)
Pino 11	D4 (Dado 4)	Pino Digital D5 do Arduino Uno
Pino 12	D5 (Dado 5)	Pino Digital D4 do Arduino Uno
Pino 13	D6 (Dado 6)	Pino Digital D3 do Arduino Uno
Pino 14	D7 (Dado 7)	Pino Digital D2 do Arduino Uno
Pino 15	A (Ânodo Backlight)	Barramento 5V através de resistor limitador de 220 Ω
Pino 16	K (Cátodo Backlight)	Barramento GND da protoboard

📦 Bibliotecas desta lição:

• LiquidCrystal.h (versão 1.0.7, nativa da Arduino IDE) — Fornece comandos de inicialização, posicionamento de cursor (setCursor) e impressão de texto (print).

Código-Fonte Completo Comentado (HelloWorld.ino):

// Lição 22: Display LCD Alfanumérico 1602 em Modo Paralelo de 4 Bits
// Kit Avançado AE086 RB2051 - RoboBuilders

// Inclusão da biblioteca oficial de gerenciamento de displays HD44780
#include <LiquidCrystal.h>

// Inicialização da biblioteca passando os pinos na ordem exata:
// LiquidCrystal(RS, Enable, D4, D5, D6, D7)
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {
  // Configura a resolução do display com 16 colunas e 2 linhas
  lcd.begin(16, 2);

  // Posiciona o cursor na Coluna 0 da Linha 0 (primeira linha)
  lcd.setCursor(0, 0);
  // Escreve a mensagem de boas-vindas
  lcd.print("RoboBuilders!");

  // Posiciona o cursor na Coluna 0 da Linha 1 (segunda linha)
  lcd.setCursor(0, 1);
  lcd.print("Kit AE086 RB2051");
}

void loop() {
  // Mantém a mensagem fixa visível; o laço loop permanece disponível para expansão
}

Teste e Ajuste de Contraste:

1. Carregue o sketch para a placa Uno.
2. Ao ligar, se a tela parecer completamente azul vazia ou mostrar apenas blocos brancos sólidos, gire lentamente o cursor do potenciômetro de 10 kΩ. O ajuste fino da tensão de contraste no pino V0 fará as letras pretas surgirem com máxima nitidez sobre o fundo azul iluminado.

---

Lição 23: Termômetro com Sensor NTC Analógico e Exibição no Display LCD

A Lição 23 integra os conhecimentos de aquisição analógica de precisão e exibição visual do Módulo 3 em uma aplicação real de instrumentação: um termômetro digital de bancada utilizando um termistor semicondutor de coeficiente negativo de temperatura (NTC de 10 kΩ) com exibição em tempo real das temperaturas em graus Celsius no display LCD 1602.

Um termistor NTC (Negative Temperature Coefficient) é um resistor cerâmico composto por óxidos metálicos sinterizados cuja resistência elétrica varia de maneira inversamente proporcional e não-linear com a temperatura: à medida que a temperatura se eleva, maior número de portadores de carga é liberado para a banda de condução, reduzindo a resistência ôhmica do componente.

Para ler essa variação no Arduino, o termistor de $10\,\text{k}\Omega$ é conectado em série com um resistor fixo de precisão de $10\,\text{k}\Omega$, formando um divisor de tensão:

$$V_{A0} = 5{,}0\,\text{V} \times \frac{R_{NTC}}{R_{NTC} + 10000\,\Omega}$$

A conversão da resistência calculada $R_{NTC}$ em temperatura absoluta em Kelvin ($T_K$) é obtida pela equação clássica de Steinhart-Hart com aproximação do parâmetro B:

$$\frac{1}{T_K} = \frac{1}{T_0} + \frac{1}{B} \ln\left(\frac{R_{NTC}}{R_0}\right)$$

Subtraindo $273{,}15$ do valor em Kelvin, obtém-se a temperatura final em graus Celsius ($^\circ\text{C}$).

Materiais Necessários:

Componente	Quantidade	Especificação Técnica / Observações
Placa Uno DIP 16u2	1	Unidade de processamento matemático
Display LCD 1602	1	Mantido montado na protoboard da Lição 22
Termistor NTC 10 kΩ (MF52D)	1	Coeficiente térmico negativo, $B = 3950\,\text{K}$
Resistor de Filme Metálico 10 kΩ (1/4W)	1	Resistor de referência do divisor de tensão (±1%)
Jumpers Macho-Macho	4	Conexões adicionais para o divisor resistivo

Conexão do Divisor do Termistor NTC:

Mantenha intactas as conexões do LCD 1602 da Lição 22 e adicione na protoboard:

Ponto do Divisor NTC	Conexão no Arduino Uno	Observação Elétrica
Terminal livre do NTC	Barramento 5V	Alimentação superior do divisor
Ponto Central (NTC + Resistor 10 kΩ)	Entrada Analógica A0	Tensão condicionada do termistor
Terminal livre do Resistor 10 kΩ	Barramento GND	Retorno para terra de referência

📦 Bibliotecas desta lição:

• LiquidCrystal.h (nativa do Arduino AVR Core) — Comunicação de dados com o display.

Código-Fonte Completo Comentado (Thermometer.ino):

// Lição 23: Termômetro Digital com NTC 10k e Display LCD 1602
// Kit Avançado AE086 RB2051 - RoboBuilders

#include <LiquidCrystal.h>

// Inicialização do display LCD com pinagem idêntica à Lição 22
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

// Pino do canal analógico conectado ao centro do divisor do termistor
const int ntcPin = A0;

// Constantes do modelo matemático de Steinhart-Hart para o termistor do kit
const float SERIES_RESISTOR = 10000.0; // Resistor fixo de 10 kΩ (10000 ohms)
const float NOMINAL_RESISTANCE = 10000.0; // Resistência nominal do NTC a 25 °C
const float NOMINAL_TEMPERATURE = 25.0; // Temperatura nominal de referência em °C
const float B_COEFFICIENT = 3950.0; // Constante Beta do fabricante

void setup() {
  // Inicializa o display LCD com 16 colunas e 2 linhas
  lcd.begin(16, 2);
  lcd.clear();

  // Escreve o cabeçalho estático na primeira linha
  lcd.setCursor(0, 0);
  lcd.print("Termometro NTC");

  // Inicia a porta serial para telemetria paralela no PC
  Serial.begin(9600);
}

void loop() {
  // Realiza a amostragem analógica da tensão no pino A0
  int adcValue = analogRead(ntcPin);

  // Calcula a resistência ôhmica equivalente instantânea do termistor
  // Formula do divisor de tensão: R_NTC = R_fixo / ((1023 / ADC) - 1)
  float resistance = SERIES_RESISTOR / ((1023.0 / adcValue) - 1.0);

  // Aplicação da aproximação de parâmetro B da equação de Steinhart-Hart
  float steinhart;
  steinhart = resistance / NOMINAL_RESISTANCE;     // (R / Ro)
  steinhart = log(steinhart);                     // ln(R / Ro)
  steinhart /= B_COEFFICIENT;                      // 1/B * ln(R / Ro)
  steinhart += 1.0 / (NOMINAL_TEMPERATURE + 273.15); // + (1 / To)
  steinhart = 1.0 / steinhart;                    // Inverte para obter Kelvin
  float tempC = steinhart - 273.15;                // Converte de Kelvin para Celsius

  // Atualiza as leituras na segunda linha do display LCD
  lcd.setCursor(0, 1);
  lcd.print("Temp: ");
  lcd.print(tempC, 1); // Exibe com uma casa decimal
  lcd.print(" ß""C   "); // ß imprime o símbolo de grau (°) da tabela ASCII do HD44780

  // Envia também para o Monitor Serial
  Serial.print("Temperatura: ");
  Serial.print(tempC, 2);
  Serial.println(" °C");

  // Amostragem a cada 1 segundo
  delay(1000);
}

Teste e Validação:

1. Carregue o programa: a tela do LCD exibirá a temperatura ambiente da sala (por exemplo, Temp: 24.8 °C).
2. Pressione a cápsula preta do termistor NTC entre os dedos: o calor do seu corpo elevará a temperatura na tela gradualmente para 30 °C a 34 °C em poucos segundos, validando a alta sensibilidade do circuito de instrumentação.

---

Módulo 4 — Registradores de Deslocamento, Displays Numéricos e Automação (Lições 24 a 28)

O Módulo 4 aborda a expansão de saídas digitais através de registradores de deslocamento serial-para-paralelo (CI 74HC595), permitindo controlar cascatas de LEDs, barras de iluminação fotoassistidas com sensores LDR, displays de 7 segmentos de 1 dígito e painéis numéricos de 4 dígitos multiplexados no tempo, economizando os pinos de GPIO do microcontrolador.

---

Lição 24: Expansão de Saídas com Registrador de Deslocamento 74HC595 (8 LEDs)

A Lição 24 ensina a técnica fundamental de conversão serial-para-paralela através do circuito integrado 74HC595, controlando 8 LEDs independentes utilizando apenas 3 pinos digitais da placa Uno.

O microcontrolador ATmega328P dispõe de apenas 14 pinos digitais. Se um projeto exigir o controle de dezenas de atuadores ou relés, o esgotamento de portas inviabilizaria a aplicação. O circuito integrado 74HC595 soluciona essa limitação contendo internamente:

1. Um Registrador de Deslocamento de 8 bits (Shift Register): Recebe bits um a um através da linha de dados DS / SER (Pino 14) sincronizados pelas bordas de subida do sinal de relógio SH_CP / SRCLK (Pino 11);
2. Um Registrador de Armazenamento de Saída (Storage / Latch Register): Ao receber um pulso de borda de subida no pino ST_CP / RCLK (Pino 12), os 8 bits acumulados no registrador de deslocamento são copiados simultaneamente para os pinos de saída paralelos Q0 a Q7 (Pinos 15, 1, 2, 3, 4, 5, 6 e 7);
3. Pino OE (Output Enable - Pino 13): Habilita as saídas quando aterrado ao GND;
4. Pino MR (Master Reset - Pino 10): Limpa o registrador se levado a LOW (deve ser mantido em 5V para operação normal).

A função nativa shiftOut(dataPin, clockPin, MSBFIRST, byte) realiza o envio síncrono serial dos 8 bits por hardware ou emulação de clock ultrarrápida.

Materiais Necessários:

Componente	Quantidade	Especificação Técnica / Observações
Placa Uno DIP 16u2	1	Unidade geradora de clock e dados seriais
Circuito Integrado 74HC595	1	Registrador de deslocamento de 8 bits em soquete DIP-16
LEDs Difusos Vermelhos 5 mm	8	Formando uma barra luminosa de 8 canais
Resistores de 220 Ω (1/4W)	8	Um resistor limitador em série para cada LED
Matriz de Contatos (Protoboard)	1	Para montagem do circuito integrado
Jumpers Macho-Macho	18	Conexões de dados, controle e ânodos dos LEDs

Pinagem do 74HC595 com o Arduino Uno:

Posicione o CI sobre o canal central da protoboard com o chanfro semicircular voltado para a esquerda (Pino 1 no canto inferior esquerdo e Pino 16 no canto superior esquerdo):

Pino no 74HC595	Nome / Função	Conexão no Arduino / Protoboard
Pino 14 (DS)	Entrada de Dados Serial (SER)	Pino Digital D12 do Arduino
Pino 12 (ST_CP)	Latch Clock / Armazenamento (RCLK)	Pino Digital D11 do Arduino
Pino 11 (SH_CP)	Shift Register Clock (SRCLK)	Pino Digital D9 do Arduino
Pino 10 (MR)	Master Reset (Ativo em LOW)	Barramento 5V (+5 VDC contínuos)
Pino 13 (OE)	Output Enable (Ativo em LOW)	Barramento GND (0 VDC)
Pino 16 (VCC)	Alimentação positiva do CI	Barramento 5V (+5 VDC contínuos)
Pino 8 (GND)	Terra do circuito integrado	Barramento GND (0 VDC)
Pinos 15, 1, 2, 3, 4, 5, 6, 7	Saídas Paralelas Q0 a Q7	Ânodos dos 8 LEDs (via resistores de 220 Ω ao GND)

📦 Bibliotecas desta lição: Nenhuma biblioteca externa necessária (utiliza a função nativa shiftOut).

Código-Fonte Completo Comentado (Eight_LED_with_74HC595_Flash_LED.ino):

// Lição 24: Expansão de Saídas Digitais com CI 74HC595
// Kit Avançado AE086 RB2051 - RoboBuilders

// Definição dos 3 pinos de controle do registrador de deslocamento
int latchPin = 11; // Conectado ao pino 12 (ST_CP / RCLK) do 74HC595
int clockPin = 9;  // Conectado ao pino 11 (SH_CP / SRCLK) do 74HC595
int dataPin = 12;  // Conectado ao pino 14 (DS / SER) do 74HC595

// Variável de 8 bits (byte) onde cada bit representa o estado de um LED (0 a 7)
byte leds = 0;

// Função auxiliar para atualizar o estado das saídas do 74HC595
void updateShiftRegister() {
  // Abaixa o pino de Latch para iniciar a transferência de dados
  digitalWrite(latchPin, LOW);

  // Envia serialmente o byte bit a bit, começando pelo bit mais significativo (MSBFIRST)
  shiftOut(dataPin, clockPin, MSBFIRST, leds);

  // Eleva o pino de Latch para copiar os bits do registrador interno para os pinos de saída Q0-Q7
  digitalWrite(latchPin, HIGH);
}

void setup() {
  // Configura os 3 pinos de barramento como saídas digitais
  pinMode(latchPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
}

void loop() {
  // Efeito 1: Acende sequencialmente os LEDs um por um da direita para a esquerda
  leds = 0;
  updateShiftRegister();
  delay(500);

  for (int i = 0; i < 8; i++) {
    bitSet(leds, i); // Coloca o bit 'i' em nível lógico 1
    updateShiftRegister();
    delay(200);
  }

  // Efeito 2: Apaga sequencialmente os LEDs um por um
  for (int i = 0; i < 8; i++) {
    bitClear(leds, i); // Coloca o bit 'i' em nível lógico 0
    updateShiftRegister();
    delay(200);
  }

  // Efeito 3: Pisca todos os 8 LEDs simultaneamente
  for (int k = 0; k < 3; k++) {
    leds = 0xFF; // Todos os 8 bits em 1 (B11111111)
    updateShiftRegister();
    delay(300);
    leds = 0x00; // Todos os 8 bits em 0 (B00000000)
    updateShiftRegister();
    delay(300);
  }
}

Teste e Validação:

1. Carregue o programa e observe a cadência luminosa: os 8 LEDs acenderão em rampa progressiva, apagarão sequencialmente e piscarão em bloco com perfeita sincronia, consumindo apenas 3 pinos do Arduino.

---

Lição 25: Comunicação Bidirecional via Monitor Serial Controlando o 74HC595

A Lição 25 expande o projeto da Lição 24 implementando um canal interativo de telemetria e comando serial assíncrono: o usuário envia caracteres numéricos (0 a 7) a partir do teclado do computador via Monitor Serial para comutar individualmente os LEDs conectados ao 74HC595.

Esta lição demonstra o tratamento do buffer de recepção serial por interrupção de hardware do microcontrolador ATmega328P. Quando um caractere ASCII é digitado no console e transmitido pela interface USB:

• O hardware UART armazena o caractere em uma fila circular de 64 bytes (Ring Buffer);
• A função Serial.available() retorna a quantidade de bytes pendentes para leitura no buffer;
• A função Serial.read() extrai o próximo caractere em formato ASCII. Ao subtrair o valor literal '0' (cujo código ASCII é 48), converte-se o caractere no inteiro numérico equivalente de 0 a 7:

$$\text{indice} = \text{caractere} - \text{'0'}$$

• A macro bitRead(leds, indice) avalia o estado atual daquele bit e bitWrite(leds, indice, novoEstado) inverte sua polaridade lógica (toggle), transmitindo o byte resultante via shiftOut().

Materiais Necessários:

Utiliza a montagem física completa da Lição 24 sem alterações nas conexões da protoboard.

📦 Bibliotecas desta lição: Nenhuma biblioteca externa necessária.

Código-Fonte Completo Comentado (The_Serial_Monitor.ino):

// Lição 25: Controle Interativo Serial do Registrador 74HC595
// Kit Avançado AE086 RB2051 - RoboBuilders

int latchPin = 11;
int clockPin = 9;
int dataPin = 12;

byte leds = 0; // Armazena a máscara de bits dos 8 LEDs

void updateShiftRegister() {
  digitalWrite(latchPin, LOW);
  shiftOut(dataPin, clockPin, MSBFIRST, leds);
  digitalWrite(latchPin, HIGH);
}

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

  // Atualiza as saídas desligando todos os LEDs no início
  updateShiftRegister();

  // Inicia a comunicação serial a 9600 baud
  Serial.begin(9600);
  Serial.println("Digite um numero de 0 a 7 para alternar o LED correspondente:");
}

void loop() {
  // Verifica se há pelo menos um caractere disponível para leitura no buffer serial
  if (Serial.available() > 0) {
    // Lê o caractere recebido da porta USB
    char ch = Serial.read();

    // Filtra apenas se for um dígito numérico válido entre '0' e '7'
    if (ch >= '0' && ch <= '7') {
      int ledIndex = ch - '0'; // Converte ASCII para valor inteiro de 0 a 7

      // Lê o estado atual do bit e inverte-o (se 1 vira 0; se 0 vira 1)
      boolean currentState = bitRead(leds, ledIndex);
      bitWrite(leds, ledIndex, !currentState);

      // Transmite a nova configuração de bits para o registrador 74HC595
      updateShiftRegister();

      // Confirmação no Monitor Serial
      Serial.print("LED ");
      Serial.print(ledIndex);
      Serial.println(!currentState ? " -> LIGADO" : " -> DESLIGADO");
    }
  }
}

Teste e Validação:

1. Carregue o programa e abra o Monitor Serial a 9600 baud.
2. Digite o caractere 3 e clique em Enviar: o quarto LED acenderá. Digite 3 novamente: o mesmo LED apagará.
3. Digite múltiplos comandos (ex: 0, 2, 4, 6): você poderá compor padrões personalizados em tempo real a partir do console.

---

Lição 26: Fotocélula (Sensor LDR) e Controle de Barra de LEDs

A Lição 26 implementa um sistema de controle fotoassistido automático: um resistor dependente de luz (LDR) ajusta dinamicamente a quantidade de LEDs acesos na barra controlada pelo 74HC595 em função da iluminância do ambiente, simulando um medidor óptico tipo bargraph ou sistema crepuscular adaptativo.

Um fotoresistor LDR (Light Dependent Resistor) é feito de um composto semicondutor de sulfeto de cádmio (CdS). No escuro total, a densidade de elétrons livres é muito baixa e sua resistência pode chegar a mais de $1\,\text{M}\Omega$. Quando incide luz visível sobre a trilha fotossensível, fótons com energia superior ao gap de banda do material liberam elétrons para a condução, derrubando a resistência do componente para valores de apenas algumas centenas de ohms ($300\,\Omega$ a $2\,\text{k}\Omega$).

Conectando o LDR em série com um resistor de precisão de $10\,\text{k}\Omega$ ao barramento 5V, a tensão analógica aplicada à entrada A0 do microcontrolador varia monotonicamente com a luminosidade:

$$V_{A0} = 5{,}0\,\text{V} \times \frac{R_{10k}}{R_{LDR} + R_{10k}}$$

A função map(leitura, minADC, maxADC, 0, 8) mapeia linearmente essa faixa contínua em um número inteiro de 0 a 8 LEDs a serem acesos na barra.

Materiais Necessários:

Componente	Quantidade	Especificação Técnica / Observações
Circuito da Lição 24 (74HC595 + 8 LEDs)	1	Mantido intacto na protoboard
Sensor Fotoresistor LDR de 5 mm	1	Faixa resistiva de 1 kΩ (luz) a 1 MΩ (escuro)
Resistor de Filme Metálico 10 kΩ (1/4W)	1	Resistor inferior do divisor resistivo
Jumpers Macho-Macho	3	Conexões de 5V, GND e A0

Conexão do Divisor LDR:

Ponto do Circuito Divisor	Conexão no Arduino Uno	Função
Terminal livre do LDR	Barramento 5V	Alimentação superior do divisor
Junção Central (LDR + Resistor 10 kΩ)	Entrada Analógica A0	Sinal de tensão analógica fotossensível
Terminal livre do Resistor 10 kΩ	Barramento GND	Retorno para terra de referência

📦 Bibliotecas desta lição: Nenhuma biblioteca externa necessária.

Código-Fonte Completo Comentado (Photocell.ino):

// Lição 26: Barra Gráfica de LEDs com LDR e CI 74HC595
// Kit Avançado AE086 RB2051 - RoboBuilders

int latchPin = 11;
int clockPin = 9;
int dataPin = 12;

const int ldrPin = A0; // Entrada analógica conectada ao divisor do fotoresistor LDR

byte leds = 0;

void updateShiftRegister() {
  digitalWrite(latchPin, LOW);
  shiftOut(dataPin, clockPin, MSBFIRST, leds);
  digitalWrite(latchPin, HIGH);
}

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

  // Inicializa o Monitor Serial para visualização dos níveis analógicos
  Serial.begin(9600);
}

void loop() {
  // Realiza a leitura da intensidade luminosa (tensão analógica em A0)
  int sensorValue = analogRead(ldrPin);

  // Mapeia a leitura analógica (calibrada entre 200 e 800) em um número de LEDs de 0 a 8
  int numLedsLit = map(sensorValue, 200, 800, 0, 8);
  numLedsLit = constrain(numLedsLit, 0, 8); // Garante que fique estritamente entre 0 e 8

  // Reconstrói a máscara de bits: acende a quantidade calculada de LEDs
  leds = 0;
  for (int i = 0; i < numLedsLit; i++) {
    bitSet(leds, i);
  }

  // Atualiza as saídas do registrador 74HC595
  updateShiftRegister();

  // Telemetria no console
  Serial.print("Luminosidade ADC: ");
  Serial.print(sensorValue);
  Serial.print(" -> LEDs Acesos: ");
  Serial.println(numLedsLit);

  delay(100); // Taxa de atualização de 10 Hz
}

Teste e Validação:

1. Carregue o sketch e observe a barra de LEDs com a iluminação ambiente normal da sala.
2. Aproxime a mão sobre o LDR cobrindo a luz: à medida que a penumbra aumenta, os LEDs vão se apagando progressivamente. Aproxime a lanterna de um celular sobre o sensor: todos os 8 LEDs acenderão em intensidade máxima.

---

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

A Lição 27 demonstra o acionamento de um display numérico de 7 segmentos de 1 dígito através do registrador 74HC595, ensinando o mapeamento de decodificação binária de dígitos decimais (0 a 9).

Um display de 7 segmentos consiste em 8 LEDs individuais (7 segmentos em barra rotulados de a a g e um ponto decimal rotulado como DP) arranjados na geometria de um número 8. No modelo de cátodo comum, todos os 8 cátodos são interligados internamente e conectados ao terra (GND), de modo que um segmento acende quando seu ânodo correspondente recebe nível lógico alto (HIGH).

Cada número de 0 a 9 é representado por um byte exclusivo onde cada bit comanda um segmento:

• Bit 0 = Segmento a (barra horizontal superior);
• Bit 1 = Segmento b (barra vertical superior direita);
• Bit 2 = Segmento c (barra vertical inferior direita);
• Bit 3 = Segmento d (barra horizontal inferior);
• Bit 4 = Segmento e (barra vertical inferior esquerda);
• Bit 5 = Segmento f (barra vertical superior esquerda);
• Bit 6 = Segmento g (barra horizontal central);
• Bit 7 = Segmento DP (ponto decimal inferior direito).

Para ilustrar: o dígito 0 requer todos os segmentos externos acesos (a,b,c,d,e,f) e apenas o segmento central g e DP apagados, gerando o byte binário B00111111 (hexadecimal 0x3F).

Materiais Necessários:

Componente	Quantidade	Especificação Técnica / Observações
Placa Uno DIP 16u2	1	Unidade controladora
Circuito Integrado 74HC595	1	Mantido montado na protoboard
Display de 7 Segmentos de 1 Dígito	1	Modelo Cátodo Comum de 0,56 polegadas (10 pinos)
Resistores de 220 Ω (1/4W)	8	Resistores limitadores em cada segmento
Jumpers Macho-Macho	12	Conexões entre o 74HC595 e o display

Conexão das Saídas Q0–Q7 aos Segmentos do Display:

Saída 74HC595	Segmento Controlado	Pino Físico do Display de 1 Dígito
Q0 (Pino 15)	Segmento a	Pino 7
Q1 (Pino 1)	Segmento b	Pino 6
Q2 (Pino 2)	Segmento c	Pino 4
Q3 (Pino 3)	Segmento d	Pino 2
Q4 (Pino 4)	Segmento e	Pino 1
Q5 (Pino 5)	Segmento f	Pino 9
Q6 (Pino 6)	Segmento g	Pino 10
Q7 (Pino 7)	Ponto Decimal DP	Pino 5
Cátodos Comuns	Pinos 3 e 8	Barramento GND da protoboard

📦 Bibliotecas desta lição: Nenhuma biblioteca externa necessária.

Código-Fonte Completo Comentado (74HC595_And_Segment_Display.ino):

// Lição 27: Display de 7 Segmentos com CI 74HC595
// Kit Avançado AE086 RB2051 - RoboBuilders

int latchPin = 11;
int clockPin = 9;
int dataPin = 12;

// Tabela de decodificação de 7 segmentos para cátodo comum (dígitos 0 a 9)
// Formato dos bits: B[DP][g][f][e][d][c][b][a]
const byte digitSegments[10] = {
  0x3F, // Dígito 0: a, b, c, d, e, f
  0x06, // Dígito 1: b, c
  0x5B, // Dígito 2: a, b, d, e, g
  0x4F, // Dígito 3: a, b, c, d, g
  0x66, // Dígito 4: b, c, f, g
  0x6D, // Dígito 5: a, c, d, f, g
  0x7D, // Dígito 6: a, c, d, e, f, g
  0x07, // Dígito 7: a, b, c
  0x7F, // Dígito 8: todos os segmentos
  0x6F  // Dígito 9: a, b, c, d, f, g
};

void updateShiftRegister(byte segments) {
  digitalWrite(latchPin, LOW);
  shiftOut(dataPin, clockPin, MSBFIRST, segments);
  digitalWrite(latchPin, HIGH);
}

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

void loop() {
  // Contagem progressiva de 0 a 9 a cada 1 segundo
  for (int i = 0; i < 10; i++) {
    updateShiftRegister(digitSegments[i]);
    delay(1000);
  }
}

Teste e Validação:

1. Carregue o programa: o display exibirá os números decimais de 0 a 9 com atualização a cada 1 segundo em ciclo infinito.

---

Lição 28: Display de 7 Segmentos de 4 Dígitos Multiplexado no Tempo

A Lição 28 estuda a técnica de multiplexação por divisão no tempo (TDM) para controlar um display numérico de 4 dígitos de 7 segmentos, explorando o fenômeno neurofisiológico da persistência da visão (Persistence of Vision — PoV).

Um módulo de 4 dígitos possui 32 segmentos luminosos no total. Se fossem acionados em paralelo puro, demandariam 32 pinos e 32 resistores. Para evitar essa complexidade, os fabricantes constroem o display com os 8 segmentos (a a g e DP) interligados em barramento compartilhado entre todos os 4 dígitos. Apenas os 4 cátodos comuns de controle de cada dígito (D1, D2, D3, D4) são pinados separadamente:

• Para acender um dígito específico, o microcontrolador aterra o cátodo comum daquele dígito (LOW), mantendo os outros 3 desligados em nível alto (HIGH);
• Em seguida, injeta pelo registrador 74HC595 os segmentos que formam o número daquele dígito;
• Mantém aceso por uma breve fração de tempo ($\approx 2\,\text{a}\,5\,\text{ms}$) e desliga;
• Passa imediatamente para o próximo dígito e repete o processo em sequência contínua (D1 $\to$ D2 $\to$ D3 $\to$ D4 $\to$ D1).

Se a frequência de varredura do ciclo completo ultrapassar $50\,\text{Hz}$ ($> 200\,\text{atualizacoes/segundo}$), a retina humana não percebe o chaveamento intermitente e enxerga os quatro dígitos permanentemente acesos e simultâneos.

Materiais Necessários:

Componente	Quantidade	Especificação Técnica / Observações
Placa Uno DIP 16u2	1	Controle de multiplexação
Circuito Integrado 74HC595	1	Geração dos segmentos em barramento paralelo
Display de 7 Segmentos de 4 Dígitos	1	Cátodo comum de 12 pinos com dois pontos de relógio
Resistores de 220 Ω (1/4W)	8	Resistores de limitação dos 8 segmentos
Jumpers Macho-Macho	16	Conexões de barramento e seletores

Conexão dos Cátodos de Seleção de Dígitos:

Dígito no Display	Pino no Display	Pino no Arduino Uno	Lógica de Habilitação
Dígito 1 (Milhar - Extrema Esquerda)	Pino 12	Pino Digital D2	Ativo em LOW (0V)
Dígito 2 (Centena)	Pino 9	Pino Digital D3	Ativo em LOW (0V)
Dígito 3 (Dezena)	Pino 8	Pino Digital D4	Ativo em LOW (0V)
Dígito 4 (Unidade - Extrema Direita)	Pino 6	Pino Digital D5	Ativo em LOW (0V)

Os 8 segmentos a a DP são conectados às saídas Q0 a Q7 do 74HC595 exatamente como na Lição 27.

📦 Bibliotecas desta lição: Nenhuma biblioteca externa necessária.

Código-Fonte Completo Comentado (Four_Digital.ino):

// Lição 28: Multiplexação Temporal de Display de 7 Segmentos de 4 Dígitos
// Kit Avançado AE086 RB2051 - RoboBuilders

int latchPin = 11;
int clockPin = 9;
int dataPin = 12;

// Pinos digitais que controlam a habilitação de cada cátodo comum dos 4 dígitos
int digitPins[4] = {2, 3, 4, 5};

// Tabela de segmentos idêntica à lição anterior
const byte digitSegments[10] = {
  0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07, 0x7F, 0x6F
};

// Vetor que armazena os 4 dígitos a serem exibidos simultaneamente (ex: número 1 2 3 4)
int displayBuffer[4] = {1, 2, 3, 4};

void updateShiftRegister(byte segments) {
  digitalWrite(latchPin, LOW);
  shiftOut(dataPin, clockPin, MSBFIRST, segments);
  digitalWrite(latchPin, HIGH);
}

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

  // Configura os 4 pinos seletores de dígitos como saídas e inicializa em HIGH (todos apagados)
  for (int d = 0; d < 4; d++) {
    pinMode(digitPins[d], OUTPUT);
    digitalWrite(digitPins[d], HIGH);
  }
}

void loop() {
  // Varre continuamente os 4 dígitos do display aplicando a técnica PoV
  for (int d = 0; d < 4; d++) {
    // 1. Envia os segmentos do número correspondente para o 74HC595
    updateShiftRegister(digitSegments[displayBuffer[d]]);

    // 2. Aterra apenas o cátodo do dígito selecionado para acendê-lo
    digitalWrite(digitPins[d], LOW);

    // 3. Mantém aceso por 3 milissegundos
    delay(3);

    // 4. Desliga o dígito (HIGH) antes de avançar para evitar efeito fantasma (ghosting)
    digitalWrite(digitPins[d], HIGH);
  }
}

Teste e Validação:

1. Carregue o programa: você verá o número estático 1234 claramente legível no display de quatro dígitos sem oscilações perceptíveis aos olhos.
2. Experimente alterar temporariamente o delay(3) para delay(500): você verá claramente cada dígito acendendo sozinho e apagando de forma alternada, compreendendo na prática o funcionamento da multiplexação temporal.

---

Módulo 5 — Acionamento de Potência, Motores e Controle de Posição (Lições 29 a 33)

O Módulo 5 aborda o estágio final da mecatrônica e robótica aplicada: a interface entre os sinais lógicos de baixa potência do microcontrolador e cargas mecânicas de alta corrente. São abordados o controle bidirecional e modulação PWM de motores de corrente contínua com circuitos de ponte H integrados (L293D), chaveamento galvânico isolado por relés eletromecânicos, acionamento unipolar de motores de passo com placas Darlington ULN2003, controle remoto sem fio via infravermelho e posicionamento angular manual de precisão via encoders rotativos em quadratura.

---

Lição 29: Controle de Motor DC com Ponte H Integrada L293D

A Lição 29 ensina como controlar a velocidade e o sentido de rotação de um motor elétrico de corrente contínua (DC) através da ponte H integrada L293D, abordando proteção indutiva contra forças contraeletromotrizes (Back-EMF).

Um motor de corrente contínua converte energia eletromagnética em torque mecânico de rotação. Uma porta do microcontrolador ATmega328P é limitada a 20 mA contínuos, ao passo que um pequeno motor DC tipo 130 consome de 150 mA a vazio até mais de 1,2 A no instante de partida ou rotor travado (stall current). Além disso, a rotação reversa exige a inversão completa da polaridade da tensão aplicada aos seus dois terminais.

O circuito integrado L293D integra internamente duas pontes H completas com transistores bipolares NPN e diodos de grampeamento de proteção (flyback clamping diodes) contra transientes indutivos de desenergização. Uma ponte H opera controlando 4 chaves semicondutoras:

• Giro Horário (Forward): Entrada 1 em nível HIGH e Entrada 2 em nível LOW;
• Giro Anti-horário (Reverse): Entrada 1 em nível LOW e Entrada 2 em nível HIGH;
• Frenagem Eletrodinâmica (Brake): Ambas as entradas no mesmo nível lógico (HIGH/HIGH ou LOW/LOW);
• Controle de Rotação (Speed): O pino ENABLE (Pino 1 do L293D) recebe um sinal PWM da placa Uno (via analogWrite), variando a tensão média eficaz entregue à armadura do motor:

$$V_{MED} = \left(\frac{\text{PWM}}{255}\right) \times V_{MOTOR}$$

Materiais Necessários:

Componente	Quantidade	Especificação Técnica / Observações
Placa Uno DIP 16u2	1	Geração de sinais lógicos e PWM
Circuito Integrado L293D	1	Ponte H quadrupla de meia-ponte em encapsulamento DIP-16
Micro Motor DC Tipo 130 (3–6V)	1	Com hélice plástica ventiladora inclusa
Fonte de Alimentação Externa (Opcional/Recomendada)	1	5V a 9V externa ou barramento da placa de ensaio
Matriz de Contatos (Protoboard)	1	Para montagem dos circuitos de potência
Jumpers Macho-Macho	10	Conexões de sinal, alimentação e motor

Pinagem do L293D com o Arduino:

Pino no L293D	Nome	Conexão no Arduino / Circuito	Função
Pino 1	1,2EN (Enable 1)	Pino Digital ~5 do Arduino	Modulação PWM de velocidade (0 a 255)
Pino 2	1A (Input 1)	Pino Digital D3 do Arduino	Linha lógica de direção A
Pino 3	1Y (Output 1)	Terminal 1 do Motor DC	Saída de potência para o motor
Pinos 4 e 5	GND	Barramento GND comum	Terra e dissipador térmico de cobre do CI
Pino 6	2Y (Output 2)	Terminal 2 do Motor DC	Saída de potência para o motor
Pino 7	2A (Input 2)	Pino Digital D4 do Arduino	Linha lógica de direção B
Pino 8	VCC2 (Alimentação Motor)	Barramento 5V (ou fonte externa de 5–9V)	Tensão de potência da armadura do motor
Pino 16	VCC1 (Alimentação Lógica)	Barramento 5V do Arduino	Tensão lógica TTL interna (5,0 VDC)

📦 Bibliotecas desta lição: Nenhuma biblioteca externa necessária.

Código-Fonte Completo Comentado (DC_Motor.ino):

// Lição 29: Controle de Velocidade e Sentido de Motor DC com Ponte H L293D
// Kit Avançado AE086 RB2051 - RoboBuilders

// Definição dos pinos de controle do L293D
const int ENABLE_PIN = 5; // Pino PWM conectado ao Enable 1 (Pino 1 do L293D)
const int DIRA_PIN   = 3; // Pino digital conectado à Entrada 1A (Pino 2 do L293D)
const int DIRB_PIN   = 4; // Pino digital conectado à Entrada 2A (Pino 7 do L293D)

void setup() {
  // Configura todas as portas de controle como saídas digitais
  pinMode(ENABLE_PIN, OUTPUT);
  pinMode(DIRA_PIN, OUTPUT);
  pinMode(DIRB_PIN, OUTPUT);
}

void loop() {
  // 1. Sentido Horário (Forward) - Rampa de aceleração suave de 0 a 100% de velocidade
  digitalWrite(DIRA_PIN, HIGH);
  digitalWrite(DIRB_PIN, LOW);

  for (int speed = 0; speed <= 255; speed += 5) {
    analogWrite(ENABLE_PIN, speed); // Aplica duty cycle progressivo
    delay(30);
  }
  delay(1000); // Mantém rotação máxima por 1 segundo

  // Desaceleração suave até a parada total
  for (int speed = 255; speed >= 0; speed -= 5) {
    analogWrite(ENABLE_PIN, speed);
    delay(30);
  }
  delay(500); // Pausa com o motor parado

  // 2. Sentido Anti-horário (Reverse) - Inversão de polaridade na armadura
  digitalWrite(DIRA_PIN, LOW);
  digitalWrite(DIRB_PIN, HIGH);

  for (int speed = 0; speed <= 255; speed += 5) {
    analogWrite(ENABLE_PIN, speed);
    delay(30);
  }
  delay(1000);

  for (int speed = 255; speed >= 0; speed -= 5) {
    analogWrite(ENABLE_PIN, speed);
    delay(30);
  }
  delay(1000);
}

Teste e Recomendações de Potência:

1. Encaixe a hélice plástica no eixo do motor para visualizar com clareza o sentido de giro e a variação da velocidade.
2. Carregue o programa: a hélice acelerará progressivamente no sentido horário, reduzirá suavemente até parar e acelerará no sentido inverso.

⚠️ Isolamento de Terra: Ao empregar baterias de 9 V ou fontes externas no pino 8 do L293D, certifique-se impreterivelmente de interligar o terminal negativo da fonte externa ao barramento GND do Arduino, garantindo que os sinais lógicos possuam o mesmo referencial elétrico de zero volt.

---

Lição 30: Módulo Relé Eletromecânico de 5V com Chaveamento Isolado

A Lição 30 estuda o acionamento de cargas elétricas de alta potência de corrente contínua ou alternada residencial (lâmpadas, bombas hidráulicas, solenoides) através de um módulo relé eletromecânico de 1 canal de 5 V com isolamento óptico por optoacoplador.

Um relé eletromecânico utiliza uma bobina indutiva para criar um campo magnético que atrai uma armadura de ferro, comutando fisicamente um conjunto de contatos mecânicos. O módulo relé do kit incorpora:

1. Optoacoplador (Isolamento Galvânico): Converte o sinal elétrico do Arduino em um feixe luminoso interno por LED infravermelho que excita um fototransistor. Não há qualquer ligação física de cobre entre a entrada lógica de 5 V da placa e a rede elétrica alternada de 127 V / 220 V nos contatos, protegendo o microcontrolador contra surtos e transientes;
2. Diodo de Proteção Flyback: Diodo conectado em antiparalelo com a bobina do relé para descarregar a energia armazenada na indutância no instante do desligamento ($V = -L \frac{di}{dt}$);
3. Contatos de Saída Reversíveis (Bornes de Parafuso):
   • COM (Comum): Terminal móvel compartilhado;
   • NA (Normalmente Aberto / NO): O circuito permanece aberto quando o relé está desenergizado e fecha ao ser ativado;
   • NF (Normalmente Fechado / NC): O circuito permanece fechado em repouso e abre ao ser ativado.

O módulo opera em lógica negativa: a ativação ocorre aplicando nível lógico LOW no pino de comando IN.

Materiais Necessários:

Componente	Quantidade	Especificação Técnica / Observações
Placa Uno DIP 16u2	1	Unidade de comando
Módulo Relé de 1 Canal (5V)	1	Contatos para 10 A em 250 VAC / 30 VDC
Jumpers Fêmea-Macho	3	VCC, GND e IN

Conexões do Módulo Relé:

Pino no Módulo Relé	Pino no Arduino Uno	Descrição Funcional
VCC	Terminal 5V	Alimentação da bobina e do optoacoplador
GND	Barramento GND	Retorno de terra
IN	Pino Digital D12	Linha de comando lógica (LOW = relé ativado)

📦 Bibliotecas desta lição: Nenhuma biblioteca externa necessária.

Código-Fonte Completo Comentado (Relay.ino):

// Lição 30: Acionamento de Módulo Relé de 5V Isolado
// Kit Avançado AE086 RB2051 - RoboBuilders

// Definição do pino conectado ao terminal de entrada de controle IN do módulo relé
const int relayPin = 12;

void setup() {
  // Configura a porta digital D12 como saída
  pinMode(relayPin, OUTPUT);

  // Inicializa o relé em estado DESLIGADO (nível HIGH na lógica negativa do optoacoplador)
  digitalWrite(relayPin, HIGH);

  Serial.begin(9600);
  Serial.println("Controle de Modulo Rele Iniciado!");
}

void loop() {
  // Ativa o relé aplicando nível lógico LOW na entrada do optoacoplador
  Serial.println("Rele: ATIVADO (Contato NA fechado)");
  digitalWrite(relayPin, LOW);
  delay(3000); // Mantém ligado por 3 segundos

  // Desativa o relé aplicando nível lógico HIGH
  Serial.println("Rele: DESATIVADO (Contato NA aberto)");
  digitalWrite(relayPin, HIGH);
  delay(3000); // Mantém desligado por 3 segundos
}

Teste e Validação:

1. Carregue o programa: a cada 3 segundos, você ouvirá o som mecânico característico de clique (click) da armadura do relé e observará o acendimento sincronizado do LED vermelho SMD indicador integrado no módulo.

⛔ Perigo de Choque Elétrico Fatal: Ao realizar ensaios com tensões residenciais alternadas de 127 V ou 220 VAC nos bornes COM e NA do relé, garanta que todos os condutores estejam isolados com fita ou borneiras seladas antes de conectar o plugue na tomada de parede. Nunca toque na face inferior da placa do relé energizada.

---

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

A Lição 31 aborda o posicionamento angular digital sem sensores de feedback utilizando o motor de passo unipolar de 4 fases 28BYJ-48 acionado pela placa de transistores Darlington de alta corrente ULN2003.

Diferente de um motor DC contínuo convencional, o motor de passo converte pulsos elétricos de excitação em deslocamentos mecânicos angulares discretos e precisos denominados passos (steps). O modelo 28BYJ-48 opera com alimentação de 5 VDC e rotor magnético interno de 32 passos por revolução acoplado a uma caixa de engrenagens redutoras de proporção de aproximadamente $1:64$ ($63{,}68395:1$ exato):

$$\text{Passos por Revolucao do Eixo de Saida} = 32 \times 64 = 2048\,\text{passos}$$

Cada passo em modo de passo completo (full-step) corresponde a um deslocamento angular de:

$$\theta_{passo} = \frac{360^\circ}{2048} \approx 0{,}1758^\circ$$

Como o microcontrolador não pode fornecer a corrente exigida pelas quatro bobinas indutivas do motor (~200 mA a 300 mA por fase), a placa ULN2003 atua como buffer de potência, contendo 7 pares de transistores Darlington NPN de alta corrente com diodos supressores de transientes integrados. Os 4 LEDs serigrafados na placa driver (A, B, C, D) acendem conforme as bobinas são energizadas sequencialmente.

Materiais Necessários:

Componente	Quantidade	Especificação Técnica / Observações
Placa Uno DIP 16u2	1	Unidade de sequenciamento de passos
Motor de Passo Unipolar 28BYJ-48 (5V)	1	4 fases com conector padrão XH de 5 vias
Placa Driver ULN2003	1	Com 4 LEDs indicadores e conector de engate rápido
Jumpers Fêmea-Macho	6	Conexões de 5V, GND e 4 linhas de fase

Conexão do Driver ULN2003 com o Arduino Uno:

Terminal no Driver ULN2003	Pino no Arduino Uno	Observação Crítica
Pino + (VCC)	Terminal 5V	Alimentação de potência de 5 VDC
Pino - (GND)	Barramento GND	Terra elétrico compartilhado
Entrada IN1	Pino Digital D8	Fase A
Entrada IN2	Pino Digital D9	Fase B
Entrada IN3	Pino Digital D10	Fase C
Entrada IN4	Pino Digital D11	Fase D

📦 Bibliotecas desta lição:

• Stepper.h (versão 1.1.3, nativa do Arduino AVR Core) — Controla sequenciamentos unipolar e bipolar de 4 fios.

Código-Fonte Completo Comentado (stepper_Example.ino):

// Lição 31: Posicionamento Angular de Precisão com Motor de Passo 28BYJ-48
// Kit Avançado AE086 RB2051 - RoboBuilders

// Inclusão da biblioteca oficial de motores de passo
#include <Stepper.h>

// Definição do número total de passos para uma rotação completa do eixo externo de 360°
const int STEPS_PER_REVOLUTION = 2048;

// ATENÇÃO À ORDEM DE PINAGEM:
// A biblioteca Stepper do Arduino foi concebida para drivers bipolares sequenciais.
// Para que o motor unipolar 28BYJ-48 gire corretamente sem trepidar,
// a sequência de pinos declarada deve cruzar as fases 2 e 3: (STEPS, IN1, IN3, IN2, IN4)
Stepper myStepper(STEPS_PER_REVOLUTION, 8, 10, 9, 11);

void setup() {
  // Define a velocidade de rotação do motor em 10 rotações por minuto (RPM)
  // Velocidades acima de 15 RPM podem causar perda de torque e travamento de passos
  myStepper.setSpeed(10);

  Serial.begin(9600);
  Serial.println("Motor de Passo 28BYJ-48 Inicializado...");
}

void loop() {
  // Executa uma volta completa de 360 graus no sentido horário (2048 passos positivos)
  Serial.println("Girando 360 graus no Sentido Horario...");
  myStepper.step(STEPS_PER_REVOLUTION);
  delay(1000); // Pausa de 1 segundo

  // Executa uma volta completa de 360 graus no sentido anti-horário (2048 passos negativos)
  Serial.println("Girando 360 graus no Sentido Anti-Horario...");
  myStepper.step(-STEPS_PER_REVOLUTION);
  delay(1000); // Pausa de 1 segundo
}

Teste e Validação:

1. Carregue o programa: o motor girará suavemente uma volta completa em um sentido, fará uma pausa de 1 segundo e retornará exatamente à posição de partida com precisão absoluta de repetição de coordenadas.

---

Lição 32: Controle de Motor de Passo com Controle Remoto Infravermelho

A Lição 32 combina os módulos das Lições 14 e 31, implementando o controle remoto sem fio do motor de passo através dos comandos decodificados do teclado infravermelho de 21 teclas.

Neste projeto de automação remota:

• A tecla VOL+ ou FORWARD comanda o motor a girar continuamente no sentido horário;
• A tecla VOL- ou BACKWARD comanda a rotação contínua no sentido anti-horário;
• A tecla PLAY/PAUSE ou STOP suspende imediatamente a rotação e desenergiza as fases;
• O receptor AX-1838HS captura os trens de pulsos a 38 kHz e gera códigos hexadecimais no laço de eventos em tempo real.

Materiais Necessários:

Componente	Quantidade	Especificação Técnica / Observações
Placa Uno DIP 16u2	1	Unidade central de controle
Motor de Passo 28BYJ-48 + Driver ULN2003	1	Conjunto motor e placa de potência
Módulo Receptor IR AX-1838HS	1	Demodulador de 38 kHz (Pino D12)
Mini Controle Remoto IR	1	Teclado transmissor
Jumpers Fêmea-Macho / Macho-Macho	9	Conexões de barramento

Mapeamento de Pinos do Circuito Integrado:

Componente	Conexão de Sinal	Pino Arduino Uno
Driver ULN2003 IN1	Fase A	Pino Digital D8
Driver ULN2003 IN2	Fase B	Pino Digital D9
Driver ULN2003 IN3	Fase C	Pino Digital D10
Driver ULN2003 IN4	Fase D	Pino Digital D11
Receptor IR (Sinal OUT)	Dados Demodulados	Pino Digital D12

📦 Bibliotecas desta lição:

• IRremote.h (versão 2.8.x, inclusa na pasta 3.Libraries/IRremote.zip) — Captura e decodifica pacotes NEC.
• Stepper.h (nativa do Arduino AVR Core) — Aciona os passos do motor.

Código-Fonte Completo Comentado (With_Remote.ino):

// Lição 32: Controle Remoto Infravermelho de Motor de Passo
// Kit Avançado AE086 RB2051 - RoboBuilders

#include <IRremote.h>
#include <Stepper.h>

const int STEPS_PER_REV = 2048;

// Inicializa o motor nos pinos 8, 10, 9, 11 (sequência cruzada para 28BYJ-48)
Stepper stepper(STEPS_PER_REV, 8, 10, 9, 11);

// Pino do receptor infravermelho
const int RECV_PIN = 12;
IRrecv irrecv(RECV_PIN);
decode_results results;

// Variável de estado do motor: 0 = Parado, 1 = Sentido Horário, -1 = Sentido Anti-horário
int motorState = 0;

void setup() {
  stepper.setSpeed(10); // Velocidade de rotação a 10 RPM
  irrecv.enableIRIn();  // Inicializa o receptor infravermelho
  Serial.begin(9600);
  Serial.println("Controle Remoto de Motor de Passo Pronto!");
}

void loop() {
  // Verifica se uma tecla do controle remoto foi pressionada
  if (irrecv.decode(&results)) {
    unsigned long val = results.value;
    Serial.print("Comando IR: 0x");
    Serial.println(val, HEX);

    // Mapeamento das teclas do mini controle remoto (Protocolo NEC):
    // Código 0xFFA857 (Tecla VOL+) -> Sentido Horário
    // Código 0xFFE01F (Tecla VOL-) -> Sentido Anti-Horário
    // Código 0xFF02FD (Tecla PLAY/PAUSE) -> Parada
    if (val == 0xFFA857 || val == 0x00FF629D) {
      motorState = 1; // Ativa rotação horária
    } else if (val == 0xFFE01F || val == 0x00FFA857) {
      motorState = -1; // Ativa rotação anti-horária
    } else if (val == 0xFF02FD || val == 0x00FF22DD) {
      motorState = 0; // Para o motor
    }

    irrecv.resume(); // Habilita a recepção do próximo código
  }

  // Executa micro-passos em cada iteração se o motor estiver ativo
  if (motorState == 1) {
    stepper.step(20); // Avança 20 passos horários
  } else if (motorState == -1) {
    stepper.step(-20); // Avança 20 passos anti-horários
  }
}

Teste e Validação:

1. Aponte o controle para o receptor na protoboard e pressione a tecla +: o motor começará a girar suavemente no sentido horário.
2. Pressione a tecla -: o motor inverterá a rotação imediatamente. Pressione Play/Pause: o motor cessará todo o movimento instantaneamente.

---

Lição 33: Controle de Motor de Passo com Módulo Encoder Rotativo (KY-040)

A Lição 33 conclui o curso demonstrando a integração mecânica de precisão entre o motor de passo e o módulo encoder rotativo incremental KY-040, permitindo posicionar angularmente o motor passo a passo de acordo com o giro manual do operador.

Diferente de um potenciômetro analógico convencional que possui batentes físicos limitadores a ~270° e perde a posição se girado além disso, um encoder rotativo incremental pode ser girado continuamente em 360° em qualquer direção infinitamente.

O módulo KY-040 gera dois sinais digitais em quadratura de fase (desfasados de 90 graus no tempo):

• Canal A (CLK): Linha de relógio do encoder;
• Canal B (DT): Linha de direção do encoder;
• Quando o eixo é girado no sentido horário (Clockwise — CW), o canal CLK muda de estado primeiro, antes do canal DT (o estado de DT é diferente de CLK na borda);
• Quando o eixo é girado no sentido anti-horário (Counter-Clockwise — CCW), o canal DT muda de estado antes de CLK (o estado de DT coincide com CLK na borda).

Ao monitorar as transições de borda na linha CLK e avaliar o nível lógico presente na linha DT, o microcontrolador detecta imediatamente o sentido e a quantidade exata de cliques manuais dados pelo operador, repassando esses passos para o motor de passo correspondente.

Materiais Necessários:

Componente	Quantidade	Especificação Técnica / Observações
Placa Uno DIP 16u2	1	Decodificação de quadratura e acionamento
Motor de Passo 28BYJ-48 + Driver ULN2003	1	Mantido montado na protoboard
Módulo Encoder Rotativo KY-040	1	Resolução de 20 pulsos por rotação completa
Jumpers Fêmea-Macho	5	VCC, GND, CLK, DT e SW

Pinagem do KY-040:

Pino no Módulo KY-040	Pino no Arduino Uno	Função
+ (VCC)	Terminal 5V	Alimentação de 5 VDC
GND	Barramento GND	Terra de referência
CLK	Pino Digital D2	Canal A em quadratura (adequado para interrupção)
DT	Pino Digital D3	Canal B de sentido em quadratura
SW	Pino Digital D4	Botão de pressão central integrado no eixo

📦 Bibliotecas desta lição:

• Stepper.h (nativa do Arduino AVR Core) — Aciona os passos do motor.

Código-Fonte Completo Comentado (With_Encoder.ino):

// Lição 33: Controle de Motor de Passo com Encoder Rotativo KY-040
// Kit Avançado AE086 RB2051 - RoboBuilders

#include <Stepper.h>

const int STEPS_PER_REV = 2048;

// Inicializa o motor de passo nos pinos 8, 10, 9, 11
Stepper stepper(STEPS_PER_REV, 8, 10, 9, 11);

// Pinos de interface do encoder KY-040
const int PinCLK = 2; // Linha de clock do encoder
const int PinDT  = 3; // Linha de dados / direção do encoder
const int PinSW  = 4; // Botão de pressão do eixo

// Armazena o estado anterior do pino CLK para detecção de borda
int lastClkState;

void setup() {
  pinMode(PinCLK, INPUT);
  pinMode(PinDT, INPUT);
  pinMode(PinSW, INPUT_PULLUP);

  stepper.setSpeed(12); // Velocidade configurada para 12 RPM

  // Realiza a leitura do estado de repouso inicial de CLK
  lastClkState = digitalRead(PinCLK);

  Serial.begin(9600);
  Serial.println("Controle por Encoder Rotativo Pronto!");
}

void loop() {
  // Lê o estado atual da linha de quadratura CLK
  int currentClkState = digitalRead(PinCLK);

  // Se ocorreu uma transição de nível no sinal CLK, um pulso mecânico foi acionado
  if (currentClkState != lastClkState && currentClkState == 1) {
    // Se o estado de DT for diferente de CLK, o giro ocorreu no SENTIDO HORÁRIO
    if (digitalRead(PinDT) != currentClkState) {
      Serial.println("Encoder: Giro Horario -> Motor Avanca");
      stepper.step(50); // Avança 50 micro-passos no motor
    } else {
      // Caso contrário, o giro ocorreu no SENTIDO ANTI-HORÁRIO
      Serial.println("Encoder: Giro Anti-Horario -> Motor Recua");
      stepper.step(-50); // Recua 50 micro-passos no motor
    }
  }

  // Atualiza o histórico de estado para o próximo ciclo de comparação
  lastClkState = currentClkState;

  // Se o botão de clique central do encoder for pressionado
  if (digitalRead(PinSW) == LOW) {
    Serial.println("Botao do Encoder Clicado -> Reset de Posicao");
    delay(300); // Debounce mecânico
  }
}

Teste e Validação Final:

1. Carregue o programa e segure o corpo do encoder rotativo entre os dedos.
2. Gire o eixo no sentido horário: a cada clique mecânico perceptível no botão rotativo, o motor de passo responderá imediatamente girando um segmento angular correspondente. Gire no sentido anti-horário e o motor acompanhará a rotação com sincronismo instantâneo, concluindo a jornada completa de aprendizado do kit.

---

Guia Diagnóstico de Falhas (Troubleshooting Guide)

A tabela abaixo compila as principais falhas elétricas, erros de compilação, problemas de comunicação USB e incompatibilidades de hardware catalogados nos ensaios práticos das 34 lições do kit AE086 RB2051, com seus respectivos métodos de resolução:

Sintoma de Falha Identificado	Causa Raiz Mais Provável	Procedimento Sistemático de Resolução
Erro avrdude: stk500_recv(): programmer is not responding durante o upload	Porta COM incorreta selecionada ou conflito de pinos UART D0/D1	Desconecte fios ligados aos pinos D0 e D1 da placa. No menu Ferramentas > Porta, selecione a porta correta. Se persistir, reinicie a IDE e troque o cabo USB
Placa não é detectada no Gerenciador de Dispositivos (sem som ao conectar USB)	Cabo USB danificado, porta USB do PC sem energia ou cabo somente carga	Utilize exclusivamente o cabo azul fornecido no kit. Conecte-o diretamente em uma porta USB traseira da placa-mãe do PC, evitando hubs USB passivos
Erro de compilação: 'XXX.h: No such file or directory'	A biblioteca externa exigida pelo código não foi instalada na IDE	Acesse o menu Sketch > Incluir Biblioteca > Adicionar Biblioteca .ZIP… e aponte para o arquivo compactado correspondente localizado na pasta 3.Libraries do kit
Caracteres ilegíveis ou símbolos estranhos (???, “) no Monitor Serial	Taxa de transmissão (baud rate) divergente entre código e console	Verifique o valor configurado na linha Serial.begin(baud). No canto inferior direito da janela do Monitor Serial, ajuste o seletor exatamente para o mesmo valor (9600 baud)
LED externo não acende de forma alguma nas Lições 2 e 3	LED conectado com polaridade invertida ou sem resistor em série	O terminal longo do LED (ânodo) deve estar voltado para o pino de sinal positivo. O terminal curto ou chanfrado (cátodo) deve estar aterrado ao barramento GND
Cores invertidas ou misturadas incorretamente no LED RGB (Lição 4)	Pinos dos canais R, G e B invertidos ou modelo ânodo comum utilizado	Confirme que o terminal mais longo (cátodo comum) está no GND. Se utilizar LED RGB Ânodo Comum, inverta a lógica matemática no código aplicando 255 - valor
Entrada com botão oscilando freneticamente sem ser pressionado (Lição 5)	Pino de entrada configurado apenas como INPUT, deixando-o flutuante	Configure sempre a porta como pinMode(pino, INPUT_PULLUP) para ativar o resistor de pull-up interno, garantindo nível lógico HIGH em repouso e LOW quando pressionado
Buzzer ativo emite som muito fraco ou imperceptível (Lição 6)	Etiqueta adesiva cobrindo o orifício acústico ou polaridade invertida	Remova o selo protetor adesivo superior do buzzer. Certifique-se de que o terminal marcado com o símbolo + na carcaça esteja conectado ao pino digital e o outro ao GND
Buzzer passivo emite apenas cliques secos e sem melodia (Lição 7)	Confundiu o buzzer passivo com o modelo ativo ou não incluiu pitches.h	O buzzer passivo possui a base de circuito impresso verde aberta. Verifique se o arquivo pitches.h está na mesma pasta do sketch e use a função nativa tone()
Servomotor SG90 treme sem girar e placa Uno reinicia continuamente (Lição 9)	Queda de tensão por pico de corrente do motor alimentado pela porta USB	Insira um capacitor eletrolítico de $100\,\mu\text{F}$ em paralelo entre o 5V e GND da protoboard, ou utilize uma fonte de alimentação externa estabilizada de 5 V para o motor
Sensor ultrassônico HC-SR04 retorna permanentemente 0 cm ou distâncias absurdas	Pinos Trig e Echo invertidos ou eco absorvido pelo obstáculo	Confirme que o pino D8 está conectado ao pino Trig e o pino D9 ao Echo. Teste com um anteparo rígido plano (papelão ou plástico) a 20 cm perpendicularmente ao sensor
Teclado matricial 4x4 não responde a nenhuma tecla pressionada (Lição 11)	Ordem dos fios do flat cable de 8 pinos invertida na ligação	Inverta os 8 pinos do conector na protoboard: os primeiros 4 pinos correspondem rigorosamente às Linhas (Rows) e os últimos 4 pinos correspondem às Colunas (Cols)
Sensor DHT11 retorna nan (Not a Number) ou valores travados (Lição 12)	Amostragem solicitada com intervalo inferior a 2 segundos	O DHT11 requer no mínimo 2000 milissegundos entre amostragens consecutivas para estabilização de leitura. Aumente o intervalo temporizado para 2500 ms
Controle remoto IR não decodifica nenhuma tecla ou emite 0xFFFFFFFF (Lição 14)	Película isolante da bateria não removida ou código de repetição do botão	Retire a fita plástica transparente protetora na base do controle. O código 0xFFFFFFFF é normal quando uma tecla é mantida pressionada; solte e aperte rapidamente
Matriz de LED 8x8 MAX7219 permanece completamente apagada (Lição 15)	Pinos de barramento serial DIN, CS e CLK trocados ou módulo em shutdown	Verifique as conexões: DIN no pino 12, CLK no pino 11 e CS no pino 10. Garanta que o comando lc.shutdown(0, false) foi executado na função setup()
MPU-6050 (GY-521) trava o barramento I2C e não envia dados (Lição 16)	Pinos I2C invertidos ou sensor mantido no modo de repouso (Sleep)	SDA deve estar conectado estritamente no pino A4 e SCL no pino A5 do Uno. Certifique-se de escrever o byte 0 no registrador 0x6B (PWR_MGMT_1) para acordar o sensor
Sensor PIR AM312 disparando falsos positivos continuamente (Lição 17)	Tempo de aquecimento térmico (warm-up) inicial não respeitado	O cristal piroelétrico necessita de 5 a 10 segundos em repouso absoluto após energizado para estabilizar as cargas térmicas. Aguarde esse intervalo antes de transitar na frente
Módulo RTC DS1307 zera as horas sempre que o Arduino é desligado (Lição 19)	Bateria botão CR2032 descarregada ou ausente no soquete	Instale uma bateria tipo moeda CR2032 de 3 V nova com a face positiva voltada para cima no soquete do módulo RTC para manter a memória CMOS do relógio alimentada
Leitor RFID RC522 não lê o cartão nem o chaveiro de 13,56 MHz (Lição 21)	Alimentação conectada erroneamente no pino 5V ou pinos SPI invertidos	O módulo RC522 queima se alimentado acima de 3,3 V. Conecte estritamente no terminal 3.3V do Arduino. Confira as linhas SPI: SCK=13, MISO=12, MOSI=11, SS=10
Display LCD 1602 exibe apenas blocos pretos ou tela azul vazia (Lição 22)	Tensão analógica do pino de contraste V0 desajustada	Gire o cursor do potenciômetro de 10 kΩ conectado ao pino 3 (V0) do LCD até que os caracteres pretos se destaquem perfeitamente em contraste com o fundo azul
Barra de LEDs do registrador 74HC595 exibe padrões caóticos (Lição 24)	Pinos de Latch (ST_CP) e Clock (SH_CP) invertidos ou pinos OE/MR soltos	Pino 12 do 595 deve ir ao pino 11 do Uno; pino 11 do 595 ao pino 9 do Uno. O pino 13 (OE) deve estar obrigatoriamente aterrado e o pino 10 (MR) ligado ao barramento 5V
Display de 7 segmentos exibe números deformados com traços trocados (Lição 27)	Ordem física dos segmentos a a g divergente na montagem dos pinos	Consulte o diagrama de pinagem do display de 1 dígito: confirme se Q0 alimenta o pino 7 (seg a), Q1 o pino 6 (seg b), Q2 o pino 4 (seg c) e assim sucessivamente
Motor DC não gira e emite apenas zumbido elétrico agudo (Lição 29)	Valor de PWM muito baixo insuficiente para vencer o atrito estático	O motor DC requer um ciclo de trabalho mínimo (geralmente PWM > 80 a 100) para vencer o atrito inicial do rotor. Eleve o valor aplicado na função analogWrite(ENABLE_PIN, valor)
Motor de passo 28BYJ-48 apenas vibra e esquenta sem rodar o eixo (Lição 31)	Sequência de acionamento das 4 fases invertida na instanciação da biblioteca	Devido à fiação interna do 28BYJ-48, a biblioteca Stepper deve ser instanciada com as fases 2 e 3 cruzadas: Stepper stepper(2048, 8, 10, 9, 11)
Encoder rotativo KY-040 pula passos ou inverte o sentido esporadicamente (Lição 33)	Repique mecânico (switch bounce) nos contatos de quadratura	Adicione capacitores cerâmicos de 10 nF a 100 nF entre os pinos CLK/DT e o GND para filtragem analógica passa-baixas, ou implemente debounce por software

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 AE086 RB2051 – Curso Completo 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.