Kit Aprendizado Robótica ESP32 34 Projetos RB2343 QE200 – Curso Completo

Introdução

Este curso apresenta o Kit Aprendizado Robótica ESP32 34 Projetos RB2343 QE200, uma formação técnica e prática integral em computação física, sistemas embarcados e Internet das Coisas (IoT — Internet of Things). O conjunto é estruturado em torno da placa controladora ESP32, equipada com microprocessador de 32 bits de alto desempenho e dois núcleos Xtensa LX6, interface de conectividade de rádio frequência dupla Wi-Fi 802.11 b/g/n e Bluetooth v4.2 (BR/EDR e BLE — Bluetooth Low Energy), conversores analógico-digitais (ADC — Analog-to-Digital Converter) de 12 bits, canais de modulação por largura de pulso (PWM — Pulse Width Modulation) via periférico LEDC, sensores capacitivos sensíveis ao toque (Touch), portas seriais assíncronas (UART — Universal Asynchronous Receiver-Transmitter), barramentos I2C (Inter-Integrated Circuit) e barramentos SPI (Serial Peripheral Interface). O kit integra uma vasta matriz de transdutores eletrônicos, incluindo sensores ambientais de temperatura e umidade, sensores de presença por infravermelho passivo (PIR — Passive Infrared), fotoresistores (LDR — Light Dependent Resistor), receptores de controle remoto infravermelho, sensores ultrassônicos telemétricos, displays de 7 segmentos de 1 e 4 dígitos, displays alfanuméricos LCD1602 com expansores I2C, servomotores angulares de 180 graus, motores de corrente contínua com hélices e estruturas mecânicas cortadas a laser para robôs e dispositivos mecatrônicos automáticos.

Este material educacional foi desenvolvido sob rigorosos critérios da engenharia eletrônica e de controle, sendo direcionado a estudantes, técnicos, projetistas e desenvolvedores que buscam dominar desde a eletrônica básica e o condicionamento de sinais analógicos até a programação distribuída de servidores HTTP embutidos e aplicações robóticas bioinspiradas. O percurso didático é dividido de forma sequencial em quatro grandes etapas: inicia-se pela preparação detalhada do ferramental de software, instalação de drivers e verificação do ritual de upload; avança pelo estudo analítico de cada componente eletrônico de forma isolada, abordando a física dos transdutores, cálculos de polarização e diagramas esquemáticos; consolida-se em projetos aplicados de automação residencial e telemetria; e culmina na montagem de estruturas mecânicas e sistemas robóticos dinâmicos. Ao término desta formação, o leitor terá domínio completo da arquitetura do microcontrolador ESP32, sabendo projetar, montar, codificar, depurar e integrar dispositivos eletrônicos inteligentes em rede com conectividade sem fio e atuação física real.

O que você vai aprender:

• Compreender a arquitetura interna do microcontrolador ESP32, mapeamento de memória Flash, SRAM, registradores e periféricos embarcados
• Instalar e configurar a IDE Arduino versão 2.x, drivers USB-Serial CH340 e o pacote oficial de placas do ESP32
• Dominar a leitura e condicionamento de sinais analógicos com o ADC de 12 bits e compensar a zona de saturação dos canais
• Implementar controle preciso de intensidade luminosa e velocidade de motores DC utilizando modulação PWM via LEDC
• Acionar servomotores de precisão com pulsos PPM gerados pela biblioteca ESP32Servo
• Decodificar pacotes de controle remoto infravermelho no protocolo NEC através do periférico receptor AX-1838
• Projetar interfaces homem-máquina em displays de 7 segmentos multiplexados dinamicamente no tempo e displays LCD1602 I2C
• Configurar e calibrar sensores telemétricos ultrassônicos HC-SR04 calculando a velocidade do som e tempo de voo acústico
• Construir sistemas de comunicação sem fio via Bluetooth Serial conectando o ESP32 a dispositivos móveis Android
• Criar servidores Web HTTP assíncronos embarcados em modo Station (STA) e Ponto de Acesso (AP) para controle de automação pelo navegador
• Montar e programar dispositivos mecatrônicos mecânicos: borboleta biônica, lixeira inteligente, cancela veicular e ventilador oscilante
• Diagnosticar e solucionar falhas de compilação, comunicação serial, conflitos de barramento e ruídos de chaveamento indutivo

Material utilizado: Kit Aprendizado Robótica Esp32 34 Projetos RB2343 QE200 disponível na loja RoboBuilders.

---

Visão Geral do Kit e Arquitetura de Hardware

A placa controladora que serve como núcleo do Kit QE200 (RoboBuilders RB2343) é baseada no SoC (System-on-Chip) ESP-WROOM-32 da Espressif Systems. Esse circuito integrado incorpora uma arquitetura de microprocessador duplo Xtensa LX6 de 32 bits, operando com frequência de clock ajustável de 80 MHz até 240 MHz. Possui 520 KB de memória SRAM interna de dados e 4 MB de memória Flash externa SPI para armazenamento de firmware e sistema de arquivos. A placa integra um conversor de nível lógico USB-Serial baseado no circuito integrado CH340, porta USB Tipo-C para transmissão de dados e alimentação primária, circuito oscilador a cristal externo de 40 MHz, regulador linear LDO integrado de alta eficiência (3,3 V com capacidade de até 800 mA), conector Jack de alimentação externa (suportando tensões contínuas de 7,2 V a 15 V) e botão de reset por hardware.

A topologia interna do processador permite o processamento simultâneo e concorrente de tarefas em dois núcleos de execução independentes (Core 0 e Core 1). Em sistemas que demandam processamento concorrente em tempo real, as pilhas de protocolos de rede sem fio (Wi-Fi 802.11 b/g/n e Bluetooth pilha HCI/L2CAP) são executadas no Core 0 gerenciadas pelo sistema operacional de tempo real FreeRTOS embutido no núcleo, enquanto a rotina principal do usuário (setup() e loop()) executa de forma desimpedida no Core 1.

Especificações Técnicas da Placa de Controle ESP32

Parâmetro de Engenharia	Especificação Técnica Oficial	Observação de Operação
Microcontrolador Central	ESP32 Xtensa Dual-Core 32-bit LX6	Frequência de clock nominal de até 240 MHz
Tensão Lógica de Operação	3,3 VDC	Nível lógico CMOS. Entradas não toleram 5V
Tensão de Alimentação USB	5,0 VDC	Fornecida via conector USB Tipo-C
Tensão de Entrada Jack DC (VIN)	7,2 V a 15,0 VDC	Regulada internamente para 3,3V via regulador LDO
Memória de Programa (Flash)	4 MB (32 Mbits) SPI Flash	Armazenamento de sketches, tabelas e partições
Memória SRAM de Dados	520 KB	Pilhas de tarefas, filas FreeRTOS e buffers de rede
Canais ADC Analógicos	18 canais (ADC1: 8 canais, ADC2: 10 canais)	Resolução nativa configurável de 12 bits (0 a 4095 passos)
Conversores Digital-Analógico (DAC)	2 canais de 8 bits	Pinos GPIO 25 e GPIO 26
Sensor de Toque Capacitivo	9 pinos Touch dedicados	Detecção de capacitância humana sem componentes externos
Canais PWM de Hardware	16 canais independentes (LEDC)	Resolução programável de 1 até 16 bits
Interfaces Seriais UART	3 interfaces UART por hardware	UART0 dedicada à gravação e Monitor Serial USB
Barramentos I2C e SPI	2 interfaces I2C e 3 interfaces SPI	I2C padrão nos pinos GPIO 21 (SDA) e GPIO 22 (SCL)
Interface de Comunicação USB	CI Conversor CH340C / CH340G	Taxas seriais suportadas de 9600 a 921600 bps
Padrão de Rádio Wi-Fi	IEEE 802.11 b/g/n (2,4 GHz)	Potência de transmissão de até 19,5 dBm
Padrão Bluetooth	Bluetooth v4.2 BR/EDR e BLE	Suporte a portas seriais SPP e GATT

Especificações dos Módulos, Atuadores e Sensores do Kit

Subsistema / Componente	Faixa de Operação	Resolução / Sensibilidade	Função Primária no Kit
Sensor Ultrassônico HC-SR04	5,0 VDC / 15 mA	2 cm a 450 cm (precisão ±3 mm)	Telemetria por tempo de voo acústico de 40 kHz
Sensor de Temperatura/Umidade DHT11	3,3 V a 5,0 VDC	0°C a 50°C (±2°C) / 20% a 90% RH (±5%)	Sensoriamento ambiental via protocolo digital proprietário
Sensor de Presença Humana PIR	4,5 V a 12,0 VDC	Alcance de até 7 metros / cone 110°	Detecção de radiação infravermelha com saída digital TTL
Fotoresistor LDR (5 mm)	Tensão máxima 150 VDC	$10\,\text{k}\Omega$ (claro) a $1\,\text{M}\Omega$ (escuro)	Sensoriamento de iluminância por variação resistiva
Potenciômetro Rotativo Linear	$10\,\text{k}\Omega$ linear (curva B)	Ângulo de giro útil de 300°	Ajuste analógico de grandezas elétricas e setpoints
Micro Servo Motor SG90	4,8 V a 6,0 VDC	Ângulo de rotação de 0° a 180°	Posicionamento angular em malha fechada via sinal PPM
Mini Motor DC com Hélice	3,0 V a 6,0 VDC	Rotação sem carga até 10.000 RPM	Acionamento dinâmico de fluxo de ar e ventilação
Módulo Receptor IR (AX-1838)	2,7 V a 5,5 VDC	Frequência de portadora de 38 kHz	Demodulação de pulsos de infravermelho de controle remoto
Display LCD1602 com I2C	5,0 VDC	16 colunas × 2 linhas (caracteres 5x8)	Interface de texto alfanumérico via barramento I2C
Display de 7 Segmentos (1 Dígito)	Tensão direta $1,8\,\text{V}$ a $2,2\,\text{V}$	8 LEDs internos (7 segmentos + ponto)	Exibição de caracteres numéricos de 0 a 9
Display 7 Segmentos (4 Dígitos)	Tensão direta $1,8\,\text{V}$ a $2,2\,\text{V}$	4 dígitos multiplexados temporalmente	Exibição de valores inteiros, relógios e contadores
Buzzer Ativo	3,3 V a 5,0 VDC	Frequência fixa de oscilação sonora ~2,5 kHz	Avisos sonoros contínuos acionados por nível lógico
Buzzer Passivo	3,3 V a 5,0 VDC	Resposta em frequência de 100 Hz a 10 kHz	Reprodução de notas musicais e tons modulados por PWM

Inventário Completo de Componentes (Packing List do Kit QE200)

O inventário abaixo lista com exatidão todos os itens estruturais, placas, circuitos integrados, sensores, atuadores e elementos de fixação que compõem o kit educacional:

• Placa controladora ESP32 ACEBOTT (processador Dual-Core Xtensa LX6, 4 MB Flash, conectores USB Tipo-C e Jack DC com chip serial CH340)
• Cabo de comunicação e alimentação USB Tipo-C para Tipo-A (comprimento de 1 metro, linhas completas de dados D+ e D-)
• Matriz de contatos (Breadboard / Protoboard) de 830 pontos de inserção com barramentos duplos de alimentação lateral destacados
• Conjunto de 65 cabos jumper flexíveis macho-macho com pinos estanhados de comprimentos variados
• Conjunto de 20 cabos jumper macho-fêmea para conexão direta de módulos e sensores
• Conjunto de 10 cabos jumper fêmea-fêmea para interligação entre pinos de sensores
• Caixa de baterias para 6 pilhas tipo AA (tensão nominal de 9V) com chave liga/desliga integrada e conector plug Jack P4 (5,5 mm × 2,1 mm)
• Diodos Emissores de Luz (LED) difusos de 5 mm: 5 unidades vermelhas, 5 unidades verdes, 5 unidades amarelas, 5 unidades azuis e 5 unidades brancas
• 1 Diodo Emissor de Luz tricolor RGB difuso de 5 mm de 4 pinos (cátodo comum)
• Pacote com 10 resistores de filme de carbono de $220\,\Omega$ (potência de 1/4W, tolerância de ±5%)
• Pacote com 10 resistores de filme de carbono de $1\,\text{k}\Omega$ (potência de 1/4W, tolerância de ±5%)
• Pacote com 10 resistores de filme de carbono de $10\,\text{k}\Omega$ (potência de 1/4W, tolerância de ±5%)
• 4 chaves tácteis tipo push-button de 4 terminais com capas plásticas protetoras destacáveis coloridas
• 1 sensor piroelétrico de movimento infravermelho passivo (PIR) com cúpula óptica Fresnel
• 1 sensor fotoresistor LDR de 5 mm sensível ao espectro visível
• 1 potenciômetro rotativo linear de $10\,\text{k}\Omega$ com curso mecânico de 300° e haste metálica
• 1 transdutor acústico buzzer eletromagnético ativo (gerador sonoro contínuo com oscilador interno)
• 1 transdutor acústico buzzer piezoelétrico passivo (excitado por sinal de áudio alternado ou PWM)
• 1 mini motor elétrico de corrente contínua (DC) de 3V a 6V com eixo estriado
• 1 hélice plástica aerodinâmica de 4 pás para motor de corrente contínua
• 1 transistor NPN de média potência para chaveamento indutivo de carga
• 1 diodo retificador de silício 1N4007 para circuito de proteção flyback contra picos indutivos
• 1 micro servomotor analógico SG90 de 9 gramas (torque de $1,8\,\text{kg}\cdot\text{cm}$, curso de 0° a 180°, cruzetas plásticas e parafusos de montagem)
• 1 sensor digital de temperatura e umidade relativa do ar DHT11
• 1 sensor telemétrico ultrassônico de distância HC-SR04 com transdutores piezoelétricos de 40 kHz
• 1 display numérico LED de 8 segmentos (1 dígito de 0,56 polegadas, cátodo comum)
• 1 display numérico LED de 8 segmentos multiplexado de 4 dígitos (0,56 polegadas, cátodo comum)
• 1 módulo receptor de radiação infravermelha AX-1838 com filtro óptico centrado em 38 kHz
• 1 controle remoto por infravermelho multifuncional em formato cartão com 21 teclas de membrana
• 1 módulo display alfanumérico LCD1602 (16 colunas por 2 linhas) com placa controladora de barramento I2C soldada (PCF8574)
• 4 cabos com terminais tipo garra de jacaré com derivação para pino Dupont macho (para testes de toque capacitivo do Touch ESP32)
• Kit estrutural de montagem mecânica em madeira reflorestada cortada a laser com peças de encaixe para 5 dispositivos alargados: Borboleta Biônica, Lixeira Inteligente, Cancela de Estacionamento, Ventilador Oscilante e Teclado Musical
• Conjunto completo de parafusos, porcas, arruelas e espaçadores metálicos M2 e M3 para fixação dos projetos estruturais
• Estojo plástico organizador translúcido de polipropileno com divisórias e travas para acomodação de todos os componentes

Somatória Geral do Kit: 28 categorias funcionais, totalizando mais de 170 peças e componentes individuais entre semicondutores, sensores, atuadores, elementos mecânicos de precisão, condutores elétricos e ferragens de montagem.

---

Mapa Consolidado de Pinos e Protocolos do ESP32 no Curso

A tabela estruturada a seguir apresenta o mapeamento unificado de todos os pinos de entrada e saída (GPIO) do microcontrolador ESP32 utilizados nas 38 lições do curso:

Pino GPIO	Tipo / Direção	Periférico do ESP32	Nível Lógico	Aplicações e Lições Associadas
GPIO 2	Entrada / Saída	Digital I/O / Touch 2 / LED interno	3,3 VDC	Lição 26 (Piano Touch), Lição 32 (Luz Bluetooth), Lição 33 (Web)
GPIO 4	Entrada / Saída	ADC2_CH0 / Touch 0 / Digital I/O	3,3 VDC	Lição 26 (Pino de toque capacitivo Touch 0)
GPIO 5	Saída	Digital I/O / Canal LEDC	3,3 VDC	Lição 1 (LED), Lição 2 (Luz Respiratória PWM), Lição 18 (Sequencial)
GPIO 12	Entrada / Saída	ADC2_CH5 / Touch 5 / Digital I/O	3,3 VDC	Lição 26 (Pino de toque capacitivo Touch 5)
GPIO 13	Entrada / Saída	ADC2_CH4 / Touch 4 / Digital I/O	3,3 VDC	Lição 26 (Pino de toque capacitivo Touch 4)
GPIO 14	Entrada / Saída	ADC2_CH6 / Touch 6 / Digital I/O	3,3 VDC	Lição 26 (Pino de toque capacitivo Touch 6)
GPIO 15	Entrada / Saída	ADC2_CH3 / Touch 3 / Digital I/O	3,3 VDC	Lição 16 (Receptor IR), Lição 26 (Pino Touch 3), Lição 29 (IR Fan)
GPIO 16	Entrada / Saída	Digital I/O / UART2 RX	3,3 VDC	Lição 14 e 15 (Segmentos de displays), Lição 23 e 24
GPIO 17	Entrada / Saída	Digital I/O / UART2 TX	3,3 VDC	Lição 14 e 15 (Segmentos de displays), Lição 23 e 24
GPIO 18	Entrada / Saída	Digital I/O / VSPI CLK	3,3 VDC	Lição 18 (Sequencial), Lição 35 (Echo Ultrassom Lixeira)
GPIO 19	Entrada / Saída	Digital I/O / VSPI MISO	3,3 VDC	Lição 18 (Sequencial), Lição 35 (Trigger Ultrassom Lixeira)
GPIO 21	Entrada / Saída	Barramento I2C SDA	3,3 VDC	Lição 17 (LCD1602 SDA), Lição 30 (Estação Ambiental I2C)
GPIO 22	Entrada / Saída	Barramento I2C SCL	3,3 VDC	Lição 17 (LCD1602 SCL), Lição 30 (Estação Ambiental I2C)
GPIO 23	Entrada / Saída	Digital I/O / VSPI MOSI	3,3 VDC	Lição 18 (LED Sequencial), Lição 19 (LED de estado)
GPIO 25	Saída	DAC1 / Canal LEDC / Digital I/O	3,3 VDC	Lição 8 (Buzzer Ativo), Lição 9 (Buzzer Passivo), Lição 25 (Quiz)
GPIO 26	Saída	DAC2 / Canal LEDC / Digital I/O	3,3 VDC	Lição 10 (Controle Motor DC), Lição 27 e 28 (Ventiladores)
GPIO 27	Saída	ADC2_CH7 / Touch 7 / Servo PPM	3,3 VDC	Lição 11 (Servo Motor), Lição 31 (Radar), Lição 34 a 37 (Projetos)
GPIO 32	Entrada	ADC1_CH4 / Touch 9	3,3 VDC	Lição 6 (Sensor LDR), Lição 21 (Poste de Luz), Lição 12 (DHT11)
GPIO 33	Entrada	ADC1_CH5 / Touch 8	3,3 VDC	Lição 4 (Botão Digital), Lição 5 (Sensor PIR), Lição 7 (Potenciômetro)
GPIO 34	Entrada	ADC1_CH6 (Apenas Entrada Digital/ADC)	3,3 VDC	Canal de leitura pura (não possui circuito interno de pull-up/pull-down)
GPIO 35	Entrada	ADC1_CH7 (Apenas Entrada Digital/ADC)	3,3 VDC	Canal de leitura analógica dedicada do ADC1

⚠️ Atenção: Os pinos GPIO 34, 35, 36 (VP) e 39 (VN) são exclusivamente entradas (Input Only). Eles não possuem transistores internos de saída e não oferecem resistores de pull-up ou pull-down por software. Sempre que utilizá-los para sensores digitais, é obrigatório conectar um resistor externo de pull-up ou pull-down físico.

---

Parte 1 — Preparação para Utilização e Ferramental de Software

Instalação da IDE Arduino e Configuração do Driver CH340

Para desenvolver, compilar e descarregar os programas no microcontrolador ESP32, utilizamos o ambiente oficial Arduino IDE (versão 2.3.x ou superior). Essa plataforma integra o compilador GCC para a arquitetura Xtensa (xtensa-esp32-elf-g++), a ferramenta de gravação de memória flash esptool.py, o gerenciador de bibliotecas e o Monitor Serial com capacidade de traçado gráfico em tempo real (Serial Plotter).

Passo 1: Download e Instalação da IDE Arduino

1. Acesse o portal oficial arduino.cc/en/software e descarregue o instalador apropriado para seu sistema operacional (Windows 64-bit, macOS Apple Silicon/Intel ou Linux AppImage).
2. Execute o instalador e autorize as permissões de instalação de drivers complementares e criação de atalhos de sistema.

Passo 2: Instalação do Driver USB-Serial CH340

A placa controladora do kit utiliza o circuito integrado CH340C para converter a comunicação serial assíncrona da UART0 do ESP32 para o barramento USB do computador:

1. Caso o sistema operacional não reconheça a porta ao conectar o cabo Tipo-C, abra a pasta Arduino(Aprendiz Experiente)\3.Instalaçao do Driver e execute o instalador SETUP.EXE contido em CH340 Driver File-Windows.
2. Clique no botão INSTALL e aguarde a mensagem de confirmação (Driver install success!).
3. Conecte o cabo USB Tipo-C da placa ao computador. Abra o Gerenciador de Dispositivos do Windows e verifique a seção Portas (COM e LPT): a placa deverá figurar como USB-SERIAL CH340 (COMx).

Passo 3: Adição do Pacote de Placas ESP32 na IDE

1. Abra a Arduino IDE e acesse o menu Arquivo > Preferências (Ctrl + ,).
2. No campo URLs do Gerenciador de Placas Adicionais, insira o endereço oficial mantido pela Espressif:

   https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json

3. Clique em OK. Acesse o menu lateral esquerdo e selecione o ícone de placas (Boards Manager).
4. No campo de pesquisa, digite esp32 e localize o pacote oficial esp32 by Espressif Systems. Selecione a versão recomendada estável 2.0.12 (ou versão 2.0.x / 3.0.x homologada) e clique em Instalar.
5. No menu superior da IDE, acesse Ferramentas > Placa > esp32 > ESP32 Dev Module.
6. Em Ferramentas > Porta, selecione a porta serial identificada no passo anterior (ex.: COM3).

---

Primeiro Programa de Validação: Hello World

Para validar a integridade de todo o ambiente de desenvolvimento, da cadeia de compilação e da interface de comunicação USB-Serial, compilaremos e enviaremos o programa de teste inicial Hello_world.ino.

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Programa de Teste: Hello_world.ino
// Validação da cadeia de compilação e comunicação serial assíncrona da UART0
// ==============================================================================

// A função setup() é executada exatamente uma única vez durante a inicialização do microcontrolador
void setup() {
  // Inicializa o periférico de comunicação serial UART0 na taxa de 115200 bits por segundo
  Serial.begin(115200);
}

// A função loop() é executada ciclicamente de forma contínua e indefinida pelo processador
void loop() {
  // Envia a cadeia de caracteres "Hello World!" pela porta serial, seguida de uma quebra de linha (

)
  Serial.println("Hello World!");
  
  // Pausa a execução da thread do usuário por 1000 milissegundos (1 segundo) para evitar saturação do buffer serial
  delay(1000);
}

Procedimento de Upload e Teste no Monitor Serial

