Kit Avançado 27 Tutoriais Placa Uno Compatível Com Arduino AE314 RB2687

Introdução

Este curso profissional apresenta uma formação técnica completa e progressiva em computação física, sistemas embarcados e engenharia de controle utilizando a plataforma de prototipagem Arduino Uno R3 e o Kit Avançado 27 Tutoriais Placa Uno Compatível com Arduino AE314 RB2687 (Super Learning Kit AE314 da Kuongshun). Ao longo de 27 projetos estruturados, são explorados desde os conceitos fundamentais de eletrônica analógica e digital até arquiteturas avançadas de automação, incluindo modulação por largura de pulso (PWM — Pulse Width Modulation), multiplexação de sinais por registradores de deslocamento, comunicação mestre-escravo por barramento I2C (Inter-Integrated Circuit), decodificação de pacotes infravermelhos (IR — Infrared) e controle de potência com pontes H e drivers Darlington.

O conteúdo foi desenvolvido sob rigorosos critérios da engenharia eletrônica, servindo tanto a estudantes e entusiastas quanto a projetistas que necessitam dominar a integração de sensores, displays, motores DC, servo motores e motores de passo unipolares. Cada projeto é apresentado de forma auto-contida nesta página única, contendo fundamentação física, tabela analítica de pinagem, diagramas esquemáticos com montagem prática em matriz de contatos (breadboard), código-fonte em linguagem C++ comentado linha por linha e procedimentos de depuração e validação experimental.

O que você vai aprender:

• Compreender a arquitetura interna do microcontrolador ATmega328P, temporizadores, registradores e conversores ADC
• Dominar a leitura e condicionamento de sinais analógicos e digitais de sensores ambientais, acústicos, ópticos e mecânicos
• Implementar controle de potência e sentido de rotação para motores DC, servomotores angulares e motores de passo 28BYJ-48
• Expandir as portas de entrada e saída (I/O) do microcontrolador utilizando registradores de deslocamento 74HC595
• Projetar interfaces homem-máquina eficientes com teclados matriciais 4x4, displays alfanuméricos LCD 16x2 I2C e displays de 7 segmentos multiplexados
• Decodificar protocolos de comunicação sem fio infravermelho (NEC) para acionamento remoto de cargas
• Aplicar boas práticas de desacoplamento elétrico, proteção contra transientes indutivos e eliminação de ruídos eletromagnéticos

Material utilizado: Kit Avançado 27 Tutoriais Placa Uno Compatível Com Arduino AE314 RB2687

---

Visão Geral da Arquitetura de Hardware e Kit AE314 RB2687

A plataforma Arduino Uno R3 é construída com base no microcontrolador de 8 bits ATmega328P da família AVR da Microchip (antiga Atmel), operando a uma frequência de clock de 16 MHz gerada por um ressonador cerâmico externo. Essa arquitetura do tipo Harvard modificada possui barramentos separados de instruções e de dados, permitindo a execução da maioria das instruções em um único ciclo de máquina e alcançando um desempenho de até 16 MIPS (Million Instructions Per Second).

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

Parâmetro de Engenharia	Especificação Técnica	Observações de Operação
Microcontrolador Principal	ATmega328P (8-bit AVR RISC)	Encapsulamento DIP-28 ou SMD
Tensão Lógica de Operação	5,0 VDC	Nível TTL padrão de entrada/saída
Tensão de Entrada Recomendada (VIN / Jack P4)	7,0 V a 12,0 VDC	Regulador linear interno LDO onboard
Tensão de Entrada Limite (VIN)	6,0 V a 20,0 VDC	Acima de 12V gera sobreaquecimento no LDO
Pinos de Entrada/Saída Digital (GPIO)	14 pinos (D0 a D13)	6 pinos suportam PWM de 8 bits por hardware
Pinos de Entrada Analógica	6 canais (A0 a A5)	Resolução de 10 bits (0 a 1023 passos)
Corrente Máxima por Pino de I/O	20 mA (típico), 40 mA (absoluto)	Não exceder 200 mA na soma de todos os pinos
Corrente Máxima na Saída de 3,3V	50 mA	Alimentada pelo chip USB ou LDO auxiliar
Memória Flash de Programa	32 KB	0,5 KB ocupados pelo bootloader Optiboot
Memória SRAM de Dados Voláteis	2 KB	Armazenamento de variáveis em tempo de execução
Memória EEPROM Não-Volátil	1 KB	Armazenamento persistente de configurações
Frequência de Clock do Núcleo	16 MHz (±0,5%)	Cristal oscilador externo de alta estabilidade
Interface de Comunicação Serial / USB	Chip CH340G / CP2102 / ATmega16U2	Conversão UART-USB assíncrona full-speed

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

O Kit Avançado AE314 RB2687 (Super Learning Kit da Kuongshun) reúne uma coleção completa de módulos, circuitos integrados, atuadores e sensores de precisão para realização dos 27 projetos práticos do curso:

• 1x Placa compatível com Arduino Uno R3 (microcontrolador ATmega328P com interface USB CH340)
• 1x Cabo USB de comunicação e programação Tipo A para Tipo B (50 cm)
• 1x Matriz de contatos (Breadboard / Protoboard) de 830 pontos com trilhas duplas de alimentação destacáveis
• 65x Cabos jumper flexíveis macho-macho de comprimentos variados
• 10x Cabos jumper fêmea-macho para conexão rápida de sensores (20 cm)
• 1x Módulo de fonte de alimentação regulada para protoboard (3,3V / 5V com chave seletora)
• 1x Conector de bateria 9V com plug Jack P4 padrão (5,5mm × 2,1mm)
• 1x Display LCD 16x2 com módulo adaptador serial I2C soldado (controlador PCF8574)
• 1x Display de 7 segmentos de 1 dígito (cátodo comum)
• 1x Display de 7 segmentos de 4 dígitos multiplexado (cátodo comum)
• 1x Módulo Matriz de LEDs 8x8 com circuito integrado de controle MAX7219
• 1x Circuito Integrado registrador de deslocamento serial-paralelo de 8 bits 74HC595
• 1x Circuito Integrado Ponte H dupla para acionamento de motores L293D
• 1x Placa controladora com circuito integrado driver Darlington ULN2003A e LEDs de fase
• 1x Micro Servo Motor SG90 de 9g com curso de 180° (com cruzetas e parafusos de fixação)
• 1x Motor de Passo Unipolar de 4 Fases 28BYJ-48 (5V DC com redução 1:64)
• 1x Mini Motor DC 5V de alta rotação
• 1x Hélice plástica aerodinâmica de 4 pás para motor DC
• 1x Módulo Relé de 1 Canal 5V com optoacoplamento e saídas NA/NF
• 1x Buzzer eletromagnético ativo (5V contínuo)
• 1x Buzzer piezoelétrico passivo (geração de frequências e melodias via PWM)
• 1x Sensor digital calibrado de temperatura e umidade DHT11
• 1x Sensor telemétrico ultrassônico de distância HC-SR04 (alcance de 2 cm a 400 cm)
• 1x Módulo sensor detector de som com microfone de eletreto e comparador LM393 com ajuste de sensibilidade
• 1x Módulo sensor de nível resistivo de água / chuva
• 1x Módulo sensor receptor infravermelho integrado AX-1838HS (38 kHz)
• 1x Controle remoto infravermelho (IR) multifunção de 21 teclas (com bateria inclusa)
• 1x Módulo analógico Joystick de 2 eixos (potenciômetros bidirecionais X/Y + chave táctil push-button Z)
• 2x Sensores de inclinação e vibração por chave de esfera metálica (Tilt Ball Switch SW-520D)
• 1x Sensor de temperatura analógico NTC (termistor de precisão 10 kΩ)
• 3x Fotocélulas fotoresistivas LDR de 5mm (sensores de luminosidade)
• 5x Chaves tácteis tipo push-button de 4 pinos (12 mm × 12 mm)
• 5x Capas protetoras em plástico ABS para push-buttons (cores variadas)
• 1x Potenciômetro rotativo linear de 10 kΩ com haste metálica
• 5x Diodos Emissores de Luz (LED) vermelhos difusos de 5mm
• 5x Diodos Emissores de Luz (LED) verdes difusos de 5mm
• 5x Diodos Emissores de Luz (LED) amarelos difusos de 5mm
• 5x Diodos Emissores de Luz (LED) azuis difusos de 5mm
• 5x Diodos Emissores de Luz (LED) brancos difusos de 5mm
• 1x LED tricolor RGB difuso de 5mm (cátodo comum e 4 pinos)
• 10x Resistores de filme de carbono de 100 Ω (1/4W - 5%)
• 10x Resistores de filme de carbono de 220 Ω (1/4W - 5%)
• 10x Resistores de filme de carbono de 1 kΩ (1/4W - 5%)
• 10x Resistores de filme de carbono de 10 kΩ (1/4W - 5%)
• 1x Estojo plástico organizador com travas e divisórias internas

📦 Somatória Geral do Kit: 187 componentes individuais (distribuídos em 45 categorias de itens funcionais, circuitos integrados, cablagem, sensores e atuadores).

---

Módulo 0 — Preparação do Ambiente e Ferramental de Software

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

Para programar o microcontrolador ATmega328P, utilizaremos a IDE Arduino (versão 2.x ou clássica 1.8.x), que integra o editor de código-fonte, a cadeia de ferramentas de compilação GCC (AVR-GCC), o utilitário de gravação de firmware AVRDUDE e o Monitor Serial.

Etapa 1: Instalação da IDE

1. Acesse o portal oficial arduino.cc/en/software e baixe a versão compatível com seu sistema operacional (Windows Installer, macOS DMG ou Linux AppImage).
2. Execute o instalador, aceite os termos de licença GNU e certifique-se de marcar todas as caixas de seleção, incluindo a instalação dos drivers USB padrão e atalhos de sistema.

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

Muitas placas Arduino Uno R3 utilizam o circuito integrado conversor CH340G no lugar do microcontrolador ATmega16U2 para comunicação serial. Se a sua placa não for reconhecida automaticamente pelo Gerenciador de Dispositivos do Windows (aparecendo como “Dispositivo Desconhecido” ou “USB2.0-Serial”):

1. Baixe o instalador oficial do driver CH340: CH341SER.EXE (ou no formato compactado CH341SER.zip).
2. Abra o executável com privilégios de administrador e clique no botão INSTALL.
3. Conecte o cabo USB da placa ao computador. Abra o Gerenciador de Dispositivos do Windows e expanda o item Portas (COM e LPT): a placa deverá figurar como USB-SERIAL CH340 (COMx), onde x é o número da porta atribuída pelo sistema operacional.

---

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

Nesta lição, você aprenderá dois pilares fundamentais no desenvolvimento profissional com Arduino: como gerenciar e instalar bibliotecas de software (C++) e como dominar a Comunicação Serial UART utilizando o Monitor Serial e o Serial Plotter da IDE Arduino para depuração e interação em tempo real.

---

1. O que são Bibliotecas e Como Instalá-las

As bibliotecas são pacotes de código C++ pré-compilados ou em código-fonte aberto que encapsulam rotinas complexas de baixo nível — como controle de registradores, temporizações em microssegundos e protocolos de comunicação (I2C, SPI, 1-Wire, UART). Elas evitam que você precise “reinventar a roda” a cada projeto, oferecendo funções simples e de alto nível como lcd.print("RoboBuilders") ou servo.write(90).

Existem três maneiras de incluir bibliotecas no ecossistema Arduino:

1. Pelo Gerenciador de Bibliotecas da IDE (Recomendado):

   • Acesse o menu Sketch -> Incluir Biblioteca -> Gerenciar Bibliotecas… (ou use o atalho Ctrl + Shift + I).
   • No campo de busca, digite o nome do sensor ou dispositivo (ex.: LiquidCrystal I2C, DHT sensor library, IRremote).
   • Localize a biblioteca oficial/recomendada e clique em Instalar. A IDE baixa e configura automaticamente todas as dependências.

2. Por Arquivo Compactado (.ZIP):

   • Se o fabricante forneceu uma biblioteca em arquivo .zip (como no kit AE314), acesse Sketch -> Incluir Biblioteca -> Adicionar Biblioteca .ZIP….
   • Selecione o arquivo no seu computador. A IDE descompactará os arquivos diretamente na sua pasta Documentos/Arduino/libraries.

3. Instalação Manual em Diretório:

   • Descompacte a pasta da biblioteca diretamente dentro do diretório Documentos/Arduino/libraries/ e reinicie a IDE Arduino.

---

2. O que é o Monitor Serial e Para que Serve?

O Monitor Serial é o canal de comunicação direto entre a placa Arduino e o seu computador via cabo USB. No circuito do Arduino Uno R3, o microcontrolador ATmega328P se comunica utilizando o protocolo assíncrono UART (Universal Asynchronous Receiver-Transmitter) através de dois pinos dedicados:

• Pino Digital 0 (RX — Receiver): Recebe dados enviados do computador para o microcontrolador.
• Pino Digital 1 (TX — Transmitter): Transmite dados do microcontrolador para a tela do computador.

O chip conversor USB-Serial (CH340 ou ATmega16U2) converte esses pulsos de 0V/5V em pacotes USB reconhecidos pelo sistema operacional como uma porta COM virtual.

Principais Aplicações do Monitor Serial:

1. Depuração e Diagnóstico (Debugging): Visualizar leituras brutas de sensores, verificar se o código entrou em uma estrutura if/else ou acompanhar contadores em tempo real.
2. Interface de Comandos: Digitar caracteres, números ou palavras no computador para que o Arduino execute tarefas (ex.: ligar relé ao digitar ‘L’, desligar ao digitar ‘D’).
3. Calibração de Sensores: Observar o valor analógico de sensores de luz (LDR), temperatura ou som no ambiente para ajustar os limiares de acionamento.

---

3. Como Abrir e Configurar o Monitor Serial

1. Abrir o Monitor Serial:

   • Clique no ícone de lupa no canto superior direito da IDE Arduino ou utilize o atalho de teclado Ctrl + Shift + M.

2. Configurar a Taxa de Transmissão (Baud Rate):

   • No canto inferior direito da janela do Monitor Serial, há um seletor de velocidade. A taxa padrão mais utilizada é 9600 baud (9600 bits por segundo).
   • Regra de Ouro: O valor configurado no seletor da janela DEVE ser exatamente o mesmo configurado no seu código em Serial.begin(9600);. Caso haja divergência (ex.: código a 9600 e monitor a 115200), você verá apenas caracteres corrompidos e ilegíveis (como ⸮⸮⸮ ou símbolos truncados).

