Entrada e Saída Digital
Como o Arduino escuta um botão sem se confundir, como ele acende um LED ou aciona um relé sem se queimar, e a física que explica as duas coisas.
Ao terminar, você consegue
- Ligar um botão em
INPUT_PULLUPe prever HIGH/LOW antes de medir. - Calcular a corrente de um LED com 220 Ω e dizer se o pino aguenta.
- Acionar um módulo relé pelo pino (ativo em LOW) sem alimentar a bobina pelo GPIO.
Se for além: explicar tensão, corrente e resistência com analogia e fórmula; dizer por que uma entrada flutuante lê lixo; adaptar tudo para o ESP32-S3 sem queimar a placa; criar o aviso de dois toques com uma variação sua.
Na bancada
- Arduino Uno + cabo USB
- Protoboard e fios jumper
- 2 botões (push-button)
- 1 resistor de 10 kΩ (marrom, preto, laranja)
- LED + resistor de 220 Ω (opcional: o LED 13 já está na placa)
- Módulo relé de 5 V (1 ou 2 canais)
- Multímetro (muito recomendado)
- ESP32-S3 N16R8: só se for fazer a seção da ponte (09)
Como estudar esta página
- Preveja antes de cada experimento. Errar a previsão é o que faz a ideia grudar.
- Teste primeiro na bancada virtual daqui, depois no kit.
- Explique com suas palavras na caixa Feynman do fim.
- Revise nas datas da agenda. Só ler uma vez não funciona.
De onde você vem e o aquecimento de hoje
Antes do assunto de hoje, um aquecimento: imprimir um nome na Serial. Vale refazer, porque a Serial volta no desafio do fim.
Onde esta aula se encaixa
- Antes daqui você já sabe ligar a placa, escolher a porta na IDE e gravar um sketch que compila.
- Também já viu o básico da Serial:
Serial.begineSerial.printlnpara a placa conversar com o computador. - Aqui o Arduino toca o mundo físico pela primeira vez: lê um botão e aciona um LED ou um relé, tudo em dois estados (0 ou 1).
- Depois daqui vêm os sinais que não são só 0 ou 1: entrada analógica (ler um valor contínuo) e PWM (simular tensão intermediária na saída).
Aquecimento: imprimir um nome na Serial
Objetivo: imprimir "Arduino" uma vez, no setup, e o seu nome a cada segundo, no loop. Clique numa linha para ver a explicação.
void setup() {
Serial.begin(9600);
Serial.println("Arduino");
}
void loop() {
Serial.println("Fabricio");
delay(1000);
}Para ver a saída: Ferramentas → Monitor Serial, e confira que o canto inferior direito mostra 9600 baud.
O que tem no Arduino Uno
Antes de ligar qualquer fio, você precisa saber o que cada fileira de furos da placa faz. Passe o mouse (ou toque) nos grupos do desenho.
Mapa da placa
InterativoPasse o mouse num grupo
Ou toque nele. A explicação de cada grupo aparece aqui.
Os quatro pinos de alimentação que você vai usar o tempo todo
- 5V: a "torneira" principal desta aula. O 5V da placa, alimentada por USB, aguenta o módulo relé daqui. Motor, fita de LED e fonte de servo não entram neste pino.
- 3.3V: uma torneira menor, para sensores de 3,3 V. Guarde este número: o ESP32-S3 inteiro vive nele.
- GND (dois pinos aqui, mais um na fileira de cima): o "ralo". É a referência de 0 V e o caminho de volta de toda corrente. Todo circuito que você montar tem de compartilhar o GND com o Arduino.
- VIN: entrada de fonte externa (7 a 12 V). Não use nesta aula.
Protoboard: a placa de prototipagem
A protoboard tem fios escondidos por dentro. Quem não sabe onde eles passam monta curto-circuito sem perceber.
Raio-X da protoboard
Clique num furoRegra prática: um componente entra numa coluna e sai por outra. Se as duas pernas do resistor caírem na mesma coluna de 5 furos, o trilho interno liga uma perna à outra e a corrente passa por fora do resistor. É como se ele não existisse.
Tensão, corrente e resistência
A Lei de Ohm cabe em uma linha. Aqui ela vem em três camadas: uma analogia, um laboratório para mexer e a fórmula com os números do seu kit.
Três palavras antes de tudo
| Grandeza | Símbolo e unidade | O que é, sem jargão | Na analogia da água |
|---|---|---|---|
| Tensão | V, em volts (V) | O "empurrão" que uma fonte dá nas cargas elétricas. Sempre medida entre dois pontos. | Pressão da água (diferença de altura entre dois tanques) |
| Corrente | I, em ampères (A) | Quanta carga passa por um ponto a cada segundo. | Vazão: litros por segundo passando no cano |
| Resistência | R, em ohms (Ω) | O quanto um caminho dificulta a passagem da corrente. | Estreitamento do cano |
Repare no detalhe que mais confunde iniciante: tensão é sempre entre dois pontos. Dizer "o pino está em 5 V" significa "5 V em relação ao GND". Por isso o GND tem de ser comum a tudo.
O laboratório logo abaixo mostra os três ao mesmo tempo: circuito com a corrente animada, o cano com a água e o gráfico. Mexa nos controles e veja as três representações mudarem juntas.
- 1 V
- 1 joule de energia entregue a cada coulomb de carga que atravessa (J/C)
- 1 A
- 1 coulomb de carga passando por segundo (C/s), cerca de 6 quintilhões de elétrons
- 1 Ω
- a resistência que deixa passar 1 A quando há 1 V sobre ela (V/A)
Conferindo as unidades: Ω × A = (V/A) × A = V. A fórmula fecha. Quando uma conta não fechar nas unidades, a conta está errada.
Laboratório da Lei de Ohm
Mexa nos controlesA fórmula com os números do seu kit
- Um LED vermelho típico "segura" cerca de 2 V para si (é a tensão de condução dele; não obedece à Lei de Ohm).
- Sobram para o resistor: 5 V − 2 V = 3 V.
- Corrente pelo resistor (e pelo LED, é o mesmo caminho): I = V ÷ R = 3 V ÷ 220 Ω = 0,0136 A = 13,6 mA.
- Conferindo o limite do pino: 13,6 mA < 20 mA recomendados. Seguro.
- Não há LED, então toda a tensão cai no resistor: V = 5 V.
- I = 5 V ÷ 10 000 Ω = 0,0005 A = 0,5 mA.
- É 40 vezes menor que o limite do pino. Por isso o pull-down pode ficar ligado o dia todo sem esquentar nada.
Calcule a corrente. Depois responda: o LED vai brilhar mais ou menos que no Uno?
Potência: por que as coisas esquentam
No exemplo do LED: 3 V × 0,0136 A = 0,041 W. Tranquilo. No preset "Curto (1 Ω)" do laboratório: 5 V ÷ 1 Ω = 5 A, e 5 V × 5 A = 25 W. Um fio fino vira aquecedor e o regulador da placa desliga por proteção, se você tiver sorte. É por isso que o resistor existe: ele transforma um curto de 25 W numa corrente inofensiva.
Como o Arduino escuta um botão
A regra do modo INPUT puro: só use quando o pino for receber 0 V ou 5 V de verdade, isto é, quando a entrada nunca ficar flutuante. Esta seção explica cada palavra dessa regra.
"Digital" significa só dois estados
No Uno (que funciona em 5 V), o chip decide assim:
Entre 1,5 V e 3,0 V a resposta é imprevisível: pode dar HIGH, pode dar LOW, pode alternar. Um bom circuito de entrada nunca deixa o pino parado nessa zona. É isso que significa dizer que a entrada precisa ver "0 ou 1 elétrico" de verdade.
O problema: a entrada flutuante
Agora olhe a ligação mais ingênua possível: um botão entre 5 V e o pino 2. Apertado, o pino vê 5 V: HIGH, certo. Solto, o pino não vê nada. Não é 0 V; é nada. Flutua.
Simulador do pino 2
Segure o botãoFlutuante: com o botão solto, nada define a tensão. Repare no voltímetro.
Tabela do experimento, preenchida pelo simulador (modo atual)
| Botão | Tensão no pino 2 | digitalRead(2) | LED 13 |
|---|---|---|---|
| Solto | — | — | — |
| Apertado | — | — | — |
Troque o modo e aperte o botão de novo: cada modo tem a sua linha "solto" e "apertado". Compare com a tabela que você vai preencher no kit, mais abaixo.
A solução: um resistor que "puxa" o pino
| Configuração | Botão solto | Botão apertado | Quem define o "solto" |
|---|---|---|---|
| Flutuante | indefinido | HIGH | Ninguém. Ruído. |
| Pull-down (resistor para o GND, botão para o 5 V) | LOW | HIGH | O resistor |
| Pull-up (resistor para o 5 V, botão para o GND) | HIGH | LOW | O resistor |
INPUT_PULLUP (resistor interno de 20 a 50 kΩ) | HIGH | LOW | O resistor dentro do chip |
Por que 10 kΩ? A física do resistor de pull
O resistor de pull tem dois trabalhos opostos, e o valor dele é um acordo entre os dois:
- Quando o botão está apertado, o resistor fica ligado direto entre 5 V e GND. Corrente desperdiçada: I = 5 V ÷ R. Resistor pequeno demais gasta corrente e esquenta.
- Quando o botão está solto, o resistor tem de "vencer" o ruído e a pequena corrente de fuga do pino (no máximo do datasheet, 1 µA; o típico é bem menor, e não medimos isso neste pino). Pela Lei de Ohm, essa fuga cria uma tensão V = Ifuga × R sobre o resistor. Resistor grande demais deixa essa tensão invadir a zona proibida.
Escolhendo o resistor de pull
DeslizeDeslize até 100 Ω: com o botão apertado, 50 mA saem do trilho de 5 V e atravessam botão e resistor até o GND — o pino é de alta impedância e não conduz nada disso. São 0,25 W dissipados no resistor, exatamente o limite de um resistor de 1/4 W, e corrente desperdiçada da fonte a cada aperto. Deslize até 10 MΩ: a fuga de 1 µA cria 10 V teóricos sobre o resistor, ou seja, o pino nunca chega perto do nível certo e qualquer ruído manda. Entre 4,7 kΩ e 100 kΩ tudo funciona. 10 kΩ é o padrão da indústria porque gasta só 0,5 mA e ainda é 10 vezes mais "forte" que o ruído típico.
INPUT_PULLUP: o resistor que já vem de graça
A chave está dentro do próprio chip: o Arduino já traz um resistor de pull-up interno, e você o liga trocando INPUT por INPUT_PULLUP. O segundo argumento do pinMode deixa de ser INPUT e passa a ser INPUT_PULLUP; o resistor externo de 10 kΩ fica dispensado. O botão vai entre o pino e o GND, e a lógica fica invertida: solto = HIGH, apertado = LOW.
É para isso que serve o ! (não) no código: digitalWrite(13, !digitalRead(2)) lê LOW quando apertado, inverte para HIGH e acende o LED. Troque a opção "Código" no simulador e veja.
Quando usar cada modo
INPUT_PULLUPpara contato seco: qualquer coisa que só fecha ou abre dois fios, sem fornecer tensão própria. Entram nessa categoria: contato de relé, interruptor, botão, pressostato (chave que fecha com pressão de ar ou água), termostato (chave que fecha com temperatura), fim de curso (chave que um carrinho ou braço aperta ao chegar ao limite). Todos os sensores de "bater e fechar" da robótica são contato seco.INPUTpuro só quando o outro lado garante 0 V ou 5 V o tempo todo, como a saída de um módulo sensor com eletrônica própria. Se houver qualquer chance de ficar solto, não use.
Experimento 1: botão com INPUT_PULLUP
Objetivo: ligar um botão no pino 2 em modo INPUT_PULLUP, usar a leitura dele para acender o LED do pino 13 e preencher a tabela de estados abaixo.
ex4_botao_pullup_uno.ino.Preencha com o que você medir no kit (fica salvo neste navegador):
| Botão | Tensão no pino 2 (multímetro) | digitalRead(2) | LED 13 |
|---|---|---|---|
| Solto | |||
| Apertado |
Como o Arduino aciona alguma coisa
Um pino de saída do Uno entrega 5 V, com 20 mA recomendados, 40 mA como máximo absoluto e 200 mA somando todos os pinos — mais um quarto limite que quase ninguém conta: a soma por grupo de portas. Vamos entender de onde vêm esses números e o que acontece se você passar deles.
Os quatro números que importam
| Limite | Valor | De onde vem | O que acontece se passar |
|---|---|---|---|
| Recomendado por pino | 20 mA | Até aqui o fabricante garante a tensão de saída (≥ 4,2 V em HIGH) | Acima disso a tensão cai e o pino aquece |
| Máximo absoluto por pino | 40 mA | "Absolute maximum rating" do datasheet do ATmega328P | Dano permanente, às vezes silencioso |
| Soma por grupo de portas | 100 mA | Notas 3 e 4 da tabela de características DC: o datasheet agrupa os pinos e limita a soma de cada grupo | O grupo inteiro sai da especificação: a tensão de saída despenca |
| Soma de todos os pinos | 200 mA | Limite dos pinos VCC e GND do chip (tudo entra e sai por eles) | O chip inteiro superaquece; a placa pode reiniciar ou morrer |
O limite que quase ninguém conta: a soma por grupo de portas
O datasheet não para nos 40 mA de um pino e nos 200 mA do chip inteiro. Nas notas da tabela de características DC ele agrupa os pinos e limita a soma de cada grupo. Traduzindo os grupos do ATmega328/P para os pinos do Uno: drenando corrente (pino em LOW, IOL) são três grupos de 100 mA — D0 a D4, D5 a D13 e A0 a A5; fornecendo corrente (pino em HIGH, IOH) são dois grupos — A0 a A5 junto com D0 a D4, e D5 a D13. Na revisão que a Arduino publica (Atmel-42735B, 2016) o teto é 100 mA nos dois casos; na revisão atual da Microchip (DS40002061B, 2020) o teto de IOH subiu para 150 mA e o de IOL continuou em 100 mA. Projete pelo número menor: 100 mA por grupo.
É por isso que oito LEDs de 13,6 mA todos nos pinos 5 a 12 não passam: são 108,8 mA num grupo só, embora a soma esteja bem abaixo dos 200 mA do chip. Espalhe as cargas entre os grupos.
Fonte: ATmega328/P, Atmel-42735B (11/2016), seção 32.2 Common DC Characteristics, Table 32-2, notas 3 e 4; conferido também em DS40002061B (Microchip, 2020), seção 30.2, Table 30-1, notas 3 e 4. Os limites de 40 mA por pino e 200 mA em VCC/GND são das Absolute Maximum Ratings (seções 32.1 e 30.1).
Regra prática: um pino digital serve para "avisar", não para "alimentar". Um LED com resistor é o máximo que ele deve alimentar direto. Tudo que tem bobina, motor ou lâmpada recebe o aviso do pino e a energia de outro lugar.
Orçamento de corrente
Quantos de cada?Cada carga fica no seu próprio pino. Verde: até 20 mA. Amarelo: entre 20 e 40 mA, funciona, mas fora da garantia. Vermelho: acima de 40 mA, não faça.
Soma de todos os pinos. Marca amarela: 100 mA, o limite de um grupo de portas. Marca preta: 200 mA, o limite do chip.
Adicione cargas para ver o orçamento.
O módulo relé: o "amplificador de aviso"
Relé é um interruptor mecânico movido por um eletroímã (a bobina). Com ele, um aviso de 5 mA do Arduino liga uma lâmpada, uma bomba d'água ou um motor de 10 A, num circuito completamente separado. O módulo relé embala o relé com o que falta: um transistor que fornece os 70 mA da bobina, um diodo que absorve o pico de desligamento e, nos bons módulos, um optoacoplador que isola o Arduino da parte de potência.
Experimento 2: acionar um relé
Objetivo: ligar o módulo relé no pino 5 e comandá-lo por um segundo botão no pino 4, sem perder o primeiro botão do pino 2 que acende o LED 13.
Simulador do experimento 2
Dois botõesO código simulado aqui é o mais ingênuo possível: digitalWrite(5, digitalRead(4)). Segure o botão B e acompanhe a cadeia: o pino 4 vai a LOW → o código copia o LOW para o pino 5 → o módulo (ativo em LOW) energiza a bobina → o contato pula de NC para NO → a carga liga.
Agora troque para "ativo em HIGH" sem mudar o código: a carga passa a ficar ligada em repouso e a desligar quando você aperta o botão. É o erro mais comum de quem monta isso pela primeira vez — e o motivo do RELE_ATIVO_EM_LOW no sketch da seção Código.
O desenho do módulo mais acima acompanha este simulador: repare no braço do contato e na lâmpada.
Armadilhas em que todo iniciante cai
Cada uma segue o mesmo ritual: leia o mito, preveja o que acontece, observe no simulador ou no kit, e só então abra a explicação.
"A corrente é gasta pelo LED."
Observe: no laboratório de Ohm, conte as bolinhas antes e depois do resistor.
"A fonte de 5 V entrega sempre a mesma corrente."
Observe: no laboratório, deixe 5 V e mude só R. A corrente muda.
"Botão apertado é sempre HIGH."
Observe: no simulador do pino, compare Pull-down e INPUT_PULLUP apertados.
! nos códigos."Se não liguei nada no pino, ele lê LOW."
Observe: simulador em Flutuante, botão solto. Olhe o voltímetro.
"GND é só o 'negativo', não importa onde ligo."
Observe: monte o experimento 1 com o botão no GND de uma protoboard sem fio GND para o Arduino. Nada funciona.
"O módulo relé liga quando mando HIGH."
Observe: simulador do experimento 2: troque "ativo em LOW" por "ativo em HIGH" com o mesmo código.
digitalWrite(5, digitalRead(4)), um módulo ativo em HIGH fica ligado em repouso e desliga quando você aperta — é o que o simulador mostra. No Uno, quando o nível desejado é HIGH, pré-carregá-lo com digitalWrite antes de declarar a saída evita uma passagem por saída LOW nessa troca; para um destino LOW, não é essa a transição evitada. Isso não descreve reset, bootloader, alimentação nem o estado da carga. Teste o módulo identificado com um LED em baixa tensão antes de uma carga real."5 V e 3,3 V são quase iguais, dá para misturar."
Observe: não observe no kit. Leia a Ponte para o ESP32-S3.
"Um pino aguenta qualquer coisa pequena."
Observe: orçamento de corrente com "bobina direto no pino" ou "motor DC".
"Se o LED piscou duas vezes num aperto só, o código está errado."
Observe: no kit, aperte e solte o botão do experimento 1 dez vezes olhando o LED 13, e releia a caixa "O que o botão faz e a aula ainda não trata".
Código completo, linha a linha
Clique em qualquer linha para ver a explicação. A versão ESP32-S3 está na seção Ponte, e todos os arquivos .ino estão listados no fim desta seção.
const int PINO_BOTAO = 2;
const int PINO_LED = 13;
void setup() {
pinMode(PINO_BOTAO, INPUT_PULLUP);
pinMode(PINO_LED, OUTPUT);
}
void loop() {
bool apertado = (digitalRead(PINO_BOTAO) == LOW);
digitalWrite(PINO_LED, apertado ? HIGH : LOW);
}
// ou: digitalWrite(PINO_LED, !digitalRead(PINO_BOTAO));const int PINO_BOTAO_LED = 2;
const int PINO_BOTAO_RELE = 4;
const int PINO_RELE = 5;
const int PINO_LED = 13;
const bool RELE_ATIVO_EM_LOW = true;
void setup() {
digitalWrite(PINO_RELE, RELE_ATIVO_EM_LOW ? HIGH : LOW);
pinMode(PINO_RELE, OUTPUT);
pinMode(PINO_BOTAO_LED, INPUT_PULLUP);
pinMode(PINO_BOTAO_RELE, INPUT_PULLUP);
pinMode(PINO_LED, OUTPUT);
}
void loop() {
bool botaoLed = (digitalRead(PINO_BOTAO_LED) == LOW);
bool botaoRele = (digitalRead(PINO_BOTAO_RELE) == LOW);
digitalWrite(PINO_LED, botaoLed ? HIGH : LOW);
bool nivelParaLigar = RELE_ATIVO_EM_LOW ? LOW : HIGH;
digitalWrite(PINO_RELE, botaoRele ? nivelParaLigar : !nivelParaLigar);
}Por que não escrever só digitalWrite(5, digitalRead(4))? Funciona no módulo ativo em LOW, mas esconde a intenção. Daqui a três meses, com vinte pinos, você vai agradecer ao código que diz o que quer.
Todos os sketches desta aula
Os seis arquivos ficam na pasta codigo/, ao lado desta página. Clique para abrir no navegador (ou salvar) e cole na IDE.
ex3_serial_nome.ino— Arduino Uno. Aquecimento: escreve "Arduino" uma vez nosetupe o seu nome a cada segundo noloop.ex4_botao_pullup_uno.ino— Arduino Uno. Experimento 1: botão no pino 2 emINPUT_PULLUPacendendo o LED 13.ex4_botao_pullup_esp32s3.ino— ESP32-S3 DevKitC-1. O mesmo experimento 1 com GPIO4 e o LED RGB da placa em verde.ex5_rele_uno.ino— Arduino Uno. Experimento 2: módulo relé no pino 5 comandado pelo botão do pino 4, sem perder o botão do pino 2.ex5_rele_esp32s3.ino— ESP32-S3 DevKitC-1. O experimento 2 em 3,3 V: botões em GPIO4 e GPIO6, sinal IN1 no GPIO5.desafio_parachoque_robo.ino— Arduino Uno. Ponto de partida do desafio: dois botões como fins de curso, relé no lugar do motor, LED 13 e Serial dizendo o lado.
O que muda quando você trocar de placa
Mais à frente a trilha migra para o ESP32. Tudo desta aula continua valendo: o que muda são os números. Um deles pode queimar sua placa.
| Nesta aula | Arduino Uno | ESP32-S3 DevKitC-1 N16R8 |
|---|---|---|
| Tensão lógica | 5 V | 3,3 V (o datasheet só garante o pino até VDD + 0,3 V; os 3,6 V são o teto dos pinos de alimentação) |
| Limiar de leitura digital | LOW ≤ 1,5 V · HIGH ≥ 3,0 V | LOW ≤ 0,825 V · HIGH ≥ 2,475 V |
| Pull-up interno | 20 a 50 kΩ, INPUT_PULLUP | ~45 kΩ, INPUT_PULLUP |
| Pull-down interno | Não existe (resistor externo) | Existe: INPUT_PULLDOWN |
| Corrente por pino | 20 mA recomendados, 40 mA máximo | ~20 mA por padrão, configurável até ~40 mA fornecendo (IOH) e ~28 mA drenando (IOL). Trate 20 mA como teto |
| Soma dos pinos | 200 mA | Menor folga. Para qualquer carga real, driver ou módulo |
| LED da placa | Pino 13, digitalWrite | LED RGB endereçável (WS2812) no GPIO48 (rev. v1.0) ou GPIO38 (v1.1): neopixelWrite(RGB_BUILTIN, r, g, b) |
| Numeração | D0 a D13, A0 a A5 | GPIOn. Comece pelos GPIO4 a 18, 21, 39 a 42, 47. O LED RGB da placa ocupa o 48 na v1.0 e o 38 na v1.1: use o outro dos dois, conforme a sua revisão |
| Pinos a evitar | 0 e 1 (Serial USB) | 0, 3, 45, 46 (boot); 35, 36, 37 (PSRAM octal do N16R8; o chip também usa 33 e 34, que nem saem do módulo); 26 a 32 (flash interno; normalmente nem saem no conector); 19 e 20 (USB nativo) |
| PWM (próxima aula) | Só 3, 5, 6, 9, 10, 11 | Praticamente qualquer GPIO |
| Analógico (próxima aula) | 10 bits: 0 a 1023 | 12 bits: 0 a 4095 |
| O que "N16R8" significa | — | 16 MB de flash e 8 MB de PSRAM (octal). Muito espaço para Wi-Fi, telas e IoT |
Levar um sinal de 5 V para 3,3 V: o divisor de tensão
É a Lei de Ohm duas vezes. Dois resistores em série dividem a tensão na proporção das resistências. Com 10 kΩ em cima e 20 kΩ embaixo, o ponto do meio fica em 5 V × 20 ÷ (10 + 20) = 3,33 V.
Para contato seco (botão, fim de curso) nada disso é necessário: o contato vai ao GND e o INPUT_PULLUP do ESP32-S3 faz o resto, exatamente como no Uno.
Arduino Uno
const int PINO_BOTAO = 2;
const int PINO_LED = 13;
void setup() {
pinMode(PINO_BOTAO, INPUT_PULLUP);
pinMode(PINO_LED, OUTPUT);
}
void loop() {
bool apertado = (digitalRead(PINO_BOTAO) == LOW);
digitalWrite(PINO_LED, apertado ? HIGH : LOW);
}ESP32-S3 N16R8
const int PINO_BOTAO = 4;
// LED RGB da placa: RGB_BUILTIN
void setup() {
pinMode(PINO_BOTAO, INPUT_PULLUP);
}
void loop() {
bool apertado = (digitalRead(PINO_BOTAO) == LOW);
if (apertado) neopixelWrite(RGB_BUILTIN, 0, 40, 0);
else neopixelWrite(RGB_BUILTIN, 0, 0, 0);
}Experimento 2 no ESP32-S3: o relé com 3,3 V
- Alimentação da bobina: siga o esquema e as faixas de VCC/JD-VCC do módulo identificado. O pino 5V/VBUS do DevKit vem da USB-C, mas isso por si só não demonstra que sua tensão ou corrente sirva para qualquer módulo. GND com GND quando o esquema do módulo pedir referência comum.
- Sinal IN1: vem do GPIO5 com 3,3 V somente depois de confirmar no manual e na medição que a entrada aceita lógica de 3,3 V e não devolve 5 V. Sem identificar o módulo, não dá para garantir lógica ativa, compatibilidade de tensão nem o papel do optoacoplador. Não force 5 V no GPIO. Se a entrada for incompatível, ela precisa de uma interface dimensionada para o módulo; teste sem carga primeiro.
- Inicialização do GPIO5: no datasheet do ESP32-S3, a Tabela 2-2 lista um pulso breve em LOW durante a energização, de 60 µs típicos. É uma evidência para tratar o relé como circuito a verificar, não uma duração máxima nem uma previsão da resposta da bobina. O sketch usa
INPUT_PULLUP → digitalWrite → OUTPUT; essa sequência foi inspecionada no Arduino-ESP32 3.3.11 e não transfere a conclusão do Uno para o ESP32-S3. - Botões: GPIO4 e GPIO6 para o GND, ambos
INPUT_PULLUP. O sketch completo está emex5_rele_esp32s3.ino.
Configuração do Arduino IDE para o N16R8
- Placa: ESP32S3 Dev Module.
- Flash Size: 16MB (128Mb). PSRAM: OPI PSRAM.
- USB CDC On Boot: Enabled (para o Monitor Serial funcionar pela porta USB-C nativa).
- Se o upload falhar: segure BOOT, aperte RESET, solte BOOT, e tente de novo.
Onde entrada e saída digital aparecem em IoT e robótica
Tudo que "bate e fecha" ou "liga e desliga" passa por esta aula.
Fim de curso de robô e impressora 3D
Contato seco em INPUT_PULLUP. Quando o carrinho encosta na chave, o pino vai a LOW e o firmware sabe que chegou ao limite. É o desafio desta aula.
Botão de emergência
Contato normalmente fechado (NC) em pull-up: em repouso lê LOW; se o fio partir ou alguém apertar, vai a HIGH e a máquina para. Falha "para o lado seguro".
Automação residencial com relé
ESP32-S3 recebe um comando pelo Wi-Fi e um pino digital aciona o módulo relé que liga a lâmpada ou a bomba. Entrada digital por Wi-Fi, saída digital por relé.
Sensor de presença (PIR, infravermelho passivo) e sensor de porta
O PIR entrega 0 V ou 3,3 V (saída "push-pull"): aqui INPUT puro é aceitável. O sensor magnético de porta é contato seco: INPUT_PULLUP.
Pressostato e termostato industriais
Dois clássicos do chão de fábrica. Uma chave que fecha com pressão ou temperatura, ligada a uma entrada com pull-up. É assim que um CLP (Controlador Lógico Programável, o computador industrial) e um Arduino "sentem" a fábrica.
Driver de motor
Pinos digitais dizem ao driver (ponte H) para onde girar; o driver fornece a corrente. O pino avisa, o driver alimenta: a regra dos 20 mA na prática.
Pratique até marcar tudo
Só passe adiante quando todos os "Eu consigo" estiverem marcados com honestidade. Tudo aqui fica salvo neste navegador.
Eu consigo…
Caixa Feynman
Explique, para alguém de 12 anos, por que um botão no Arduino precisa de um resistor de pull-up e o que o INPUT_PULLUP faz. Se travar numa palavra, é ali que está a lacuna: volte à seção e tente de novo.
Agora a Lei de Ohm: explique por que o resistor de 220 Ω "protege" o LED, com os números.
Salva sozinho enquanto você digitaFlashcards
Clique para virar. Tente responder em voz alta antes.
Agenda de revisão espaçada
As datas contam a partir do dia em que você abriu esta página pela primeira vez. Revisar em intervalos crescentes é a técnica com mais evidência científica que existe para não esquecer.
Exercício de revisão: Serial + entrada digital
Modifique o experimento 1 para imprimir na Serial, a cada 200 ms, a palavra "APERTADO" ou "SOLTO" conforme o botão, além de acender o LED. Depois responda: por que aparecem às vezes duas linhas "APERTADO" e "SOLTO" alternadas num aperto rápido?
void setup() {
Serial.begin(9600);
pinMode(2, INPUT_PULLUP);
pinMode(13, OUTPUT);
}
void loop() {
bool apertado = (digitalRead(2) == LOW);
digitalWrite(13, apertado);
Serial.println(apertado ? "APERTADO" : "SOLTO");
delay(200);
}As linhas alternadas em apertos rápidos são o repique (bounce) do contato metálico, ou o seu aperto caindo entre duas amostras de 200 ms. Sensores de contato exigem tratamento de repique, tema de aulas futuras.
Dois toques, um aviso
Dois botões em INPUT_PULLUP, cada um no GND: esquerda no pino 2, direita no pino 4. O módulo relé no pino 5 faz o papel de "motor" (ativo em LOW). Enquanto os dois estão soltos, o motor fica ligado. Se qualquer um ler LOW, o motor para na hora e a Serial diz o lado: esquerda, direita ou os dois. Só religa quando os dois botões voltam a HIGH.
O que vale como pronto: a Serial diz o lado certo enquanto você segura o botão.
O que não vale como falha sua: o relé tremer e a Serial repetir a colisão quando você solta o botão. É o repique da caixa verde do experimento 1: o sketch libera o trinco na primeira leitura HIGH do contato, que ainda está quicando. Não "conserte" com delay aleatório. A aula seguinte começa neste sintoma.
Ainda não: chassi, motor de verdade, debounce, interrupção. Quem ligou motor no 5V da placa saiu do contrato.
Um sketch de partida está em desafio_parachoque_robo.ino. Para valer como "criar", faça uma variação com o kit desta aula: contar colisões na Serial, ou adaptar para o ESP32-S3 com o LED RGB vermelho na batida. Segundo relé / "dar ré" fica de fora: pede canal que a bancada de hoje não exige.
Monte primeiro no Wokwi (relé, dois botões), depois no kit com uma carga de baixa tensão.
Simuladores e fontes
Grátis, no navegador. Cada um serve para uma coisa diferente.
Wokwi
Arduino Uno e ESP32-S3 com o código de verdade. Monte: Uno + pushbutton no pino 2 e GND, cole o sketch do experimento 1. Depois adicione um "Relay Module" no pino 5 e um segundo botão no 4. Exemplo pronto de pull-up: wokwi.com/projects/378748597724238849.
Falstad CircuitJS
Mostra a corrente fluindo como pontinhos. Monte: fonte 5 V, resistor 10 kΩ e uma chave (Draw → Passive → Switch) no arranjo pull-down; olhe a tensão do nó ao abrir e fechar. Depois troque para pull-up.
Tinkercad Circuits
Protoboard virtual com Arduino e multímetro. Ideal para treinar a montagem física do experimento 1 antes de encostar no kit e ver os trilhos internos ao passar o mouse.
PhET: Kit de Construção de Circuitos DC
Física pura: bateria, resistor, lâmpada, amperímetro e voltímetro. Monte bateria + resistor e confirme I = V ÷ R com os medidores. Veja os elétrons andando devagar.
Canal Crescer Indústria de Automação
Canal do professor Cristiano Nazário, com mais de 400 vídeos. Foi com ele que eu aprendi eletrônica. Blog: crescerengenharia.com/blog.
Datasheets usados nesta aula
ATmega328/P (Atmel-42735B), §§18.2.1 e 18.2.3 (reset em alta impedância e transição entrada/saída), limites por pino e por grupo de portas, limiares e pull-up interno; e ESP32-S3, Tabela 2-2, pp. 18–19 (glitch de power-up), além de 3,3 V, pull-up e strapping. A sequência das APIs foi inspecionada no Arduino AVR Core 1.8.6, no Arduino-ESP32 3.3.11, gpio.c, no gpio.h e no ESP-IDF v5.5.5, gpio.c. Pinout do DevKitC-1: Random Nerd Tutorials.
Glossário
- Tensão (V)
- Diferença de "empurrão" elétrico entre dois pontos, em volts. Sempre relativa a uma referência (GND).
- Corrente (I)
- Quantidade de carga que passa por segundo, em ampères. 1 mA = 0,001 A.
- Resistência (R)
- Oposição à passagem de corrente, em ohms. 10 kΩ = 10 000 Ω.
- Potência (P)
- Energia por segundo, em watts. P = V × I. É o que esquenta.
- GND
- Ground, terra. Referência de 0 V e caminho de retorno da corrente.
- HIGH / LOW
- Os dois estados de um pino digital: perto de 5 V (3,3 V no ESP32) ou perto de 0 V.
- Zona proibida
- Faixa de tensão entre os limiares de LOW e HIGH, onde a leitura não é garantida.
- Entrada flutuante
- Pino configurado como entrada sem caminho definido para 5 V nem GND. Lê ruído.
- Pull-up / Pull-down
- Resistor que "puxa" o pino para 5 V (up) ou GND (down) quando nada mais o define.
- INPUT_PULLUP
- Modo do pinMode que liga o pull-up interno (20 a 50 kΩ no Uno, ~45 kΩ no ESP32-S3).
- Contato seco
- Sensor ou chave que apenas fecha ou abre dois fios, sem fornecer tensão própria.
- PIR
- Passive InfraRed, infravermelho passivo: sensor que detecta o calor em movimento de um corpo. Entrega 0 V ou 3,3 V numa saída push-pull.
- Fim de curso
- Chave acionada mecanicamente quando uma peça chega ao limite do movimento.
- Pressostato / Termostato
- Chaves que fecham ou abrem por pressão ou por temperatura.
- Relé
- Interruptor mecânico movido por um eletroímã (bobina). Separa o circuito de controle do de potência.
- COM / NO / NC
- Bornes do contato do relé: comum, normalmente aberto e normalmente fechado.
- Ativo em LOW
- Entrada que "liga" quando recebe 0 V. Comum em módulos relé.
- Optoacoplador
- LED + fototransistor no mesmo chip: passa o sinal por luz, isolando eletricamente os lados.
- Divisor de tensão
- Dois resistores em série que entregam, no ponto do meio, uma fração da tensão total.
- PWM
- Modulação por largura de pulso: liga e desliga rápido para simular tensão intermediária. Assunto da saída analógica.
- GPIO
- General Purpose Input/Output: pino de uso geral, que o programa configura como entrada ou saída. É como o ESP32-S3 numera os pinos (GPIO4, GPIO5…), no lugar do D0–D13 do Uno.
- Strapping pins
- Pinos do ESP32-S3 lidos no boot para decidir o modo de inicialização (0, 3, 45, 46).
- N16R8
- Sufixo do módulo ESP32-S3: 16 MB de flash e 8 MB de PSRAM.
- Repique (bounce)
- Vibração mecânica do contato ao fechar ou abrir: em poucos milissegundos o pino lê HIGH-LOW-HIGH várias vezes. Trata-se por software (esperar alguns ms) ou por hardware.
- Impedância
- Quanto um ponto do circuito se opõe à passagem de corrente. "Alta impedância" é o estado de um pino em modo entrada: ele quase não puxa nem fornece corrente, só observa a tensão.
- Acoplamento capacitivo
- Campo elétrico de um fio ou da sua mão induzindo tensão num condutor vizinho, sem contato. É o que faz uma entrada flutuante captar "lixo".
- Protoboard
- Placa de furos com trilhos metálicos por dentro, para montar circuitos sem solda. Colunas de 5 furos ligadas entre si e trilhos laterais de alimentação.
- Sketch
- O nome que o Arduino dá a um programa: o arquivo
.inocomsetup()eloop(). - WS2812
- LED RGB "endereçável": recebe cor por um único fio de dados, num protocolo próprio. É o LED colorido do ESP32-S3 DevKitC-1.
- PSRAM
- Memória RAM externa ao núcleo, dentro do módulo ESP32-S3. O N16R8 traz 8 MB dela, usados por telas, buffers de rede e imagens.
Aula autoral de Fabrício Ferreira. Aprendi eletrônica no curso do professor Cristiano Nazário (Crescer Indústria de Automação). Esta página não reproduz o material do curso. Site independente, sem vínculo com a empresa. Números técnicos conferidos nos datasheets do ATmega328P (Microchip) e do ESP32-S3 (Espressif).
Metodologia: prática de recuperação, revisão espaçada, exemplos resolvidos, três camadas concreto → visual → fórmula, e desmontagem de equívocos.