1. Conecte a placa ESP32 ao computador via cabo USB Tipo-C.
2. Certifique-se de que a placa ESP32 Dev Module e a respectiva porta serial estão selecionadas.
3. Clique no botão de upload (seta para a direita). O compilador gerará a imagem binária e o utilitário esptool.py gravará os setores da memória Flash.
4. Ao término da mensagem de sucesso (Leaving... Hard resetting via RTS pin...), abra o Monitor Serial (Ctrl + Shift + M).
5. Configure a taxa de comunicação no canto superior direito do Monitor Serial para exatamente 115200 baud.
6. Resultado Esperado: O Monitor Serial passará a imprimir a cada 1 segundo a mensagem Hello World!.

---

Tabela-Mestre de Bibliotecas do Curso

A tabela estruturada a seguir consolida todas as bibliotecas externas e dependências de software necessárias para a execução integral das 38 lições do kit. Cada biblioteca possui sua respectiva versão homologada, método recomendado de instalação via Gerenciador de Bibliotecas da IDE e link alternativo em arquivo ZIP:

Biblioteca (#include)	Termo de Busca no Gerenciador	Versão Homologada	Repositório Oficial / Download ZIP	Lições Dependentes
DHT sensor library (<DHT.h>)	DHT sensor library	Versão 1.4.6 (Adafruit)	Adafruit/DHT-sensor-lib	Lição 12, Lição 28, Lição 30
Adafruit Unified Sensor (<Adafruit_Sensor.h>)	Adafruit Unified Sensor	Versão 1.1.14 (Adafruit)	Adafruit/Adafruit_Sensor	Dependência transitiva obrigatória do DHT
ESP32Servo (<ESP32Servo.h>)	ESP32Servo	Versão 1.1.1 (Kevin Harrington)	madhephaestus/ESP32Servo	Lição 11, 31, 34, 35, 36, 37
IRremote (<IRremote.hpp> / <IRremote.h>)	IRremote	Versão 4.1.2 (ArminJo)	Arduino-IRremote/Arduino-IRremote	Lição 16, Lição 29
LiquidCrystal_I2C (<LiquidCrystal_I2C.h>)	LiquidCrystal_I2C	Versão 1.1.4 (Frank de Brabander)	johnrickman/LiquidCrystal_I2C	Lição 17, Lição 30
BluetoothSerial (<BluetoothSerial.h>)	Embutida no pacote ESP32	Versão do Núcleo ESP32 2.0.x	Integrada nativamente ao core Espressif	Lição 32
WiFi (<WiFi.h>)	Embutida no pacote ESP32	Versão do Núcleo ESP32 2.0.x	Integrada nativamente ao core Espressif	Lição 33
WebServer (<WebServer.h>)	Embutida no pacote ESP32	Versão do Núcleo ESP32 2.0.x	Integrada nativamente ao core Espressif	Lição 33

💡 Dica de Instalação: Para instalar as bibliotecas externas recomendadas, utilize o menu Sketch > Incluir Biblioteca > Gerenciar Bibliotecas... na Arduino IDE. Ao instalar a biblioteca DHT sensor library, a IDE exibirá uma caixa de diálogo perguntando se deseja instalar todas as dependências: selecione Install All para garantir a presença do Adafruit Unified Sensor. Alternativamente, utilize os arquivos .zip fornecidos na pasta Arduino(Aprendiz Experiente)\4.Biblioteca através do menu Sketch > Incluir Biblioteca > Adicionar Biblioteca .ZIP....

---

Parte 2 — Aprendizagem dos Módulos e Componentes

Nesta segunda parte do curso, estudaremos analiticamente cada componente, transdutor, sensor e atuador fornecido no kit de forma individual e progressiva. Para cada módulo, abordaremos os princípios físicos de funcionamento, as equações de engenharia que regem o circuito, os diagramas esquemáticos e práticos de ligação na matriz de contatos com o microcontrolador ESP32, as bibliotecas de software necessárias, o código-fonte C++ completo e comentado linha por linha, além dos procedimentos de teste e validação de bancada com o resultado esperado.

---

Lição 1: LED

O Diodo Emissor de Luz (LED — Light Emitting Diode) é um semicondutor de junção p-n que converte diretamente energia elétrica em luz visível através do fenômeno da eletroluminescência. Quando o dispositivo é polarizado diretamente (com o anodo positivo em relação ao catodo), os elétrons da banda de condução recombinam-se com as lacunas da banda de valência, liberando fótons cujo comprimento de onda e cor dependem da energia do gap de banda (bandgap) do material semicondutor utilizado (como arsenieto de gálio ou nitreto de gálio).

Para garantir a integridade do componente e do pino de saída digital do microcontrolador ESP32, é obrigatório inserir um resistor limitador de corrente em série com o circuito. A equação que determina o valor da resistência $R$ a partir da Lei de Ohm é dada por:

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

onde $V_{CC}$ é a tensão fornecida pelo pino GPIO do ESP32 ($3,3\,\text{V}$), $V_F$ é a queda de tensão direta no LED (tipicamente $2,0\,\text{V}$ para LEDs vermelhos comuns) e $I_F$ é a corrente de operação contínua desejada (projetada comumente para $6\,\text{mA}$ a $10\,\text{mA}$). Aplicando os valores de projeto:

$$R = \frac{3,3\,\text{V} - 2,0\,\text{V}}{0,006\,\text{A}} = 216,6\,\Omega \approx 220\,\Omega$$

Portanto, o resistor padronizado de $220\,\Omega$ incluído no kit é o elemento ideal para polarizar o dispositivo com alta luminosidade e total segurança operacional para o silício do microcontrolador.

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Matriz de contatos (Breadboard) de 830 pontos
• 1x Cabo de comunicação USB Tipo-C
• 1x Diodo Emissor de Luz (LED) difuso vermelho de 5 mm
• 1x Resistor de filme de carbono de $220\,\Omega$ (1/4W)
• 2x Cabos jumper flexíveis macho-macho

Ligações Elétricas e Pinagem

Terminal do Componente	Pino da Placa ESP32	Tipo de Sinal	Descrição Funcional
Anodo do LED (Terminal longo)	GPIO 5	Saída Digital	Nível lógico ALTO (3,3V) para acender, BAIXO (0V) para apagar
Catodo do LED (Terminal curto)	Resistor $220\,\Omega$	Série Elétrica	Conecta-se em série ao resistor limitador de corrente
Terminal oposto do Resistor	GND	Referência (0V)	Retorno para o barramento comum de terra (GND)

📦 Bibliotecas desta lição: nenhuma — o firmware utiliza exclusivamente as funções nativas de entrada e saída digital da linguagem (pinMode(), digitalWrite() e delay()), dispensando o download de bibliotecas externas.

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 1: Acionamento Digital de LED
// ==============================================================================

// Define o pino GPIO 5 como o terminal de controle digital do LED
int ledPin = 5;

// A função setup() configura os periféricos na inicialização da placa
void setup() {
  // Configura a direção do pino GPIO 5 como saída digital (OUTPUT)
  pinMode(ledPin, OUTPUT);
}

// A função loop() repete a rotina de controle indefinidamente
void loop() {
  // Coloca o pino GPIO 5 em nível lógico ALTO (3,3V), polarizando o LED e acendendo-o
  digitalWrite(ledPin, HIGH);
  
  // Mantém o estado aceso por um intervalo de 1000 milissegundos (1 segundo)
  delay(1000);
  
  // Coloca o pino GPIO 5 em nível lógico BAIXO (0V), cortando a corrente e apagando o LED
  digitalWrite(ledPin, LOW);
  
  // Mantém o estado apagado por um intervalo de 1000 milissegundos (1 segundo)
  delay(1000);
}

Procedimento de Gravação e Teste de Bancada

1. Monte o circuito na breadboard conectando o terminal longo (anodo) ao GPIO 5 e o terminal curto (catodo) ao resistor de $220\,\Omega$, conectando a outra ponta do resistor ao barramento GND.
2. Conecte o cabo USB Tipo-C e selecione a porta COM correspondente na Arduino IDE.
3. Carregue o programa clicando em Upload.
4. Resultado Esperado: O LED vermelho passará a piscar ciclicamente, permanecendo exatamente 1 segundo aceso e 1 segundo apagado em repetição contínua.

---

Lição 2: Luz Respiratória (Breathing Light / PWM)

O microcontrolador ESP32 é um dispositivo puramente digital cujos pinos de saída só podem assumir estados discretos ($0\,\text{V}$ ou $3,3\,\text{V}$). Para obter variações graduais de brilho e simular tensões intermediárias contínuas, utiliza-se a técnica de Modulação por Largura de Pulso (PWM — Pulse Width Modulation). O periférico de hardware responsável por essa função no silício do ESP32 chama-se LEDC (LED Control), composto por múltiplos canais com temporizadores independentes.

O PWM opera chaveando a saída digital entre os níveis alto e baixo em frequência constante e elevada (superior à persistência da visão humana). A tensão média eficaz $\bar{V}$ entregue à carga é governada pelo ciclo de trabalho (duty cycle) $D$, definido matematicamente pela relação:

$$D = \frac{T_{ON}}{T_{ON} + T_{OFF}} = \frac{T_{ON}}{T}$$ $$\bar{V} = D \times V_{CC}$$

onde $T_{ON}$ é o tempo em que o sinal permanece no nível alto dentro do período total $T$, e $V_{CC}$ é a tensão lógica ($3,3\,\text{V}$). Com uma resolução de 8 bits ($2^8 = 256$ passos discretos, de 0 a 255), o valor numérico determina proporcionalmente o duty cycle: quando o valor é 0, a tensão média é $0\,\text{V}$; quando o valor é 128, a tensão média é $1,65\,\text{V}$ ($D = 50\%$); e quando atinge 255, a tensão média é $3,3\,\text{V}$ ($D = 100\%$).

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Matriz de contatos (Breadboard) de 830 pontos
• 1x Diodo Emissor de Luz (LED) difuso vermelho de 5 mm
• 1x Resistor de filme de carbono de $220\,\Omega$ (1/4W)
• 2x Cabos jumper flexíveis macho-macho

Ligações Elétricas e Pinagem

Terminal do Componente	Pino da Placa ESP32	Tipo de Sinal	Descrição Funcional
Anodo do LED	GPIO 5	Saída PWM (LEDC)	Sinal chaveado modulado em largura de pulso
Catodo do LED	Resistor $220\,\Omega$	Série Elétrica	Limitação de corrente
Terminal oposto do Resistor	GND	Referência (0V)	Retorno de terra

📦 Bibliotecas desta lição: nenhuma — a função nativa analogWrite() do núcleo ESP32 gerencia automaticamente o periférico LEDC de hardware.

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 2: Efeito de Luz Respiratória com Modulação PWM
// ==============================================================================

// Pino GPIO 5 configurado para acionamento por PWM
int ledPin = 5;

void setup() {
  // Define o pino GPIO 5 como saída digital habilitada para modulação
  pinMode(ledPin, OUTPUT);
}

void loop() {
  // Rampa de subida: aumenta gradativamente o brilho de 0 até 255 em passos de 5 unidades
  for (int brightness = 0; brightness <= 255; brightness += 5) {
    // Escreve o ciclo de trabalho no pino utilizando a abstração nativa analogWrite()
    analogWrite(ledPin, brightness);
    // Pausa de 5 milissegundos para cadenciar a velocidade do efeito de aceleração
    delay(5);
  }
  
  // Rampa de descida: reduz gradativamente o brilho de 255 até 0 em passos de 5 unidades
  for (int brightness = 255; brightness >= 0; brightness -= 5) {
    // Atualiza o valor do duty cycle no registrador do periférico LEDC
    analogWrite(ledPin, brightness);
    // Pausa de 5 milissegundos para suavizar a transição de decaimento luminoso
    delay(5);
  }
}

Procedimento de Gravação e Teste de Bancada

1. Mantenha o mesmo circuito elétrico montado na Lição 1 (LED no GPIO 5 através do resistor de $220\,\Omega$).
2. Faça o upload do firmware para a placa ESP32.
3. Resultado Esperado: O LED passará a variar sua intensidade luminosa de forma suave e harmônica, clareando suavemente até o brilho máximo e diminuindo até apagar por completo, em um ciclo respiratório contínuo.

---

Lição 3: LED RGB

O LED RGB é um componente optoeletrônico que reúne três pastilhas semicondutoras distintas em um mesmo encapsulamento difuso de 5 mm: uma emissora de luz vermelha (Red), uma verde (Green) e uma azul (Blue). A síntese aditiva de cores baseia-se na sobreposição controlada das três cores primárias do espectro luminoso. Variando a intensidade individual de cada canal entre 0 e 255 através de modulação PWM, é possível produzir milhões de tonalidades cromáticas distintas, como amarelo (Vermelho + Verde), ciano (Verde + Azul), magenta (Vermelho + Azul) e branco (Vermelho + Verde + Azul balanceados).

O componente fornecido no kit é do tipo Cátodo Comum (Common Cathode), o que significa que os catodos das três pastilhas semicondutoras internas estão eletricamente unificados no terminal mais longo do encapsulamento, o qual deve ser conectado ao barramento negativo de terra (GND). Os outros três terminais correspondem aos anodos independentes de cada cor.

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Matriz de contatos (Breadboard) de 830 pontos
• 1x Diodo Emissor de Luz Tricolor (LED RGB) difuso de 4 pinos (cátodo comum)
• 3x Resistores de filme de carbono de $220\,\Omega$ (1/4W)
• 4x Cabos jumper flexíveis macho-macho

Ligações Elétricas e Pinagem

Terminal do LED RGB	Pino da Placa ESP32	Tipo de Sinal	Função do Terminal
Terminal Vermelho (R)	GPIO 5 (via resistor $220\,\Omega$)	Saída PWM	Controle de intensidade da cor vermelha
Cátodo Comum (Terminal mais longo)	GND	Referência (0V)	Retorno comum de terra de todos os canais
Terminal Verde (G)	GPIO 18 (via resistor $220\,\Omega$)	Saída PWM	Controle de intensidade da cor verde
Terminal Azul (B)	GPIO 19 (via resistor $220\,\Omega$)	Saída PWM	Controle de intensidade da cor azul

📦 Bibliotecas desta lição: nenhuma — utiliza saídas PWM de hardware independentes via analogWrite().

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 3: Controle e Mistura Cromática de LED RGB
// ==============================================================================

// Mapeamento dos pinos GPIO conectados aos anodos de cada canal cromático
int redPin = 5;     // Terminal da cor vermelha
int greenPin = 18;  // Terminal da cor verde
int bluePin = 19;   // Terminal da cor azul

// Função auxiliar modular para escrita dos valores de PWM nos três canais
void setColor(int red, int green, int blue) {
  // Ajusta o duty cycle do canal vermelho (0 a 255)
  analogWrite(redPin, red);
  // Ajusta o duty cycle do canal verde (0 a 255)
  analogWrite(greenPin, green);
  // Ajusta o duty cycle do canal azul (0 a 255)
  analogWrite(bluePin, blue);
}

void setup() {
  // Configura os três pinos de controle cromático como saídas digitais
  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);
}

void loop() {
  // Exibe a cor Vermelha pura: R=255, G=0, B=0
  setColor(255, 0, 0);
  delay(1000);
  
  // Exibe a cor Verde pura: R=0, G=255, B=0
  setColor(0, 255, 0);
  delay(1000);
  
  // Exibe a cor Azul pura: R=0, G=0, B=255
  setColor(0, 0, 255);
  delay(1000);
  
  // Exibe a cor Amarela (síntese aditiva de Vermelho e Verde): R=255, G=255, B=0
  setColor(255, 255, 0);
  delay(1000);
  
  // Exibe a cor Magenta (síntese de Vermelho e Azul): R=255, G=0, B=255
  setColor(255, 0, 255);
  delay(1000);
  
  // Exibe a cor Ciano (síntese de Verde e Azul): R=0, G=255, B=255
  setColor(0, 255, 255);
  delay(1000);
  
  // Exibe a cor Branca (mistura balanceada das três cores primárias): R=255, G=255, B=255
  setColor(255, 255, 255);
  delay(1000);
}

Procedimento de Gravação e Teste de Bancada

1. Posicione o LED RGB na protoboard. Identifique o terminal mais longo (cátodo comum) e conecte-o ao GND.
2. Interligue cada anodo (R, G, B) a um resistor de $220\,\Omega$ e conecte os extremos aos pinos GPIO 5, 18 e 19.
3. Carregue o código na placa ESP32.
4. Resultado Esperado: O LED exibirá ciclicamente vermelho, verde, azul, amarelo, magenta, ciano e branco em intervalos regulares de 1 segundo.

---

Lição 4: Botões (Push-Buttons e Entradas Digitais)

A leitura de sinais de controle humanos em sistemas embarcados requer o uso de chaves tácteis (push-buttons). No estado aberto, as lâminas internas do botão estão eletricamente desconectadas. Ao pressionar o botão, estabelece-se um curto-circuito temporário entre os contatos metálicos.

Se conectarmos um botão diretamente entre a alimentação e um pino de entrada sem uma referência fixa de polarização, o pino permanecerá com impedância infinita quando a chave estiver aberta, flutuando (floating input) e captando ruídos eletrostáticos e eletromagnéticos aleatórios. Para resolver esse comportamento, adota-se um resistor de pull-down (ou resistor de pull-up). Na configuração pull-down com resistor de $10\,\text{k}\Omega$, o pino é referenciado com firmeza ao terra ($0\,\text{V}$, nível lógico BAIXO ou LOW) enquanto a chave estiver aberta. Ao pressionar o botão, o pino é conectado ao barramento de $3,3\,\text{V}$ (nível lógico ALTO ou HIGH), drenando uma corrente ínfima e segura de:

$$I = \frac{3,3\,\text{V}}{10\,\text{k}\Omega} = 0,33\,\text{mA}$$

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Matriz de contatos (Breadboard) de 830 pontos
• 1x Chave táctil tipo push-button de 4 terminais com capa plástica
• 1x Resistor de filme de carbono de $10\,\text{k}\Omega$ (resistor de pull-down)
• 1x Cabo de comunicação USB Tipo-C
• 3x Cabos jumper flexíveis macho-macho

Ligações Elétricas e Pinagem

Terminal do Componente	Pino da Placa ESP32	Tipo de Sinal	Função do Circuito
Terminal 1 do Botão	3,3V	Alimentação Positiva	Fornece potencial alto quando o botão é pressionado
Terminal 2 do Botão	GPIO 33	Entrada Digital	Pino sensor lido pela função digitalRead()
Resistor de $10\,\text{k}\Omega$	Entre GPIO 33 e GND	Pull-down	Drena ruídos para o terra quando a chave está aberta

📦 Bibliotecas desta lição: nenhuma — opera com leitura digital nativa via digitalRead().

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 4: Leitura de Entrada Digital com Push-Button
// ==============================================================================

// Pino GPIO 33 conectado ao circuito do botão com pull-down externo
int buttonPin = 33;

void setup() {
  // Inicializa a interface de comunicação serial a 115200 bps
  Serial.begin(115200);
  
  // Configura o pino GPIO 33 como entrada digital de sinal
  pinMode(buttonPin, INPUT);
}

void loop() {
  // Lê o estado lógico instantâneo do pino (0 para LOW, 1 para HIGH)
  int buttonState = digitalRead(buttonPin);
  
  // Imprime o valor booleano lido na saída do Monitor Serial
  Serial.println(buttonState);
  
  // Pausa de 100 milissegundos para limitar a taxa de dados transmitidos
  delay(100);
}

Procedimento de Gravação e Teste de Bancada

1. Monte o circuito na breadboard conectando um dos lados do botão ao $3,3\,\text{V}$ e o outro lado ao GPIO 33, colocando o resistor de $10\,\text{k}\Omega$ do GPIO 33 para o GND.
2. Grave o código no ESP32 e abra o Monitor Serial configurado em 115200 baud.
3. Resultado Esperado: Enquanto o botão estiver solto, o Monitor Serial imprimirá continuamente o valor 0. Ao pressionar o botão físico, o valor passará instantaneamente para 1.

---

Lição 5: Sensor de Infravermelhos Humano (Sensor PIR)

O Sensor de Infravermelho Passivo (PIR — Passive Infrared Sensor) baseia-se no efeito piroelétrico para detectar a presença e o deslocamento de corpos quentes, como seres humanos e animais. Todo corpo biológico cuja temperatura esteja acima do zero absoluto emite radiação eletromagnética contínua na faixa do infravermelho termodinâmico (com comprimento de onda entre $8\,\mu\text{m}$ e $14\,\mu\text{m}$).

O elemento sensor interno é composto por dois cristais de tantalato de lítio piroelétricos dispostos em oposição de polaridade. Na frente do elemento sensor, há uma cúpula plástica translúcida chamada Lente de Fresnel. A lente de Fresnel divide o ambiente em múltiplas zonas focais alternadas de detecção. Quando um indivíduo passa em frente ao sensor, seu corpo cruza sequencialmente feixes ópticos distintos, criando uma diferença térmica entre as duas placas piroelétricas que gera uma pequena tensão piezoelétrica amplificada por um comparador interno (como o circuito integrado BISS0001). Ao detectar o deslocamento, a saída digital do módulo comuta para nível alto ($3,3\,\text{V}$ ou $5\,\text{V}$) durante um intervalo de tempo ajustável.

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Matriz de contatos (Breadboard) de 830 pontos
• 1x Módulo Sensor de Movimento PIR
• 3x Cabos jumper flexíveis macho-fêmea ou macho-macho

Ligações Elétricas e Pinagem

Pino do Módulo PIR	Pino da Placa ESP32	Tipo de Sinal	Função do Terminal
VCC	5V ou 3,3V	Alimentação Elétrica	Tensão de operação do circuito de amplificação
OUT	GPIO 33	Entrada Digital	Nível ALTO ao detectar movimento, BAIXO em repouso
GND	GND	Referência (0V)	Retorno de terra

📦 Bibliotecas desta lição: nenhuma — a saída do módulo é digital padrão TTL.

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 5: Sensoriamento de Presença com Sensor PIR
// ==============================================================================

// Pino GPIO 33 configurado para receber o sinal de disparo do módulo PIR
int pirPin = 33;

void setup() {
  // Inicializa o canal serial para visualização de eventos de presença
  Serial.begin(115200);
  
  // Define o pino GPIO 33 como entrada digital
  pinMode(pirPin, INPUT);
}

void loop() {
  // Realiza a leitura instantânea da saída do sensor PIR
  int pirState = digitalRead(pirPin);
  
  // Avalia se houve detecção de movimentação de fonte térmica
  if (pirState == HIGH) {
    // Alerta no Monitor Serial indicando detecção positiva
    Serial.println("Corpo humano ou movimento detectado!");
  } else {
    // Estado de repouso: nenhuma alteração térmica no ambiente
    Serial.println("Ambiente seguro - nenhum movimento detectado.");
  }
  
  // Pausa de amostragem de 500 milissegundos entre varreduras
  delay(500);
}

Procedimento de Gravação e Teste de Bancada

1. Interligue o VCC do sensor ao 5V da placa ESP32, GND ao GND e pino OUT ao GPIO 33.
2. Carregue o código na placa e abra o Monitor Serial em 115200 bps.
3. Aguarde cerca de 30 a 60 segundos com o sensor em repouso absoluto para a estabilização térmica do elemento piroelétrico interno.
4. Resultado Esperado: Ao movimentar a mão a cerca de 1 metro na frente do sensor, o Monitor Serial exibirá imediatamente Corpo humano ou movimento detectado!.