3. Configurar o Finalizador de Linha (Line Ending):

   • Sem fim de linha (No line ending): Envia apenas os caracteres digitados.
   • Nova linha (Newline \n): Adiciona o caractere de quebra de linha 0x0A.
   • Retorno de carro (Carriage Return \r): Adiciona o caractere 0x0D.
   • Ambos NL & CR (\r\n): Envia os dois finalizadores padrão do Windows. Útil quando você deseja detectar o fim de um comando com Serial.readStringUntil('\n').

4. Ferramenta Serial Plotter (Traçador Gráfico):

   • Acesse Ferramentas -> Serial Plotter ou tecle Ctrl + Shift + L.
   • Ao imprimir números na serial seguidos de Serial.println(), a IDE desenha um gráfico dinâmico em forma de onda em tempo real (ideal para sensores de distância, sinais sonoros e oscilações de temperatura).

---

4. Funções Essenciais de Programação Serial

Função C++	Descrição e Comportamento
Serial.begin(9600);	Inicializa a interface UART a 9600 bps no setup().
Serial.print(dado);	Envia o dado (texto, número, variável) sem quebrar linha.
Serial.println(dado);	Envia o dado e adiciona uma quebra de linha (\r\n) ao final.
Serial.println(valor, HEX);	Imprime um número em base hexadecimal (ex.: 255 vira FF).
Serial.println(valor, BIN);	Imprime um número em base binária (ex.: 5 vira 101).
Serial.println(pi, 4);	Imprime um número float com 4 casas decimais de precisão.
Serial.available()	Retorna o número de bytes recebidos que estão esperando no buffer da serial.
Serial.read()	Lê o primeiro caractere disponível no buffer de entrada.
Serial.parseInt()	Converte e extrai automaticamente o próximo número inteiro digitado.

---

O programa a seguir ilustra a inicialização do canal serial, a transmissão contínua de telemetria com temporização via millis(), e a recepção de comandos do usuário:

/*
 * CURSO ARDUINO UNO R3 AE314 - ROBOBUILDERS
 * Lição 1: Demonstração Completa de Comunicação Serial Bidirecional
 * Autor: Engenheiro Especialista em Sistemas Embarcados
 */

// Variáveis de controle de tempo não-bloqueante
unsigned long tempoAnterior = 0;
const unsigned long intervaloTelemetria = 1000; // Envia dados a cada 1 segundo (1000ms)
unsigned long contadorCiclos = 0;

void setup() {
  // 1. Inicializa o barramento serial com taxa de 9600 bits por segundo
  Serial.begin(9600);

  // Aguarda a estabilização da conexão USB
  while (!Serial) {
    ; // Necessário para placas com USB nativo (Leonardo, Micro, etc.)
  }

  // 2. Imprime o cabeçalho de boas-vindas do sistema
  Serial.println(F("=================================================="));
  Serial.println(F("  CURSO ARDUINO UNO R3 - MONITOR SERIAL ATIVO    "));
  Serial.println(F("  RoboBuilders - Engenharia e Computacao Fisica   "));
  Serial.println(F("=================================================="));
  Serial.println(F("Instrucoes:"));
  Serial.println(F(" - Digite '1' para LIGAR o LED da placa (Pino 13)"));
  Serial.println(F(" - Digite '0' para DESLIGAR o LED da placa"));
  Serial.println(F(" - Digite 'T' para solicitar a leitura de telemetria"));
  Serial.println(F("--------------------------------------------------"));

  // Configura o pino do LED onboard como saída
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, LOW);
}

void loop() {
  unsigned long tempoAtual = millis();

  // Rotina 1: Telemetria Periódica Automática (Sem usar delay)
  if (tempoAtual - tempoAnterior >= intervaloTelemetria) {
    tempoAnterior = tempoAtual;
    contadorCiclos++;

    // Leitura analógica de referência (ex.: ruído do pino A0 desconectado)
    int valorA0 = analogRead(A0);
    float tensaoA0 = (valorA0 * 5.0) / 1023.0;

    Serial.print(F("[TELEMETRIA #"));
    Serial.print(contadorCiclos);
    Serial.print(F("] Tempo Ativo: "));
    Serial.print(tempoAtual / 1000);
    Serial.print(F("s | Leitura A0: "));
    Serial.print(valorA0);
    Serial.print(F(" ("));
    Serial.print(tensaoA0, 2);
    Serial.println(F(" V)"));
  }

  // Rotina 2: Recepção e Tratamento de Comandos do Teclado
  if (Serial.available() > 0) {
    char comandoRecebido = Serial.read();

    // Processamento do comando
    switch (comandoRecebido) {
      case '1':
        digitalWrite(LED_BUILTIN, HIGH);
        Serial.println(F(">> [RESPOSTA]: LED D13 ATIVADO com sucesso!"));
        break;

      case '0':
        digitalWrite(LED_BUILTIN, LOW);
        Serial.println(F(">> [RESPOSTA]: LED D13 DESATIVADO!"));
        break;

      case 'T':
      case 't':
        Serial.print(F(">> [STATUS DO SISTEMA]: Memoria SRAM livre: "));
        Serial.println(F("OK | Clock: 16MHz"));
        break;

      case '\r':
      case '\n':
        // Ignora quebras de linha enviadas pelo teclado
        break;

      default:
        Serial.print(F(">> [AVISO]: Comando '"));
        Serial.print(comandoRecebido);
        Serial.println(F("' nao reconhecido. Use 1, 0 ou T."));
        break;
    }
  }
}

---

Tabela-Mestre de Bibliotecas do Curso

Todas as bibliotecas usadas nos 27 projetos, com versão fixada. Instale pela via do Gerenciador (recomendado) ou pelo ZIP da pasta 4.libraries do kit Kuongshun. Cada lição repete seu box próprio antes do código.