---

Lição 6: Resistor Fotossensível (Fotoresistor LDR)

O Fotoresistor (LDR — Light Dependent Resistor) é um transdutor passivo cujo valor de resistência elétrica varia inversamente em função do fluxo luminoso incidente sobre sua superfície ativa. O dispositivo é construído com um filme de sulfeto de cádmio (CdS), um material semicondutor com alta resistência na ausência de luz. Quando os fótons de luz visível atingem o material com energia superior à largura da banda proibida, elétrons livres são promovidos para a banda de condução, criando pares elétron-lacuna e reduzindo drasticamente a resistência elétrica interna.

Em ambientes escuros, a resistência do LDR do kit atinge valores elevados superiores a $1\,\text{M}\Omega$. Sob luz solar direta ou lâmpadas intensas, essa resistência decai para valores entre $1\,\text{k}\Omega$ e $10\,\text{k}\Omega$. Para converter essa variação resistiva em um sinal de tensão elétrica mensurável pelo conversor analógico-digital (ADC) do ESP32, o LDR é associado em série a um resistor fixo de referência $R_1 = 10\,\text{k}\Omega$, compondo um divisor de tensão:

$$V_{OUT} = V_{CC} \times \frac{R_1}{R_1 + R_{LDR}}$$

onde $V_{CC} = 3,3\,\text{V}$. Quando a intensidade de luz aumenta, $R_{LDR}$ diminui e a tensão $V_{OUT}$ na junção sobe em direção a $3,3\,\text{V}$. No escuro, $R_{LDR}$ sobe e $V_{OUT}$ cai para próximo de $0\,\text{V}$. O conversor ADC de 12 bits do ESP32 digitaliza essa tensão contínua em uma faixa numérica inteira de 0 a 4095 passos discretos.

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Matriz de contatos (Breadboard) de 830 pontos
• 1x Fotoresistor LDR de 5 mm
• 1x Resistor de filme de carbono de $10\,\text{k}\Omega$ (1/4W)
• 1x Cabo USB Tipo-C
• 4x Cabos jumper flexíveis macho-macho

Ligações Elétricas e Pinagem

Conexão do Circuito	Pino do ESP32	Tipo de Sinal	Descrição Funcional
Terminal 1 do LDR	3,3V	Alimentação Positiva	Conectado ao barramento de 3,3V
Nó Central (Junção LDR + Resistor)	GPIO 32	Entrada Analógica (ADC1_CH4)	Tensão analógica proporcional à luz
Terminal oposto do Resistor $10\,\text{k}\Omega$	GND	Referência (0V)	Retorno para o barramento comum de terra

📦 Bibliotecas desta lição: nenhuma — a conversão é realizada pela função nativa de hardware analogRead().

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 6: Leitura Analógica de Iluminância com Fotoresistor LDR
// ==============================================================================

// Pino analógico GPIO 32 associado ao canal interno ADC1_CH4 do ESP32
int ldrPin = 32;

void setup() {
  // Inicializa o canal serial para exibição dos valores digitalizados de luminosidade
  Serial.begin(115200);
  
  // Configura a resolução do conversor analógico-digital para 12 bits (0 a 4095)
  analogReadResolution(12);
}

void loop() {
  // Lê a tensão no nó do divisor e converte para um número inteiro entre 0 e 4095
  int ldrValue = analogRead(ldrPin);
  
  // Imprime o valor analógico no Monitor Serial
  Serial.print("Leitura Analógica LDR: ");
  Serial.println(ldrValue);
  
  // Aguarda 200 milissegundos antes da próxima amostragem
  delay(200);
}

Procedimento de Gravação e Teste de Bancada

1. Monte o circuito na breadboard conectando o LDR entre o 3,3V e o GPIO 32, e o resistor de $10\,\text{k}\Omega$ entre o GPIO 32 e o GND.
2. Carregue o programa e abra o Monitor Serial (ou o Plotter Serial em Ferramentas > Plotter Serial).
3. Resultado Esperado: Sob a iluminação normal de uma sala, o valor oscilará entre 1500 e 2500. Ao cobrir o sensor com a ponta do dedo, o valor cairá para menos de 500. Ao aproximar a lanterna de um smartphone, a leitura subirá para mais de 3500.

---

Lição 7: Potenciômetros (Entrada Analógica Ajustável)

O Potenciômetro é um resistor eletromecânico de três terminais dotado de uma pista condutiva de filme de carbono e um contato deslizante móvel (cursor ou wiper). Os dois terminais fixos externos conectam-se aos extremos da pista de resistência nominal total ($R_{TOTAL} = 10\,\text{k}\Omega$), enquanto o terminal central é acoplado mecanicamente ao eixo de rotação.

Ao alimentar os terminais externos com $0\,\text{V}$ (GND) e $3,3\,\text{V}$ (VCC), o componente atua como um divisor de tensão contínuo. Conforme o eixo é rotacionado em seu curso mecânico útil de 300°, a proporção resistiva varia, produzindo no cursor uma tensão que varia linearmente de $0\,\text{V}$ até $3,3\,\text{V}$. A conversão realizada pelo conversor analógico-digital de 12 bits do ESP32 traduz essa tensão na relação direta:

$$V_{SINAL} = \frac{ADC \times 3,3\,\text{V}}{4095}$$

onde $ADC$ é a leitura inteira obtida via software. Esse circuito é a base fundamental para a construção de controles de ganho, controles de velocidade, seletores de modos e interfaces analógicas analógicas.

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Matriz de contatos (Breadboard) de 830 pontos
• 1x Potenciômetro rotativo linear de $10\,\text{k}\Omega$
• 1x Cabo USB Tipo-C
• 3x Cabos jumper flexíveis macho-macho

Ligações Elétricas e Pinagem

Terminal do Potenciômetro	Pino da Placa ESP32	Tipo de Sinal	Função do Terminal
Terminal Externo 1	3,3V	Alimentação Positiva	Potencial elétrico de referência superior
Terminal Central (Cursor)	GPIO 33	Entrada Analógica (ADC1_CH5)	Tensão dividida ajustável linearmente
Terminal Externo 2	GND	Referência (0V)	Retorno para o barramento comum de terra

📦 Bibliotecas desta lição: nenhuma — utiliza a conversão analógica padrão da linguagem.

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 7: Aquisição de Dados Analógicos com Potenciômetro
// ==============================================================================

// Pino GPIO 33 conectado ao terminal móvel (cursor central) do potenciômetro
int potPin = 33;

void setup() {
  // Inicia a comunicação serial a 115200 baud
  Serial.begin(115200);
}

void loop() {
  // Digitaliza a tensão analógica do cursor em uma escala inteira de 0 a 4095
  int potValue = analogRead(potPin);
  
  // Calcula o valor físico de tensão correspondente em Volts para fins didáticos
  float voltage = (potValue * 3.3) / 4095.0;
  
  // Imprime os valores processados na interface do Monitor Serial
  Serial.print("Valor Bruto ADC: ");
  Serial.print(potValue);
  Serial.print(" | Tensao Calculada: ");
  Serial.print(voltage, 2);
  Serial.println(" V");
  
  // Intervalo de leitura de 150 milissegundos
  delay(150);
}

Procedimento de Gravação e Teste de Bancada

1. Encaixe o potenciômetro na protoboard e conecte os terminais das pontas ao 3,3V e GND, e o pino central ao GPIO 33.
2. Carregue o programa e visualize os dados no Monitor Serial.
3. Resultado Esperado: Ao girar o potenciômetro totalmente no sentido anti-horário, a leitura indicará 0 ($0,00\,\text{V}$). Conforme o eixo é girado no sentido horário, os valores sobem linearmente até atingir 4095 ($3,30\,\text{V}$).

---

Lição 8: Buzzer Ativo

O Buzzer Ativo é um transdutor eletroacústico dotado de um circuito oscilador eletrônico interno integrado. Diferentemente de caixas de som e transdutores passivos, o buzzer ativo não necessita de um sinal alternado de áudio para produzir som: basta aplicar uma tensão contínua (DC) estável entre seus terminais positivo e negativo para que seu oscilador excite uma membrana piezoelétrica metálica na frequência de ressonância mecânica padrão, gerando um tom agudo e constante em aproximadamente $2,5\,\text{kHz}$.

Para distingui-lo visualmente do buzzer passivo, o buzzer ativo possui a base inferior selada com resina preta e vem de fábrica com um adesivo de proteção na saída superior com a indicação de polaridade positiva (+).

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Matriz de contatos (Breadboard) de 830 pontos
• 1x Buzzer Ativo de 5V
• 2x Cabos jumper flexíveis macho-macho

Ligações Elétricas e Pinagem

Terminal do Buzzer Ativo	Pino da Placa ESP32	Tipo de Sinal	Função do Terminal
Terminal Positivo (+) [Pino longo]	GPIO 25	Saída Digital	Nível ALTO (3,3V) para apitar, BAIXO (0V) para silenciar
Terminal Negativo (-) [Pino curto]	GND	Referência (0V)	Retorno para o barramento comum de terra

📦 Bibliotecas desta lição: nenhuma — opera diretamente por acionamento digital em nível lógico alto e baixo.

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 8: Acionamento Sonoro de Alarme com Buzzer Ativo
// ==============================================================================

// Pino GPIO 25 configurado como a saída de acionamento do buzzer
int buzzerPin = 25;

void setup() {
  // Configura a direção do pino GPIO 25 como saída digital de potência lógica
  pinMode(buzzerPin, OUTPUT);
}

void loop() {
  // Aplica nível lógico ALTO (3,3V) no anodo do buzzer, disparando o som
  digitalWrite(buzzerPin, HIGH);
  // Mantém o alerta sonoro ativo por 500 milissegundos
  delay(500);
  
  // Aplica nível lógico BAIXO (0V) no anodo do buzzer, cortando a oscilação
  digitalWrite(buzzerPin, LOW);
  // Mantém o silêncio por 500 milissegundos
  delay(500);
}

Procedimento de Gravação e Teste de Bancada

1. Posicione o buzzer ativo na breadboard, conectando o pino positivo marcado ao GPIO 25 e o pino negativo ao GND.
2. Carregue o programa na placa ESP32.
3. Resultado Esperado: O componente emitirá bips sonoros intermitentes em intervalos regulares de meio segundo de som e meio segundo de silêncio.

---

Lição 9: Buzzer Passivo (Geração de Tons e Frequências)

Diferente do buzzer ativo, o Buzzer Passivo não possui circuito oscilador interno. Seu elemento transdutor é uma pastilha piezoelétrica pura que deforma mecanicamente sob a ação de um campo elétrico alternado. Se aplicarmos uma tensão contínua em seus terminais, o dispositivo emitirá apenas um breve estalo mecânico durante a carga capacitiva e permanecerá em silêncio absoluto.

Para que o buzzer passivo produza notas acústicas contínuas, o microcontrolador deve gerar um trem de pulsos de onda quadrada periódica na frequência exata desejada para cada nota musical. O período $T$ da onda de excitação é relacionado com a frequência sonora fundamental $f$ pela fórmula:

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

Por exemplo, para emitir a nota musical Lá da 4ª oitava ($A_4$), cuja frequência padrão de afinação é $f = 440\,\text{Hz}$, o período total deve ser de:

$$T = \frac{1}{440\,\text{Hz}} \approx 2272\,\mu\text{s}$$

com cada semiciclo durando aproximadamente $1136\,\mu\text{s}$ no nível alto e $1136\,\mu\text{s}$ no nível baixo. O microcontrolador ESP32 executa essa síntese de forma precisa através do periférico de hardware LEDC e da função nativa tone().

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Matriz de contatos (Breadboard) de 830 pontos
• 1x Buzzer Passivo
• 2x Cabos jumper flexíveis macho-macho

Ligações Elétricas e Pinagem

Terminal do Buzzer Passivo	Pino da Placa ESP32	Tipo de Sinal	Função do Circuito
Terminal de Sinal (+)	GPIO 25	Saída PWM / Tone	Sinal sonoro alternado em frequência musical
Terminal de Terra (-)	GND	Referência (0V)	Retorno comum de terra

📦 Bibliotecas desta lição: nenhuma — a função nativa tone() e noTone() do núcleo ESP32 gerencia a modulação em frequência de forma transparente.

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 9: Reprodução de Escala Musical com Buzzer Passivo
// ==============================================================================

// Pino GPIO 25 utilizado para emissão da forma de onda acústica
int buzzerPin = 25;

// Tabela com as frequências fundamentais em Hertz (Hz) da escala diatônica maior de Dó
int notes[] = {
  262, // Dó (C4)
  294, // Ré (D4)
  330, // Mi (E4)
  349, // Fá (F4)
  392, // Sol (G4)
  440, // Lá (A4)
  494, // Si (B4)
  523  // Dó agudo (C5)
};

void setup() {
  // Configura o pino GPIO 25 como saída de sinal
  pinMode(buzzerPin, OUTPUT);
}

void loop() {
  // Percorre o vetor de notas musicais executando cada frequência sequencialmente
  for (int i = 0; i < 8; i++) {
    // A função tone(pino, frequencia) sintetiza a onda quadrada no pino do buzzer
    tone(buzzerPin, notes[i]);
    // Mantém a nota soando por 300 milissegundos
    delay(300);
    // Interrompe a emissão do tom para destacar a separação acústica entre as notas
    noTone(buzzerPin);
    // Intervalo de silêncio de 50 milissegundos entre notas consecutivas
    delay(50);
  }
  
  // Pausa de 1000 milissegundos antes de repetir a escala completa
  delay(1000);
}

Procedimento de Gravação e Teste de Bancada

1. Conecte o buzzer passivo na protoboard com o pino de sinal no GPIO 25 e o terra no GND.
2. Descarregue o sketch na placa ESP32.
3. Resultado Esperado: O transdutor executará com perfeição a escala musical de 8 notas ascendentes (Dó, Ré, Mi, Fá, Sol, Lá, Si e Dó agudo), pausando 1 segundo e recomeçando o ciclo.

---

Lição 10: Motor de Corrente Contínua (Acionamento e Controle de Velocidade)

O Motor de Corrente Contínua (Motor DC) é um atuador rotativo que converte energia elétrica em torque mecânico por indução eletromagnética através da interação entre o campo magnético do estator e a corrente que circula pelas bobinas do rotor.

Um pino digital de um microcontrolador CMOS como o ESP32 é dimensionado para fornecer no máximo cerca de $20\,\text{mA}$ a $40\,\text{mA}$ em regime estático. Um pequeno motor DC consome facilmente correntes de regime entre $100\,\text{mA}$ e $300\,\text{mA}$, e correntes de pico de partida (stall current) que podem ultrapassar $1\,\text{A}$. Tentar ligar o motor diretamente ao pino do microcontrolador causaria destruição térmica imediata do transistor interno do ESP32.

Por essa razão, é obrigatório utilizar um circuito de chaveamento com um transistor bipolar NPN (como o S8050) operando como interruptor eletrônico saturado. Uma corrente de controle diminuta fornecida pelo GPIO 26 na base do transistor satura a junção coletor-emissor, permitindo que a corrente principal flua da fonte de alimentação através do motor para o terra. Além disso, como os enrolamentos do motor são bobinas fortemente indutivas, o corte abrupto da corrente no chaveamento gera picos perigosos de sobretensão por força contraeletromotriz calculados pela Lei de Faraday-Neumann:

$$V_{IND} = -L \times \frac{di}{dt}$$

Para dissipar essa energia indutiva com segurança, conecta-se um diodo retificador de proteção flyback (1N4007) em paralelo reverso com o motor.

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Matriz de contatos (Breadboard) de 830 pontos
• 1x Mini Motor DC de 3V a 6V com hélice plástica
• 1x Transistor NPN de chaveamento (S8050 ou 2N2222)
• 1x Diodo retificador 1N4007 (proteção flyback)
• 1x Resistor de filme de carbono de $1\,\text{k}\Omega$ (polarização de base)
• 1x Cabo USB Tipo-C e fios jumper

Ligações Elétricas e Pinagem

Componente / Terminal	Conexão Elétrica	Função do Circuito
Base do Transistor NPN	Resistor de $1\,\text{k}\Omega$ ao GPIO 26	Limitação de corrente na base do transistor
Emissor do Transistor NPN	GND	Referência comum de terra
Coletor do Transistor NPN	Terminal Negativo do Motor	Chaveamento para o terra em saturação
Terminal Positivo do Motor	5V / VIN	Linha de alimentação de potência
Diodo Flyback 1N4007	Catodo no 5V / Anodo no Coletor	Grampeamento de transientes indutivos de desenergização

📦 Bibliotecas desta lição: nenhuma — controle digital direto e controle por modulação PWM via analogWrite().

Código-Fonte 10.1: Acionamento Digital Liga/Desliga

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 10.1: Chaveamento Digital de Motor DC via Transistor
// ==============================================================================

// Pino GPIO 26 conectado à base do transistor NPN através do resistor de 1k
int motorPin = 26;

void setup() {
  // Configura o pino como saída digital de controle
  pinMode(motorPin, OUTPUT);
}

void loop() {
  // Satura o transistor (nível ALTO), ligando o motor em rotação máxima
  digitalWrite(motorPin, HIGH);
  delay(3000); // Permanece ligado por 3 segundos
  
  // Corta a condução do transistor (nível BAIXO), desligando o motor
  digitalWrite(motorPin, LOW);
  delay(2000); // Permanece desligado por 2 segundos
}

Código-Fonte 10.2: Controle Gradual de Velocidade por PWM

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 10.2: Aceleração e Controle de Rotação por PWM
// ==============================================================================

int motorPin = 26;

void setup() {
  pinMode(motorPin, OUTPUT);
}

void loop() {
  // Rampa de aceleração: aumenta o ciclo de trabalho de 0 até 255
  for (int speed = 0; speed <= 255; speed += 5) {
    analogWrite(motorPin, speed);
    delay(50);
  }
  delay(1000);
  
  // Rampa de desaceleração: reduz o ciclo de trabalho de 255 até 0
  for (int speed = 255; speed >= 0; speed -= 5) {
    analogWrite(motorPin, speed);
    delay(50);
  }
  delay(1000);
}

Procedimento de Gravação e Teste de Bancada

1. Encaixe a hélice plástica no eixo metálico do motor DC com cuidado.
2. Monte o circuito do transistor, diodo e resistor na breadboard.
3. Carregue o programa 10.2 na placa ESP32.
4. Resultado Esperado: O motor começará a girar suavemente, aumentando sua rotação até a velocidade máxima, estabilizando por 1 segundo e diminuindo gradativamente a rotação até parar por completo.

---

Lição 11: Servomotor (Micro Servo SG90)

O Servomotor é um atuador eletromecânico rotativo de precisão que opera em malha fechada (closed loop). O dispositivo integra em um único invólucro compacto um motor DC, um trem de engrenagens de redução de alto torque, um potenciômetro solidário ao eixo de saída que atua como sensor de posição angular e uma placa de controle eletrônico comparador.

O posicionamento do eixo é comandado através de um trem de pulsos de Modulação por Posição de Pulso (PPM / Pulse Position Modulation) com frequência fixa de $50\,\text{Hz}$ (período total de $T = 20\,\text{ms}$). A largura temporal do pulso positivo dentro desse período determina a posição angular do eixo de $0^\circ$ a $180^\circ$:

$$\theta = \frac{t_{pulso} - 500\,\mu\text{s}}{2000\,\mu\text{s}} \times 180^\circ$$

• Um pulso de $500\,\mu\text{s}$ ($0,5\,\text{ms}$) posiciona o servo no batente angular de $0^\circ$.
• Um pulso de $1500\,\mu\text{s}$ ($1,5\,\text{ms}$) centraliza o servo exatamente em $90^\circ$.
• Um pulso de $2500\,\mu\text{s}$ ($2,5\,\text{ms}$) desloca o servo para o batente angular máximo de $180^\circ$.

Para controlar servomotores no ESP32 sem conflito com o escalonador FreeRTOS, utiliza-se a biblioteca especializada ESP32Servo.

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Micro Servo Motor SG90 de 9g com cruzeta plástica
• 3x Cabos jumper flexíveis macho-fêmea ou macho-macho

Ligações Elétricas e Pinagem

Fio do Servo SG90	Pino da Placa ESP32	Tipo de Sinal	Descrição Funcional
Marrom (ou Preto)	GND	Referência (0V)	Retorno elétrico de alimentação e sinal
Vermelho	5V	Alimentação Positiva	Alimentação do motor e circuito interno
Laranja (ou Amarelo)	GPIO 27	Saída PPM / PWM	Trem de pulsos de comando angular

📦 Bibliotecas desta lição: ESP32Servo por Kevin Harrington, John K. Bennett (versão homologada 1.1.1).

• Via Gerenciador (recomendado): Acesse Sketch > Incluir Biblioteca > Gerenciar Bibliotecas... -> digite ESP32Servo -> selecione a versão 1.1.1 -> clique em Instalar.
• Via ZIP: Baixe o arquivo oficial em madhephaestus/ESP32Servo (Code > Download ZIP) ou use o arquivo ESP32Servo.zip localizado na pasta Arduino(Aprendiz Experiente)\4.Biblioteca -> menu Sketch > Incluir Biblioteca > Adicionar Biblioteca .ZIP....

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 11: Varredura e Posicionamento Angular com Servomotor
// ==============================================================================

// Inclui a biblioteca de geração de temporização precisa para servos no ESP32
#include <ESP32Servo.h>

// Instancia o objeto de controle do servomotor
Servo myServo;

// Define o pino GPIO 27 para transmissão do sinal de controle PPM
int servoPin = 27;

void setup() {
  // Aloca um canal de temporizador de hardware do ESP32 para o servo
  ESP32PWM::allocateTimer(0);
  
  // Ajusta a frequência de pulso para o padrão internacional de servos analógicos (50 Hz)
  myServo.setPeriodHertz(50);
  
  // Vincula o pino GPIO 27 e calibra os limites de pulso para 500us (0°) e 2500us (180°)
  myServo.attach(servoPin, 500, 2500);
}

void loop() {
  // Varredura angular progressiva: move o eixo de 0° até 180° em passos de 1 grau
  for (int pos = 0; pos <= 180; pos += 1) {
    myServo.write(pos); // Escreve o ângulo desejado no servo
    delay(15);          // Aguarda 15 milissegundos para o movimento mecânico
  }
  
  // Varredura angular regressiva: move o eixo de 180° até 0° em passos de 1 grau
  for (int pos = 180; pos >= 0; pos -= 1) {
    myServo.write(pos); // Atualiza a posição
    delay(15);          // Aguarda o deslocamento mecânico
  }
}

Procedimento de Gravação e Teste de Bancada

1. Conecte os 3 fios do servomotor (Marrom no GND, Vermelho no 5V, Laranja no GPIO 27). Fixe a cruzeta plástica no eixo.
2. Carregue o programa no ESP32.
3. Resultado Esperado: O braço do servomotor realizará uma varredura contínua de 180 graus de um lado para o outro de forma suave e contínua.

---

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

O Sensor DHT11 é um módulo eletrônico calibrado em laboratório capaz de medir simultaneamente a temperatura ambiente e a umidade relativa do ar. O transdutor de umidade é do tipo resistivo de filme de polímero com eletrodos entrelaçados, cuja condutância varia com a condensação superficial de moléculas de vapor de água. O transdutor de temperatura é um termistor NTC (Negative Temperature Coefficient) de precisão.

O módulo integra um circuito microcontrolador de 8 bits dedicado que processa internamente os sinais analógicos e os transmite ao ESP32 através de um barramento digital de fio único (Single-Wire proprietário). A cada requisição iniciada pelo ESP32 com um pulso de nível baixo de pelo menos $18\,\text{ms}$, o DHT11 responde enviando um pacote sequencial de 40 bits formatado em 5 bytes:

• Byte 1: Parte inteira da umidade relativa
• Byte 2: Parte decimal da umidade
• Byte 3: Parte inteira da temperatura
• Byte 4: Parte decimal da temperatura
• Byte 5: Checksum de paridade para validação matemática da transmissão

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Módulo sensor de temperatura e umidade DHT11
• 3x Cabos jumper flexíveis macho-fêmea

Ligações Elétricas e Pinagem

Terminal do Módulo DHT11	Pino da Placa ESP32	Tipo de Sinal	Função do Terminal
VCC (+)	3,3V ou 5V	Alimentação Positiva	Linha de alimentação do sensor
DATA (Sinal / Out)	GPIO 32	Barramento Digital Single-Wire	Linha bidirecional assíncrona de dados
GND (-)	GND	Referência (0V)	Retorno comum de terra

📦 Bibliotecas desta lição: DHT sensor library por Adafruit (versão 1.4.6) e dependência obrigatória Adafruit Unified Sensor (versão 1.1.14).

• Via Gerenciador (recomendado): Sketch > Incluir Biblioteca > Gerenciar Bibliotecas... -> busque DHT sensor library -> clique em Instalar e confirme Install All na caixa de diálogo de dependências.
• Via ZIP: Utilize o arquivo DHT.zip contido em Arduino(Aprendiz Experiente)\4.Biblioteca.

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 12: Sensoriamento Termodinâmico de Ambiente com DHT11
// ==============================================================================

// Inclui a biblioteca oficial da Adafruit para decodificação do protocolo do DHT
#include "DHT.h"

// Define o pino GPIO 32 como a via de transmissão serial de dados do sensor
#define DHTPIN 32

// Define o tipo exato do sensor utilizado (DHT11)
#define DHTTYPE DHT11

// Instancia o objeto dht informando o pino físico e o tipo do sensor
DHT dht(DHTPIN, DHTTYPE);

void setup() {
  // Inicializa o canal de comunicação serial com o computador a 115200 bps
  Serial.begin(115200);
  
  // Imprime cabeçalho inicial de diagnóstico
  Serial.println("Inicializando leitura de temperatura e umidade com DHT11...");
  
  // Inicializa o barramento e configura as temporizações internas do sensor
  dht.begin();
}

void loop() {
  // O DHT11 requer um intervalo de no mínimo 2 segundos entre leituras consecutivas
  delay(2000);
  
  // Realiza a leitura da umidade relativa do ar em percentual (%)
  float humidity = dht.readHumidity();
  
  // Realiza a leitura da temperatura ambiente na escala Celsius (°C)
  float temperature = dht.readTemperature();
  
  // Avalia se a leitura retornou erro numérico (NaN - Not a Number)
  if (isnan(humidity) || isnan(temperature)) {
    Serial.println("Falha de comunicação: verifique as ligações físicas do DHT11!");
    return;
  }
  
  // Exibe os dados formatados com rigor técnico no Monitor Serial
  Serial.print("Umidade Relativa: ");
  Serial.print(humidity, 1);
  Serial.print(" % | Temperatura: ");
  Serial.print(temperature, 1);
  Serial.println(" °C");
}

Procedimento de Gravação e Teste de Bancada

1. Conecte o pino de dados do DHT11 ao GPIO 32, positivo ao 3,3V e negativo ao GND.
2. Grave o código no ESP32 e abra o Monitor Serial em 115200 baud.
3. Resultado Esperado: O Monitor Serial exibirá a cada 2 segundos os valores térmicos reais da bancada (ex.: Umidade Relativa: 58.0 % | Temperatura: 24.5 °C).

---

Lição 13: Sensor Ultrassônico (Telemetria HC-SR04)

O Sensor Ultrassônico HC-SR04 é um instrumento telemétrico que utiliza ondas sonoras de alta frequência inaudíveis ao ouvido humano ($40\,\text{kHz}$) para medir distâncias sem contato mecânico. O módulo é composto por um transdutor piezelétrico transmissor de ultrassom (Trig), um transdutor piezelétrico receptor (Echo) e um circuito eletrônico integrado de controle e amplificação.

O processo de medição inicia-se quando o ESP32 emite um pulso em nível alto com duração mínima de $10\,\mu\text{s}$ no pino de disparo (Trig). Em resposta, o módulo emite automaticamente uma rajada acústica de 8 pulsos sonoros senoidais a $40\,\text{kHz}$. No mesmo instante, a saída de eco (Echo) é elevada para nível alto ($3,3\,\text{V}$). A onda acústica propaga-se pelo ar, atinge o alvo, reflete e retorna ao transdutor receptor. Quando o circuito detecta o retorno do eco acústico, a saída Echo comuta novamente para nível baixo.

A duração temporal $\Delta t$ em que o pino Echo permaneceu no nível alto corresponde exatamente ao tempo de voo (Time of Flight) de ida e volta do som. Conhecendo a velocidade de propagação do som no ar em temperatura ambiente padrão ($v_{som} \approx 343\,\text{m/s}$ ou $0,0343\,\text{cm}/\mu\text{s}$), a distância $d$ do obstáculo é calculada pela equação da cinemática linear:

$$d = \frac{\Delta t \times v_{som}}{2}$$

Dividindo por 2 (pois o som percorre a distância duas vezes: ida e volta), obtém-se a constante de cálculo em centímetros:

$$d = \frac{\Delta t}{58,3}\,\text{cm}$$

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Sensor Ultrassônico HC-SR04
• 1x Matriz de contatos (Breadboard) de 830 pontos
• 4x Cabos jumper flexíveis macho-fêmea ou macho-macho

Ligações Elétricas e Pinagem

Terminal do HC-SR04	Pino da Placa ESP32	Tipo de Sinal	Função do Terminal
VCC	5V	Alimentação Positiva	Fornece 5V para o circuito piezoelétrico
Trig (Disparo)	GPIO 19	Saída Digital	Pulso de disparo de $10\,\mu\text{s}$
Echo (Retorno)	GPIO 18	Entrada Digital	Pulso proporcional ao tempo de voo acústico
GND	GND	Referência (0V)	Retorno para o barramento comum de terra

📦 Bibliotecas desta lição: nenhuma — utiliza a função nativa pulseIn() para cronometrar a duração do pulso de eco com precisão de microssegundos.

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 13: Telemetria por Tempo de Voo com Sensor Ultrassônico HC-SR04
// ==============================================================================

// Pino de disparo (Trigger) conectado ao GPIO 19
const int trigPin = 19;
// Pino de eco acústico (Echo) conectado ao GPIO 18
const int echoPin = 18;

void setup() {
  // Inicia a comunicação serial para exibição da telemetria
  Serial.begin(115200);
  
  // Configura o pino Trigger como saída de pulso
  pinMode(trigPin, OUTPUT);
  // Configura o pino Echo como entrada para medição da largura do pulso
  pinMode(echoPin, INPUT);
}

void loop() {
  // Garante que o pino de disparo inicie em nível baixo limpo
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  
  // Emite o pulso de disparo de alta precisão com duração de 10 microssegundos
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  
  // Mede o tempo em microssegundos em que o pino Echo permanece em nível alto
  long duration = pulseIn(echoPin, HIGH, 30000); // Timeout de 30ms (~5 metros)
  
  // Calcula a distância física em centímetros
  float distance = (duration * 0.0343) / 2.0;
  
  // Avalia se a leitura está dentro da faixa operacional do sensor (2 cm a 400 cm)
  if (duration == 0 || distance > 400.0) {
    Serial.println("Fora de alcance ou sem eco detectado.");
  } else {
    Serial.print("Distancia Medida: ");
    Serial.print(distance, 1);
    Serial.println(" cm");
  }
  
  // Pausa de 100 milissegundos entre medições consecutivas
  delay(100);
}

Procedimento de Gravação e Teste de Bancada

1. Conecte o HC-SR04 na protoboard: VCC no 5V, GND no GND, Trig no GPIO 19 e Echo no GPIO 18.
2. Grave o código e abra o Monitor Serial em 115200 baud.
3. Posicione um obstáculo plano (como um livro ou a palma da mão) à frente dos transdutores.
4. Resultado Esperado: O Monitor Serial exibirá a distância física real em centímetros com precisão milimétrica conforme o obstáculo é aproximado ou afastado.

---

Lição 14: Display de 8 Segmentos (1 Dígito)

O Display de 7 Segmentos (frequentemente chamado de display de 8 segmentos por incluir o ponto decimal DP — Decimal Point) é um componente optoeletrônico formado por oito diodos emissores de luz individuais dispostos geometricamente na forma do número ‘8’. Os segmentos são padronizados internacionalmente pelas letras alfabéticas A, B, C, D, E, F, G e DP.

O componente do kit é do tipo Cátodo Comum (Common Cathode), no qual os terminais negativos (cátodos) de todos os 8 LEDs internos estão unidos internamente nos pinos centrais 3 e 8, que devem ser ligados ao barramento de terra (GND). Para acender qualquer segmento específico, basta aplicar nível lógico ALTO ($3,3\,\text{V}$) no pino do ânodo correspondente através de um resistor limitador. Acendendo combinações padronizadas de segmentos, formam-se todos os algarismos numéricos decimais de 0 a 9 e caracteres hexadecimais de A a F.

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Matriz de contatos (Breadboard) de 830 pontos
• 1x Display de 7 segmentos de 1 dígito (cátodo comum)
• 8x Resistores de filme de carbono de $220\,\Omega$ (1/4W)
• 10x Cabos jumper flexíveis macho-macho

Ligações Elétricas e Pinagem

Segmento do Display	Pino do Display	Pino da Placa ESP32	Nível Lógico para Acender
Segmento A	Pino 7	GPIO 16 (via $220\,\Omega$)	HIGH
Segmento B	Pino 6	GPIO 4 (via $220\,\Omega$)	HIGH
Segmento C	Pino 4	GPIO 0 (via $220\,\Omega$)	HIGH
Segmento D	Pino 2	GPIO 2 (via $220\,\Omega$)	HIGH
Segmento E	Pino 1	GPIO 15 (via $220\,\Omega$)	HIGH
Segmento F	Pino 9	GPIO 17 (via $220\,\Omega$)	HIGH
Segmento G	Pino 10	GPIO 5 (via $220\,\Omega$)	HIGH
Ponto Decimal (DP)	Pino 5	GPIO 18 (via $220\,\Omega$)	HIGH
Cátodo Comum	Pinos 3 ou 8	GND	Conectado diretamente ao terra

📦 Bibliotecas desta lição: nenhuma — controle digital direto por manipulação de pinos GPIO e matrizes binárias.

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 14: Contador Decimal em Display de 8 Segmentos (1 Dígito)
// ==============================================================================

// Vetor com os 7 pinos GPIO conectados aos segmentos A, B, C, D, E, F e G
int segPins[] = {16, 4, 0, 2, 15, 17, 5};

// Matriz de decodificação binária dos dígitos de 0 a 9 em lógica de cátodo comum
// Ordem das colunas: {A, B, C, D, E, F, G} (1 = Aceso, 0 = Apagado)
const byte digits[10][7] = {
  {1, 1, 1, 1, 1, 1, 0}, // 0
  {0, 1, 1, 0, 0, 0, 0}, // 1
  {1, 1, 0, 1, 1, 0, 1}, // 2
  {1, 1, 1, 1, 0, 0, 1}, // 3
  {0, 1, 1, 0, 0, 1, 1}, // 4
  {1, 0, 1, 1, 0, 1, 1}, // 5
  {1, 0, 1, 1, 1, 1, 1}, // 6
  {1, 1, 1, 0, 0, 0, 0}, // 7
  {1, 1, 1, 1, 1, 1, 1}, // 8
  {1, 1, 1, 1, 0, 1, 1}  // 9
};

// Função modular que aplica os níveis lógicos nos pinos dos segmentos para o dígito informado
void displayDigit(int num) {
  for (int i = 0; i < 7; i++) {
    digitalWrite(segPins[i], digits[num][i]);
  }
}

void setup() {
  // Inicializa todos os pinos de controle dos segmentos como saídas digitais
  for (int i = 0; i < 7; i++) {
    pinMode(segPins[i], OUTPUT);
    digitalWrite(segPins[i], LOW); // Inicia apagado
  }
}

void loop() {
  // Conta ciclicamente de 0 até 9
  for (int d = 0; d <= 9; d++) {
    displayDigit(d); // Atualiza os segmentos
    delay(1000);     // Mantém o dígito visível por 1 segundo
  }
}

Procedimento de Gravação e Teste de Bancada

1. Encaixe o display na protoboard cruzando a fenda central.
2. Ligue os pinos centrais ao GND e cada pino de segmento a um resistor de $220\,\Omega$ conectado ao respectivo GPIO.
3. Carregue o programa no ESP32.
4. Resultado Esperado: O display exibirá os algarismos de 0 a 9 em sequência cronometrada a cada 1 segundo.

---

Lição 15: Display de 4 Dígitos 8 Segmentos (Multiplexação Temporal)

Controlar 4 dígitos de 8 segmentos de forma independente exigiria $4 \times 8 = 32$ saídas digitais. Como essa quantidade de pinos inviabilizaria o uso de outros periféricos, a indústria da eletrônica adota a técnica da multiplexação por divisão no tempo (Time-Division Multiplexing).

No display de 4 dígitos, os segmentos homólogos dos quatro dígitos (todos os anodos A juntos, todos os anodos B juntos, etc.) são interligados internamente em um barramento comum de apenas 8 vias. Cada dígito individual possui seu próprio terminal de cátodo comum independente ($D_1, D_2, D_3, D_4$).

O microcontrolador apresenta os dados de cada dígito sequencialmente no barramento comum de segmentos, ativando temporariamente apenas o cátodo daquele dígito específico por alguns milissegundos ($2\,\text{ms}$ a $5\,\text{ms}$). Em seguida, apaga o dígito, apresenta o padrão do segundo dígito e ativa o segundo cátodo, repetindo o processo para o terceiro e quarto dígitos. Quando essa varredura completa ocorre em uma frequência de atualização superior a $50\,\text{Hz}$ (período total menor que $20\,\text{ms}$), o fenômeno fisiológico da persistência da visão (retinal persistence) funde os quatro flashes luminosos individuais em uma imagem contínua e nítida para os olhos humanos.

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Matriz de contatos (Breadboard) de 830 pontos
• 1x Módulo Display de 7 segmentos de 4 dígitos (cátodo comum)
• 8x Resistores de filme de carbono de $220\,\Omega$ (1/4W)
• 14x Cabos jumper flexíveis macho-macho

Ligações Elétricas e Pinagem

Terminal do Display	Função	Pino da Placa ESP32
Barramento de Segmentos (A a G e DP)	Anodos comuns multiplexados	GPIOs 16, 4, 0, 2, 15, 17, 5 e 18 (via $220\,\Omega$)
Dígito 1 (D1 - Milhar)	Cátodo comum do 1º dígito	GPIO 12
Dígito 2 (D2 - Centena)	Cátodo comum do 2º dígito	GPIO 13
Dígito 3 (D3 - Dezena)	Cátodo comum do 3º dígito	GPIO 14
Dígito 4 (D4 - Unidade)	Cátodo comum do 4º dígito	GPIO 27

📦 Bibliotecas desta lição: nenhuma — a varredura multiplexada é gerenciada diretamente pela rotina de temporização do firmware.

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 15: Multiplexação Temporal em Display de 4 Dígitos
// ==============================================================================

// Pinos dos segmentos A, B, C, D, E, F e G
int segPins[] = {16, 4, 0, 2, 15, 17, 5};

// Pinos de controle de seleção dos cátodos dos 4 dígitos (D1, D2, D3, D4)
int digitPins[] = {12, 13, 14, 27};

// Matriz de padrões binários dos números de 0 a 9
const byte digits[10][7] = {
  {1, 1, 1, 1, 1, 1, 0}, // 0
  {0, 1, 1, 0, 0, 0, 0}, // 1
  {1, 1, 0, 1, 1, 0, 1}, // 2
  {1, 1, 1, 1, 0, 0, 1}, // 3
  {0, 1, 1, 0, 0, 1, 1}, // 4
  {1, 0, 1, 1, 0, 1, 1}, // 5
  {1, 0, 1, 1, 1, 1, 1}, // 6
  {1, 1, 1, 0, 0, 0, 0}, // 7
  {1, 1, 1, 1, 1, 1, 1}, // 8
  {1, 1, 1, 1, 0, 1, 1}  // 9
};

// Apaga todos os dígitos para evitar efeito fantasma (ghosting) na transição
void clearDigits() {
  for (int i = 0; i < 4; i++) {
    digitalWrite(digitPins[i], HIGH); // Em cátodo comum, HIGH desativa o catodo
  }
}

// Configura os segmentos de acordo com o algarismo informado
void setSegments(int num) {
  for (int i = 0; i < 7; i++) {
    digitalWrite(segPins[i], digits[num][i]);
  }
}

void setup() {
  // Configura os pinos de segmentos como saída
  for (int i = 0; i < 7; i++) {
    pinMode(segPins[i], OUTPUT);
  }
  // Configura os pinos de seleção de dígitos como saída
  for (int i = 0; i < 4; i++) {
    pinMode(digitPins[i], OUTPUT);
    digitalWrite(digitPins[i], HIGH); // Inicializa com dígitos desabilitados
  }
}

void loop() {
  // Valores estáticos de teste para demonstrar a multiplexação (exibe "1 2 3 4")
  int displayValues[4] = {1, 2, 3, 4};
  
  // Realiza a varredura contínua dos 4 dígitos
  for (int i = 0; i < 4; i++) {
    clearDigits();                 // Desativa os cátodos para evitar efeito fantasma
    setSegments(displayValues[i]); // Aplica o padrão de segmentos do dígito atual
    digitalWrite(digitPins[i], LOW);// Habilita o cátodo do dígito ativo (LOW ativa)
    delay(3);                      // Mantém aceso por 3ms para persistência retiniana
  }
}

Procedimento de Gravação e Teste de Bancada

1. Faça as ligações do barramento de segmentos através dos resistores e conecte os quatro cátodos aos pinos de seleção.
2. Carregue o programa no ESP32.
3. Resultado Esperado: O display exibirá os quatro algarismos 1 2 3 4 acesos e estáveis de forma simultânea e uniforme, sem cintilação perceptível.

---

Lição 16: Controle Remoto Infravermelho (Receptor IR AX-1838)

A comunicação sem fio por Infravermelho (IR) é o padrão dominante em controles remotos de eletrônicos de consumo. O transmissor é composto por um LED de infravermelho emitindo luz invisível com comprimento de onda de $940\,\text{nm}$, modulada em uma frequência de portadora padrão de 38 kHz para imunidade contra luz ambiente artificial.

O módulo receptor AX-1838 integra em seu encapsulamento fotodiodo receptor, filtro óptico seletivo, pré-amplificador, limitador, circuito passa-banda de 38 kHz e demodulador. A saída do sensor entrega diretamente o sinal digital demodulado em banda básica.

O protocolo utilizado pelo controle do kit é o padrão NEC. Cada comando enviado pelo controle consiste em uma rajada de inicialização (Leader Code) de $9\,\text{ms}$ em nível baixo seguida de $4,5\,\text{ms}$ em nível alto, acompanhada de 32 bits de dados com modulação por distância de pulsos:

• 8 bits de endereço de dispositivo
• 8 bits de endereço invertido (para verificação de integridade)
• 8 bits de código de comando da tecla
• 8 bits de código de comando invertido

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Módulo Receptor Infravermelho AX-1838
• 1x Controle remoto infravermelho multifunção de 21 teclas
• 3x Cabos jumper flexíveis macho-fêmea

Ligações Elétricas e Pinagem

Terminal do AX-1838	Pino da Placa ESP32	Tipo de Sinal	Função do Terminal
VCC (+)	3,3V ou 5V	Alimentação Positiva	Alimentação elétrica do receptor
GND (-)	GND	Referência (0V)	Retorno de terra
OUT / S (Sinal)	GPIO 15	Entrada Digital	Saída digital demodulada TTL

📦 Bibliotecas desta lição: IRremote por ArminJo / shirriff (versão homologada 4.1.2).

• Via Gerenciador (recomendado): Acesse Sketch > Incluir Biblioteca > Gerenciar Bibliotecas... -> busque IRremote -> instale a versão 4.1.2.
• Via ZIP: Baixe o repositório oficial Arduino-IRremote/Arduino-IRremote ou adicione o arquivo IRremote.zip da pasta Arduino(Aprendiz Experiente)\4.Biblioteca.

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 16: Decodificação de Controle Remoto Infravermelho (Protocolo NEC)
// ==============================================================================

// Inclui a biblioteca IRremote para recepção e decodificação do sinal de 38 kHz
#include <IRremote.hpp>

// Pino GPIO 15 conectado à saída de dados demodulados (OUT) do receptor IR
const int IR_RECEIVE_PIN = 15;

void setup() {
  // Inicializa o canal serial para visualização dos códigos das teclas
  Serial.begin(115200);
  
  // Inicia o processo de recepção por interrupção de hardware no pino configurado
  IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
  
  Serial.println("Receptor Infravermelho pronto para decodificacao de teclas...");
}

void loop() {
  // Avalia se um pacote infravermelho completo foi recebido e decodificado
  if (IrReceiver.decode()) {
    // Imprime o valor do comando recebido em formato hexadecimal legível
    Serial.print("Protocolo: ");
    Serial.print(IrReceiver.getProtocolString());
    Serial.print(" | Comando Hexadecimal: 0x");
    Serial.println(IrReceiver.decodedIRData.command, HEX);
    
    // Habilita o receptor para capturar o próximo pacote de dados
    IrReceiver.resume();
  }
}

Procedimento de Gravação e Teste de Bancada

1. Conecte o receptor AX-1838: VCC no 3,3V, GND no GND e sinal no GPIO 15.
2. Puxe a película plástica isoladora da bateria do controle remoto.
3. Carregue o programa e abra o Monitor Serial em 115200 baud.
4. Resultado Esperado: Ao pressionar qualquer tecla do controle apontando para o receptor, o Monitor Serial exibirá o protocolo NEC e o código hexadecimal correspondente daquela tecla (ex.: tecla POWER exibirá 0x45).

---

Lição 17: Display LCD1602 com Adaptador Serial I2C

O display LCD1602 é uma interface alfanumérica de cristal líquido capaz de exibir 32 caracteres distribuídos em 2 linhas de 16 colunas. Em sua interface paralela nativa (baseada no controlador padrão Hitachi HD44780), o display necessita de pelo menos 6 a 10 pinos digitais para operação.

Para economizar pinos no microcontrolador, o display do kit é fornecido com uma placa adaptadora serial soldada em sua parte traseira, baseada no expansor de portas PCF8574. O PCF8574 comunica-se com o ESP32 através do barramento serial síncrono I2C (Inter-Integrated Circuit), exigindo apenas duas linhas de sinal:

• SDA (Serial Data): Linha bidirecional de dados síncronos, conectada ao pino nativo GPIO 21 do ESP32.
• SCL (Serial Clock): Linha de pulsos de relógio gerada pelo mestre, conectada ao pino GPIO 22 do ESP32.

O endereço físico padrão do circuito PCF8574 no barramento I2C é comumente configurado de fábrica em 0x27 (ou 0x3F). A placa adaptadora conta ainda com um trimpot de ajuste de contraste e uma ponte de jumper para habilitar a luz de fundo (backlight) azul.

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Módulo Display LCD1602 com interface serial I2C soldada (PCF8574)
• 4x Cabos jumper flexíveis fêmea-macho

Ligações Elétricas e Pinagem

Terminal do Módulo I2C LCD	Pino da Placa ESP32	Tipo de Sinal	Função da Interface
GND	GND	Referência (0V)	Retorno comum de terra
VCC	5V	Alimentação Positiva	Alimentação de 5V para o display e backlight
SDA	GPIO 21	Linha I2C Serial Data	Barramento de transmissão bidirecional de dados
SCL	GPIO 22	Linha I2C Serial Clock	Linha de sinal de sincronismo de clock

📦 Bibliotecas desta lição: LiquidCrystal_I2C por Frank de Brabander / Marco Schwartz (versão 1.1.4).

• Via Gerenciador (recomendado): Acesse Sketch > Incluir Biblioteca > Gerenciar Bibliotecas... -> pesquise por LiquidCrystal_I2C -> instale a versão 1.1.4.
• Via ZIP: Baixe o arquivo em johnrickman/LiquidCrystal_I2C ou utilize o arquivo LiquidCrystal_I2C.zip da pasta Arduino(Aprendiz Experiente)\4.Biblioteca.

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 17: Interface Alfanumérica com Display LCD1602 I2C
// ==============================================================================

// Inclui as bibliotecas de comunicação pelo barramento I2C e controle do LCD
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// Instancia o objeto lcd passando: endereço I2C (0x27), 16 colunas e 2 linhas
LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
  // Inicializa o display LCD e a comunicação I2C
  lcd.init();
  
  // Liga a iluminação de fundo (backlight) azul
  lcd.backlight();
  
  // Posiciona o cursor na coluna 0 da linha 0 (primeira linha superior)
  lcd.setCursor(0, 0);
  // Escreve a mensagem de identificação institucional
  lcd.print("RoboBuilders");
  
  // Posiciona o cursor na coluna 0 da linha 1 (segunda linha inferior)
  lcd.setCursor(0, 1);
  // Escreve o subtítulo da lição
  lcd.print("ESP32 QE200 Kit");
}

void loop() {
  // O texto permanece fixo exibido com alta legibilidade
  delay(1000);
}

Procedimento de Gravação e Teste de Bancada

1. Conecte os 4 fios do módulo I2C: GND ao GND, VCC ao 5V, SDA ao GPIO 21 e SCL ao GPIO 22.
2. Carregue o programa no ESP32.
3. Se os caracteres não estiverem visíveis ou aparecerem como blocos brancos sólidos, gire suavemente o potenciômetro de contraste azul na parte traseira da placa I2C com uma chave de fenda até obter o contraste ideal.
4. Resultado Esperado: O display acenderá o fundo azul e exibirá com nitidez RoboBuilders na primeira linha e ESP32 QE200 Kit na segunda linha.

---

Parte 3 — Projetos Abrangentes de Aplicação

Nesta terceira parte do curso, integramos múltiplos transdutores, sensores, atuadores e periféricos de comunicação sem fio estudados isoladamente para construir sistemas completos de automação residencial, instrumentação científica, interfaces hápticas e controle remoto pela Internet das Coisas (IoT). Cada projeto aborda a modelagem lógica do sistema, equações de conversão, esquemáticos e montagens práticas, código C++ comentado linha por linha e validação experimental de bancada.

---

Lição 18: Luz de Água (LED Sequencial / Running Light)

O projeto da Luz de Água (Running Light ou sequência tipo “efeito cascata”) simula visualmente o fluxo dinâmico de um fluido através do acionamento sequencial temporizado de uma fileira de diodos emissores de luz.

O algoritmo implementa uma máquina de deslocamento linear. Um vetor unidimensional indexa os pinos GPIO conectados a cada LED individual. Através de um laço de repetição (for), o microcontrolador acende o LED da posição corrente $i$, aguarda um intervalo de tempo $\Delta t = 100\,\text{ms}$, apaga o LED $i$ e avança para a posição $i + 1$. Quando o ponteiro atinge o último LED da extremidade direita, a direção de deslocamento pode ser invertida ou reiniciada, criando a ilusão óptica de movimento fluido contínuo.

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Matriz de contatos (Breadboard) de 830 pontos
• 5x Diodos Emissores de Luz (LEDs vermelhos ou coloridos)
• 5x Resistores de filme de carbono de $220\,\Omega$ (1/4W)
• 7x Cabos jumper flexíveis macho-macho

Ligações Elétricas e Pinagem

Componente	Terminal	Pino da Placa ESP32	Tipo de Sinal
LED 1	Anodo (via resistor $220\,\Omega$)	GPIO 5	Saída Digital
LED 2	Anodo (via resistor $220\,\Omega$)	GPIO 18	Saída Digital
LED 3	Anodo (via resistor $220\,\Omega$)	GPIO 19	Saída Digital
LED 4	Anodo (via resistor $220\,\Omega$)	GPIO 21	Saída Digital
LED 5	Anodo (via resistor $220\,\Omega$)	GPIO 23	Saída Digital
Catodos de todos os LEDs	Terminal curto comum	GND	Retorno comum de terra

📦 Bibliotecas desta lição: nenhuma — opera com saídas digitais nativas.

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 18: Efeito Luminoso Sequencial de LEDs (Running Light)
// ==============================================================================

// Vetor indexado com os 5 pinos GPIO de controle dos LEDs
int ledPins[] = {5, 18, 19, 21, 23};
// Quantidade total de elementos no arranjo óptico
int ledCount = 5;

void setup() {
  // Inicializa todos os 5 pinos como saídas digitais em nível baixo
  for (int i = 0; i < ledCount; i++) {
    pinMode(ledPins[i], OUTPUT);
    digitalWrite(ledPins[i], LOW);
  }
}

void loop() {
  // Varredura da esquerda para a direita
  for (int i = 0; i < ledCount; i++) {
    digitalWrite(ledPins[i], HIGH); // Acende o LED da posição i
    delay(100);                     // Mantém aceso por 100ms
    digitalWrite(ledPins[i], LOW);  // Apaga o LED antes de avançar
  }
  
  // Varredura inversa: da direita para a esquerda
  for (int i = ledCount - 1; i >= 0; i--) {
    digitalWrite(ledPins[i], HIGH); // Acende o LED da posição i
    delay(100);                     // Mantém aceso por 100ms
    digitalWrite(ledPins[i], LOW);  // Apaga o LED
  }
}

Procedimento de Gravação e Teste de Bancada

1. Enfileire os 5 LEDs na protoboard, intercalando com seus respectivos resistores de $220\,\Omega$ e conectando aos GPIOs 5, 18, 19, 21 e 23.
2. Carregue o programa no ESP32.
3. Resultado Esperado: Os LEDs acenderão em sequência rítmica de ida e volta, criando um efeito dinâmico contínuo e sincronizado de água corrente.

---

Lição 19: Luz Controlada por Botão (Controle de Estado / Toggle)

O controle de acionamento em automação predial comumente substitui interruptores mecânicos pesados por botões de pulso eletrônicos (push-buttons). No entanto, um botão de pulso só permanece fisicamente acionado enquanto o dedo do usuário o pressiona.

Para transformar uma chave de pulso momentânea em um interruptor biestável (Flip-Flop ou controle tipo Toggle que liga com um toque e desliga com o próximo), o firmware deve monitorar a borda de subida (rising edge) do sinal digital. Além disso, as lâminas metálicas internas dos botões produzem repiques mecânicos indesejados durante o fechamento do contato, chamados de bouncing. Se não houver tratamento, um único clique físico pode disparar dezenas de transições espúrias em frações de milissegundo. O firmware resolve esse fenômeno através de um filtro de atraso temporal (debouncing por software).

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Matriz de contatos (Breadboard) de 830 pontos
• 1x Chave táctil push-button com capa plástica
• 1x Diodo Emissor de Luz (LED vermelho de 5 mm)
• 1x Resistor de filme de carbono de $220\,\Omega$ (limitador do LED)
• 1x Resistor de filme de carbono de $10\,\text{k}\Omega$ (pull-down do botão)
• 5x Cabos jumper flexíveis macho-macho

Ligações Elétricas e Pinagem

Componente	Terminal	Pino do ESP32	Tipo de Sinal
LED	Anodo (via resistor $220\,\Omega$)	GPIO 5	Saída Digital
LED	Catodo	GND	Referência de terra
Botão	Terminal 1	3,3V	Linha de alimentação
Botão	Terminal 2	GPIO 33	Entrada Digital
Resistor Pull-down $10\,\text{k}\Omega$	Entre GPIO 33 e GND	GND	Dreno de impedância

📦 Bibliotecas desta lição: nenhuma — a lógica biestável com debouncing é implementada puramente em software nativo.

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 19: Comutação Biestável (Toggle) com Filtro de Debouncing
// ==============================================================================

const int buttonPin = 33; // Pino de entrada da chave táctil
const int ledPin = 5;      // Pino de saída do LED indicador

int ledState = LOW;        // Armazena o estado atual do LED (LOW = desligado, HIGH = ligado)
int lastButtonState = LOW; // Guarda a leitura física do botão na iteração anterior

void setup() {
  pinMode(buttonPin, INPUT);
  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, ledState); // Inicia com o LED apagado
}

void loop() {
  // Realiza a leitura física atual da chave
  int currentButtonState = digitalRead(buttonPin);
  
  // Detecta a transição de borda de subida: o botão era LOW e agora é HIGH
  if (currentButtonState == HIGH && lastButtonState == LOW) {
    // Inverte a variável lógica de estado (de LOW para HIGH, ou de HIGH para LOW)
    ledState = !ledState;
    // Atualiza a saída física do pino com o novo estado
    digitalWrite(ledPin, ledState);
    // Filtro temporal de debouncing: bloqueia novos disparos durante repiques mecânicos
    delay(50);
  }
  
  // Atualiza a variável histórica para a próxima verificação cíclica
  lastButtonState = currentButtonState;
}

Procedimento de Gravação e Teste de Bancada

1. Monte o circuito na breadboard conectando o LED no GPIO 5 e o push-button no GPIO 33 com pull-down de $10\,\text{k}\Omega$.
2. Carregue o programa no ESP32.
3. Resultado Esperado: Ao dar um clique rápido no botão, o LED acenderá e permanecerá aceso mesmo após soltar o dedo. Ao clicar novamente, o LED apagará instantaneamente, operando como um interruptor liga/desliga inteligente estável.

---

Lição 20: Luz Sensível do Corpo Humano (Sensor PIR com Temporizador)

Este projeto implementa o sistema de iluminação automática temporizada amplamente empregado em corredores inteligentes, halls de entrada e garagens de condomínios.

O microcontrolador ESP32 monitora continuamente a saída digital do sensor piroelétrico PIR. Quando um indivíduo entra no campo de visão da lente Fresnel, o sensor sinaliza nível alto. O ESP32 detecta o evento, acende imediatamente a lâmpada (LED indicador) e inicia uma contagem regressiva de tempo através da função não bloqueante millis(). Enquanto houver pessoas se movimentando na área, o temporizador é reiniciado continuamente. Quando o ambiente volta ao estado de repouso por um tempo superior ao limite de segurança pré-programado (ex.: 5 segundos), o firmware desliga automaticamente a iluminação, gerando máxima eficiência energética.

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Matriz de contatos (Breadboard) de 830 pontos
• 1x Módulo Sensor de Presença Humana PIR
• 1x Diodo Emissor de Luz (LED vermelho de 5 mm)
• 1x Resistor de filme de carbono de $220\,\Omega$ (1/4W)
• 5x Cabos jumper flexíveis macho-fêmea e macho-macho

Ligações Elétricas e Pinagem

Componente / Pino	Conexão na Placa ESP32	Tipo de Sinal	Função no Sistema
PIR VCC	5V	Alimentação Positiva	Alimentação do módulo sensor
PIR GND	GND	Referência (0V)	Retorno de terra
PIR OUT	GPIO 33	Entrada Digital	Sinalização de presença em nível lógico ALTO
LED Anodo	GPIO 5 (via resistor $220\,\Omega$)	Saída Digital	Atuador luminoso de iluminação
LED Catodo	GND	Referência (0V)	Retorno de terra

📦 Bibliotecas desta lição: nenhuma — temporização realizada através do relógio interno de hardware do ESP32.

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 20: Sistema de Iluminação Temporizada Inteligente com PIR
// ==============================================================================

const int pirPin = 33; // Pino conectado à saída do sensor PIR
const int ledPin = 5;  // Pino de controle da iluminação LED

void setup() {
  pinMode(pirPin, INPUT);
  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, LOW); // Inicia desligado
}

void loop() {
  // Verifica se o sensor detectou radiação térmica infravermelha em movimento
  int motionDetected = digitalRead(pirPin);
  
  if (motionDetected == HIGH) {
    // Acende a luz imediatamente
    digitalWrite(ledPin, HIGH);
    // Mantém a iluminação ligada por 5 segundos após a detecção
    delay(5000);
  } else {
    // Sem movimentação: mantém a lâmpada apagada
    digitalWrite(ledPin, LOW);
  }
}

Procedimento de Gravação e Teste de Bancada

1. Monte o sensor PIR no GPIO 33 e o LED com resistor no GPIO 5.
2. Carregue o firmware e afaste-se do circuito por 30 segundos para permitir a estabilização térmica da cápsula piroelétrica.
3. Resultado Esperado: Ao movimentar a mão em frente ao sensor, o LED acenderá imediatamente e permanecerá iluminado por 5 segundos, apagando-se em seguida caso você permaneça imóvel.

---

Lição 21: Luz Controlada por Luz (Poste Automático com LDR)

Os sistemas de iluminação pública moderna utilizam relés fotoelétricos para acender automaticamente as luminárias durante o anoitecer e desligá-las ao alvorecer.

Neste projeto, o microcontrolador ESP32 lê continuamente o divisor de tensão formado pelo fotoresistor LDR e pelo resistor de $10\,\text{k}\Omega$ através de sua entrada analógica de 12 bits (GPIO 32). Conforme a luz do dia diminui, a resistência do LDR sobe e a tensão analógica lida pelo ADC cai. O firmware compara a leitura digitalizada $ADC$ com um limiar de histerese calibrado $L_{escuro} = 1500$. Quando $ADC < L_{escuro}$, o microcontrolador comuta o pino GPIO 5 para nível alto, acendendo o LED de alta intensidade. Quando a luz natural retorna ($ADC \ge L_{escuro}$), a iluminação é desligada automaticamente.

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Matriz de contatos (Breadboard) de 830 pontos
• 1x Fotoresistor LDR de 5 mm
• 1x Resistor de filme de carbono de $10\,\text{k}\Omega$ (divisor analógico)
• 1x Diodo Emissor de Luz (LED vermelho de 5 mm)
• 1x Resistor de filme de carbono de $220\,\Omega$ (limitador do LED)
• 5x Cabos jumper flexíveis macho-macho

Ligações Elétricas e Pinagem

Componente	Terminal	Pino do ESP32	Tipo de Sinal
LDR + Resistor $10\,\text{k}\Omega$	Junção Central do Divisor	GPIO 32	Entrada Analógica (ADC1_CH4)
LED	Anodo (via resistor $220\,\Omega$)	GPIO 5	Saída Digital de Iluminação
Alimentações	VCC do LDR no 3,3V / Retornos no GND	3,3V e GND	Barramentos de alimentação

📦 Bibliotecas desta lição: nenhuma — utiliza conversão analógica nativa com calibração por limiar numérico.

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 21: Poste de Iluminação Pública Crepuscular Inteligente
// ==============================================================================

const int ldrPin = 32; // Entrada analógica do sensor de luminosidade LDR
const int ledPin = 5;  // Saída de controle da lâmpada (LED)

// Limiar de disparo de escuridão (calibrado para valores de 12 bits entre 0 e 4095)
const int lightThreshold = 1500;

void setup() {
  Serial.begin(115200);
  pinMode(ledPin, OUTPUT);
}

void loop() {
  // Lê a luminosidade analógica ambiente instantânea
  int lightLevel = analogRead(ldrPin);
  
  Serial.print("Luminosidade Atual: ");
  Serial.println(lightLevel);
  
  // Se a luminosidade for menor que o limiar (ambiente escuro), acende a iluminação
  if (lightLevel < lightThreshold) {
    digitalWrite(ledPin, HIGH); // Acende a lâmpada
  } else {
    digitalWrite(ledPin, LOW);  // Apaga a lâmpada sob a luz do dia
  }
  
  delay(200); // Amostragem a cada 200 milissegundos
}

Procedimento de Gravação e Teste de Bancada

1. Carregue o firmware e abra o Monitor Serial em 115200 baud para acompanhar os valores numéricos.
2. Com a luz ambiente normal, o LED permanecerá apagado.
3. Resultado Esperado: Cubra o sensor LDR com a mão ou uma tampa opaca simulando o anoitecer. O LED acenderá instantaneamente. Ao retirar a mão, o LED se apagará imediatamente.

---

Lição 22: Luz com Ajuste de Cor (Sintetizador RGB com Potenciômetro)

Este projeto implementa uma interface homem-máquina para controle cromático de iluminação ambiente (Mood Light ou luminária cromoterápica inteligente).

O usuário rotaciona um potenciômetro linear analógico de $10\,\text{k}\Omega$. O microcontrolador ESP32 digitaliza a posição do eixo através do ADC de 12 bits ($0$ a $4095$). O algoritmo divide o espectro total de rotação em faixas matemáticas angulares e calcula proporções de modulação PWM simultâneas para os três canais do LED RGB (Vermelho, Verde e Azul). Conforme o eixo é girado de $0^\circ$ a $300^\circ$, a luminária transita suavemente do vermelho para o amarelo, depois para o verde, ciano, azul, violeta e retorna ao branco, permitindo sintonizar qualquer matiz do círculo cromático com precisão contínua.

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Matriz de contatos (Breadboard) de 830 pontos
• 1x Potenciômetro rotativo linear de $10\,\text{k}\Omega$
• 1x Diodo Emissor de Luz Tricolor (LED RGB cátodo comum)
• 3x Resistores de filme de carbono de $220\,\Omega$ (1/4W)
• 7x Cabos jumper flexíveis macho-macho

Ligações Elétricas e Pinagem

Componente	Terminal	Pino do ESP32	Tipo de Sinal
Potenciômetro	Cursor Central	GPIO 33	Entrada Analógica (ADC1_CH5)
LED RGB	Terminal Vermelho (R)	GPIO 5 (via $220\,\Omega$)	Saída PWM (LEDC)
LED RGB	Cátodo Comum	GND	Referência comum de terra
LED RGB	Terminal Verde (G)	GPIO 18 (via $220\,\Omega$)	Saída PWM (LEDC)
LED RGB	Terminal Azul (B)	GPIO 19 (via $220\,\Omega$)	Saída PWM (LEDC)

📦 Bibliotecas desta lição: nenhuma — modulação de cor realizada por mapeamento matemático direto sobre o periférico LEDC.

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 22: Sintetizador Cromático Contínuo com Potenciômetro
// ==============================================================================

const int potPin = 33;    // Entrada analógica do potenciômetro
const int redPin = 5;     // Saída PWM do canal Vermelho
const int greenPin = 18;  // Saída PWM do canal Verde
const int bluePin = 19;   // Saída PWM do canal Azul

void setup() {
  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);
}

void loop() {
  // Lê a posição do potenciômetro (0 a 4095)
  int val = analogRead(potPin);
  
  int r = 0, g = 0, b = 0;
  
  // Algoritmo de interpolação do círculo cromático em 3 zonas proporcionais
  if (val < 1365) {
    // Transição da faixa Vermelho -> Verde
    r = map(val, 0, 1365, 255, 0);
    g = map(val, 0, 1365, 0, 255);
    b = 0;
  } else if (val < 2730) {
    // Transição da faixa Verde -> Azul
    r = 0;
    g = map(val, 1365, 2730, 255, 0);
    b = map(val, 1365, 2730, 0, 255);
  } else {
    // Transição da faixa Azul -> Vermelho
    r = map(val, 2730, 4095, 0, 255);
    g = 0;
    b = map(val, 2730, 4095, 255, 0);
  }
  
  // Aplica as componentes cromáticas calculadas nas saídas PWM
  analogWrite(redPin, r);
  analogWrite(greenPin, g);
  analogWrite(bluePin, b);
  
  delay(20); // Atualização suave a 50 Hz
}

Procedimento de Gravação e Teste de Bancada

1. Grave o código e gire o eixo do potenciômetro lentamente de ponta a ponta.
2. Resultado Esperado: O LED RGB navegará por todas as cores do arco-íris de maneira contínua, permitindo selecionar manualmente qualquer tonalidade desejada.

---

Lição 23: Dados Eletrônicos (Gerador com Display de 8 Segmentos)

Jogos de tabuleiro tradicionais utilizam dados físicos de 6 faces para gerar eventos aleatórios. Neste projeto, construímos um Dado Eletrônico Digital à prova de vícios mecânicos utilizando o display de 7 segmentos de 1 dígito e uma chave táctil push-button.

Para garantir imprevisibilidade estatística real na geração dos números aleatórios, o firmware aproveita o ruído térmico aleatório e as flutuações eletrostáticas presentes em um pino analógico desconectado (floating pin, como o GPIO 35) para inicializar a semente do algoritmo gerador de números pseudoaleatórios (PRNG) através da função randomSeed(analogRead(35)). Ao pressionar o botão, o display executa uma animação de rotação rápida de segmentos por 1 segundo (simulando o dado rolando sobre a mesa) e desacelera suavemente até fixar em um número aleatório sorteado no intervalo uniforme entre 1 e 6:

$$P(X = k) = \frac{1}{6}, \quad k \in \{1, 2, 3, 4, 5, 6\}$$

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Matriz de contatos (Breadboard) de 830 pontos
• 1x Display de 7 segmentos de 1 dígito (cátodo comum)
• 1x Chave táctil push-button de 4 pinos com capa
• 7x Resistores de filme de carbono de $220\,\Omega$ (limitadores dos segmentos)
• 1x Resistor de filme de carbono de $10\,\text{k}\Omega$ (pull-down do botão)
• 12x Cabos jumper flexíveis macho-macho

Ligações Elétricas e Pinagem

Componente	Terminal	Pino do ESP32	Tipo de Sinal
Segmentos A a G	Pinos 7, 6, 4, 2, 1, 9, 10	GPIOs 16, 4, 0, 2, 15, 17, 5 (via $220\,\Omega$)	Saídas Digitais
Cátodo Comum	Pinos 3 ou 8	GND	Referência de terra
Botão de Sorteio	Terminal de Sinal	GPIO 33 (com pull-down de $10\,\text{k}\Omega$)	Entrada Digital