Biblioteca (#include)	Buscar no Gerenciador	Versão usada no curso	Download ZIP (espelho oficial)	Lições
SimpleDHT.h (SimpleDHT)	SimpleDHT por Winlin	1.0.2	winlinvip/SimpleDHT (Code > Download ZIP) ou ZIP do kit	9
IRremote.h (IRremote)	IRremote por shirriff	2.8.1 (série 2.x — NUNCA 3.x/4.x)	Arduino-IRremote/Arduino-IRremote ou ZIP do kit	10, 27
Servo.h (Servo)	embutida na IDE	1.1.2 (equivale à embutida)	ZIP Servo.zip do kit	11
SR04.h (SR04)	SR04 por Martin Sosic	série 1.x (ZIP do kit sem versionamento)	ZIP HC-SR04.zip do kit	14
Keypad.h (Keypad)	Keypad por Mark Stanley, Alexander Brevig	3.1.1	Chris—A/Keypad (Code > Download ZIP) ou ZIP do kit	16
LiquidCrystal_I2C.h (LiquidCrystal_I2C + Wire)	LiquidCrystal I2C por Frank de Brabander	1.1.2	fdebrabander/Arduino-LiquidCrystal-I2C-library ou ZIP do kit	20, 21
Stepper.h (Stepper)	embutida na IDE	1.1.3 (equivale à embutida)	ZIP Stepper.zip do kit	26, 27
pitches.h (aba do sketch)	não é Gerenciador — aba do sketch	tabela oficial Arduino	pitches.h oficial ou ZIP pitches.zip do kit	8

⚠️ Atenção: o código das Lições 10 e 27 usa a API IRrecv/decode_results, que só existe na série 2.x do IRremote. Fixe a versão 2.8.1 no menu do Gerenciador e nunca instale a latest (3.x/4.x) nessas lições. O DHT sensor library da Adafruit NÃO serve para a Lição 9 — use o SimpleDHT 1.0.2.

---

Módulo 1 — Fundamentos Digitais, Temporização e Modulação PWM

---

Projeto 1 (Lição 2): LED Piscante (Blink) e Controle de Saídas Digitais

O projeto clássico Blink é a porta de entrada para a computação física, permitindo validar o fluxo completo de compilação, transmissão de binários via bootloader e controle dos transistores internos de chaveamento dos pinos de I/O do microcontrolador ATmega328P.

Fundamentação Física e Teoria Eletrônica

A corrente no LED é limitada pelo resistor em série segundo a Lei de Ohm:

$$I_{LED} = \frac{V_{CC} - V_F}{R}$$

onde $V_{CC} = 5\,\text{V}$ é a alimentação, $V_F \approx 2\,\text{V}$ é a queda direta no LED e $R$ é o resistor em série. Com $R = 220\,\Omega$:

$$I_{LED} = \frac{5 - 2}{220} \approx 13{,}6\,\text{mA}$$

valor seguro, abaixo do limite de $20\,\text{mA}$ por pino do ATmega328P. Os pinos digitais do Arduino Uno podem assumir dois estados lógicos: HIGH (+5,0V) ou LOW (0V/GND). Um diodo emissor de luz (LED) é um componente semicondutor de junção P-N que emite fótons quando polarizado diretamente. No entanto, os LEDs possuem uma curva característica não-linear com baixíssima resistência dinâmica após atingir sua tensão de condução ((forward voltage $V_f \approx 1{,}8\text{V} \text{ a } 2{,}2\text{V}$ para LEDs vermelhos)). Conectar um LED diretamente entre os 5V e o GND sem um resistor de limitação de corrente causará uma corrente excessiva que destruirá a junção do LED e danificará a porta do microcontrolador.

A determinação do resistor de proteção é feita pela Lei de Ohm:

$$R = \frac{V_{CC} - V_f}{I_f} = \frac{5{,}0\text{V} - 2{,}0\text{V}}{0{,}015\text{A}} = \frac{3{,}0\text{V}}{0{,}015\text{A}} = 200\,\Omega \quad (\text{Resistor adotado: } 220\,\Omega)$$

Portanto, utilizamos o resistor padrão comercial de 220 Ω presente no kit.

Tabela de Componentes Necessários

Componente	Quantidade	Descrição / Especificação
Placa Arduino Uno R3	1	Microcontrolador ATmega328P com cabo USB
Matriz de Contatos (Breadboard)	1	830 pontos de conexão
LED Difuso Vermelho 5mm	1	V_f = 2,0V, I_f = 15mA
Resistor de Filme de Carbono	1	220,Ω, 1/4W (tolerância 5% ou 1%)
Cabos Jumper Macho-Macho	2	Condutores flexíveis de ligação

Diagrama Esquemático e Ligação na Protoboard

Tabela de Pinagem e Conexões

Terminal do Componente	Conexão no Arduino Uno	Função do Sinal
Ânodo do LED (terminal longo)	Pino Digital 10 (via resistor 220 Ω)	Saída digital controlada por software
Cátodo do LED (terminal curto / chanfro)	Pino GND (Terra)	Referência de 0V comum do circuito

📦 Bibliotecas desta lição: nenhuma — o código usa digitalWrite()/delay() nativos, sem biblioteca externa.

Código-Fonte Completo (.ino) com Análise Linha a Linha

// ============================================================================
// PROJETO 1 (LIÇÃO 2) — LED PISCANTE (BLINK)
// RoboBuilders — Curso Intermediário Para Arduino Uno R3
// ============================================================================

// Declaração da constante que armazena o número do pino digital conectado ao LED
const int pinoLed = 10;

void setup() {
  // Configura a direção do pino digital como SAÍDA (OUTPUT)
  // Isso habilita os transistores internos de acionamento em modo push-pull
  pinMode(pinoLed, OUTPUT);


void loop() {
  // Coloca o pino digital em nível lógico ALTO (5V), acendendo o LED
  digitalWrite(pinoLed, HIGH);
  
  // Pausa a execução do microcontrolador por 1000 milissegundos (1 segundo)
  delay(1000);
  
  // Coloca o pino digital em nível lógico BAIXO (0V), apagando o LED
  digitalWrite(pinoLed, LOW);
  
  // Pausa a execução do microcontrolador por mais 1000 milissegundos (1 segundo)
  delay(1000);

Procedimento de Teste e Validação

1. Monte o circuito na matriz de contatos com o cabo USB desconectado;
2. Conecte o cabo USB ao computador e selecione a porta COM correspondente na IDE Arduino;
3. Clique no botão Carregar (Upload). O LED conectado ao pino 10 e o LED onboard L (conectado ao pino 13) piscarão a cada 1 segundo alternadamente.

💡 Dica: Experimente alterar os parâmetros da função delay() para 200 milissegundos para gerar um efeito estroboscópico de sinalização de emergência.

---

Projeto 2 (Lição 3): Controle de Brilho de LED com PWM e Modulação por Largura de Pulso

Os microcontroladores não possuem conversores digital-analógico (DAC) nativos nas suas saídas para gerar tensões analógicas contínuas variáveis. Para contornar essa restrição, utiliza-se a técnica de Modulação por Largura de Pulso (PWM).

Teoria da Modulação por Largura de Pulso (PWM)

O ciclo de trabalho (duty cycle) e a tensão média sobre a carga são:

$$D = \frac{t_{ON}}{T} = \frac{t_{ON}}{t_{ON} + t_{OFF}}$$ $$V_{med} = D \cdot V_{CC}$$

Com analogWrite(pino, 127), $D = 127/255 \approx 0{,}50$ e $V_{med} \approx 2{,}5\,\text{V}$ — metade do brilho máximo. O PWM gera uma onda quadrada de frequência fixa (aproximadamente 490 Hz nos pinos 3, 9, 10 e 11 do Uno, e 980 Hz nos pinos 5 e 6), variando a fração de tempo em que o sinal permanece em nível alto durante cada ciclo de período (T). Essa razão é denominada Ciclo de Trabalho (Duty Cycle):

$$\text{Duty Cycle (\%)} = \frac{t_{ON}}{T} \times 100\%$$

A tensão média aparente aplicada à carga é proporcional ao ciclo de trabalho:

$$V_{med} = V_{CC} \times \frac{\text{Duty Cycle}}{100}$$

Como a frequência de chaveamento é superior à persistência retiniana humana (~60 Hz), o olho humano percebe a variação da tensão média como uma alteração suave na intensidade luminosa do LED (fading). Na biblioteca padrão do Arduino, a função analogWrite(pino, valor) aceita valores de 8 bits entre 0 (0% Duty Cycle, 0V) e 255 (100% Duty Cycle, 5V).

Tabela de Componentes Necessários

Componente	Quantidade	Descrição / Especificação
Placa Arduino Uno R3	1	Microcontrolador ATmega328P
Matriz de Contatos (Breadboard)	1	830 pontos
LED Difuso Verde 5mm	1	V_f = 2,2V, I_f = 15mA
Resistor de Limitação	1	220,Ω, 1/4W
Cabos Jumper Macho-Macho	2	Condutores flexíveis

Montagem Física na Protoboard

📦 Bibliotecas desta lição: nenhuma — o código usa analogWrite() nativo (PWM por hardware), sem biblioteca externa.

Código-Fonte Completo (.ino) com Análise Linha a Linha

// ============================================================================
// PROJETO 2 (LIÇÃO 3) — CONTROLE DE BRILHO POR PWM (FADING)
// RoboBuilders — Curso Intermediário Para Arduino Uno R3
// ============================================================================

// O pino 9 suporta modulação PWM por hardware (marcado com símbolo til '~')
const int pinoLed = 9;

// Variável para armazenar o valor do brilho atual (0 a 255)
int brilho = 0;

// Quantidade de incremento/decremento a cada iteração do loop
int passo = 5;

void setup() {
  // Configura o pino 9 como saída digital
  pinMode(pinoLed, OUTPUT);


void loop() {
  // Aplica a modulação PWM no pino 9 com o ciclo de trabalho atual
  analogWrite(pinoLed, brilho);

  // Incrementa ou decrementa o valor do brilho
  brilho = brilho + passo;

  // Inverte a direção do esmaecimento quando atinge os extremos da escala
  if (brilho <= 0 || brilho >= 255) {
    passo = -passo; // Inverte o sinal do passo (+5 vira -5, ou vice-versa)
  

  // Pausa de 30 milissegundos para tornar a transição visualmente suave
  delay(30);

---

Projeto 3 (Lição 4): Mistura de Cores com LED RGB e Síntese Aditiva

Um LED RGB integra três pastilhas semicondutoras distintas em um único invólucro plástico: uma emissora de luz Vermelha (Red), uma Verde (Green) e uma Azul (Blue).

Teoria da Síntese Aditiva de Cores

Baseando-se no modelo de cores tricromático aditivo RGB, a combinação das três cores primárias em diferentes proporções de intensidade luminosa permite gerar qualquer cor do espectro visível.

• Vermelho + Verde = Amarelo
• Vermelho + Azul = Magenta
• Verde + Azul = Ciano
• Vermelho + Verde + Azul na potência máxima = Branco Puro

O LED fornecido no Kit AE314 é do tipo Cátodo Comum (Common Cathode), onde o terminal mais longo é conectado diretamente ao GND (0V), e os outros três terminais correspondem aos ânodos das cores Vermelha, Verde e Azul.

Tabela de Componentes Necessários

Componente	Quantidade	Descrição / Especificação
Placa Arduino Uno R3	1	Microcontrolador ATmega328P
Matriz de Contatos (Breadboard)	1	830 pontos
LED RGB 5mm (Cátodo Comum)	1	Terminais R, GND, G, B
Resistores de Limitação de Corrente	3	220,Ω, 1/4W (um para cada canal de cor)
Cabos Jumper Macho-Macho	4	Conexões de sinal e terra

Diagrama de Ligação e Montagem Física

Tabela de Conexões de Pinos

Terminal do LED RGB	Pino do Arduino Uno	Função	Resistor em Série
Vermelho (R)	Pino Digital 6 (PWM)	Canal de modulação cor vermelha	220 Ω
Cátodo Comum (GND - terminal longo)	Pino GND	Referência de 0V comum	Direto ao terra
Verde (G)	Pino Digital 5 (PWM)	Canal de modulação cor verde	220 Ω
Azul (B)	Pino Digital 3 (PWM)	Canal de modulação cor azul	220 Ω

📦 Bibliotecas desta lição: nenhuma — o código usa analogWrite() nativo nos pinos 3, 5 e 6, sem biblioteca externa.

Código-Fonte Completo (.ino) com Análise Linha a Linha

// ============================================================================
// PROJETO 3 (LIÇÃO 4) — SÍNTESE DE CORES COM LED RGB
// RoboBuilders — Curso Intermediário Para Arduino Uno R3
// ============================================================================

// Definição dos pinos PWM conectados a cada canal de cor do LED RGB
#define PINO_AZUL  3
#define PINO_VERDE 5
#define PINO_VERM  6

// Protótipo de função auxiliar para aplicação direta das intensidades RGB
void definirCor(int r, int g, int b) {
  analogWrite(PINO_VERM,  r); // Controla o Duty Cycle do canal vermelho (0-255)
  analogWrite(PINO_VERDE, g); // Controla o Duty Cycle do canal verde (0-255)
  analogWrite(PINO_AZUL,  b); // Controla o Duty Cycle do canal azul (0-255)


void setup() {
  // Configura os três pinos de controle de cor como saídas digitais
  pinMode(PINO_VERM, OUTPUT);
  pinMode(PINO_VERDE, OUTPUT);
  pinMode(PINO_AZUL, OUTPUT);


void loop() {
  // 1. Vermelho Puro
  definirCor(255, 0, 0);
  delay(1000);

  // 2. Verde Puro
  definirCor(0, 255, 0);
  delay(1000);

  // 3. Azul Puro
  definirCor(0, 0, 255);
  delay(1000);

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

  // 5. Ciano (Verde + Azul)
  definirCor(0, 255, 255);
  delay(1000);

  // 6. Magenta (Vermelho + Azul)
  definirCor(255, 0, 255);
  delay(1000);

  // 7. Branco Puro (Todas as cores ativas)
  definirCor(255, 255, 255);
  delay(1000);

  // 8. Transição suave (Fade) entre cores primárias
  for (int i = 0; i < 255; i++) {
    definirCor(255 - i, i, 0); // Transita de Vermelho para Verde
    delay(10);
  
  for (int i = 0; i < 255; i++) {
    definirCor(0, 255 - i, i); // Transita de Verde para Azul
    delay(10);
  
  for (int i = 0; i < 255; i++) {
    definirCor(i, 0, 255 - i); // Transita de Azul para Vermelho
    delay(10);
  

---

Módulo 2 — Entradas Digitais, Sensores Eletromecânicos e Sinais Sonoros

---

Projeto 4 (Lição 5): Leitura de Entradas Digitais com Botões Push-Button e Pull-Up Interno

A leitura de sinais binários de sensores de contato seco e botões de pressão (push-buttons) é fundamental para a interação usuário-máquina e fins de curso em robótica.

Teoria de Estados Flutuantes e Resistores de Pull-Up

Quando um pino digital é configurado como entrada (INPUT), sua impedância interna é extremamente elevada (~100 MΩ). Se o pino for deixado sem conexão definida (circuito aberto), ele atuará como uma antena captando ruído eletromagnético ambiente, oscilando imprevisivelmente entre HIGH e LOW (estado flutuante ou floating).

Para garantir um estado elétrico determinístico quando a chave estiver aberta, utiliza-se um resistor de Pull-Up (que puxa a tensão para +5V) ou Pull-Down (que puxa para GND). O microcontrolador ATmega328P possui resistores de pull-up internos ativáveis por software (INPUT_PULLUP) com valor típico entre 20 kΩ e 50 kΩ, eliminando a necessidade de componentes externos na placa.

Quando configurado como INPUT_PULLUP:

• Botão Solto (Aberto): O pino lê HIGH (5V através do resistor interno de pull-up).
• Botão Pressionado (Fechado): O pino é aterrado diretamente e lê LOW (0V). Essa é a chamada Lógica Invertida (Active-LOW).

Tabela de Componentes Necessários

Componente	Quantidade	Descrição / Especificação
Placa Arduino Uno R3	1	Microcontrolador ATmega328P
Matriz de Contatos (Breadboard)	1	830 pontos
Chaves Táteis Push-Button 12x12mm	2	Botão A (liga) e Botão B (desliga)
LED Difuso Amarelo 5mm	1	V_f = 2,0V
Resistor de Limitação	1	220,Ω, 1/4W
Cabos Jumper Macho-Macho	5	Condutores flexíveis

Montagem Física na Protoboard

📦 Bibliotecas desta lição: nenhuma — o código usa digitalRead() e INPUT_PULLUP nativos, sem biblioteca externa.

Código-Fonte Completo (.ino) com Análise Linha a Linha

// ============================================================================
// PROJETO 4 (LIÇÃO 5) — ENTRADAS DIGITAIS COM PULL-UP INTERNO
// RoboBuilders — Curso Intermediário Para Arduino Uno R3
// ============================================================================

// Pinos de conexão dos botões e do LED indicador
const int pinoLed = 5;
const int pinoBotaoA = 9; // Botão para LIGAR o LED
const int pinoBotaoB = 8; // Botão para DESLIGAR o LED

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

  // Configura os pinos dos botões como entradas com resistor PULL-UP interno ativado
  // O pino lerá HIGH quando solto e LOW quando pressionado
  pinMode(pinoBotaoA, INPUT_PULLUP);
  pinMode(pinoBotaoB, INPUT_PULLUP);


void loop() {
  // Lê o estado lógico atual do Botão A
  if (digitalRead(pinoBotaoA) == LOW) {
    // Se o botão A foi pressionado (nível LOW), liga o LED
    digitalWrite(pinoLed, HIGH);
  

  // Lê o estado lógico atual do Botão B
  if (digitalRead(pinoBotaoB) == LOW) {
    // Se o botão B foi pressionado (nível LOW), desliga o LED
    digitalWrite(pinoLed, LOW);
  

---

Projeto 5 (Lição 6): Detecção de Inclinação e Orientação Espacial com Sensor Tilt Ball Switch

O sensor de inclinação mecânico (Tilt Ball Switch) é um transdutor eletromecânico discreto projetado para detectar a orientação angular e inclinação de corpos rígidos em robótica e sistemas de segurança veicular.

Princípio Físico de Funcionamento

No interior da cápsula metálica cilíndrica hermética, existe um par de contatos elétricos condutores na base e uma pequena esfera metálica livre.

• Quando o sensor é posicionado na vertical (com os terminais voltados para baixo), a gravidade atrai a esfera de encontro aos dois terminais, fechando o circuito elétrico (baixa resistência, condução plena).
• Quando o sensor é inclinado acima de um ângulo crítico ($\approx 15^\circ \text{ a } 30^\circ$) ou invertido, a esfera metálica se desloca para a outra extremidade do invólucro, abrindo o contato elétrico (circuito aberto, resistência infinita).

Tabela de Componentes Necessários

Componente	Quantidade	Descrição / Especificação
Placa Arduino Uno R3	1	Microcontrolador ATmega328P
Matriz de Contatos (Breadboard)	1	830 pontos
Sensor de Inclinação Tilt Ball Switch	1	Chave esférica metálica de 2 terminais
LED Difuso Vermelho 5mm	1	V_f = 2,0V
Resistor de Limitação de Corrente	1	220,Ω, 1/4W
Cabos Jumper Macho-Macho	3	Condutores de sinal

Montagem Física na Protoboard

📦 Bibliotecas desta lição: nenhuma — o código usa digitalRead() nativo, sem biblioteca externa.

Código-Fonte Completo (.ino) com Análise Linha a Linha

// ============================================================================
// PROJETO 5 (LIÇÃO 6) — SENSOR DE INCLINAÇÃO TILT BALL SWITCH
// RoboBuilders — Curso Intermediário Para Arduino Uno R3
// ============================================================================

const int pinoLed = 13;      // LED onboard do pino 13 como indicador de alarme
const int pinoSensorTilt = 2; // Pino de entrada digital com interrupção externa

void setup() {
  // Configura o pino 13 como saída digital
  pinMode(pinoLed, OUTPUT);

  // Configura o pino 2 como entrada com pull-up interno ativado
  pinMode(pinoSensorTilt, INPUT_PULLUP);


void loop() {
  // Realiza a leitura do estado de contato da esfera metálica
  int estadoTilt = digitalRead(pinoSensorTilt);

  // Se o sensor estiver inclinado (esfera desconectada, pino em nível HIGH pelo pull-up)
  if (estadoTilt == HIGH) {
    digitalWrite(pinoLed, HIGH); // Aciona o LED de sinalização de inclinação
   else {
    digitalWrite(pinoLed, LOW);  // Desliga o LED quando o sensor estiver nivelado
  

  // Pequeno retardo de 50ms para filtragem de repique mecânico (debounce)
  delay(50);

---

Projeto 6 (Lição 7): Emissão de Sinais Sonoros e Alarmes com Buzzer Ativo

Sinalizadores acústicos são essenciais para interfaces de usuário, confirmações sonoras de comandos e alertas críticos em equipamentos autônomos.

Diferença Estrutural entre Buzzer Ativo e Passivo

Um Buzzer Ativo possui um oscilador eletrônico interno transistorizado acoplado a um diafragma piezoelétrico ou eletromagnético.

• Basta aplicar uma tensão DC contínua de 5V aos seus terminais para que o oscilador interno entre em ressonância e emita um tom sonoro de frequência fixa constante (normalmente entre 2 kHz e 2,5 kHz).
• O controle por software é binário: nível HIGH emite som, nível LOW silencia o dispositivo.
• O buzzer ativo é facilmente identificado pelo adesivo selador de proteção em sua superfície superior e pela base encapsulada em resina epóxi preta.

Tabela de Componentes Necessários

Componente	Quantidade	Descrição / Especificação
Placa Arduino Uno R3	1	Microcontrolador ATmega328P
Matriz de Contatos (Breadboard)	1	830 pontos
Buzzer Ativo 5V	1	Corrente nominal ~30mA, frequência fixa ~2,3 kHz
Cabos Jumper Macho-Macho	2	Condutores flexíveis

Montagem Física na Protoboard

📦 Bibliotecas desta lição: nenhuma — o código usa digitalWrite()/delay() nativos, sem biblioteca externa.

Código-Fonte Completo (.ino) com Análise Linha a Linha

// ============================================================================
// PROJETO 6 (LIÇÃO 7) — EMISSÒO DE SINAIS SONOROS COM BUZZER ATIVO
// RoboBuilders — Curso Intermediário Para Arduino Uno R3
// ============================================================================

const int pinoBuzzer = 12; // Pino digital conectado ao polo positivo (+) do buzzer

void setup() {
  // Configura o pino 12 como saída digital de potência
  pinMode(pinoBuzzer, OUTPUT);


void loop() {
  // 1. Emite um pulso sonoro de alerta curto (Bip de 100ms)
  digitalWrite(pinoBuzzer, HIGH);
  delay(100);
  digitalWrite(pinoBuzzer, LOW);
  delay(100);

  // 2. Emite um segundo pulso sonoro de confirmação
  digitalWrite(pinoBuzzer, HIGH);
  delay(100);
  digitalWrite(pinoBuzzer, LOW);
  
  // Pausa de 2 segundos antes de repetir a rotina de sinalização
  delay(2000);

---

Projeto 7 (Lição 8): Síntese de Frequências Musicais com Buzzer Passivo

Ao contrário do buzzer ativo, o Buzzer Passivo não possui circuito oscilador interno. Ele consiste puramente em um transdutor piezoelétrico magnético acoplado a uma membrana metálica flexível.

Teoria Acústica e Geração de Ondas Quadradas

Para produzir som com um buzzer passivo, o microcontrolador deve enviar um sinal elétrico periódico alternado de frequência variável (f). A frequência do sinal elétrico determina a altura musical (nota) gerada:

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

Por exemplo, para gerar a nota musical Lá 4 (A4, diapasão padrão de orquestra), o Arduino deve chavear a saída a uma frequência exata de 440 Hz (período T = 2,27 ms).

A biblioteca de núcleo do Arduino fornece a função de temporização por hardware tone(pino, frequencia, duracao) e noTone(pino), permitindo reproduzir escalas cromáticas e melodias complexas utilizando a tabela de frequências padronizada pitches.h.

Tabela de Componentes Necessários

Componente	Quantidade	Descrição / Especificação
Placa Arduino Uno R3	1	Microcontrolador ATmega328P
Matriz de Contatos (Breadboard)	1	830 pontos
Buzzer Passivo Piezoelétrico	1	Impedância ~16 Ω, resposta de frequência 10 Hz a 10 kHz
Cabos Jumper Macho-Macho	2	Condutores flexíveis

Montagem Física na Protoboard

📦 Bibliotecas desta lição: pitches.h — não é biblioteca do Gerenciador, é uma aba do sketch com a tabela de notas.

• Download: pitches.h oficial ou ZIP pitches.zip da pasta 4.libraries do kit.
• Instalação: com o sketch aberto, Nova aba (Ctrl+Shift+N), nomear pitches.h, colar o conteúdo, salvar na mesma pasta. O #include "pitches.h" (entre aspas) só compila com a aba junto ao .ino (instalada pelo quadro acima).

Código-Fonte Completo (.ino) com Análise Linha a Linha

// ============================================================================
// PROJETO 7 (LIÇÃO 8) — SÍNTESE DE NOTAS MUSICAIS COM BUZZER PASSIVO
// RoboBuilders — Curso Intermediário Para Arduino Uno R3
// ============================================================================

// Definição das constantes de frequência das notas musicais (em Hertz)
#define NOTE_C5  523  // Dó 5
#define NOTE_D5  587  // Ré 5
#define NOTE_E5  659  // Mi 5
#define NOTE_F5  698  // Fá 5
#define NOTE_G5  784  // Sol 5
#define NOTE_A5  880  // Lá 5
#define NOTE_B5  988  // Si 5
#define NOTE_C6  1047 // Dó 6

const int pinoBuzzer = 8; // Pino digital conectado ao buzzer passivo

// Vetor com as notas musicais da escala de Dó Maior
int melodia[] = {
  NOTE_C5, NOTE_D5, NOTE_E5, NOTE_F5, NOTE_G5, NOTE_A5, NOTE_B5, NOTE_C6
;

// Duração de cada nota em milissegundos
int duracaoNota = 300;

void setup() {
  // A função tone() inicializa automaticamente o Timer interno e configura o pino


void loop() {
  // Percorre as 8 notas da escala musical sequencialmente
  for (int notaAtual = 0; notaAtual < 8; notaAtual++) {
    // Gera a frequência no pino do buzzer pela duração especificada
    tone(pinoBuzzer, melodia[notaAtual], duracaoNota);

    // Pausa proporcional entre notas para permitir a distinção sonora (staccato)
    int pausaEntreNotas = duracaoNota * 1.30;
    delay(pausaEntreNotas);

    // Interrompe a geração de sinal no pino
    noTone(pinoBuzzer);
  

  // Pausa de 2 segundos antes de reiniciar a reprodução da escala
  delay(2000);

---

Módulo 3 — Aquisição de Sinais Ambientais e Sensores Físicos

---

Projeto 8 (Lição 9): Estação Climatológica com Sensor Digital de Temperatura e Umidade DHT11

O DHT11 é um sensor digital integrado composto por um elemento resistivo de detecção de umidade por polímero condutivo, um termistor NTC para medição de temperatura e um microcontrolador interno de 8 bits para conversão analógico-digital e calibração de fábrica.

Protocolo de Comunicação Proprietário Single-Bus

O DHT11 exige intervalo mínimo entre leituras (taxa máxima de 1 Hz):

$$T_{amostragem} \geq 1\,\text{s}$$

ou seja, o intervalo entre dois dht11.read() consecutivos deve obedecer a $T_{amostragem} \geq 1000\,\text{ms}$, o que o delay(1000) ao fim do loop() garante. Diferente dos barramentos I2C ou SPI, o DHT11 comunica-se utilizando uma interface de barramento unifilar (Single-Wire 1-Wire bidirecional) em um único pino de dados:

1. O Arduino envia um pulso de inicialização (Start Signal), mantendo a linha em nível LOW por pelo menos 18 ms e depois liberando-a para nível HIGH por 20 a 40 µs40 µs;
2. O DHT11 responde com um sinal de presença de 80 µs em nível LOW seguido de 80 µs em nível HIGH;
3. O sensor transmite 40 bits de dados (5 bytes):
   • Byte 1: Parte inteira da Umidade Relativa (UR %)
   • Byte 2: Parte decimal da Umidade
   • Byte 3: Parte inteira da Temperatura (°C)
   • Byte 4: Parte decimal da Temperatura
   • Byte 5: Checksum (soma de validação: Byte1 + Byte2 + Byte3 + Byte4 = Byte5)

Especificações Técnicas do Sensor DHT11

Grandeza Medida	Faixa de Medição	Precisão de Calibração	Resolução do Dado
Umidade Relativa	20% a 90% UR	\pm 5% UR	1% UR (8 bits)
Temperatura	0°C a 50°C	\pm 2,0,^\circC	1,^\circC (8 bits)
Frequência de Amostragem	1 Hz (1 leitura por segundo)	Tempo de resposta ~2s	Tensão: 3,3V a 5,5V DC

Montagem Física na Protoboard

📦 Bibliotecas desta lição: SimpleDHT por Winlin (versão 1.0.2).

• Via Gerenciador (recomendado): Sketch > Incluir Biblioteca > Gerenciar Bibliotecas… → buscar SimpleDHT → selecionar 1.0.2 → Instalar → reiniciar a IDE.
• Via ZIP: usar SimpleDHT.zip da pasta 4.libraries do kit → Sketch > Incluir Biblioteca > Adicionar Biblioteca .ZIP… → reiniciar a IDE.
• Conferência: Arquivo > Exemplos > SimpleDHT > DHT11Default deve abrir e compilar sem No such file or directory (instalada pelo quadro acima).

Código-Fonte Completo (.ino) com Análise Linha a Linha

// ============================================================================
// PROJETO 8 (LIÇÃO 9) — LEITURA DE TEMPERATURA E UMIDADE COM DHT11
// RoboBuilders — Curso Intermediário Para Arduino Uno R3
// ============================================================================

#include <SimpleDHT.h> // Inclusão da biblioteca de decodificação do protocolo DHT

// Definição do pino digital conectado ao terminal DATA do sensor DHT11
const int pinoDHT11 = 2;

// Instanciação do objeto de controle do sensor
SimpleDHT11 dht11;

void setup() {
  // Inicializa a comunicação serial assíncrona a 9600 bps
  Serial.begin(9600);
  Serial.println(F("========================================"));
  Serial.println(F("RoboBuilders — Monitoramento DHT11 Ativo"));
  Serial.println(F("========================================"));


void loop() {
  // Variáveis para armazenamento dos valores lidos de temperatura e umidade
  byte temperatura = 0;
  byte umidade = 0;
  
  // Executa a requisição de leitura ao sensor DHT11
  // A função read() retorna SimpleDHTErrSuccess (0) quando os dados e o checksum estão corretos
  int erro = dht11.read(pinoDHT11, &temperatura, &umidade, NULL);
  
  if (erro != SimpleDHTErrSuccess) {
    Serial.print(F("Falha na leitura do sensor DHT11, Código do erro: "));
    Serial.println(erro);
    delay(1000);
    return;
  

  // Transmite os dados formatados para o Monitor Serial
  Serial.print(F("Temperatura Ambiente: "));
  Serial.print((int)temperatura);
  Serial.print(F(" °C  |  Umidade Relativa: "));
  Serial.print((int)umidade);
  Serial.println(F(" % UR"));

  // Respeita o intervalo mínimo de amostragem de 1,5 segundos do DHT11
  delay(1500);

---

Projeto 9 (Lição 10): Comunicação Infravermelha e Decodificação de Controle Remoto IR

A comunicação sem fio por luz infravermelha (IR) é amplamente utilizada em controle remoto de eletroeletrônicos e robôs móveis.

Modulação Óptica e o Protocolo NEC

A luz ambiente (sol, lâmpadas fluorescentes e filamentos) emite radiação infravermelha contínua. Para evitar interferências, os transmissores modulam a luz infravermelha a uma frequência portadora de 38 kHz.

O receptor integrado AX-1838HS possui um fotodiodo com filtro óptico de luz visível, amplificador de ganho automático (AGC) e filtro passa-faixa sintonizado em 38 kHz. Quando detecta rajadas de pulsos a 38 kHz, ele satura e coloca seu pino de saída em nível LOW (Active-LOW).

No Protocolo NEC, cada tecla pressionada envia um cabeçalho de 9 ms seguido por 32 bits de dados codificados por tempo de pulso:

• Bit ‘0’: Pulso de 562,5 µs seguido de espaço de 562,5 µs (Total 1,125 ms).
• Bit ‘1’: Pulso de 562,5 µs seguido de espaço de 1,6875 ms (Total 2,25 ms).

Montagem Física na Protoboard

📦 Bibliotecas desta lição: IRremote por shirriff (versão 2.8.1 — série 2.x, NUNCA 3.x/4.x).

• Via Gerenciador (recomendado): Sketch > Incluir Biblioteca > Gerenciar Bibliotecas… → buscar IRremote → selecionar 2.8.1 → Instalar → reiniciar a IDE.
• Via ZIP: usar IRremote.zip da pasta 4.libraries do kit → Sketch > Incluir Biblioteca > Adicionar Biblioteca .ZIP… → reiniciar a IDE.
• Por que fixar a 2.x: o código usa IRrecv/decode_results, removidos na 3.x. Instalar a latest quebra a compilação (instalada pelo quadro acima).

Código-Fonte Completo (.ino) com Análise Linha a Linha

// ============================================================================
// PROJETO 9 (LIÇÃO 10) — DECODIFICAÇÃO DE CONTROLE REMOTO INFRAVERMELHO
// RoboBuilders — Curso Intermediário Para Arduino Uno R3
// ============================================================================

#include <IRremote.h> // Inclusão da biblioteca de recepção e decodificação IR

const int pinoReceptorIR = 11; // Pino digital conectado ao terminal OUT do sensor
const int pinoLedStatus  = 13; // LED indicador de recepção de comando

IRrecv receptorIR(pinoReceptorIR); // Cria o objeto receptor
decode_results resultados;         // Estrutura para armazenar o código hexadecimal decodificado

void setup() {
  Serial.begin(9600);
  pinMode(pinoLedStatus, OUTPUT);

  // Inicializa o processo de escuta e amostragem do receptor infravermelho
  receptorIR.enableIRIn();
  Serial.println(F("Receptor IR inicializado. Aponte o controle e pressione uma tecla..."));


void loop() {
  // Verifica se um pacote infravermelho completo foi recebido e decodificado com sucesso
  if (receptorIR.decode(&resultados)) {
    // Acende brevemente o LED para indicar recebimento do frame
    digitalWrite(pinoLedStatus, HIGH);

    // Imprime o código hexadecimal da tecla pressionada
    Serial.print(F("Código Hexadecimal Recebido: 0x"));
    Serial.println(resultados.value, HEX);

    // Mapeamento e identificação de comandos do controle remoto AE314
    switch (resultados.value) {
      case 0xFFA25D: Serial.println(F("Comando: Tecla POWER / Desligar")); break;
      case 0xFF629D: Serial.println(F("Comando: Tecla MODE")); break;
      case 0xFFE21D: Serial.println(F("Comando: Tecla MUTE")); break;
      case 0xFF22DD: Serial.println(F("Comando: Tecla PLAY/PAUSE")); break;
      case 0xFF02FD: Serial.println(F("Comando: Tecla AVANÇAR >>|")); break;
      case 0xFFC23D: Serial.println(F("Comando: Tecla RETROCEDER |<<")); break;
      case 0xFF30CF: Serial.println(F("Comando: Tecla 1")); break;
      case 0xFF18E7: Serial.println(F("Comando: Tecla 2")); break;
      case 0xFF7A85: Serial.println(F("Comando: Tecla 3")); break;
      default:       Serial.println(F("Comando: Tecla Genérica ou Repetição (0xFFFFFFFF)")); break;
    

    delay(100);
    digitalWrite(pinoLedStatus, LOW);

    // Libera o receptor para capturar o próximo pacote de pulsos
    receptorIR.resume();
  

---

Projeto 10 (Lição 11): Controle Preciso de Posição Angular com Micro Servo Motor SG90

Os servomotores são atuadores eletromecânicos de malha fechada (closed-loop) amplamente utilizados na robótica para articulação de braços robóticos, gimbals de câmeras e superfícies de controle de aeromodelos.

Arquitetura Interna e Controle por Trem de Pulsos PWM

A posição angular é proporcional à largura do pulso de controle (período de $20\,\text{ms}$):

$$\tau(\theta) = 1\,\text{ms} + \frac{\theta}{180^{\circ}} \cdot 1\,\text{ms}$$

de modo que $\theta = 0^{\circ}$ corresponde a $\tau = 1\,\text{ms}$, $\theta = 90^{\circ}$ a $\tau = 1{,}5\,\text{ms}$ e $\theta = 180^{\circ}$ a $\tau = 2\,\text{ms}$. O micro servo Tower Pro SG90 integra em seu invólucro: um motor DC de alta rotação, uma caixa de engrenagens de redução em nylon, um potenciômetro acoplado ao eixo de saída (sensor de posição angular de feedback) e uma placa controladora proporcional.

O controle de posição não se dá pela amplitude da tensão, mas pela largura temporal do pulso positivo dentro de um período fixo de repetição de 20 ms (50 Hz):

• Pulso de 1,0 ms (1000 µs): Posiciona o eixo no limite esquerdo (0°);
• Pulso de 1,5 ms (1500 µs): Posiciona o eixo no centro (90°);
• Pulso de 2,0 ms (2000 µs): Posiciona o eixo no limite direito (180°).

Montagem Física na Protoboard

📦 Bibliotecas desta lição: Servo — embutida na IDE (equivale à versão 1.1.2), nada a baixar.

• Instalação: nenhuma. Confira em Arquivo > Exemplos > Servo > Sweep que o exemplo abre e compila.

Código-Fonte Completo (.ino) com Análise Linha a Linha

// ============================================================================
// PROJETO 10 (LIÇÃO 11) — CONTROLE DE POSICIONAMENTO DO SERVO MOTOR SG90
// RoboBuilders — Curso Intermediário Para Arduino Uno R3
// ============================================================================

#include <Servo.h> // Inclusão da biblioteca oficial Servo (usa Timer 1 por hardware)

const int pinoServo = 9; // Pino digital conectado ao fio de sinal (Laranja/Amarelo)
Servo meuServo;          // Instanciação do objeto controlador do servo

void setup() {
  // Conecta o objeto ao pino digital especificado e configura limites de 544 a 2400 us
  meuServo.attach(pinoServo);


void loop() {
  // Varredura angular suave de 0 até 180 graus
  for (int angulo = 0; angulo <= 180; angulo += 1) {
    meuServo.write(angulo); // Envia o comando angular desejado
    delay(15);              // Aguarda o servo atingir a posição mecânica
  

  delay(500); // Pausa de meio segundo no batente de 180 graus

  // Varredura de retorno de 180 até 0 graus
  for (int angulo = 180; angulo >= 0; angulo -= 1) {
    meuServo.write(angulo);
    delay(15);
  

  delay(500); // Pausa de meio segundo na posição inicial de 0 graus

---

Projeto 11 (Lição 12): Controle Bidirecional Analógico com Módulo Joystick de 2 Eixos

O módulo Joystick Analógico PS2 fornece navegação bidirecional contínua nos eixos X e Y além de um botão digital no eixo Z.

Princípio Físico do Divisor de Tensão Resistivo

O conversor ADC de 10 bits do ATmega328P converte a tensão do cursor em:

$$N = \left\lfloor \frac{V_{in}}{V_{REF}} \cdot 1023 \right\rfloor$$

com $V_{REF} = 5\,\text{V}$; na posição central do joystick, $V_{in} \approx 2{,}5\,\text{V}$ e $N \approx 511$. O módulo é composto por dois potenciômetros lineares de 10 kΩ posicionados ortogonalmente a 90° e acoplados a uma alavanca mecânica com mola centralizadora.

• O cursor central de cada potenciômetro atua como um divisor de tensão:

$$V_{out} = V_{CC} \times \frac{R_2}{R_1 + R_2}$$

• Em repouso (alavanca no centro), a tensão gerada em ambos os eixos é aproximadamente 2,5V, lida pelo conversor analógico-digital (ADC) de 10 bits do Arduino como o valor intermediário ≈ 512 (na escala de 0 a 1023).
• O deslocamento total para um lado leva a leitura para 0 (0V) e para o lado oposto leva para 1023 (+5V).

Montagem Física na Protoboard

📦 Bibliotecas desta lição: nenhuma — o código usa analogRead() nativo, sem biblioteca externa.

Código-Fonte Completo (.ino) com Análise Linha a Linha

// ============================================================================
// PROJETO 11 (LIÇÃO 12) — LEITURA DE JOYSTICK ANALÓGICO BIDIRECIONAL
// RoboBuilders — Curso Intermediário Para Arduino Uno R3
// ============================================================================

const int pinoEixoX  = A0; // Pino de entrada analógica conectado ao cursor X
const int pinoEixoY  = A1; // Pino de entrada analógica conectado ao cursor Y
const int pinoBotaoZ = 8;  // Pino de entrada digital conectado à chave tátil (SW)

void setup() {
  Serial.begin(9600);
  // O pino SW do joystick conecta-se ao terra quando pressionado, necessitando de pull-up
  pinMode(pinoBotaoZ, INPUT_PULLUP);


void loop() {
  // Realiza a conversão analógico-digital dos eixos (retorna 0 a 1023)
  int valorX = analogRead(pinoEixoX);
  int valorY = analogRead(pinoEixoY);
  int botaoPressionado = (digitalRead(pinoBotaoZ) == LOW) ? 1 : 0;

  // Imprime os valores telemétricos na Serial
  Serial.print(F("Eixo X: "));
  Serial.print(valorX);
  Serial.print(F(" | Eixo Y: "));
  Serial.print(valorY);
  Serial.print(F(" | Botão SW: "));
  Serial.println(botaoPressionado ? F("PRESSIONADO") : F("SOLTO"));

  delay(150); // Taxa de amostragem de dados

---

Projeto 12 (Lição 13): Monitoramento de Nível de Líquidos e Detecção Resistiva de Água

O sensor de nível de água por condutividade resistiva é aplicado em reservatórios, sistemas de detecção de vazamentos e irrigação automatizada.

Princípio de Condutividade Iônica

A placa do sensor possui uma série de trilhas condutoras de cobre paralelas e expostas conectadas alternadamente à linha de alimentação (+5V) e à linha de medição ligada a um resistor de pull-down.

A água potável contém íons dissolvidos que conduzem eletricidade. Quando a água entra em contato com as trilhas, fecha-se um circuito resistivo em paralelo:

• Quanto maior a altura da lâmina d’água em contato com a placa, maior é a área condutiva e menor é a resistência elétrica entre as trilhas;
• Pela Lei de Ohm, a corrente que flui para o resistor de pull-down aumenta, elevando proporcionalmente a tensão na entrada analógica A0.

Montagem Física na Protoboard

📦 Bibliotecas desta lição: nenhuma — o código usa analogRead() nativo, sem biblioteca externa.

Código-Fonte Completo (.ino) com Análise Linha a Linha

// ============================================================================
// PROJETO 12 (LIÇÃO 13) — SENSOR RESISTIVO DE NÍVEL DE ÁGUA
// RoboBuilders — Curso Intermediário Para Arduino Uno R3
// ============================================================================

const int pinoSensorAgua = A0; // Pino analógico de leitura da tensão condutiva

void setup() {
  Serial.begin(9600);


void loop() {
  // Lê a tensão proporcional ao nível de água (0 a 1023)
  int nivelLeitura = analogRead(pinoSensorAgua);

  Serial.print(F("Sinal Analógico: "));
  Serial.print(nivelLeitura);
  Serial.print(F(" -> Status: "));

  // Classificação analítica do volume de água
  if (nivelLeitura < 50) {
    Serial.println(F("[ RESERVATÓRIO SECO ]"));
   else if (nivelLeitura < 300) {
    Serial.println(F("[ NÍVEL BAIXO ]"));
   else if (nivelLeitura < 600) {
    Serial.println(F("[ NÍVEL MÉDIO ]"));
   else {
    Serial.println(F("[ NÍVEL ALTO / CRÍTICO ]"));
  

  delay(500);

---

Projeto 13 (Lição 14): Medição de Distância e Sonar Telemétrico com Sensor Ultrassônico HC-SR04

O sensor telemétrico ultrassônico HC-SR04 opera sob o princípio da Ecolocalização (Sonar Time-of-Flight), emitindo pulsos acústicos inaudíveis de alta frequência e calculando o tempo decorrido até o recebimento do eco refletido pelo obstáculo.

Física Acústica e Equação de Cinemática

A distância ao obstáculo é calculada pelo tempo de voo do eco, com $v_{som} \approx 343\,\text{m/s}$:

$$d = \frac{v_{som} \cdot t_{eco}}{2} = \frac{t_{eco\,(\mu s)}}{58}\,\text{cm}$$

O fator $58$ converte microssegundos em centímetros já considerando ida e volta do pulso; a divisão por $2$ elimina o percurso duplo. A velocidade do som no ar à temperatura padrão de 20°C é de aproximadamente v_{som = 340 m/s (0,034 cm/µs ou \frac{1{29,41 cm/µs).

1. O Arduino emite um pulso de disparo de 10,\mus em nível HIGH no pino Trig (Trigger);
2. O transdutor piezoelétrico transmissor emite automaticamente uma rajada acústica de 8 ciclos em 40 kHz;
3. O pino Echo do sensor vai para nível HIGH e permanece nesse estado até que a cápsula receptora detecte o eco refletido;
4. Como a onda sonora realiza um percurso de ida e volta, a distância real (D) até o objeto é dada por:

$$D = \frac{t_{eco\,(\mu s)} \times 0{,}034\,\text{cm}/\mu\text{s}}{2} = \frac{t_{eco\,(\mu s)}}{58}\,\text{cm}$$

Montagem Física na Protoboard

📦 Bibliotecas desta lição: SR04 por Martin Sosic (série 1.x; ZIP do kit sem versionamento).

• Via ZIP (recomendado aqui): usar HC-SR04.zip da pasta 4.libraries do kit → Sketch > Incluir Biblioteca > Adicionar Biblioteca .ZIP… → reiniciar a IDE.
• Via Gerenciador: buscar SR04 → instalar a série 1.x → reiniciar a IDE.
• Conferência: Arquivo > Exemplos > SR04 > SR04_Example deve abrir e compilar; sr04.Distance() precisa existir (instalada pelo quadro acima).

Código-Fonte Completo (.ino) com Análise Linha a Linha

// ============================================================================
// PROJETO 13 (LIÇÃO 14) — SONAR TELEMÉTRICO COM SENSOR ULTRASSÔNICO HC-SR04
// RoboBuilders — Curso Intermediário Para Arduino Uno R3
// ============================================================================

const int pinoTrig = 12; // Pino digital para envio do pulso de disparo (Trigger)
const int pinoEcho = 11; // Pino digital para leitura da largura do pulso de eco (Echo)

void setup() {
  Serial.begin(9600);
  pinMode(pinoTrig, OUTPUT);
  pinMode(pinoEcho, INPUT);

  // Garante que o pino de disparo inicie em nível baixo
  digitalWrite(pinoTrig, LOW);
  delayMicroseconds(5);


void loop() {
  // 1. Gera um pulso limpo de Trigger de exatamente 10 microssegundos
  digitalWrite(pinoTrig, LOW);
  delayMicroseconds(2);
  digitalWrite(pinoTrig, HIGH);
  delayMicroseconds(10);
  digitalWrite(pinoTrig, LOW);

  // 2. Mede o tempo em microssegundos em que o pino Echo permanece em nível HIGH
  // Timeout de 30000 us (alcance máximo teórico de ~5 metros)
  long duracaoPulso = pulseIn(pinoEcho, HIGH, 30000);

  // 3. Converte o tempo de voo na distância em centímetros
  float distanciaCm = (duracaoPulso * 0.0343) / 2.0;

  // Imprime os resultados calculados
  if (duracaoPulso == 0 || distanciaCm > 400.0) {
    Serial.println(F("Fora de alcance ou obstáculo não detectado (> 4 metros)"));
   else {
    Serial.print(F("Distância Medida: "));
    Serial.print(distanciaCm, 1);
    Serial.println(F(" cm"));
  

  delay(200); // Intervalo de medição

---

Projeto 14 (Lição 15): Detecção de Ruído e Monitoramento Acústico com Módulo Sensor de Som

O módulo sensor de som integra um microfone capacitivo de eletreto acoplado a um circuito de amplificação e ao comparador de tensão analógico de alta velocidade LM393.

Circuito Comparador LM393 e Saídas Analógica/Digital

O módulo disponibiliza duas saídas complementares:

1. Saída Analógica (AO): Disponibiliza diretamente o sinal de áudio em tempo real amplificado, permitindo quantificar a amplitude sonora e o nível de ruído em dB.
2. Saída Digital (DO): Fornece um sinal binário (0 ou 1) acionado quando a amplitude sonora ultrapassa o limiar de tensão ajustado pelo potenciômetro multivoltas de calibração na placa.

Montagem Física na Protoboard

📦 Bibliotecas desta lição: nenhuma — o código usa analogRead()/digitalRead() nativos (dois sketches: saída analógica e digital), sem biblioteca externa.

Código-Fonte Completo (.ino) com Análise Linha a Linha

// ============================================================================
// PROJETO 14 (LIÇÃO 15) — MONITORAMENTO ACÚSTICO ANALÓGICO E DIGITAL
// RoboBuilders — Curso Intermediário Para Arduino Uno R3
// ============================================================================

const int pinoEntradaAnaloga = A0; // Leitura de amplitude contínua (AO)
const int pinoEntradaDigital = 3;  // Leitura do limiar do comparador (DO)
const int pinoLedAlarme      = 13; // LED indicador de ruído excessivo

void setup() {
  Serial.begin(9600);
  pinMode(pinoEntradaDigital, INPUT);
  pinMode(pinoLedAlarme, OUTPUT);


void loop() {
  // Lê a forma de onda do sinal de som e o estado binário do comparador
  int amplitudeSonora = analogRead(pinoEntradaAnaloga);
  int disparoLimiar   = digitalRead(pinoEntradaDigital);

  Serial.print(F("Amplitude Sonora (AO): "));
  Serial.print(amplitudeSonora);
  Serial.print(F(" | Limiar Disparado (DO): "));
  Serial.println(disparoLimiar == LOW ? F("SOM DETECTADO!") : F("SILÊNCIO"));

  // Se o som ultrapassou o limiar (nível LOW na saída digital do LM393)
  if (disparoLimiar == LOW) {
    digitalWrite(pinoLedAlarme, HIGH); // Acende o alarme
    delay(100);
   else {
    digitalWrite(pinoLedAlarme, LOW);
  

  delay(20);

---

Módulo 4 — Interfaces Homem-Máquina e Expansão de Portas

---

Projeto 15 (Lição 16): Entrada de Dados Numéricos com Teclado Matricial de Membrana 4x4

O teclado matricial de membrana de 16 teclas (4 linhas × 4 colunas) permite a inserção de senhas, parâmetros numéricos e seleção de menus com economia drástica de pinos de I/O.

Teoria da Multiplexação e Varredura Matricial (Matrix Scanning)

Conectar 16 botões individuais de forma independente exigiria 16 pinos dedicados do microcontrolador. Na topologia matricial, os botões são dispostos nos cruzamentos de 4 linhas e 4 colunas condutoras, necessitando de apenas 8 pinos (4 Linhas + 4 Colunas).

O algoritmo de varredura atua da seguinte forma:

1. As 4 linhas são configuradas como saídas e as 4 colunas como entradas com pull-up;
2. Uma linha por vez é colocada em nível lógico LOW (enquanto as outras permanecem em HIGH);
3. O microcontrolador lê o estado das 4 colunas. Se uma tecla for pressionada naquela linha, a respectiva coluna lerá nível LOW;
4. A combinação unívoca do índice da Linha com o índice da Coluna identifica com precisão a tecla pressionada.

Montagem Física na Protoboard

📦 Bibliotecas desta lição: Keypad por Mark Stanley, Alexander Brevig (versão 3.1.1).

• Via Gerenciador (recomendado): Sketch > Incluir Biblioteca > Gerenciar Bibliotecas… → buscar Keypad → selecionar 3.1.1 → Instalar → reiniciar a IDE.
• Via ZIP: baixar em Chris—A/Keypad (Code > Download ZIP) ou usar Keypad.zip da pasta 4.libraries do kit → Adicionar Biblioteca .ZIP… → reiniciar a IDE.
• Conferência: Arquivo > Exemplos > Keypad > HelloKeypad deve abrir e compilar sem No such file or directory (instalada pelo quadro acima).

Código-Fonte Completo (.ino) com Análise Linha a Linha

// ============================================================================
// PROJETO 15 (LIÇÃO 16) — TECLADO MATRICIAL DE MEMBRANA 4X4
// RoboBuilders — Curso Intermediário Para Arduino Uno R3
// ============================================================================

#include <Keypad.h> // Inclusão da biblioteca de varredura matricial

// Definição das dimensões da matriz do teclado
const byte LINHAS  = 4;
const byte COLUNAS = 4;

// Mapeamento dos caracteres correspondentes à disposição física das teclas
char mapaTeclas[LINHAS][COLUNAS] = {
  {'1', '2', '3', 'A',
  {'4', '5', '6', 'B',
  {'7', '8', '9', 'C',
  {'*', '0', '#', 'D'
;

// Pinos digitais conectados às 4 linhas do teclado
byte pinosLinhas[LINHAS]   = {9, 8, 7, 6;

// Pinos digitais conectados às 4 colunas do teclado
byte pinosColunas[COLUNAS] = {5, 4, 3, 2;

// Instanciação e inicialização do objeto controlador da matriz Keypad
Keypad tecladoMatricial = Keypad(
  makeKeymap(mapaTeclas),
  pinosLinhas,
  pinosColunas,
  LINHAS,
  COLUNAS
);

void setup() {
  Serial.begin(9600);
  Serial.println(F("Teclado Matricial 4x4 inicializado. Pressione uma tecla..."));


void loop() {
  // Executa a varredura não-bloqueante da matriz e retorna o caractere se houver pressão
  char teclaPressionada = tecladoMatricial.getKey();

  if (teclaPressionada != NO_KEY) {
    Serial.print(F("Tecla Pressionada: [ "));
    Serial.print(teclaPressionada);
    Serial.println(F(" ]"));
  

---

Projeto 16 (Lição 17): Expansão de Portas Digitais com Registrador de Deslocamento 74HC595

O circuito integrado 74HC595 é um registrador de deslocamento (Shift Register) de 8 bits com entrada serial e saídas paralelas (SIPO — Serial-In Parallel-Out) dotado de trava de armazenamento (Storage Latch).

Teoria do Deslocamento Serial e Latch

O CI 74HC595 permite controlar 8 saídas digitais independentes consumindo apenas 3 pinos do Arduino:

1. DS (Data / Pino 14): Linha de dados seriais onde os bits são enviados sequencialmente (0 ou 1);
2. SH_CP (Shift Clock / Pino 11): Linha de clock de deslocamento. A cada transição de subida (Rising Edge), o registrador interno desloca os bits existentes uma posição e carrega o novo bit presente em DS;
3. ST_CP (Latch Clock / Pino 12): Linha de trava de saída. Quando essa linha vai de LOW para HIGH, todos os 8 bits armazenados internamente são transferidos instantaneamente para os pinos de saída externos (Q0 a Q7).

A função nativa do Arduino shiftOut(pinoDados, pinoClock, ordemBits, valorByte) executa a transmissão serial síncrona dos 8 bits por hardware/software em microssegundos.

Montagem Física na Protoboard

📦 Bibliotecas desta lição: nenhuma — o código usa shiftOut() nativo, sem biblioteca externa.

Código-Fonte Completo (.ino) com Análise Linha a Linha

// ============================================================================
// PROJETO 16 (LIÇÃO 17) — EXPANSÒO DE 8 SAÍDAS DIGITAIS COM 74HC595
// RoboBuilders — Curso Intermediário Para Arduino Uno R3
// ============================================================================

const int pinoLatch = 11; // Conectado ao pino 12 (ST_CP) do 74HC595
const int pinoClock = 9;  // Conectado ao pino 11 (SH_CP) do 74HC595
const int pinoData  = 12; // Conectado ao pino 14 (DS) do 74HC595

byte padraoLeds = 0; // Variável de 8 bits (1 byte) que representa o estado dos 8 LEDs

// Função para atualizar as saídas físicas do registrador 74HC595
void atualizarRegistrador() {
  digitalWrite(pinoLatch, LOW); // Abre a trava de armazenamento
  shiftOut(pinoData, pinoClock, LSBFIRST, padraoLeds); // Transmite os 8 bits
  digitalWrite(pinoLatch, HIGH); // Fecha a trava e atualiza as 8 saídas simultaneamente


void setup() {
  pinMode(pinoLatch, OUTPUT);
  pinMode(pinoClock, OUTPUT);
  pinMode(pinoData, OUTPUT);


void loop() {
  // 1. Efeito Sequencial: Acende os LEDs um a um da direita para a esquerda
  for (int i = 0; i < 8; i++) {
    bitSet(padraoLeds, i); // Seta o bit 'i' como 1
    atualizarRegistrador();
    delay(100);
  

  // 2. Apaga os LEDs um a um na ordem inversa
  for (int i = 7; i >= 0; i--) {
    bitClear(padraoLeds, i); // Seta o bit 'i' como 0
    atualizarRegistrador();
    delay(100);
  

  // 3. Efeito Pisca-Pisca com todos os 8 LEDs simultaneamente
  padraoLeds = 0b11111111; // Todos os bits em nível alto (0xFF)
  atualizarRegistrador();
  delay(300);

  padraoLeds = 0b00000000; // Todos os bits em nível baixo (0x00)
  atualizarRegistrador();
  delay(300);

---

Projeto 17 (Lição 18): Controle Interativo de LEDs via Comandos do Monitor Serial

Este projeto integra a comunicação bidirecional UART com o registrador 74HC595, permitindo que o operador digite comandos textuais no computador para ligar ou desligar individualmente qualquer um dos 8 LEDs.

Fluxo de Comunicação Serial Interativo

O microcontrolador monitora continuamente o buffer de recepção serial (Serial.available()). Quando caracteres ASCII correspondentes aos números de '0' a '7' são recebidos, a função bitWrite() altera o bit correspondente no registrador e envia o novo byte para o 74HC595.

📦 Bibliotecas desta lição: nenhuma — o código usa shiftOut() e Serial nativos, sem biblioteca externa.

Código-Fonte Completo (.ino) com Análise Linha a Linha

// ============================================================================
// PROJETO 17 (LIÇÃO 18) — CONTROLE SERIAL INTERATIVO DE SAÍDAS DIGITAIS
// RoboBuilders — Curso Intermediário Para Arduino Uno R3
// ============================================================================

const int pinoLatch = 11;
const int pinoClock = 9;
const int pinoData  = 12;

byte estadoLeds = 0; // Armazena o mapa de bits dos 8 LEDs

void atualizarRegistrador() {
  digitalWrite(pinoLatch, LOW);
  shiftOut(pinoData, pinoClock, LSBFIRST, estadoLeds);
  digitalWrite(pinoLatch, HIGH);


void setup() {
  pinMode(pinoLatch, OUTPUT);
  pinMode(pinoClock, OUTPUT);
  pinMode(pinoData, OUTPUT);
  
  Serial.begin(9600);
  atualizarRegistrador();
  
  Serial.println(F("Digite o número do LED (0 a 7) para alternar seu estado (Ligar/Desligar):"));


void loop() {
  // Verifica se há caracteres pendentes no buffer de entrada serial
  if (Serial.available() > 0) {
    char caractereRecebido = Serial.read();

    // Filtra apenas dígitos válidos entre '0' e '7'
    if (caractereRecebido >= '0' && caractereRecebido <= '7') {
      int indiceLed = caractereRecebido - '0'; // Converte ASCII para valor inteiro (0-7)

      // Inverte o estado do bit selecionado (Toggle)
      bitWrite(estadoLeds, indiceLed, !bitRead(estadoLeds, indiceLed));
      atualizarRegistrador();

      Serial.print(F("LED [ "));
      Serial.print(indiceLed);
      Serial.print(F(" ] alternado para: "));
      Serial.println(bitRead(estadoLeds, indiceLed) ? F("LIGADO") : F("DESLIGADO"));
    
  

---

Projeto 18 (Lição 19): Fotometria e Controle de Iluminação Automática com Fotocélula LDR

Um LDR (Light Dependent Resistor ou Fotorresistor de Sulfeto de Cádmio - CdS) varia sua resistência ôhmica inversamente proporcional à irradiância da luz incidente.

Física do Semicondutor e Divisor de Tensão Fotométrico

A tensão lida em A0 segue o divisor formado pelo LDR e o resistor fixo de $10\,\text{k}\Omega$:

$$V_{A0} = V_{CC} \cdot \frac{R_{fixo}}{R_{LDR} + R_{fixo}}$$

No escuro, $R_{LDR} > 1\,\text{M}\Omega$ e $V_{A0} \approx 0\,\text{V}$; sob luz intensa, $R_{LDR} < 1\,\text{k}\Omega$ e $V_{A0} \to 5\,\text{V}$. Na escuridão total, os elétrons estão presos na banda de valência e a resistência do LDR é extremamente alta (R_{escuro} > 1\text{ M}\Omega). Quando fótons de luz visível atingem o material, a energia transferida libera elétrons para a banda de condução, reduzindo a resistência para algumas centenas de ohms (R_{claro} \approx 500,\Omega a 2 kΩ).

Associando o LDR a um resistor de referência de 10 kΩ, formamos um divisor de tensão lido pela porta analógica A0:

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

• Alta luminosidade \implies R_{LDR baixo \implies V_{A0 alto (próximo de 1023);
• Escuridão \implies R_{LDR alto \implies V_{A0 baixo (próximo de 0).

Montagem Física na Protoboard

📦 Bibliotecas desta lição: nenhuma — o código usa analogRead() nativo, sem biblioteca externa.

Código-Fonte Completo (.ino) com Análise Linha a Linha

// ============================================================================
// PROJETO 18 (LIÇÃO 19) — BARRA DE LEDS FOTOMÉTRICA COM LDR E 74HC595
// RoboBuilders — Curso Intermediário Para Arduino Uno R3
// ============================================================================

const int pinoLDR   = A0; // Pino analógico de leitura do divisor LDR
const int pinoLatch = 11;
const int pinoClock = 9;
const int pinoData  = 12;

void atualizarRegistrador(byte dados) {
  digitalWrite(pinoLatch, LOW);
  shiftOut(pinoData, pinoClock, LSBFIRST, dados);
  digitalWrite(pinoLatch, HIGH);


void setup() {
  pinMode(pinoLatch, OUTPUT);
  pinMode(pinoClock, OUTPUT);
  pinMode(pinoData, OUTPUT);
  Serial.begin(9600);


void loop() {
  // Lê a intensidade de luz no LDR (0 a 1023)
  int leituraLuz = analogRead(pinoLDR);
  
  // Mapeia a leitura analógica para uma escala de 0 a 8 LEDs acesos
  int numeroLedsAcesos = map(leituraLuz, 200, 900, 0, 8);
  numeroLedsAcesos = constrain(numeroLedsAcesos, 0, 8);

  // Constrói a máscara de bits proporcional
  byte mascaraLeds = 0;
  for (int i = 0; i < numeroLedsAcesos; i++) {
    bitSet(mascaraLeds, i);
  

  atualizarRegistrador(mascaraLeds);

  Serial.print(F("Luminosidade LDR: "));
  Serial.print(leituraLuz);
  Serial.print(F(" -> LEDs Ativos: "));
  Serial.println(numeroLedsAcesos);

  delay(100);

---

Projeto 19 (Lição 20): Exibição Alfanumérica com Display LCD 16x2 e Barramento I2C

O display de cristal líquido alfanumérico padrão HD44780 (16x2) possui 16 colunas e 2 linhas de texto. Quando utilizado em modo paralelo clássico, necessita de no mínimo 6 a 10 pinos de controle.

O Barramento I2C e o Expansor PCF8574

Para reduzir a fiação a apenas 2 fios de comunicação, o display do Kit AE314 possui uma placa traseira com o circuito integrado conversor PCF8574 (expansor I2C para barramento paralelo de 8 bits).

O barramento I2C opera com mestre único e múltiplos escravos através de endereçamento de 7 bits (endereço padrão 0x27 ou 0x3F), utilizando as linhas:

• SDA (Serial Data Line): Pino A4 no Arduino Uno;
• SCL (Serial Clock Line): Pino A5 no Arduino Uno.

Montagem Física na Protoboard

📦 Bibliotecas desta lição: LiquidCrystal_I2C por Frank de Brabander (versão 1.1.2) + Wire embutida.

• Via Gerenciador (recomendado): buscar LiquidCrystal I2C → selecionar 1.1.2 (Frank de Brabander) → Instalar → reiniciar a IDE. Atenção a forks homônimos (ex.: Marco Schwartz) com API diferente.
• Via ZIP: usar LiquidCrystal_I2C.zip da pasta 4.libraries do kit → Adicionar Biblioteca .ZIP… → reiniciar a IDE.
• Conferência: Arquivo > Exemplos > LiquidCrystal I2C > HelloWorld deve abrir e compilar; endereço típico 0x27 (alguns módulos usam 0x3F) — rode um sketch I2C Scanner em caso de tela apagada (instalada pelo quadro acima).

Código-Fonte Completo (.ino) com Análise Linha a Linha

// ============================================================================
// PROJETO 19 (LIÇÃO 20) — COMUNICAÇÃO COM DISPLAY LCD 16X2 VIA I2C
// RoboBuilders — Curso Intermediário Para Arduino Uno R3
// ============================================================================

#include <Wire.h>              // Biblioteca nativa para barramento I2C
#include <LiquidCrystal_I2C.h> // Biblioteca para controle do display LCD via PCF8574

// Configura o display com o endereço 0x27, 16 colunas e 2 linhas
LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
  // Inicializa a interface de comunicação do display LCD
  lcd.init();
  
  // Liga a luz de fundo (Backlight) azul do display
  lcd.backlight();

  // Posiciona o cursor na Coluna 0, Linha 0 (Primeira Linha)
  lcd.setCursor(0, 0);
  lcd.print("RoboBuilders");

  // Posiciona o cursor na Coluna 0, Linha 1 (Segunda Linha)
  lcd.setCursor(0, 1);
  lcd.print("Arduino Uno R3");


void loop() {
  // Demonstração de contagem de tempo de operação em segundos
  lcd.setCursor(11, 1);
  lcd.print(millis() / 1000);
  delay(500);

---

Projeto 20 (Lição 21): Termômetro Digital de Precisão com Termistor NTC e Display LCD I2C

Este projeto integra um Termistor NTC (coeficiente térmico negativo) com a tela LCD 16x2 para criar um termômetro digital autônomo de bancada.

A Equação de Steinhart-Hart e Parâmetro Beta (β)

A temperatura absoluta do termistor NTC de $10\,\text{k}\Omega$ ($\beta = 3950$) segue:

$$\frac{1}{T} = A + B \cdot \ln(R) + C \cdot \ln^3(R)$$

na forma Beta simplificada usada no firmware:

$$T = \frac{1}{\frac{1}{T_0} + \frac{1}{\beta} \cdot \ln\left(\frac{R}{R_0}\right)} \quad [\text{K}]$$

com $T_0 = 298{,}15\,\text{K}$ e $R_0 = 10\,\text{k}\Omega$; a conversão final é $T_C = T - 273{,}15$. A resistência ôhmica de um termistor NTC decresce não-linearmente com a elevação da temperatura. Para converter a resistência elétrica (R) em temperatura absoluta em Kelvin (T), emprega-se a Equação do Parâmetro Beta:

$$\frac{1}{T} = \frac{1}{T_0} + \frac{1}{\beta} \cdot \ln\left(\frac{R_{\text{NTC}}}{R_0}\right) \implies T(^\circ\text{C}) = T(\text{K}) - 273{,}15$$

Onde T_0 = 298,15 K (25°C), R_0 = 10 kΩ e B = 3950 K para o termistor padrão do kit. Convertendo para graus Celsius: T(^\circC) = T(K) - 273,15.

📦 Bibliotecas desta lição: LiquidCrystal_I2C 1.1.2 — a mesma da Lição 20, nada a baixar.

• Conferência: se a Lição 20 compilou, esta também compila. Wire é embutida na IDE.

Código-Fonte Completo (.ino) com Análise Linha a Linha

// ============================================================================
// PROJETO 20 (LIÇÃO 21) — TERM—METRO DIGITAL COM TERMISTOR NTC E LCD I2C
// RoboBuilders — Curso Intermediário Para Arduino Uno R3
// ============================================================================

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <math.h>

LiquidCrystal_I2C lcd(0x27, 16, 2);

const int pinoNTC = A0; // Pino analógico conectado ao divisor de tensão com NTC

// Constantes do modelo matemático do termistor NTC 10k 3950
const float RESISTOR_DIVISOR = 10000.0; // Resistor de 10 kΩ em série
const float BETA             = 3950.0;  // Coeficiente Beta do fabricante
const float TEMPERATURA_REF  = 298.15;  // 25 °C em Kelvin
const float RESISTENCIA_REF  = 10000.0; // 10 kΩ a 25 °C

void setup() {
  lcd.init();
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("Termometro NTC");


void loop() {
  int valorADC = analogRead(pinoNTC);

  // Calcula a resistência atual do NTC pelo divisor de tensão
  float tensaoNTC = (valorADC * 5.0) / 1023.0;
  float resistenciaNTC = (5.0 - tensaoNTC) * RESISTOR_DIVISOR / tensaoNTC;

  // Aplicação da equação simplificada de Steinhart-Hart / Parâmetro Beta
  float steinhart;
  steinhart = resistenciaNTC / RESISTENCIA_REF;      // (R / Ro)
  steinhart = log(steinhart);                        // ln(R / Ro)
  steinhart /= BETA;                                 // 1/B * ln(R / Ro)
  steinhart += 1.0 / TEMPERATURA_REF;                // + (1 / To)
  steinhart = 1.0 / steinhart;                       // Inverte para obter Temperatura em Kelvin
  float temperaturaCelsius = steinhart - 273.15;     // Converte para Celsius

  // Atualiza a exibição no display LCD
  lcd.setCursor(0, 1);
  lcd.print("Temp: ");
  lcd.print(temperaturaCelsius, 1);
  lcd.print((char)223); // Símbolo de grau '°'
  lcd.print("C   ");

  delay(500);

---

Projeto 21 (Lição 22): Contagem Numérica em Display de 7 Segmentos via 74HC595

O Display de 7 Segmentos é constituído por 7 diodos LEDs retangulares dispostos no formato do algarismo ‘8’ (denominados segmentos a, b, c, d, e, f, g) mais um ponto decimal (DP).

Integrando o registrador de deslocamento 74HC595, controlamos todos os 8 segmentos utilizando apenas 3 pinos do microcontrolador através de uma tabela de decodificação binária de dígitos.

Montagem Física na Protoboard

📦 Bibliotecas desta lição: nenhuma — o código usa shiftOut() nativo, sem biblioteca externa.

Código-Fonte Completo (.ino) com Análise Linha a Linha

// ============================================================================
// PROJETO 21 (LIÇÃO 22) — CONTADOR DE 0 A 9 EM DISPLAY DE 7 SEGMENTOS
// RoboBuilders — Curso Intermediário Para Arduino Uno R3
// ============================================================================

const int pinoLatch = 11;
const int pinoClock = 9;
const int pinoData  = 12;

// Tabela de decodificação binária para os dígitos de 0 a 9 (Cátodo Comum)
// Mapeamento das saídas Q0..Q7 do 74HC595 para os segmentos: A, B, C, D, E, F, G, DP
byte digitos7Seg[10] = {
  0b11111100, // Dígito 0 (Segmentos A,B,C,D,E,F ligados)
  0b01100000, // Dígito 1 (Segmentos B,C ligados)
  0b11011010, // Dígito 2 (Segmentos A,B,D,E,G ligados)
  0b11110010, // Dígito 3 (Segmentos A,B,C,D,G ligados)
  0b01100110, // Dígito 4 (Segmentos B,C,F,G ligados)
  0b10110110, // Dígito 5 (Segmentos A,C,D,F,G ligados)
  0b10111110, // Dígito 6 (Segmentos A,C,D,E,F,G ligados)
  0b11100000, // Dígito 7 (Segmentos A,B,C ligados)
  0b11111110, // Dígito 8 (Todos os segmentos ligados)
  0b11110110  // Dígito 9 (Segmentos A,B,C,D,F,G ligados)
;

void atualizarDisplay(byte mascara) {
  digitalWrite(pinoLatch, LOW);
  shiftOut(pinoData, pinoClock, LSBFIRST, mascara);
  digitalWrite(pinoLatch, HIGH);


void setup() {
  pinMode(pinoLatch, OUTPUT);
  pinMode(pinoClock, OUTPUT);
  pinMode(pinoData, OUTPUT);


void loop() {
  // Contagem progressiva de 0 a 9
  for (int digito = 0; digito < 10; digito++) {
    atualizarDisplay(digitos7Seg[digito]);
    delay(1000); // 1 segundo por dígito
  

---

Projeto 22 (Lição 23): Cronômetro e Multiplexação Temporal em Display de 4 Dígitos de 7 Segmentos

Para acionar um display com 4 dígitos numéricos sem necessitar de 32 pinos, utiliza-se a técnica de Multiplexação por Divisão no Tempo (Time-Division Multiplexing).

Princípio de Multiplexação por Persistência Visual

Todos os segmentos correspondentes (a, b, c…) dos 4 dígitos são eletricamente interligados em paralelo em um barramento comum acionado pelo 74HC595. No entanto, o cátodo comum de cada dígito (D1, D2, D3, D4) é controlado individualmente por um pino do microcontrolador:

1. Habilita-se o Dígito 1 e envia-se o padrão do 1º número;
2. Aguarda-se um intervalo de tempo crítico de 2 a 4 milissegundos;
3. Desabilita-se o Dígito 1, habilita-se o Dígito 2 e envia-se o 2º número;
4. Repete-se o processo ciclicamente para os dígitos 3 e 4.

Como o ciclo completo de varredura ocorre a uma frequência superior a 100 Hz, o cérebro humano integra as imagens e percebe todos os 4 dígitos continuamente iluminados e sem cintilação (flickering).

Montagem Física na Protoboard

📦 Bibliotecas desta lição: nenhuma — o código usa shiftOut() nativo (multiplexação por persistência visual), sem biblioteca externa.

Código-Fonte Completo (.ino) com Análise Linha a Linha

// ============================================================================
// PROJETO 22 (LIÇÃO 23) — CRON—METRO MULTIPLEXADO EM DISPLAY DE 4 DÍGITOS
// RoboBuilders — Curso Intermediário Para Arduino Uno R3
// ============================================================================

const int pinoLatch = 9;  // ST_CP do 74HC595
const int pinoClock = 10; // SH_CP do 74HC595
const int pinoData  = 8;  // DS do 74HC595

// Pinos de controle de habilitação dos 4 dígitos (Cátodos Comuns)
const int pinosDigitos[4] = {2, 3, 4, 5;

// Tabela de dígitos hexadecimais para display de 7 segmentos
const byte tabelaSegmentos[10] = {
  0x3F, // 0
  0x06, // 1
  0x5B, // 2
  0x4F, // 3
  0x66, // 4
  0x6D, // 5
  0x7D, // 6
  0x07, // 7
  0x7F, // 8
  0x6F  // 9
;

void atualizarSegmentos(byte padrao) {
  digitalWrite(pinoLatch, LOW);
  shiftOut(pinoData, pinoClock, MSBFIRST, padrao);
  digitalWrite(pinoLatch, HIGH);


// Função para exibir um número de 4 dígitos na tela multiplexada
void exibirNumero4Digitos(int numero) {
  int digitos[4];
  digitos[0] = (numero / 1000) % 10; // Milhar
  digitos[1] = (numero / 100) % 10;  // Centena
  digitos[2] = (numero / 10) % 10;   // Dezena
  digitos[3] = numero % 10;          // Unidade

  for (int i = 0; i < 4; i++) {
    // 1. Apaga todos os dígitos antes de trocar o padrão para evitar fantasmas (ghosting)
    for (int k = 0; k < 4; k++) digitalWrite(pinosDigitos[k], HIGH);

    // 2. Envia os segmentos correspondentes ao dígito atual
    atualizarSegmentos(tabelaSegmentos[digitos[i]]);

    // 3. Habilita apenas o dígito ativo (Nível LOW para Cátodo Comum)
    digitalWrite(pinosDigitos[i], LOW);

    // 4. Retardo de persistência retiniana
    delay(3);
  


void setup() {
  pinMode(pinoLatch, OUTPUT);
  pinMode(pinoClock, OUTPUT);
  pinMode(pinoData, OUTPUT);

  for (int i = 0; i < 4; i++) {
    pinMode(pinosDigitos[i], OUTPUT);
    digitalWrite(pinosDigitos[i], HIGH);
  


int contador = 0;
unsigned long tempoUltimoIncremento = 0;

void loop() {
  // Incrementa a contagem a cada 100 milissegundos
  if (millis() - tempoUltimoIncremento > 100) {
    contador++;
    if (contador > 9999) contador = 0;
    tempoUltimoIncremento = millis();
  

  // Mantém a varredura multiplexada ativa continuamente
  exibirNumero4Digitos(contador);

---

Módulo 5 — Acionamentos Eletromecânicos, Motores e Controle de Potência

---

Projeto 23 (Lição 24): Acionamento Bidirecional de Motor DC com Circuito Integrado L293D

Motores elétricos de corrente contínua (DC) convertem energia elétrica em energia mecânica rotacional através da interação entre campos magnéticos e condutores percorridos por corrente.

Teoria da Ponte H e Força Contraeletromotriz (Back-EMF)

No controle de velocidade por PWM no pino ENABLE, a tensão média no motor é:

$$V_{motor} = D \cdot V_S = \frac{\text{analogWrite}}{255} \cdot V_S$$

com analogWrite(ENABLE, 128), $D \approx 0{,}50$ e o motor recebe cerca de metade da tensão de alimentação $V_S$. Um pino de I/O do microcontrolador ATmega328P é capaz de fornecer no máximo 20 mA a 40 mA, enquanto um pequeno motor DC consome tipicamente entre 100 mA e 500 mA em vazio e mais de 1 A durante a partida ou rotor travado (stall current). Conectar um motor diretamente à porta do microcontrolador destruirá a saída instantaneamente.

Além disso, os enrolamentos do motor são indutores puros (L). Ao interromper abruptamente a corrente em uma bobina indutiva, a derivada da corrente no tempo gera um pico de alta tensão de polaridade reversa dado pela Lei de Faraday-Lenz:

$$V_{induzida} = -L\,\frac{di}{dt}$$

Esse pico de Força Contraeletromotriz (Back-EMF) pode facilmente ultrapassar centenas de volts, destruindo os transistores de comando.

O circuito integrado L293D é um driver quádruplo de meia-ponte (Ponte H Dupla) capaz de fornecer até 600 mA contínuos por canal (picos de 1,2 A) com diodos de grampeamento de proteção (Flyback Diodes) integrados internamente:

• Enable (Pino 1 / 9): Controla a velocidade de rotação via modulação PWM;
• Input 1 e Input 2 (Pinos 2 e 7): Determinam o sentido de rotação (Horário: HIGH/LOW, Anti-horário: LOW/HIGH, Frenagem: HIGH/HIGH ou LOW/LOW).

Montagem Física na Protoboard

📦 Bibliotecas desta lição: nenhuma — o código usa digitalWrite()/analogWrite() nativos, sem biblioteca externa.

Código-Fonte Completo (.ino) com Análise Linha a Linha

// ============================================================================
// PROJETO 23 (LIÇÃO 24) — CONTROLE BIDIRECIONAL DE MOTOR DC COM L293D
// RoboBuilders — Curso Intermediário Para Arduino Uno R3
// ============================================================================

#define PINO_ENABLE 5 // Pino PWM conectado ao Enable 1,2 (Pino 1 do L293D)
#define PINO_DIR_A  3 // Pino digital conectado a Input 1 (Pino 2 do L293D)
#define PINO_DIR_B  4 // Pino digital conectado a Input 2 (Pino 7 do L293D)

void setup() {
  pinMode(PINO_ENABLE, OUTPUT);
  pinMode(PINO_DIR_A, OUTPUT);
  pinMode(PINO_DIR_B, OUTPUT);


void loop() {
  // 1. Rotação no Sentido Horário com Aceleração Gradual por PWM
  digitalWrite(PINO_DIR_A, HIGH);
  digitalWrite(PINO_DIR_B, LOW);
  for (int velocidade = 0; velocidade <= 255; velocidade += 5) {
    analogWrite(PINO_ENABLE, velocidade);
    delay(20);
  
  delay(1000);

  // 2. Desaceleração suave até a parada total
  for (int velocidade = 255; velocidade >= 0; velocidade -= 5) {
    analogWrite(PINO_ENABLE, velocidade);
    delay(20);
  
  delay(500);

  // 3. Rotação no Sentido Anti-Horário com Aceleração Gradual
  digitalWrite(PINO_DIR_A, LOW);
  digitalWrite(PINO_DIR_B, HIGH);
  for (int velocidade = 0; velocidade <= 255; velocidade += 5) {
    analogWrite(PINO_ENABLE, velocidade);
    delay(20);
  
  delay(1000);

  // 4. Parada suave
  for (int velocidade = 255; velocidade >= 0; velocidade -= 5) {
    analogWrite(PINO_ENABLE, velocidade);
    delay(20);
  
  delay(1000);

---

Projeto 24 (Lição 25): Comutação de Cargas Elétricas de Alta Potência com Módulo Relé de 5V

O relé eletromecânico é o componente padrão para isolação galvânica e acionamento de cargas elétricas de alta potência em corrente alternada (como lâmpadas de 110V/220V AC, bombas d’água e solenoides) a partir de sinais lógicos de 5V DC.

Acoplamento Óptico e Isolação Galvânica

O módulo relé de 1 canal integra:

1. Optoacoplador: Transfere o sinal de controle por meio de luz infravermelha, isolando eletricamente o microcontrolador contra ruídos e transientes da rede elétrica;
2. Transistor Driver: Amplifica a corrente para energizar a bobina do relé (~70 mA);
3. Diodo Flyback: Dissipa a energia indutiva no desligamento da bobina;
4. Contatos Mecânicos SPDT:
   • COM (Comum): Terminal central de alimentação da carga;
   • NA / NO (Normalmente Aberto): Circuito aberto em repouso, fecha quando o relé é acionado;
   • NF / NC (Normalmente Fechado): Circuito fechado em repouso, abre quando o relé é acionado.

Montagem Física na Protoboard

📦 Bibliotecas desta lição: nenhuma — o código usa digitalWrite() nativo, sem biblioteca externa.

Código-Fonte Completo (.ino) com Análise Linha a Linha

// ============================================================================
// PROJETO 24 (LIÇÃO 25) — ACIONAMENTO DE MÓDULO RELÉ DE 5V
// RoboBuilders — Curso Intermediário Para Arduino Uno R3
// ============================================================================

const int pinoRele = 7; // Pino digital conectado à entrada 'IN' do módulo relé

void setup() {
  pinMode(pinoRele, OUTPUT);
  
  // A maioria dos módulos relé com optoacoplador opera em lógica invertida (Active-LOW)
  // HIGH = Relé Desligado (Desarmado)
  // LOW  = Relé Ligado (Armado / Atracado)
  digitalWrite(pinoRele, HIGH);
  
  Serial.begin(9600);
  Serial.println(F("Módulo Relé Inicializado. Alternando estados a cada 3 segundos..."));


void loop() {
  // 1. Atraca o relé (conecta os contatos COM e NA)
  Serial.println(F("Relé: [ LIGADO ] -> Contato NA fechado"));
  digitalWrite(pinoRele, LOW);
  delay(3000);

  // 2. Desarma o relé (conecta os contatos COM e NF)
  Serial.println(F("Relé: [ DESLIGADO ] -> Contato NA aberto"));
  digitalWrite(pinoRele, HIGH);
  delay(3000);

---

Projeto 25 (Lição 26): Controle de Posicionamento e Passo Preciso com Motor 28BYJ-48 e Driver ULN2003

O Motor de Passo 28BYJ-48 é um atuador unipolar de 4 fases acoplado a uma caixa de engrenagens de redução planetária interna com razão 1:64, permitindo posicionamento angular micrométrico de alta repetibilidade sem perda de passos.

Eletromagnetismo e Sequenciamento de Fases

O 28BYJ-48 possui redução interna de $1{:}64$ e $32$ passos por volta no eixo do motor, totalizando no eixo de saída:

$$N_{passos/volta} = 32 \times 64 = 2048$$

logo o ângulo por passo é $\alpha = 360^{\circ}/2048 \approx 0{,}176^{\circ}$, o que explica o valor de stepsPerRevolution usado no firmware. O rotor interno magnético gira em resposta à energização sequencial ordenada das 4 bobinas estatóricas (fases A, B, C, D):

• O motor possui ângulo de passo de base de 5,625° / 64 = 0,08789° por passo na saída do redutor;
• São necessários 4096 meios-passos (Half-Step) ou 2048 passos completos (Full-Step) para completar 1 revolução completa de 360° no eixo externo.

A placa de acionamento utiliza a matriz de transistores Darlington ULN2003A, que amplifica a corrente para energizar cada bobina enquanto os 4 LEDs onboard fornecem diagnóstico visual das fases ativas.

Montagem Física na Protoboard

📦 Bibliotecas desta lição: Stepper — embutida na IDE (equivale à versão 1.1.3), nada a baixar.

• Instalação: nenhuma (o Stepper.zip da pasta 4.libraries do kit é a mesma biblioteca). Confira em Arquivo > Exemplos > Stepper > stepper_oneRevolution que o exemplo abre e compila.

Código-Fonte Completo (.ino) com Análise Linha a Linha

// ============================================================================
// PROJETO 25 (LIÇÃO 26) — CONTROLE DE MOTOR DE PASSO 28BYJ-48 COM ULN2003
// RoboBuilders — Curso Intermediário Para Arduino Uno R3
// ============================================================================

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

// Número de passos internos por revolução antes da redução mecânica
const int PASSOS_POR_VOLTA_EIXO = 32;

// Ordem dos pinos no driver ULN2003: IN1, IN3, IN2, IN4 (Sequência obrigatória 1-3-2-4)
Stepper motorPasso(PASSOS_POR_VOLTA_EIXO, 8, 10, 9, 11);

void setup() {
  // Define a velocidade de rotação em Rotações Por Minuto (RPM)
  motorPasso.setSpeed(500); // 500 RPM no eixo interno (~10 a 15 RPM no eixo de saída com redutor)
  Serial.begin(9600);
  Serial.println(F("Motor de Passo 28BYJ-48 Pronto."));


void loop() {
  // 1. Executa 1 volta completa (2048 passos) no Sentido Horário
  Serial.println(F("Girando 360 graus no Sentido Horário..."));
  motorPasso.step(2048);
  delay(1000);

  // 2. Executa 1 volta completa (2048 passos) no Sentido Anti-Horário
  Serial.println(F("Girando 360 graus no Sentido Anti-Horário..."));
  motorPasso.step(-2048);
  delay(1000);

---

Projeto 26 (Lição 27): Controle Remoto sem Fio de Motor de Passo com Protocolo Infravermelho

O projeto final de integração do curso combina o receptor infravermelho AX-1838HS, o controle remoto IR de 21 teclas, o driver ULN2003 e o motor de passo 28BYJ-48 em um sistema mecatrônico de posicionamento sem fio de alta precisão.

Arquitetura de Integração de Sistemas

O firmware implementa uma máquina de estados:

• Tecla ‘1’: Gira o motor de passo +90° no sentido horário (512 passos);
• Tecla ‘2’: Gira o motor de passo -90° no sentido anti-horário (-512 passos);
• Tecla ‘VOL+’: Gira 1 revolução completa (+360°);
• Tecla ‘VOL-’: Gira 1 revolução reversa (-360°);
• Tecla ‘PLAY/PAUSE’: Interrompe o movimento imediatamente.

📦 Bibliotecas desta lição: IRremote 2.8.1 (a mesma da Lição 10, nada a baixar) + Stepper embutida.

• Conferência: se a Lição 10 compilou com a série 2.x fixada, este projeto compila sem novas instalações.

Código-Fonte Completo (.ino) com Análise Linha a Linha

// ============================================================================
// PROJETO 26 (LIÇÃO 27) — CONTROLE REMOTO IR DE MOTOR DE PASSO
// RoboBuilders — Curso Intermediário Para Arduino Uno R3
// ============================================================================

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

// Configuração do motor de passo 28BYJ-48
const int PASSOS_POR_VOLTA = 32;
Stepper motorPasso(PASSOS_POR_VOLTA, 8, 10, 9, 11);

// Configuração do receptor infravermelho
const int pinoReceptorIR = 12;
IRrecv receptorIR(pinoReceptorIR);
decode_results resultadosIR;

void setup() {
  motorPasso.setSpeed(500);
  receptorIR.enableIRIn(); // Inicializa o receptor IR
  Serial.begin(9600);
  Serial.println(F("Sistema Integrado IR + Motor de Passo Inicializado."));
  Serial.println(F("Pressione [1] para +90°, [2] para -90°, [VOL+] para +360°, [VOL-] para -360°"));


void loop() {
  // Verifica se um comando infravermelho válido foi recebido
  if (receptorIR.decode(&resultadosIR)) {
    unsigned long codigoRecebido = resultadosIR.value;
    Serial.print(F("Código IR: 0x"));
    Serial.println(codigoRecebido, HEX);

    switch (codigoRecebido) {
      case 0xFF30CF: // Tecla '1'
        Serial.println(F("Comando: Girar +90 Graus (512 passos)"));
        motorPasso.step(512);
        break;

      case 0xFF18E7: // Tecla '2'
        Serial.println(F("Comando: Girar -90 Graus (-512 passos)"));
        motorPasso.step(-512);
        break;

      case 0xFF629D: // Tecla 'VOL+'
        Serial.println(F("Comando: Girar +360 Graus (2048 passos)"));
        motorPasso.step(2048);
        break;

      case 0xFFA857: // Tecla 'VOL-'
        Serial.println(F("Comando: Girar -360 Graus (-2048 passos)"));
        motorPasso.step(-2048);
        break;

      default:
        break;
    

    // Libera o buffer para a próxima captura de tecla
    receptorIR.resume();
  

---

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

A tabela diagnóstica abaixo sintetiza as principais falhas elétricas, de firmware e de conectividade encontradas durante o desenvolvimento dos projetos deste curso, com seus respectivos procedimentos de correção:

Sintoma Observado	Causa Mais Provável	Procedimento de Diagnóstico e Correção
Placa não é detectada pela IDE (“Porta Serial não encontrada”)	Driver CH340 ausente ou cabo USB danificado	Instalar o driver CH341SER.EXE com privilégios de administrador; trocar o cabo USB Tipo A-B por um cabo com vias de dados íntegras.
Erro de compilação: “fatal error: LiquidCrystal_I2C.h: No such file”	Biblioteca externa não instalada	Acessar o Gerenciador de Bibliotecas da IDE e instalar a biblioteca correspondente ou incluir o arquivo .ZIP fornecido na pasta do kit.
O display LCD 16x2 I2C acende a luz de fundo, mas exibe apenas quadrados brancos	Contraste descalibrado ou endereço I2C incorreto	Ajustar o trimpot azul de contraste na traseira do módulo I2C com uma chave de fenda; rodar um sketch I2C Scanner para confirmar o endereço (0x27 ou 0x3F).
O motor de passo vibra intensamente, mas não gira	Sequência incorreta dos pinos de fase	Garantir que a ordem dos pinos na declaração da biblioteca Stepper seja estritamente (passos, IN1, IN3, IN2, IN4) — pinos 8, 10, 9, 11 no Arduino.
A leitura de botões ou sensores de contato oscila aleatoriamente	Pino em estado flutuante (floating pin)	Configurar a porta com pinMode(pino, INPUT_PULLUP) para ativar o resistor de elevação interno ou instalar resistor de 10 kΩ externo para o GND/5V.
O sensor ultrassônico HC-SR04 retorna apenas 0 cm ou valores fora de escala	Tensão de alimentação insuficiente ou timeout curto	Alimentar o HC-SR04 diretamente no barramento de 5V estável do Arduino; verificar se o pulso de disparo no pino Trigger possui 10 µs precisos.
Arduino reinicia (reset) repentinamente ao ligar motores ou relés	Queda de tensão (Brownout Reset) provocada por pico de corrente	Alimentar cargas indutivas pesadas através de uma fonte de alimentação externa de 5V/9V com o terra (GND) interligado ao GND do Arduino; adicionar capacitor eletrolítico de $100\,\mu\text{F}$ em paralelo com a alimentação.
Caracteres corrompidos ou ilegíveis no Monitor Serial	Incompatibilidade de Baud Rate	Ajustar o seletor de velocidade no canto inferior direito do Monitor Serial para corresponder exatamente ao valor declarado em Serial.begin(9600).

---

---

Solução de problemas

Olá! Sou o assistente técnico da RoboBuilders. Descreva seu problema com o Kit Avançado 27 Tutoriais Placa Uno Compatível Com Arduino AE314 RB2687 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.