📦 Bibliotecas desta lição: nenhuma — opera com geração matemática pseudoaleatória e decodificação binária de segmentos.

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 23: Simulador de Dados Eletrônicos com Animação e Sorteio
// ==============================================================================

const int buttonPin = 33;
int segPins[] = {16, 4, 0, 2, 15, 17, 5}; // A, B, C, D, E, F, G

// Padrões binários dos números de 1 a 6
const byte diceNumbers[7][7] = {
  {0, 0, 0, 0, 0, 0, 0}, // 0 (Apagado)
  {0, 1, 1, 0, 0, 0, 0}, // 1
  {1, 1, 0, 1, 1, 0, 1}, // 2
  {1, 1, 1, 1, 0, 0, 1}, // 3
  {0, 1, 1, 0, 0, 1, 1}, // 4
  {1, 0, 1, 1, 0, 1, 1}, // 5
  {1, 0, 1, 1, 1, 1, 1}  // 6
};

void showNumber(int num) {
  for (int i = 0; i < 7; i++) {
    digitalWrite(segPins[i], diceNumbers[num][i]);
  }
}

void setup() {
  for (int i = 0; i < 7; i++) {
    pinMode(segPins[i], OUTPUT);
  }
  pinMode(buttonPin, INPUT);
  
  // Inicializa o gerador aleatório utilizando ruído eletrostático do ADC flutuante
  randomSeed(analogRead(35));
  showNumber(0); // Inicia com display em branco
}

void loop() {
  // Aguarda o pressionamento do botão de sorteio
  if (digitalRead(buttonPin) == HIGH) {
    // Efeito de animação rápida simulando o giro do dado
    for (int i = 0; i < 15; i++) {
      int temp = random(1, 7);
      showNumber(temp);
      delay(40 + (i * 15)); // Desaceleração gradual
    }
    
    // Sorteio definitivo final
    int finalRoll = random(1, 7);
    showNumber(finalRoll);
    
    // Aguarda soltar o botão e aplica pausa de segurança
    delay(500);
  }
}

Procedimento de Gravação e Teste de Bancada

1. Carregue o programa no ESP32.
2. Pressione o botão táctil na protoboard.
3. Resultado Esperado: O display executará uma sequência visual dinâmica e parará de forma firme em um número aleatório entre 1 e 6 a cada pressão do botão.

---

Lição 24: Contador Digital (Exibição Dinâmica em 4 Dígitos)

A contagem de peças em linhas de produção, catracas de acesso e cronômetros digitais exige o registro de contagens acumuladas superiores a um dígito. Este projeto implementa um Contador de Pulsos Digital de 4 Dígitos com capacidade de registrar eventos de $0000$ até $9999$.

O sistema utiliza a técnica de multiplexação temporal estudada na Lição 15 combinada com aritmética de divisão e módulo inteiro para decompor o valor corrente da variável contadora $N$ em seus quatro dígitos posicionais correspondentes:

• Milhar ($D_1$): $d_1 = \lfloor N / 1000 \rfloor$
• Centena ($D_2$): $d_2 = \lfloor (N \% 1000) / 100 \rfloor$
• Dezena ($D_3$): $d_3 = \lfloor (N \% 100) / 10 \rfloor$
• Unidade ($D_4$): $d_4 = N \% 10$

Um botão táctil é configurado com interrupção por software para incrementar o contador a cada toque físico, enquanto a rotina principal mantém a varredura multiplexada contínua a $100\,\text{Hz}$ para visualização estável.

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Matriz de contatos (Breadboard) de 830 pontos
• 1x Módulo Display de 4 dígitos (cátodo comum)
• 1x Chave táctil push-button com resistor de $10\,\text{k}\Omega$
• 8x Resistores de filme de carbono de $220\,\Omega$ (1/4W)
• 15x Cabos jumper flexíveis macho-macho

Ligações Elétricas e Pinagem

Linha do Circuito	Pinos da Placa ESP32	Função no Sistema
Segmentos A a G	GPIOs 16, 4, 0, 2, 15, 17, 5 (via $220\,\Omega$)	Barramento comum de segmentos multiplexados
Cátodos de Dígitos D1 a D4	GPIOs 12, 13, 14, 27	Habilitação seletiva de cátodo em nível BAIXO
Botão Incrementador	GPIO 33 (com resistor pull-down)	Entrada digital geradora de pulsos de contagem

📦 Bibliotecas desta lição: nenhuma — processamento aritmético e varredura multiplexada em código nativo.

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 24: Contador Decimal de 4 Dígitos Multiplexado no Tempo
// ==============================================================================

int segPins[] = {16, 4, 0, 2, 15, 17, 5};
int digitPins[] = {12, 13, 14, 27};
const int buttonPin = 33;

const byte digits[10][7] = {
  {1, 1, 1, 1, 1, 1, 0}, {0, 1, 1, 0, 0, 0, 0}, {1, 1, 0, 1, 1, 0, 1},
  {1, 1, 1, 1, 0, 0, 1}, {0, 1, 1, 0, 0, 1, 1}, {1, 0, 1, 1, 0, 1, 1},
  {1, 0, 1, 1, 1, 1, 1}, {1, 1, 1, 0, 0, 0, 0}, {1, 1, 1, 1, 1, 1, 1},
  {1, 1, 1, 1, 0, 1, 1}
};

int count = 0;
int lastBtn = LOW;

void showDisplay(int value) {
  int d[4];
  d[0] = (value / 1000) % 10;
  d[1] = (value / 100) % 10;
  d[2] = (value / 10) % 10;
  d[3] = value % 10;
  
  for (int i = 0; i < 4; i++) {
    // Desliga todos os dígitos
    for (int k = 0; k < 4; k++) digitalWrite(digitPins[k], HIGH);
    
    // Atualiza os segmentos para o algarismo correspondente
    for (int s = 0; s < 7; s++) digitalWrite(segPins[s], digits[d[i]][s]);
    
    // Habilita apenas o dígito da posição atual
    digitalWrite(digitPins[i], LOW);
    delay(2);
  }
}

void setup() {
  for (int i = 0; i < 7; i++) pinMode(segPins[i], OUTPUT);
  for (int i = 0; i < 4; i++) {
    pinMode(digitPins[i], OUTPUT);
    digitalWrite(digitPins[i], HIGH);
  }
  pinMode(buttonPin, INPUT);
}

void loop() {
  int btn = digitalRead(buttonPin);
  if (btn == HIGH && lastBtn == LOW) {
    count++;
    if (count > 9999) count = 0;
    delay(20); // Debounce
  }
  lastBtn = btn;
  
  showDisplay(count);
}

Procedimento de Gravação e Teste de Bancada

1. Carregue o programa no ESP32.
2. Pressione o botão conectado ao GPIO 33.
3. Resultado Esperado: O display iniciará em 0000 e incrementará uma unidade de forma precisa a cada clique no botão físico, avançando para 0001, 0002 até atingir qualquer valor desejado sem falhas de contagem.

---

Lição 25: Dispositivo de Resposta Rápida (Quiz Buzzer com Lockout)

Em competições acadêmicas e programas de perguntas e respostas de televisão (Quiz Shows), é comum utilizar um sistema eletrônico de prioridade no qual múltiplos participantes disputam quem aciona primeiro o botão de resposta.

O circuito integra três botões de resposta, três LEDs coloridos de indicação individual e um buzzer ativo para confirmação sonora. A arquitetura de software implementa uma lógica de travamento mútuo (lockout): quando o primeiro competidor pressiona seu botão, o microcontrolador ESP32 detecta o evento em microssegundos, acende imediatamente o LED exclusivo daquele competidor, emite um bipe sonoro agudo no buzzer e congela o sistema, ignorando totalmente os botões dos concorrentes. O sistema só é liberado para a próxima pergunta após o mediador acionar o botão de reset.

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Matriz de contatos (Breadboard) de 830 pontos
• 3x Chaves tácteis push-buttons (Participantes 1, 2 e 3)
• 3x Resistores de filme de carbono de $10\,\text{k}\Omega$ (pull-down dos botões)
• 3x Diodos Emissores de Luz (LEDs vermelho, verde e amarelo)
• 3x Resistores de filme de carbono de $220\,\Omega$ (limitadores dos LEDs)
• 1x Buzzer ativo de 5V
• 14x Cabos jumper flexíveis macho-macho

Ligações Elétricas e Pinagem

Participante	Pino do Botão	Pino do LED Indicador	Cor do LED
Competidor 1	GPIO 33 (pull-down)	GPIO 5 (via $220\,\Omega$)	Vermelho
Competidor 2	GPIO 32 (pull-down)	GPIO 18 (via $220\,\Omega$)	Verde
Competidor 3	GPIO 35 (pull-down)	GPIO 19 (via $220\,\Omega$)	Amarelo
Buzzer Sonoro	Conectado ao GPIO 25	Avisa acionamento do vencedor	Transdutor acústico

📦 Bibliotecas desta lição: nenhuma — lógica booleana de prioridade e trava em tempo real.

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 25: Sistema de Resposta Rápida (Quiz Buzzer com Trava Lockout)
// ==============================================================================

const int btn1 = 33, btn2 = 32, btn3 = 35;
const int led1 = 5, led2 = 18, led3 = 19;
const int buzzerPin = 25;

bool locked = false; // Flag de travamento mútuo do sistema

void setup() {
  pinMode(btn1, INPUT);
  pinMode(btn2, INPUT);
  pinMode(btn3, INPUT);
  
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
  pinMode(buzzerPin, OUTPUT);
}

void triggerWinner(int led) {
  locked = true;              // Trava o sistema contra outros cliques
  digitalWrite(led, HIGH);    // Acende o LED do competidor mais rápido
  digitalWrite(buzzerPin, HIGH); // Dispara o alarme sonoro
  delay(300);
  digitalWrite(buzzerPin, LOW);
  delay(3000);                // Mantém o vencedor visível por 3 segundos
  
  // Reseta o circuito para a próxima rodada
  digitalWrite(led, LOW);
  locked = false;
}

void loop() {
  if (!locked) {
    if (digitalRead(btn1) == HIGH) triggerWinner(led1);
    else if (digitalRead(btn2) == HIGH) triggerWinner(led2);
    else if (digitalRead(btn3) == HIGH) triggerWinner(led3);
  }
}

Procedimento de Gravação e Teste de Bancada

1. Monte os três circuitos de botão e seus respectivos LEDs na breadboard.
2. Carregue o programa no ESP32.
3. Peça a dois ou mais participantes para tentarem pressionar seus respectivos botões simultaneamente.
4. Resultado Esperado: Apenas o competidor mais rápido terá seu LED aceso acompanhado de um bipe sonoro instantâneo, travando a leitura dos demais competidores de forma totalmente justa e precisa.

---

Lição 26: Piano de Frutas (Teclas de Toque Capacitivo Touch)

O microcontrolador ESP32 possui em seu silício uma matriz de sensores de toque capacitivo integrados (Touch Pins). Ao contrário de botões mecânicos que exigem fechamento de circuito elétrico, o sensor de toque capacitivo mede a variação da capacitância eletrostática parasita introduzida pela proximidade da mão ou do corpo humano em um elemento metálico condutor.

A medição baseia-se na cronometragem do tempo de carga e descarga de um oscilador RC interno. Em repouso, o pino possui capacitância natural muito baixa e o registrador interno atinge contagens elevadas (valores típicos entre 70 e 100). Quando o corpo humano toca no condutor (ou em uma fruta rica em eletrólitos condutivos, como maçã, banana ou limão conectada ao pino por um cabo garra de jacaré), a capacitância equivalente aumenta e a leitura numérica cai bruscamente para valores inferiores a 30:

$$C_{TOTAL} = C_{PLACA} + C_{CORPO}$$

Ao detectar que a leitura capacitiva caiu abaixo do limiar calibrado ($T_{LIDO} < 30$), o microcontrolador reconhece o toque e dispara no buzzer passivo a frequência acústica da nota musical correspondente, transformando frutas ou objetos condutivos em teclas de um teclado musical háptico.

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Matriz de contatos (Breadboard) de 830 pontos
• 1x Buzzer passivo
• 4x Cabos com garra de jacaré e derivação Dupont macho
• 4x Frutas ou objetos metálicos condutivos (maçãs, bananas, clips metálicos)
• 4x Cabos jumper macho-macho

Ligações Elétricas e Pinagem

Terminal Condutivo	Pino Touch do ESP32	Tipo de Periférico	Nota Musical Emitida
Tecla 1 (Fruta 1)	GPIO 4	Touch 0 (Capacitivo)	Nota Dó (C4 - 262 Hz)
Tecla 2 (Fruta 2)	GPIO 2	Touch 2 (Capacitivo)	Nota Ré (D4 - 294 Hz)
Tecla 3 (Fruta 3)	GPIO 15	Touch 3 (Capacitivo)	Nota Mi (E4 - 330 Hz)
Tecla 4 (Fruta 4)	GPIO 13	Touch 4 (Capacitivo)	Nota Fá (F4 - 349 Hz)
Buzzer Passivo (+)	GPIO 25	Saída de Áudio Tone	Transdutor acústico musical

📦 Bibliotecas desta lição: nenhuma — a função nativa touchRead() do ESP32 lê os osciladores capacitivos de hardware e tone() gera as notas.

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 26: Piano Musical de Frutas com Sensores de Toque Capacitivo
// ==============================================================================

const int buzzerPin = 25; // Pino conectado ao buzzer passivo

// Pinos com função nativa de toque capacitivo (Touch)
const int touchPin1 = 4;  // Touch 0
const int touchPin2 = 2;  // Touch 2
const int touchPin3 = 15; // Touch 3
const int touchPin4 = 13; // Touch 4

// Limiar empírico de detecção de contato humano capacitivo
const int threshold = 30;

void setup() {
  Serial.begin(115200);
  pinMode(buzzerPin, OUTPUT);
}

void loop() {
  // Lê a capacitância instantânea em cada canal condutivo
  int val1 = touchRead(touchPin1);
  int val2 = touchRead(touchPin2);
  int val3 = touchRead(touchPin3);
  int val4 = touchRead(touchPin4);
  
  if (val1 < threshold) {
    tone(buzzerPin, 262); // Emite Dó (C4)
  } else if (val2 < threshold) {
    tone(buzzerPin, 294); // Emite Ré (D4)
  } else if (val3 < threshold) {
    tone(buzzerPin, 330); // Emite Mi (E4)
  } else if (val4 < threshold) {
    tone(buzzerPin, 349); // Emite Fá (F4)
  } else {
    noTone(buzzerPin);     // Silencia o buzzer quando nenhum condutor é tocado
  }
  
  delay(30); // Intervalo de amostragem
}

Procedimento de Gravação e Teste de Bancada

1. Fixe as garras jacaré nos pinos GPIO 4, 2, 15 e 13 e conecte as outras pontas em quatro frutas ou pedaços de folha de alumínio apoiados na bancada.
2. Carregue o programa no ESP32.
3. Resultado Esperado: Ao tocar o dedo na primeira fruta, o buzzer reproduzirá a nota Dó. Ao tocar na segunda, emitirá Ré; na terceira, Mi; e na quarta, Fá, operando como um instrumento musical interativo.

---

Lição 27: Ventilador de Velocidade Variável (Potenciômetro + Motor DC)

O controle fino de fluxo de ventilação em climatizadores e sistemas de ar condicionado baseia-se na variação contínua da tensão média aplicada sobre os enrolamentos do rotor do motor de corrente contínua.

Neste projeto, conectamos o potenciômetro linear ao canal analógico GPIO 33 e o circuito de acionamento do motor DC (transistor NPN e diodo flyback) ao canal PWM GPIO 26. O conversor ADC do ESP32 adquire o valor analógico de 12 bits ($0$ a $4095$). O firmware utiliza a função de mapeamento proporcional map() para converter essa faixa de entrada na resolução de 8 bits do canal PWM ($0$ a $255$):

$$DutyCycle = \left\lfloor \frac{ADC \times 255}{4095} \right\rfloor$$

Além disso, como os motores DC apresentam uma zona morta (deadband) decorrente do atrito estático das escovas e inércia do rotor, valores de PWM abaixo de 40 não conseguem vencer o torque resistente. O firmware aplica uma compensação de corte: quando o potenciômetro estiver nos primeiros 5% de curso, o motor permanece completamente em repouso; a partir desse ponto, o motor parte suavemente e acelera linearmente até 10.000 RPM.

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Matriz de contatos (Breadboard) de 830 pontos
• 1x Potenciômetro rotativo linear de $10\,\text{k}\Omega$
• 1x Mini Motor DC de 3V a 6V com hélice plástica
• 1x Transistor NPN de média potência (S8050)
• 1x Diodo retificador 1N4007 (proteção flyback)
• 1x Resistor de filme de carbono de $1\,\text{k}\Omega$
• 7x Cabos jumper flexíveis macho-macho

Ligações Elétricas e Pinagem

Componente	Terminal	Conexão no ESP32	Tipo de Sinal
Potenciômetro	Cursor Central	GPIO 33	Entrada Analógica (ADC)
Transistor NPN	Base (via resistor de $1\,\text{k}\Omega$)	GPIO 26	Saída PWM (LEDC)
Diodo Flyback 1N4007	Catodo no 5V / Anodo no Coletor	Paralelo Reverso ao Motor	Proteção contra picos indutivos
Alimentações	5V no motor e potenciômetro / Retornos no GND	5V e GND	Barramentos de potência e referência

📦 Bibliotecas desta lição: nenhuma — modulação PWM nativa com mapeamento numérico.

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 27: Controle Contínuo de Rotação de Ventilador DC por Potenciômetro
// ==============================================================================

const int potPin = 33;   // Pino de entrada analógica do potenciômetro
const int motorPin = 26; // Pino de saída PWM conectado à base do transistor

void setup() {
  pinMode(motorPin, OUTPUT);
}

void loop() {
  // Aquisição do valor do potenciômetro (0 a 4095)
  int potValue = analogRead(potPin);
  
  // Converte a faixa analógica de 12 bits para a escala de 8 bits do PWM (0 a 255)
  int motorSpeed = map(potValue, 0, 4095, 0, 255);
  
  // Tratamento de zona morta: se o comando for muito baixo, desliga o motor
  if (motorSpeed < 20) {
    motorSpeed = 0;
  }
  
  // Aplica o ciclo de trabalho PWM proporcional ao motor DC
  analogWrite(motorPin, motorSpeed);
  
  delay(20); // Taxa de amostragem de 50 Hz
}

Procedimento de Gravação e Teste de Bancada

1. Encaixe a hélice plástica no motor com cuidado.
2. Monte o circuito do transistor, diodo flyback e potenciômetro.
3. Carregue o programa no ESP32.
4. Resultado Esperado: Com o potenciômetro todo à esquerda, o ventilador permanecerá desligado. Conforme você gira o eixo no sentido horário, o motor parte e aumenta suavemente o fluxo de vento até a rotação máxima.

---

Lição 28: Ventilador Termostático Inteligente (Controle Automático por DHT11)

A automação industrial e os sistemas de refrigeração de data centers operam ventiladores e exaustores em malha de controle termostática, acelerando a rotação de acordo com o aquecimento das placas eletrônicas para manter o equilíbrio térmico e reduzir o consumo energético.

Neste projeto, integramos o sensor digital DHT11 (GPIO 32) ao circuito de potência do motor DC (GPIO 26). O microcontrolador lê periodicamente a temperatura em graus Celsius. O algoritmo implementa uma curva de controle proporcional:

• Se $T < 26^\circ\text{C}$: O sistema encontra-se em faixa térmica segura; o motor permanece totalmente desligado ($PWM = 0$).
• Se $26^\circ\text{C} \le T \le 32^\circ\text{C}$: A velocidade do ventilador é modulada proporcionalmente entre a velocidade média e máxima:

$$PWM = \text{map}(T, 26, 32, 120, 255)$$

• Se $T > 32^\circ\text{C}$: Alerta de sobreaquecimento; o ventilador é acionado imediatamente em potência máxima contínua ($PWM = 255$).

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Matriz de contatos (Breadboard) de 830 pontos
• 1x Sensor digital de temperatura e umidade DHT11
• 1x Mini Motor DC com hélice plástica
• 1x Transistor NPN (S8050), Diodo 1N4007 e resistor de $1\,\text{k}\Omega$
• 8x Cabos jumper flexíveis macho-fêmea e macho-macho

Ligações Elétricas e Pinagem

Componente	Terminal	Pino do ESP32	Tipo de Sinal
Sensor DHT11	Pino de Dados (DATA)	GPIO 32	Barramento Digital Single-Wire
Motor DC	Base do Transistor (via $1\,\text{k}\Omega$)	GPIO 26	Saída PWM de Potência
Alimentações	5V no motor e DHT11 / Retornos no GND	5V e GND	Barramentos de alimentação

📦 Bibliotecas desta lição: DHT sensor library por Adafruit (versão 1.4.6) e dependência Adafruit Unified Sensor (versão 1.1.14).

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 28: Climatizador Automático com Controle Termostático por DHT11
// ==============================================================================

#include "DHT.h"

#define DHTPIN 32
#define DHTTYPE DHT11

DHT dht(DHTPIN, DHTTYPE);
const int motorPin = 26;

void setup() {
  Serial.begin(115200);
  pinMode(motorPin, OUTPUT);
  dht.begin();
}

void loop() {
  delay(2000); // Intervalo de estabilização térmica do DHT11
  
  float temp = dht.readTemperature();
  
  if (isnan(temp)) {
    Serial.println("Erro na leitura do DHT11!");
    return;
  }
  
  Serial.print("Temperatura de Bancada: ");
  Serial.print(temp, 1);
  Serial.println(" °C");
  
  // Controle proporcional de atuação
  if (temp < 26.0) {
    analogWrite(motorPin, 0); // Desligado em temperatura amena
    Serial.println("Estado do Ventilador: DESLIGADO (temperatura segura)");
  } else if (temp >= 26.0 && temp <= 32.0) {
    int pwm = map(temp, 26, 32, 120, 255);
    analogWrite(motorPin, pwm);
    Serial.print("Estado do Ventilador: LIGADO PROPORCIONAL (PWM: ");
    Serial.print(pwm);
    Serial.println(")");
  } else {
    analogWrite(motorPin, 255); // Potência total em sobreaquecimento
    Serial.println("Estado do Ventilador: POTÊNCIA MÁXIMA (Alerta Térmico)");
  }
}

Procedimento de Gravação e Teste de Bancada

1. Grave o código no ESP32 e acompanhe as leituras no Monitor Serial.
2. Em temperatura ambiente padrão de cerca de 23°C a 25°C, o ventilador permanecerá desligado.
3. Resultado Esperado: Aproxime a respiração quente ou um objeto aquecido da cápsula azul do DHT11. Quando a temperatura ultrapassar 26°C, o ventilador ligará automaticamente, aumentando a velocidade de rotação conforme a temperatura sobe.

---

Lição 29: Ventilador Remoto por Infravermelho (Acionamento e Velocidade via IR)

Neste projeto, transformamos o ventilador de bancada em um eletrodoméstico operado por controle remoto sem fio via raios infravermelhos.

O módulo receptor AX-1838 (GPIO 15) decodifica os comandos do controle remoto de 21 teclas através da biblioteca IRremote. O firmware estrutura uma máquina de estados com quatro modos de operação:

• Tecla POWER (0x45): Liga ou desliga o sistema.
• Tecla 1 (0x30): Seleciona a Velocidade 1 (Brisa suave, $PWM = 100$).
• Tecla 2 (0x18): Seleciona a Velocidade 2 (Ventilação média, $PWM = 180$).
• Tecla 3 (0x7A): Seleciona a Velocidade 3 (Ventilação máxima, $PWM = 255$).

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Matriz de contatos (Breadboard) de 830 pontos
• 1x Módulo Receptor Infravermelho AX-1838
• 1x Controle remoto infravermelho de 21 teclas
• 1x Mini Motor DC com hélice, transistor NPN, diodo 1N4007 e resistor de $1\,\text{k}\Omega$
• 8x Cabos jumper flexíveis macho-fêmea e macho-macho

Ligações Elétricas e Pinagem

Componente	Terminal	Pino do ESP32	Tipo de Sinal
Receptor IR	Saída OUT	GPIO 15	Entrada Digital Demodulada
Motor DC	Base do Transistor (via $1\,\text{k}\Omega$)	GPIO 26	Saída PWM de Potência
Alimentações	5V no motor e receptor / Retornos no GND	5V e GND	Barramentos de alimentação

📦 Bibliotecas desta lição: IRremote por ArminJo (versão 4.1.2).

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 29: Ventilador Multivelocidades com Controle Remoto Infravermelho
// ==============================================================================

#include <IRremote.hpp>

const int IR_RECEIVE_PIN = 15;
const int motorPin = 26;

bool fanOn = false;
int fanSpeed = 150;

void setup() {
  Serial.begin(115200);
  pinMode(motorPin, OUTPUT);
  IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
  analogWrite(motorPin, 0); // Inicia desligado
}

void loop() {
  if (IrReceiver.decode()) {
    auto cmd = IrReceiver.decodedIRData.command;
    Serial.print("Comando IR Recebido: 0x");
    Serial.println(cmd, HEX);
    
    // Decodificação das teclas do controle
    if (cmd == 0x45) { // Tecla POWER
      fanOn = !fanOn;
      analogWrite(motorPin, fanOn ? fanSpeed : 0);
    } else if (cmd == 0x30 && fanOn) { // Tecla 1
      fanSpeed = 100;
      analogWrite(motorPin, fanSpeed);
    } else if (cmd == 0x18 && fanOn) { // Tecla 2
      fanSpeed = 180;
      analogWrite(motorPin, fanSpeed);
    } else if (cmd == 0x7A && fanOn) { // Tecla 3
      fanSpeed = 255;
      analogWrite(motorPin, fanSpeed);
    }
    
    IrReceiver.resume(); // Prepara receptor para o próximo pulso
  }
}

Procedimento de Gravação e Teste de Bancada

1. Carregue o programa no ESP32.
2. Aponte o controle remoto para o sensor AX-1838 e pressione a tecla POWER.
3. Resultado Esperado: O ventilador ligará na velocidade intermediária. Pressione as teclas 1, 2 e 3 para alterar o fluxo de ar entre velocidade suave, média e máxima. Ao pressionar POWER novamente, o ventilador desligará imediatamente.

---

Lição 30: Estação de Monitoramento Ambiental (DHT11 + Display LCD1602 I2C)

Este projeto constrói um instrumento de telemetria científica autônomo para medição de qualidade do ar e conforto térmico em ambientes laboratoriais ou residenciais.

O microcontrolador ESP32 realiza a aquisição digital contínua da temperatura e da umidade relativa do ar através do DHT11 (GPIO 32) e formata esses valores na interface alfanumérica do display LCD1602 conectado ao barramento I2C (SDA no GPIO 21 e SCL no GPIO 22). O firmware atualiza os mostradores a cada 2 segundos, exibindo na primeira linha o texto Temp: xx.x C com símbolo de graus personalizado e na segunda linha Umid: xx.x %, garantindo leitura visual de alta precisão e baixo consumo de pinos do microcontrolador.

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Matriz de contatos (Breadboard) de 830 pontos
• 1x Sensor digital de temperatura e umidade DHT11
• 1x Display LCD1602 com módulo serial I2C integrado (PCF8574)
• 7x Cabos jumper flexíveis fêmea-macho

Ligações Elétricas e Pinagem

Dispositivo	Pino no Módulo	Pino no ESP32	Tipo de Barramento
Sensor DHT11	Pino DATA	GPIO 32	Barramento Single-Wire
Display LCD1602 I2C	SDA	GPIO 21	Barramento I2C Serial Data
Display LCD1602 I2C	SCL	GPIO 22	Barramento I2C Serial Clock
Alimentações	VCC e GND	5V e GND	Barramentos comuns

📦 Bibliotecas desta lição: DHT sensor library por Adafruit (versão 1.4.6) e LiquidCrystal_I2C por Frank de Brabander (versão 1.1.4).

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 30: Estação Termodinâmica com Exibição em Display LCD1602 I2C
// ==============================================================================

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include "DHT.h"

#define DHTPIN 32
#define DHTTYPE DHT11

DHT dht(DHTPIN, DHTTYPE);
LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
  dht.begin();
  lcd.init();
  lcd.backlight();
  
  lcd.setCursor(0, 0);
  lcd.print("Estacao Clima");
  lcd.setCursor(0, 1);
  lcd.print("Iniciando...");
  delay(1500);
  lcd.clear();
}

void loop() {
  delay(2000); // Cadência de leitura de 2 segundos
  
  float h = dht.readHumidity();
  float t = dht.readTemperature();
  
  if (isnan(h) || isnan(t)) {
    lcd.setCursor(0, 0);
    lcd.print("Erro no Sensor! ");
    return;
  }
  
  // Linha 1: Temperatura
  lcd.setCursor(0, 0);
  lcd.print("Temp: ");
  lcd.print(t, 1);
  lcd.print(" C    ");
  
  // Linha 2: Umidade
  lcd.setCursor(0, 1);
  lcd.print("Umid: ");
  lcd.print(h, 1);
  lcd.print(" %    ");
}

Procedimento de Gravação e Teste de Bancada

1. Conecte o DHT11 e o LCD1602 I2C de acordo com a tabela de pinagem.
2. Carregue o programa no ESP32.
3. Resultado Esperado: O display acenderá o backlight azul e exibirá continuamente a temperatura em graus Celsius e a umidade relativa do ar em percentual em tempo real com excelente nitidez.

---

Lição 31: Sistema de Alarme por Radar (Ultrassom + Servo + Buzzer)

Sistemas telemétricos de defesa e veículos autônomos utilizam sensores de varredura mecânica panorâmica para mapear o espaço ao redor e detectar intrusões perimetrais.

Neste projeto, acoplamos o sensor ultrassônico HC-SR04 solidariamente sobre a cruzeta do micro servomotor SG90 (GPIO 27). O servo executa uma varredura angular contínua de $15^\circ$ a $165^\circ$ em passos discretos de $3^\circ$. A cada passo angular $\theta$, o sensor ultrassônico emite um pulso telemétrico e mede a distância física $d$ até o obstáculo mais próximo. Se um objeto for detectado dentro do raio crítico de segurança de $20\,\text{cm}$, o microcontrolador interrompe imediatamente a varredura, acende o LED vermelho de alerta e dispara o buzzer ativo (GPIO 25) com bipes rápidos de alarme sonoro, retornando à varredura somente após o obstáculo ser removido.

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Matriz de contatos (Breadboard) de 830 pontos
• 1x Micro Servomotor SG90 com cruzetas
• 1x Sensor Ultrassônico telemétrico HC-SR04
• 1x Buzzer ativo de 5V
• 1x Diodo Emissor de Luz (LED vermelho com resistor de $220\,\Omega$)
• 12x Cabos jumper flexíveis macho-fêmea e macho-macho

Ligações Elétricas e Pinagem

Componente	Terminal	Pino do ESP32	Tipo de Sinal
Servomotor SG90	Sinal Laranja	GPIO 27	Saída de Controle PPM
Ultrassom HC-SR04	Trig (Disparo)	GPIO 19	Saída Digital de Pulso
Ultrassom HC-SR04	Echo (Retorno)	GPIO 18	Entrada de Tempo de Voo
Buzzer Ativo	Terminal Positivo	GPIO 25	Saída Digital de Alarme
LED Vermelho	Anodo (via resistor $220\,\Omega$)	GPIO 5	Saída Digital de Alerta

📦 Bibliotecas desta lição: ESP32Servo por Kevin Harrington (versão 1.1.1).

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 31: Radar Telemétrico Panorâmico de 180° com Alarme de Intrusão
// ==============================================================================

#include <ESP32Servo.h>

Servo radarServo;
const int servoPin = 27;
const int trigPin = 19;
const int echoPin = 18;
const int buzzerPin = 25;
const int ledPin = 5;

// Função auxiliar para medição telemétrica de distância
float getDistance() {
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  
  long duration = pulseIn(echoPin, HIGH, 25000); // Timeout de 25ms (~4 metros)
  if (duration == 0) return 999.0;
  return (duration * 0.0343) / 2.0;
}

void setup() {
  Serial.begin(115200);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  pinMode(buzzerPin, OUTPUT);
  pinMode(ledPin, OUTPUT);
  
  ESP32PWM::allocateTimer(0);
  radarServo.setPeriodHertz(50);
  radarServo.attach(servoPin, 500, 2500);
}

void loop() {
  // Varredura de 15° até 165°
  for (int angle = 15; angle <= 165; angle += 3) {
    radarServo.write(angle);
    delay(30);
    
    float dist = getDistance();
    if (dist < 20.0) { // Intrusão detectada a menos de 20 cm
      digitalWrite(ledPin, HIGH);
      digitalWrite(buzzerPin, HIGH);
      delay(150);
      digitalWrite(buzzerPin, LOW);
      digitalWrite(ledPin, LOW);
    }
  }
  
  // Varredura reversa de 165° até 15°
  for (int angle = 165; angle >= 15; angle -= 3) {
    radarServo.write(angle);
    delay(30);
    
    float dist = getDistance();
    if (dist < 20.0) {
      digitalWrite(ledPin, HIGH);
      digitalWrite(buzzerPin, HIGH);
      delay(150);
      digitalWrite(buzzerPin, LOW);
      digitalWrite(ledPin, LOW);
    }
  }
}

Procedimento de Gravação e Teste de Bancada

1. Fixe o sensor HC-SR04 sobre a cruzeta do servomotor.
2. Carregue o programa no ESP32.
3. Resultado Esperado: O servomotor movimentará o sensor em arco panorâmico de um lado para o outro. Ao colocar a mão a menos de 20 cm do sensor em qualquer ângulo, o radar emitirá bipes sonoros agudos de alarme e piscará o LED vermelho.

---

Lição 32: Luz Controlada por Bluetooth (Bluetooth Serial SPP + App Android)

O microcontrolador ESP32 conta com um rádio transceptor de alta potência integrado com suporte aos padrões Bluetooth Classic (v4.2 BR/EDR) e Bluetooth Low Energy (BLE).

Neste projeto, utilizamos a biblioteca nativa BluetoothSerial, que emula o protocolo de porta serial padrão SPP (Serial Port Profile) sobre a camada RFCOMM do Bluetooth. A placa ESP32 anuncia-se no espaço aéreo com o identificador de dispositivo ESP32_LED_Control. Através do aplicativo oficial Android Bluetooth_light.apk (fornecido na pasta Arduino(Aprendiz Experiente)\5.APP), o usuário emparelha o smartphone com a placa e transmite caracteres ASCII de controle via rádio:

• Caractere '1': Liga o LED indicador (GPIO 2).
• Caractere '0': Desliga o LED indicador (GPIO 2).

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Matriz de contatos (Breadboard) de 830 pontos
• 1x Diodo Emissor de Luz (LED ou LED interno da placa no GPIO 2)
• 1x Resistor de filme de carbono de $220\,\Omega$ (1/4W)
• 1x Smartphone Android com Bluetooth e app Bluetooth_light.apk instalado

Ligações Elétricas e Pinagem

Componente	Terminal	Pino do ESP32	Tipo de Sinal
LED Indicador	Anodo (via resistor $220\,\Omega$)	GPIO 2	Saída Digital comutada via Bluetooth
LED Indicador	Catodo	GND	Retorno comum de terra

📦 Bibliotecas desta lição: BluetoothSerial.h — biblioteca nativa embutida diretamente no pacote oficial de placas do ESP32 da Espressif.

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 32: Automação Sem Fio via Bluetooth Serial SPP com App Android
// ==============================================================================

// Inclui o driver nativo de Bluetooth Serial Classic do ESP32
#include "BluetoothSerial.h"

// Verifica se o suporte a Bluetooth clássico está habilitado no SDK
#if !defined(CONFIG_BT_ENABLED) || !defined(CONFIG_BLUEDROID_ENABLED)
#error Bluetooth Classic desabilitado nas configuracoes do chip!
#endif

// Instancia o objeto do canal serial sem fio
BluetoothSerial SerialBT;

const int ledPin = 2; // LED onboard ou conectado na breadboard

void setup() {
  Serial.begin(115200);
  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, LOW);
  
  // Inicializa o rádio Bluetooth e define o nome de identificação na rede sem fio
  SerialBT.begin("ESP32_LED_Control");
  Serial.println("Bluetooth ativo. Emparelhe o dispositivo 'ESP32_LED_Control'...");
}

void loop() {
  // Verifica se há dados recebidos pela porta serial Bluetooth
  if (SerialBT.available()) {
    char incomingChar = SerialBT.read();
    Serial.print("Comando Bluetooth Recebido: ");
    Serial.println(incomingChar);
    
    if (incomingChar == '1') {
      digitalWrite(ledPin, HIGH); // Liga o LED
      SerialBT.println("LED LIGADO");
    } else if (incomingChar == '0') {
      digitalWrite(ledPin, LOW);  // Desliga o LED
      SerialBT.println("LED DESLIGADO");
    }
  }
}

Procedimento de Gravação e Teste de Bancada

1. Grave o código no ESP32.
2. Instale o arquivo Bluetooth_light.apk em seu celular Android.
3. No smartphone, vá em Configurações > Bluetooth e emparelhe o dispositivo ESP32_LED_Control.
4. Abra o aplicativo, selecione o dispositivo emparelhado e pressione os botões ON e OFF.
5. Resultado Esperado: O LED na bancada ligará e desligará em tempo real sem qualquer fio de conexão física com o smartphone.

---

Lição 33: Controle Web via Servidor HTTP (Automação IoT por Navegador)

O microcontrolador ESP32 incorpora uma pilha completa de protocolos de rede TCP/IP sobre a interface de rádio Wi-Fi 802.11 b/g/n. Essa capacidade permite que a própria placa funcione como um servidor Web embutido (Embedded HTTP Web Server), servindo documentos HTML, folhas de estilo CSS e manipulando requisições assíncronas REST sem a necessidade de um computador externo.

Neste projeto, o ESP32 conecta-se à rede local sem fio (modo Station - STA) ou cria sua própria rede Wi-Fi autônoma (modo Access Point - AP). O firmware instancia um servidor HTTP na porta padrão 80 utilizando a biblioteca WebServer. Quando o usuário digita o endereço IP da placa no navegador (ex.: http://192.168.1.150 ou http://192.168.4.1), o ESP32 entrega uma página Web moderna e responsiva com botões interativos estilizados para ligar e desligar a iluminação da residência remotamente.

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Matriz de contatos (Breadboard) de 830 pontos
• 1x Diodo Emissor de Luz (LED vermelho de 5 mm)
• 1x Resistor de filme de carbono de $220\,\Omega$ (1/4W)
• 1x Computador ou Smartphone conectado à mesma rede Wi-Fi

Ligações Elétricas e Pinagem

Componente	Terminal	Pino do ESP32	Tipo de Sinal
LED Indicador	Anodo (via resistor $220\,\Omega$)	GPIO 2	Saída Digital comutada via página Web
LED Indicador	Catodo	GND	Retorno de terra

📦 Bibliotecas desta lição: WiFi.h e WebServer.h — bibliotecas nativas integradas ao pacote oficial da placa ESP32.

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 33: Servidor Web HTTP Embarcado para Automação Residencial IoT
// ==============================================================================

#include <WiFi.h>
#include <WebServer.h>

// Credenciais da rede Wi-Fi local (substitua pelas de seu roteador)
const char* ssid = "SUA_REDE_WIFI";
const char* password = "SUA_SENHA_WIFI";

// Instancia o servidor Web na porta padrão HTTP 80
WebServer server(80);

const int ledPin = 2; // LED a ser controlado

// Função geradora do documento HTML com botões estilizados
String getPage() {
  String html = "<!DOCTYPE html><html><head><meta charset='utf-8'>";
  html += "<meta name='viewport' content='width=device-width, initial-scale=1.0'>";
  html += "<title>RoboBuilders - Servidor ESP32</title>";
  html += "<style>body{font-family:Arial,sans-serif;text-align:center;background:#f4f4f9;padding:20px;}";
  html += "h1{color:#1c1c1c;}";
  html += ".btn{display:inline-block;padding:15px 30px;margin:10px;font-size:18px;color:#fff;border-radius:8px;text-decoration:none;font-weight:bold;}";
  html += ".btn-on{background:#fa634f;}.btn-off{background:#1c1c1c;}";
  html += "</style></head><body>";
  html += "<h1>Controle Web ESP32 QE200</h1>";
  html += "<p>Automação Residencial e IoT</p>";
  html += "<a class='btn btn-on' href='/on'>LIGAR ILUMINAÇÃO</a>";
  html += "<a class='btn btn-off' href='/off'>DESLIGAR ILUMINAÇÃO</a>";
  html += "</body></html>";
  return html;
}

// Manipulador da rota raiz ("/")
void handleRoot() {
  server.send(200, "text/html", getPage());
}

// Manipulador da rota de ligar ("/on")
void handleOn() {
  digitalWrite(ledPin, HIGH);
  server.send(200, "text/html", getPage());
}

// Manipulador da rota de desligar ("/off")
void handleOff() {
  digitalWrite(ledPin, LOW);
  server.send(200, "text/html", getPage());
}

void setup() {
  Serial.begin(115200);
  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, LOW);
  
  // Conecta ao ponto de acesso Wi-Fi
  WiFi.begin(ssid, password);
  Serial.print("Conectando ao Wi-Fi");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("
Wi-Fi Conectado com sucesso!");
  Serial.print("Endereço IP Local do ESP32: ");
  Serial.println(WiFi.localIP());
  
  // Mapeia os endpoints HTTP
  server.on("/", handleRoot);
  server.on("/on", handleOn);
  server.on("/off", handleOff);
  
  // Inicia o servidor Web
  server.begin();
  Serial.println("Servidor Web HTTP em operacao na porta 80!");
}

void loop() {
  // Processa as requisições HTTP recebidas dos navegadores clientes
  server.handleClient();
}

Procedimento de Gravação e Teste de Bancada

1. Abra o sketch, substitua SUA_REDE_WIFI e SUA_SENHA_WIFI pelos dados de sua rede e faça o upload.
2. Abra o Monitor Serial em 115200 baud e anote o IP exibido (ex.: 192.168.1.150).
3. Abra o navegador (Google Chrome, Firefox ou Safari) em seu computador ou smartphone conectado à mesma rede e digite o IP na barra de endereços.
4. Resultado Esperado: Uma página Web carregará com os botões interativos LIGAR ILUMINAÇÃO e DESLIGAR ILUMINAÇÃO. Ao clicar nos botões na página Web, o LED físico na bancada comutará de estado instantaneamente.

---

Parte 4 — Projetos Alargados de Robótica e Estrutura

Nesta quarta parte do curso, expandimos a eletrônica pura para a mecatrônica e a robótica estrutural. Utilizando os elementos estruturais de madeira reflorestada cortados a laser, parafusos, porcas e articulações mecânicas fornecidos no kit (e compatíveis com o chassis mecânico expansível QE201), construímos robôs bioinspirados e dispositivos autônomos com dinâmica física real.

Para todos os projetos que utilizam servomotores acoplados a braços mecânicos, alavancas e engrenagens, a regra de ouro da engenharia de montagem mecatrônica é a Calibração do Ponto Zero do Servo (Servo Zero-Point Calibration). Antes de fixar qualquer parafuso ou braço plástico no eixo estriado do servomotor, o atuador deve ser energizado eletricamente e posicionado no ângulo de referência padrão ($90^\circ$ ou $0^\circ$) através do sketch auxiliar de calibração Servo_Initialize.ino. Caso essa etapa seja negligenciada, o motor poderá tentar girar além de seu limite mecânico durante a inicialização, provocando danos aos dentes das engrenagens plásticas internas.

---

Lição 34: Borboletas Biônicas Inteligentes (Cinemática Bioinspirada)

A robótica bioinspirada projeta mecanismos artificiais mimetizando as soluções cinemáticas desenvolvidas pela natureza. O projeto da Borboleta Biônica Inteligente recria o movimento elegante e harmônico do batimento de asas de lepidópteros através de um mecanismo articulado de quatro barras de curso oscilante acionado pelo micro servomotor SG90 (GPIO 27).

O servomotor realiza um ciclo oscilatório angular suave entre $45^\circ$ e $135^\circ$. A trajetória angular $\theta(t)$ é suavizada por uma função senoidal contínua para evitar choques inerciais nas extremidades das asas plásticas translúcidas. Ao mesmo tempo, um sensor de luminosidade LDR monitora a luz incidente: quando o ambiente é iluminado, a borboleta bate as asas com vigor; ao cair da noite ou ao cobrir o sensor, a borboleta recolhe suavemente as asas e entra em repouso biológico.

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Kit estrutural cortado a laser da Borboleta Biônica com asas articuladas
• 1x Micro Servomotor SG90 com parafusos de fixação M2
• 1x Fotoresistor LDR de 5 mm com resistor de $10\,\text{k}\Omega$
• 8x Cabos jumper flexíveis macho-fêmea

Ligações Elétricas e Pinagem

Componente	Terminal	Pino do ESP32	Tipo de Sinal
Servomotor SG90	Sinal de Controle	GPIO 27	Saída PPM de Movimento
Sensor LDR	Junção Analógica	GPIO 32	Entrada Analógica de Iluminância
Alimentações	5V no servo e LDR / Retornos no GND	5V e GND	Barramentos de alimentação

📦 Bibliotecas desta lição: ESP32Servo por Kevin Harrington (versão 1.1.1).

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 34: Mecanismo de Batimento de Asas de Borboleta Biônica
// ==============================================================================

#include <ESP32Servo.h>

Servo butterflyServo;
const int servoPin = 27;
const int ldrPin = 32;

void setup() {
  Serial.begin(115200);
  pinMode(ldrPin, INPUT);
  
  ESP32PWM::allocateTimer(0);
  butterflyServo.setPeriodHertz(50);
  butterflyServo.attach(servoPin, 500, 2500);
  butterflyServo.write(90); // Posiciona em repouso inicial
}

void loop() {
  int light = analogRead(ldrPin);
  
  // Se houver luz suficiente no ambiente, ativa o batimento das asas
  if (light > 1000) {
    // Movimento ascendente das asas: 45° a 135°
    for (int a = 45; a <= 135; a += 5) {
      butterflyServo.write(a);
      delay(20);
    }
    // Movimento descendente das asas: 135° a 45°
    for (int a = 135; a >= 45; a -= 5) {
      butterflyServo.write(a);
      delay(20);
    }
  } else {
    // Ambiente escuro: recolhe as asas a 90° e descansa
    butterflyServo.write(90);
    delay(500);
  }
}

Procedimento de Gravação e Teste de Bancada

1. Monte as peças de madeira e engrenagens da borboleta de acordo com o manual estrutural.
2. Carregue o programa e aponte uma fonte de luz para o sensor LDR.
3. Resultado Esperado: A borboleta começará a bater suas asas graciosamente. Ao cobrir o sensor com a mão, ela recolherá as asas e permanecerá em repouso estático.

---

Lição 35: Lixeira Inteligente (Abertura Automática por Ultrassom)

A preservação da higiene em ambientes hospitalares e cozinhas residenciais requer o descarte de resíduos sem contato físico com a tampa da lixeira.

Este projeto constrói uma Lixeira Automática Inteligente dotada de sensor ultrassônico telemétrico HC-SR04 montado na face frontal da tampa basculante de madeira. O microcontrolador mede continuamente a distância das mãos do usuário. Quando um objeto aproxima-se a menos de $15\,\text{cm}$, o ESP32 aciona o micro servomotor SG90 acoplado à dobradiça da tampa, abrindo-a suavemente a $90^\circ$. A tampa permanece totalmente aberta por 4 segundos para que o descarte seja realizado com calma. Em seguida, o servomotor rotaciona de volta para $0^\circ$, fechando o recipiente de forma estanque e silenciosa.

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Estrutura mecânica de lixeira cortada a laser em madeira com tampa basculante
• 1x Micro Servomotor SG90 com cruzetas e parafusos
• 1x Sensor Ultrassônico HC-SR04
• 10x Cabos jumper flexíveis fêmea-macho

Ligações Elétricas e Pinagem

Componente	Terminal	Pino do ESP32	Tipo de Sinal
Servomotor da Tampa	Linha de Pulso PPM	GPIO 27	Saída de Controle Angular
Ultrassom HC-SR04	Trig (Disparo)	GPIO 19	Saída Digital
Ultrassom HC-SR04	Echo (Retorno)	GPIO 18	Entrada de Tempo de Voo
Alimentações	5V no servo e ultrassom / Retornos no GND	5V e GND	Barramentos de alimentação

📦 Bibliotecas desta lição: ESP32Servo por Kevin Harrington (versão 1.1.1).

Código de Inicialização do Ponto Zero do Servo (Servo_Initialize.ino)

#include <ESP32Servo.h>
Servo testServo;
void setup() {
  ESP32PWM::allocateTimer(0);
  testServo.setPeriodHertz(50);
  testServo.attach(27, 500, 2500);
  testServo.write(0); // Posiciona no batente zero antes da montagem mecânica
}
void loop() { delay(1000); }

Código-Fonte Principal Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 35: Lixeira Inteligente com Abertura e Fechamento Automáticos
// ==============================================================================

#include <ESP32Servo.h>

Servo lidServo;
const int servoPin = 27;
const int trigPin = 19;
const int echoPin = 18;

float readDistance() {
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  
  long duration = pulseIn(echoPin, HIGH, 25000);
  if (duration == 0) return 999.0;
  return (duration * 0.0343) / 2.0;
}

void setup() {
  Serial.begin(115200);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  
  ESP32PWM::allocateTimer(0);
  lidServo.setPeriodHertz(50);
  lidServo.attach(servoPin, 500, 2500);
  lidServo.write(0); // Tampa fechada
}

void loop() {
  float distance = readDistance();
  
  // Se a mão estiver a menos de 15 cm, abre a tampa
  if (distance > 0 && distance < 15.0) {
    Serial.println("Objeto detectado: ABRINDO TAMPA");
    lidServo.write(90); // Abre a tampa em 90 graus
    delay(4000);        // Permanece aberta por 4 segundos
    
    Serial.println("FECHANDO TAMPA");
    lidServo.write(0);  // Fecha suavemente
    delay(500);
  }
  
  delay(100);
}

Procedimento de Gravação e Teste de Bancada

1. Calibre o servo no ângulo zero carregando o sketch auxiliar antes de parafusar a tampa.
2. Monte a estrutura de madeira da lixeira com o servomotor e o sensor ultrassônico.
3. Carregue o programa principal no ESP32.
4. Resultado Esperado: Aproxime a mão a 10 cm dos olhos do sensor ultrassônico. A tampa abrirá automaticamente a 90 graus, esperará 4 segundos e fechará com segurança.

---

Lição 36: Portões Inteligentes / Cancela Automática (Cancela de Estacionamento)

Os estacionamentos modernos e praças de pedágio automatizadas operam barreiras mecânicas elevatórias (Cancelas de Acesso) controladas por sensores telemétricos e microcontroladores.

Neste projeto, construímos a réplica mecatrônica de uma Cancela de Acesso Veicular. Uma haste de cancela em madeira articulada é acoplada diretamente ao eixo do micro servomotor SG90 (GPIO 27). Na base de aproximação do veículo, é montado o sensor ultrassônico telemétrico HC-SR04. Na posição fechada, a cancela repousa horizontalmente em $0^\circ$. Ao detectar a aproximação de um automóvel em miniatura a menos de $10\,\text{cm}$, o microcontrolador eleva a haste suavemente para a posição vertical de $90^\circ$, acendendo um LED verde de passagem livre e emitindo um bipe duplo de autorização. Após a passagem do veículo, a haste retorna à posição horizontal e o LED vermelho de bloqueio é reativado.

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Kit estrutural cortado a laser de Cancela de Estacionamento com haste elevatória
• 1x Micro Servomotor SG90
• 1x Sensor Ultrassônico HC-SR04
• 2x LEDs (Vermelho e Verde) com resistores de $220\,\Omega$
• 1x Buzzer ativo de 5V
• 12x Cabos jumper flexíveis fêmea-macho e macho-macho

Ligações Elétricas e Pinagem

Componente	Terminal	Pino do ESP32	Tipo de Sinal
Servomotor da Haste	Sinal Laranja	GPIO 27	Saída PPM de Movimento
Ultrassom HC-SR04	Trig / Echo	GPIO 19 / GPIO 18	Barramento Telemétrico
Sinalizador Semafórico	LED Verde / LED Vermelho	GPIO 5 / GPIO 2	Saídas Digitais de Trânsito
Buzzer Ativo	Terminal Positivo	GPIO 25	Sinalização Acústica

📦 Bibliotecas desta lição: ESP32Servo por Kevin Harrington (versão 1.1.1).

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 36: Cancela Eletrônica Veicular com Sinalização Semafórica
// ==============================================================================

#include <ESP32Servo.h>

Servo gateServo;
const int servoPin = 27;
const int trigPin = 19;
const int echoPin = 18;
const int ledGreen = 5;
const int ledRed = 2;
const int buzzerPin = 25;

float getDist() {
  digitalWrite(trigPin, LOW); delayMicroseconds(2);
  digitalWrite(trigPin, HIGH); delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  long d = pulseIn(echoPin, HIGH, 25000);
  if (d == 0) return 999.0;
  return (d * 0.0343) / 2.0;
}

void setup() {
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  pinMode(ledGreen, OUTPUT);
  pinMode(ledRed, OUTPUT);
  pinMode(buzzerPin, OUTPUT);
  
  ESP32PWM::allocateTimer(0);
  gateServo.setPeriodHertz(50);
  gateServo.attach(servoPin, 500, 2500);
  
  gateServo.write(0); // Posição horizontal (fechada)
  digitalWrite(ledRed, HIGH);
  digitalWrite(ledGreen, LOW);
}

void loop() {
  float dist = getDist();
  
  // Veículo aproximou-se a menos de 10 cm da barreira
  if (dist > 0 && dist < 10.0) {
    digitalWrite(ledRed, LOW);
    digitalWrite(ledGreen, HIGH);
    
    // Alerta sonoro de abertura
    digitalWrite(buzzerPin, HIGH); delay(100); digitalWrite(buzzerPin, LOW);
    
    // Levanta a cancela para 90 graus
    for (int a = 0; a <= 90; a += 3) {
      gateServo.write(a);
      delay(20);
    }
    
    // Aguarda o veículo passar (mantém aberta por 4 segundos)
    delay(4000);
    
    // Baixa a cancela de volta para 0 graus
    for (int a = 90; a >= 0; a -= 3) {
      gateServo.write(a);
      delay(20);
    }
    
    digitalWrite(ledGreen, LOW);
    digitalWrite(ledRed, HIGH);
  }
  
  delay(150);
}

Procedimento de Gravação e Teste de Bancada

1. Monte a estrutura de cancela de madeira com o servomotor calibrado.
2. Carregue o programa no ESP32.
3. Resultado Esperado: O semáforo manterá o LED vermelho aceso com a barra fechada. Ao aproximar um carrinho ou a mão a menos de 10 cm do sensor, o LED verde acenderá, um bipe soará e a barra se levantará a 90 graus, fechando após a passagem.

---

Lição 37: Ventilador de Cabeça Oscilante (Mecatrônica Biaxal)

Os ventiladores de torre e de pedestal residenciais utilizam mecanismos combinados para ventilar um ambiente: um motor elétrico de alta velocidade para acionar a hélice aerodinâmica e um motor secundário de baixa rotação ou servomotor para movimentar o cabeçote horizontalmente em um movimento de varredura angular (oscilação panorâmica).

Neste projeto mecatrônico biaxal, integramos o motor DC com hélice (GPIO 26) montado sobre uma plataforma giratória de madeira acionada pelo micro servomotor SG90 (GPIO 27). O controle é operado através de comandos do controle remoto infravermelho. Quando ativado, o motor DC gira continuamente criando fluxo de ar enquanto o servomotor executa um movimento pendular oscilante lento entre $40^\circ$ e $140^\circ$, distribuindo a ventilação por toda a área da sala.

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Kit estrutural de Ventilador Oscilante cortado a laser em madeira
• 1x Mini Motor DC com hélice plástica, transistor NPN, diodo 1N4007 e resistor de $1\,\text{k}\Omega$
• 1x Micro Servomotor SG90
• 1x Módulo Receptor Infravermelho AX-1838
• 1x Controle remoto infravermelho de 21 teclas
• 14x Cabos jumper flexíveis macho-fêmea e macho-macho

Ligações Elétricas e Pinagem

Atuador / Sensor	Terminal	Pino do ESP32	Tipo de Controle
Motor DC da Hélice	Base do Transistor NPN	GPIO 26	Saída PWM de Rotação
Servomotor da Base	Sinal de Controle PPM	GPIO 27	Saída de Movimento Oscilante
Receptor IR	Saída OUT	GPIO 15	Recepção de Comandos de 38 kHz
Alimentações	5V nos motores e receptor / Retornos no GND	5V e GND	Barramentos de potência

📦 Bibliotecas desta lição: ESP32Servo por Kevin Harrington (versão 1.1.1) e IRremote por ArminJo (versão 4.1.2).

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 37: Ventilador com Rotação da Hélice e Movimento Oscilante Panorâmico
// ==============================================================================

#include <ESP32Servo.h>
#include <IRremote.hpp>

Servo oscServo;
const int servoPin = 27;
const int motorPin = 26;
const int irPin = 15;

bool fanRunning = false;
bool oscillating = true;
int currentAngle = 90;
int sweepDir = 1;

void setup() {
  pinMode(motorPin, OUTPUT);
  analogWrite(motorPin, 0);
  
  IrReceiver.begin(irPin, ENABLE_LED_FEEDBACK);
  
  ESP32PWM::allocateTimer(0);
  oscServo.setPeriodHertz(50);
  oscServo.attach(servoPin, 500, 2500);
  oscServo.write(currentAngle);
}

void loop() {
  // Processa comandos do controle infravermelho
  if (IrReceiver.decode()) {
    auto cmd = IrReceiver.decodedIRData.command;
    if (cmd == 0x45) { // Tecla POWER: liga/desliga o conjunto
      fanRunning = !fanRunning;
      analogWrite(motorPin, fanRunning ? 220 : 0);
    } else if (cmd == 0x46) { // Tecla MODE: habilita/desabilita a oscilação
      oscillating = !oscillating;
    }
    IrReceiver.resume();
  }
  
  // Executa o movimento oscilante se o ventilador estiver ligado
  if (fanRunning && oscillating) {
    currentAngle += sweepDir * 2;
    if (currentAngle >= 140) sweepDir = -1;
    else if (currentAngle <= 40) sweepDir = 1;
    
    oscServo.write(currentAngle);
    delay(30);
  } else {
    delay(20);
  }
}

Procedimento de Gravação e Teste de Bancada

1. Monte o conjunto do cabeçote do motor DC sobre o acoplador do servo e parafuse a estrutura.
2. Carregue o programa no ESP32.
3. Aponte o controle remoto e pressione a tecla POWER.
4. Resultado Esperado: A hélice girará gerando vento contínuo enquanto o cabeçote oscila suavemente de 40 a 140 graus em movimento panorâmico elegante. Pressione a tecla MODE para travar a ventilação em uma direção fixa.

---

Lição 38: Piano Eletrônico (Teclado Musical com Buzzer Passivo)

Sintetizadores musicais e órgãos eletrônicos geram acordes e melodias convertendo o pressionamento de teclas em frequências acústicas de onda quadrada ou senoidal.

Neste projeto mecatrônico de encerramento do kit, montamos a estrutura em madeira do Piano Eletrônico. Uma fileira de 4 chaves tácteis tipo push-button com capas coloridas é fixada no painel superior do instrumento. Cada botão é associado a uma nota musical fundamental da escala diatônica temperada através do buzzer passivo (GPIO 25):

• Tecla 1 (GPIO 33): Nota Dó ($C_4 = 262\,\text{Hz}$)
• Tecla 2 (GPIO 32): Nota Ré ($D_4 = 294\,\text{Hz}$)
• Tecla 3 (GPIO 35): Nota Mi ($E_4 = 330\,\text{Hz}$)
• Tecla 4 (GPIO 34): Nota Fá ($F_4 = 349\,\text{Hz}$)

O algoritmo monitora as entradas digitais com velocidade de varredura superior a $1000\,\text{Hz}$. Quando qualquer tecla é pressionada, o microcontrolador ESP32 excita o buzzer passivo instantaneamente com a frequência correspondente enquanto a tecla estiver pressionada, cortando o som no momento exato em que o dedo é solto, permitindo ao usuário tocar músicas e melodias completas.

Componentes Necessários

• 1x Placa controladora ESP32 ACEBOTT
• 1x Estrutura de madeira cortada a laser do Piano Eletrônico
• 4x Chaves tácteis push-buttons com capas plásticas coloridas
• 4x Resistores de filme de carbono de $10\,\text{k}\Omega$ (resistores de pull-down)
• 1x Buzzer passivo
• 12x Cabos jumper flexíveis macho-macho

Ligações Elétricas e Pinagem

Tecla Musical	Pino de Entrada	Nota Musical Associada	Frequência Acústica (Hz)
Tecla 1 (Dó)	GPIO 33 (pull-down)	Dó (C4)	$262\,\text{Hz}$
Tecla 2 (Ré)	GPIO 32 (pull-down)	Ré (D4)	$294\,\text{Hz}$
Tecla 3 (Mi)	GPIO 35 (pull-down)	Mi (E4)	$330\,\text{Hz}$
Tecla 4 (Fá)	GPIO 34 (pull-down)	Fá (F4)	$349\,\text{Hz}$
Buzzer Passivo	GPIO 25	Saída Tone	Transdutor Sonoro Musical

📦 Bibliotecas desta lição: nenhuma — utiliza a geração por hardware nativa do comando tone() e noTone().

Código-Fonte Comentado Linha a Linha

// ==============================================================================
// Curso Kit Aprendizado Robótica ESP32 QE200 - RoboBuilders
// Lição 38: Teclado de Piano Eletrônico com Síntese Sonora
// ==============================================================================

const int buzzerPin = 25; // Pino de saída de áudio para o buzzer passivo

// Pinos de leitura das teclas musicais
const int btnDo = 33;
const int btnRe = 32;
const int btnMi = 35;
const int btnFa = 34;

// Frequências das notas em Hertz
const int NOTE_DO = 262;
const int NOTE_RE = 294;
const int NOTE_MI = 330;
const int NOTE_FA = 349;

void setup() {
  pinMode(buzzerPin, OUTPUT);
  pinMode(btnDo, INPUT);
  pinMode(btnRe, INPUT);
  pinMode(btnMi, INPUT);
  pinMode(btnFa, INPUT);
}

void loop() {
  // Avalia o pressionamento simultâneo ou individual de cada tecla
  if (digitalRead(btnDo) == HIGH) {
    tone(buzzerPin, NOTE_DO);
  } else if (digitalRead(btnRe) == HIGH) {
    tone(buzzerPin, NOTE_RE);
  } else if (digitalRead(btnMi) == HIGH) {
    tone(buzzerPin, NOTE_MI);
  } else if (digitalRead(btnFa) == HIGH) {
    tone(buzzerPin, NOTE_FA);
  } else {
    noTone(buzzerPin); // Silencia o instrumento ao soltar as teclas
  }
  
  delay(10); // Varredura de alta responsividade háptica a 100 Hz
}

Procedimento de Gravação e Teste de Bancada

1. Encaixe os 4 botões e o buzzer no chassi de madeira do piano e conclua as ligações.
2. Carregue o código na placa ESP32.
3. Resultado Esperado: Pressione cada tecla com os dedos: o piano emitirá as notas Dó, Ré, Mi e Fá com afinação limpa e resposta instantânea, permitindo a execução de toques melódicos rítmicos.

---

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

A tabela analítica a seguir reúne os sintomas mais frequentes de falhas elétricas, erros de compilação, problemas no upload de firmware e anomalias de sensores encontrados durante o desenvolvimento dos projetos do kit, acompanhados de suas causas raízes e procedimentos de correção em engenharia:

Sintoma Observado	Causa Raiz Mais Provável	Ação Corretiva Recomendada
Erro A fatal error occurred: Failed to connect to ESP32: Timed out waiting for packet header durante o upload	O chip ESP32 não conseguiu comutar automaticamente para o modo de bootloader (ROM Download Mode) através das linhas DTR/RTS da porta USB-Serial CH340.	1. Pressione e mantenha pressionado o botão físico BOOT (ou IO0) na placa controladora quando o terminal da Arduino IDE exibir Connecting....... 2. Solte o botão assim que a barra percentual de escrita começar a progredir. 3. Para uma solução definitiva de hardware, insira um capacitor eletrolítico de $10\,\mu\text{F}$ entre o pino EN e o pino GND da placa.
Porta Serial COM não aparece na lista de portas da Arduino IDE	Falta de instalação do driver USB-Serial CH340 no sistema operacional, ou utilização de cabo USB exclusivamente de carga (sem as linhas de dados D+ e D-).	1. Instale o pacote oficial de drivers executando o utilitário SETUP.EXE contido na pasta CH340 Driver File-Windows. 2. Substitua o cabo USB por um cabo certificado para dados que acompanhe o kit. 3. Teste conectar o cabo em outra porta USB traseira da placa-mãe do computador.
Monitor Serial exibe caracteres ilegíveis, pontos de interrogação ou símbolos estranhos	Divergência de taxa de transmissão em bits por segundo (baud rate) entre a instrução Serial.begin() do firmware e a configuração da janela do Monitor Serial.	Ajuste a caixa de seleção de taxa no canto superior direito do Monitor Serial da IDE Arduino para exatamente 115200 baud, que é o padrão utilizado em todas as lições do curso.
Display LCD1602 I2C acende a iluminação azul de fundo, mas não exibe qualquer letra ou caractere	1. Contraste óptico descalibrado no trimpot traseiro do módulo PCF8574. 2. Endereço hexadecimal I2C incorreto no código (usando 0x27 quando a placa é 0x3F).	1. Pegue uma chave de fenda de ponta chata e gire lentamente o potenciômetro de contraste azul na parte traseira da placa I2C até as letras pretas surgirem com nitidez. 2. Execute um código de I2C Scanner para confirmar se o endereço da sua placa é 0x27 ou 0x3F e atualize a linha LiquidCrystal_I2C lcd(0x27, 16, 2);.
Sensor DHT11 imprime constantemente nan (Not a Number) ou exibe mensagem de falha de leitura	1. Conexão física frouxa no pino de sinal GPIO 32. 2. Solicitação de leitura em intervalos inferiores a 2 segundos (desrespeitando a taxa máxima do transdutor).	1. Verifique os contatos dos fios jumper na protoboard. 2. Certifique-se de que a rotina loop() possui um delay(2000) ou mais antes de cada invocação de dht.readTemperature(), pois o sensor DHT11 aquece internamente se consultado em frequência elevada.
Micro Servomotor SG90 treme continuamente, emite ruído agudo de engrenagens ou reinicia o ESP32 ao se mover	Queda abrupta de tensão na linha de alimentação de 5V decorrente do pico de corrente transitória de partida do motor (Brownout Reset do microcontrolador).	1. Nunca alimente servomotores diretamente pelo pino de 3,3V do ESP32. 2. Utilize a linha de 5V da porta USB ou conecte a caixa de pilhas de 9V externa no conector Jack DC. 3. Instale um capacitor eletrolítico de desacoplamento de $100\,\mu\text{F}$ a $470\,\mu\text{F}$ entre os barramentos de alimentação de 5V e GND da protoboard.
Sensor Ultrassônico HC-SR04 retorna sempre 0.0 cm ou valores estáticos de 999 cm	Fios de Trigger e Echo invertidos, ou sensor alimentado com tensão insuficiente de 3,3V.	1. O sensor HC-SR04 padrão exige alimentação nominal estrita de 5,0 VDC no pino VCC para excitar os cristais piezelétricos de 40 kHz com potência suficiente. 2. Certifique-se de que o pino Trig está no GPIO 19 e o Echo no GPIO 18.
Sensor PIR detecta movimento falso contínuo mesmo com o ambiente vazio	O elemento piroelétrico ainda está em fase de calibração térmica inicial, ou o sensor está posicionado próximo à antena de rádio Wi-Fi da placa ESP32.	1. Ao energizar o circuito, afaste-se da bancada por 60 segundos completos para que os cristais de tantalato de lítio estabilizem a referência térmica. 2. Mantenha o sensor PIR a pelo menos 15 cm de distância física da antena onboard do ESP32 para evitar interferência eletromagnética (EMI) de RF.
Falha de compilação #include <ESP32Servo.h>: No such file or directory	A biblioteca especializada não foi instalada no ambiente da Arduino IDE.	Abra o menu Sketch > Incluir Biblioteca > Gerenciar Bibliotecas..., digite ESP32Servo e instale a versão 1.1.1 mantida por Kevin Harrington.
O aplicativo móvel Android não consegue conectar ao Bluetooth do ESP32	Conflito com conexões BLE abertas ou falta de permissão de localização/dispositivos próximos no sistema Android.	1. Certifique-se de que a placa executou com sucesso a instrução SerialBT.begin("ESP32_LED_Control");. 2. Acesse as configurações de Bluetooth do smartphone Android e realize o pareamento prévio do dispositivo antes de abrir o aplicativo Bluetooth_light.apk. 3. Conceda permissão de Localização e Dispositivos Próximos nas configurações do aplicativo.

Solução de problemas

Olá! Sou o assistente técnico da RoboBuilders. Descreva seu problema com o Kit Aprendizado Robótica ESP32 34 Projetos RB2343 QE200 – 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.