Eletrônica · Arduino Uno e ESP32-S3

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.

Tempo: 90 a 120 min com o kit na mão Placa de hoje: Arduino Uno. Ponte para o ESP32-S3 N16R8 no fim

Ao terminar, você consegue

Explicar tensão, corrente e resistência com uma analogia e com a fórmula.
Dizer por que uma entrada "flutuante" lê lixo e como um resistor de pull-up ou pull-down resolve.
Ligar um botão com INPUT_PULLUP e prever se ele lê HIGH ou LOW.
Calcular a corrente de um LED com resistor e dizer se um pino aguenta uma carga.
Acionar um módulo relé com segurança e explicar COM, NO e NC.
Adaptar tudo isso para o ESP32-S3 (3,3 V) sem queimar a placa.
Criar um para-choque de robô com dois fins de curso.

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 para a ponte no fim

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.

01 · Aquecimento

Onde estamos e o que ficou da aula passada

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.begin e Serial.println para 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

Enunciado: usando Serial.println, escreva "Arduino" dentro do setup e o seu nome na função loop a cada 1 segundo. Clique numa linha para ver a explicação.

ex3_serial_nome.ino

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.

02 · A placa

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

Interativo

Fileira de cima: 14 portas digitais (0 a 13). Fileira de baixo: alimentação à esquerda e entradas analógicas à direita. O til (~) marca as 6 portas que também fazem PWM: 3, 5, 6, 9, 10 e 11.

Passe 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. Alimenta módulos e o resistor de pull-up externo.
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.

03 · A bancada

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 furo

Clique em qualquer furo para ver todos os furos que estão ligados a ele por dentro. Ative o raio-X para ver todos os trilhos de uma vez.

Mostrar raio-X (todos os trilhos)

Furo clicado—

Ligado aclique num furo

Regra 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.

04 · Física · Lei de Ohm

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.

Analogia · água no cano

Imagine uma bomba d'água empurrando água por um circuito fechado de canos. A pressão da bomba é a tensão. A vazão de água é a corrente. Um trecho de cano estreito é a resistência.

Três consequências que você consegue "sentir": mais pressão com o mesmo cano, mais vazão. Cano mais estreito com a mesma pressão, menos vazão. E a água que sai da bomba é a mesma que volta para ela: a vazão não é "gasta" no caminho.

Onde a analogia quebra: a água precisa de espaço vazio para correr; os elétrons já estão dentro do fio, o que se propaga é o empurrão (quase na velocidade da luz), embora cada elétron ande a milímetros por segundo. E a analogia não explica corrente alternada nem capacitores. Serve para tudo desta aula, que é corrente contínua.

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.

V = R × ILê-se: a tensão sobre um componente é a resistência dele vezes a corrente que passa por ele. Reorganizando: I = V ÷ R e R = V ÷ I.

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 controles

Cada bolinha é um "pacote de carga". Conte: entram tantas no resistor quantas saem. A corrente não é consumida; o que o resistor consome é energia (esquenta).

Mais pressão (V), fluxo mais rápido. Cano mais estreito (R), fluxo mais lento.

Para um resistor fixo, corrente e tensão são uma reta que passa pela origem. A inclinação é 1/R. Passe o mouse para ler valores.

Tensão da fonte V5,0 V Resistência R220 Ω

LED com 220 Ω Pull-down 10 kΩ Curto (1 Ω)

Corrente I22,7 mA

Potência P = V×I114 mW

Um pino do Uno aguenta?Acima dos 20 mA recomendados

Mostrar os elétrons de verdade (sentido oposto)

A fórmula com os números do seu kit

Exemplo resolvido · LED vermelho com resistor de 220 Ω em 5 V

Um LED vermelho "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.

Complete as lacunas · resistor de 10 kΩ direto em 5 V (o pull-down desta aula)

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.

5 V; 0,0005 A; 0,5 mA. Se você escreveu 0,5 A, faltou converter: 1 A = 1000 mA.

Sozinho · o mesmo LED no ESP32-S3 (3,3 V) com 220 Ω

Calcule a corrente. Depois responda: o LED vai brilhar mais ou menos que no Uno?

(3,3 − 2,0) ÷ 220 = 0,0059 A = 5,9 mA. Menos da metade dos 13,6 mA: o LED acende, mas mais fraco. Para o mesmo brilho no ESP32-S3, use 100 Ω (13 mA).

Potência: por que as coisas esquentam

P = V × IPotência em watts (W): energia por segundo. Um resistor comum do kit aguenta 0,25 W (1/4 W).

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.

05 · Entrada digital

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:

0 V1,5 V3,0 V5 V

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 o instrutor quer dizer com "0 e 1 elétrico".

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ão

O ponto preto é o pino 2. O que define a tensão dele é o caminho que existe entre 5 V, o pino e o GND. Sem caminho, ele flutua.

Flutuante Pull-down Pull-up externo INPUT_PULLUP

Tensão no pino0,0 V

digitalRead(2)LOW

Código que liga o LED 13: digitalWrite(13, digitalRead(2)) digitalWrite(13, !digitalRead(2))

Flutuante: com o botão solto, nada define a tensão. Repare no voltímetro.

Tabela do exercício 4, 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 (na casa de 1 µA). Pela Lei de Ohm, essa fuga cria uma tensão V = I_fuga × R sobre o resistor. Resistor grande demais deixa essa tensão invadir a zona proibida.

Escolhendo o resistor de pull

Deslize

Resistor de pull10 kΩ

Corrente com botão apertado0,5 mA

Tensão de fuga com botão solto (1 µA)10 mV

VereditoÓtimo

Deslize até 100 Ω: 50 mA desperdiçados a cada aperto, mais que o máximo de um pino. 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. Com um argumento a mais no pinMode você ativa esse resistor e dispensa o de 10 kΩ. 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 o rádio "Código" no simulador e veja.

Quando usar cada modo

INPUT_PULLUP para 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 no limite). Todos os sensores de "bater e fechar" da robótica são contato seco.
INPUT puro 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.

Dois fios e um botão. O código completo está na seção Código, e o sketch ex4_botao_pullup_uno.ino na pasta codigo/.

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

06 · Saída digital

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. Vamos entender de onde vêm esses três números e o que acontece se você passar deles.

Em HIGH, a corrente sai do 5 V, passa pela chave de cima, pelos ~40 Ω internos, pelo resistor de 220 Ω e pelo LED até o GND. É por isso que um pino "em HIGH" mede uns 4,2 V com 20 mA de carga, e não 5 V cravados.

Os três 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 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

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?

Pior pino0 mA

Soma de todos0 mA

Soma de todos os pinos (limite 200 mA)

Cada carga fica no seu próprio pino. Verde: até 20 mA. Laranja: entre 20 e 40 mA, funciona mas fora da garantia. Vermelho: acima de 40 mA, não faça.

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.

Do lado esquerdo da linha tracejada, tudo é 5 V e miliampères. Do lado direito, a carga tem a fonte dela. COM é o pino comum; em repouso ele está ligado ao NC e, com a bobina energizada, muda para o NO. Para "ligar algo ao apertar", use COM e NO.

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.

Os dois botões vão para o GND (pull-up interno). O módulo recebe 5V e GND do Arduino e o aviso no IN1. A carga tem fonte própria e passa por COM e NO.

Simulador do exercício 5

Dois botões

módulo ativo em LOW módulo ativo em HIGH

digitalRead(2)HIGH

digitalRead(4)HIGH

LED 13apagado

pino 5 → IN1HIGH

Relérepouso

Cargadesligada

Segure o botão B e acompanhe a cadeia: pino 4 vai a LOW → o código copia para o pino 5 → o módulo (ativo em LOW) energiza a bobina → o contato pula de NC para NO → a carga liga. Troque para "ativo em HIGH" e veja o que acontece com o mesmo código: é o erro mais comum de quem monta isso pela primeira vez.

O desenho do módulo mais acima acompanha este simulador: repare no braço do contato e na lâmpada.

07 · Equívocos comuns

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.

Mito 1

"A corrente é gasta pelo LED."

Observe: no laboratório de Ohm, conte as bolinhas antes e depois do resistor.

A corrente é a mesma em qualquer ponto de um caminho único. O que o LED gasta é energia (a tensão cai 2 V sobre ele). Corrente é vazão; energia é o que a bomba entregou à água.

Mito 2

"A fonte de 5 V entrega sempre a mesma corrente."

Observe: no laboratório, deixe 5 V e mude só R. A corrente muda.

Fonte de tensão fixa a tensão; a corrente é decidida pela carga (I = V ÷ R). Sem carga, corrente zero. Com curto, corrente até a fonte desistir. Por isso "quantos ampères a fonte fornece" é um limite, não uma imposição.

Mito 3

"Botão apertado é sempre HIGH."

Observe: no simulador do pino, compare Pull-down e INPUT_PULLUP apertados.

Depende de para onde o botão leva o pino. Com INPUT_PULLUP o botão vai ao GND: apertado = LOW. É a configuração mais usada, e é a razão do ! nos códigos.

Mito 4

"Se não liguei nada no pino, ele lê LOW."

Observe: simulador em Flutuante, botão solto. Olhe o voltímetro.

"Nada ligado" não é 0 V; é indefinido. O pino vira antena. Só um caminho com resistência definida (pull-up ou pull-down) dá a ele um nível de repouso.

Mito 5

"GND é só o 'negativo', não importa onde ligo."

Observe: monte o exercício 4 com o botão no GND de uma protoboard sem fio GND para o Arduino. Nada funciona.

GND é a referência de 0 V e o caminho de retorno de toda corrente. Dois circuitos só "conversam" se compartilham o GND. Primeiro fio de qualquer montagem: GND com GND.

Mito 6

"O módulo relé liga quando mando HIGH."

Observe: simulador do exercício 5: troque "ativo em LOW" por "ativo em HIGH" com o mesmo código.

A maioria dos módulos de 5 V é ativa em LOW. A carga liga no boot e desliga quando você "liga". Sempre teste o módulo com um LED antes de pendurar uma carga real, e inicialize o pino no estado "desligado" no setup.

Mito 7

"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.

3,3 V numa entrada de 5 V funciona (fica acima dos 3,0 V do HIGH). 5 V numa entrada de 3,3 V passa do máximo absoluto (3,6 V) e pode queimar o ESP32-S3. A regra é uma só: nunca 5 V num pino de 3,3 V.

Mito 8

"Um pino aguenta qualquer coisa pequena."

Observe: orçamento de corrente com "bobina direto no pino" ou "motor DC".

"Pequeno" para nós é grande para 40 Ω de silício. Motor, bobina, lâmpada e buzzer potente recebem só o aviso do pino; a energia vem de um transistor, driver ou módulo.

08 · Sketches

Código completo, linha a linha

Clique em qualquer linha para ver a explicação. Os mesmos arquivos estão na pasta codigo/ da aula; a versão ESP32-S3 está na seção Ponte.

Exercício 4 · ex4_botao_pullup_uno.ino

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));

Exercício 5 · ex5_rele_uno.ino

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() {
  pinMode(PINO_BOTAO_LED,  INPUT_PULLUP);
  pinMode(PINO_BOTAO_RELE, INPUT_PULLUP);
  pinMode(PINO_LED,  OUTPUT);
  pinMode(PINO_RELE, OUTPUT);
  digitalWrite(PINO_RELE, RELE_ATIVO_EM_LOW ? HIGH : LOW);
}

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.

09 · Ponte Arduino Uno → ESP32-S3 N16R8

O que muda quando você trocar de placa

O curso migra para o ESP32 mais à frente. 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 (máximo absoluto 3,6 V no pino)
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 recomendado, 40 mA máximo	~20 mA por padrão (configurável até ~40 mA). 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, 38 a 42, 47, 48
Pinos a evitar	0 e 1 (Serial USB)	0, 3, 45, 46 (boot); 35, 36, 37 (PSRAM octal do N16R8); 19 e 20 (USB nativo)
PWM (aula 1.8)	Só 3, 5, 6, 9, 10, 11	Praticamente qualquer GPIO
Analógico (aula 1.7)	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.

A mesma corrente atravessa os dois resistores. A tensão em cada um é proporcional à resistência: 2/3 dela fica no de 20 kΩ.

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

Exercício 4

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

ex4_botao_pullup_esp32s3.ino

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);
}

Exercício 5 no ESP32-S3: o relé com 3,3 V

Bobina do módulo: alimente VCC (ou JD-VCC) com o pino 5V/VBUS do DevKit, que repassa os 5 V da USB-C. GND com GND.
Sinal IN1: vem do GPIO5 com 3,3 V. A maioria dos módulos com optoacoplador aceita. Se o relé ficar "meio ligado" ou não desligar, use um módulo de 3,3 V ou um transistor NPN entre o GPIO e o IN.
Botões: GPIO4 e GPIO6 para o GND, ambos INPUT_PULLUP. O sketch completo está em codigo/ex5_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.

10 · Para que serve

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 no 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) 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 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.

11 · Maestria

Pratique até marcar tudo

Só passe para a aula 1.7 quando todos os "Eu consigo" estiverem marcados com honestidade. Tudo aqui fica salvo neste navegador.

Flashcards

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 intercalado (aula 1.5 + 1.6)

Modifique o exercício 4 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 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.

Desafio de criação

Para-choque de robô

Dois botões fazem o papel de fins de curso (esquerda no pino 2, direita no pino 4). O módulo relé no pino 5 é o "motor". Enquanto nada é tocado, o motor fica ligado. Ao bater em qualquer lado: o motor desliga na hora, o LED 13 pisca três vezes e a Serial diz de que lado foi a colisão. O robô só religa quando o para-choque é solto.

Um sketch de partida está em codigo/desafio_parachoque_robo.ino. Para valer como "criar", faça uma variação sua: dar ré por um segundo com um segundo relé, contar colisões, ou portar para o ESP32-S3 com o LED RGB vermelho na batida.

Monte primeiro no Wokwi (relé, dois botões), depois no kit com uma carga de baixa tensão.

12 · Ferramentas

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 exercício 4. 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 exercício 4 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

ATmega328P (limites de corrente, limiares, pull-up interno) e ESP32-S3 (3,3 V, 45 kΩ, strapping). Pinout do DevKitC-1: Random Nerd Tutorials.

13 · Termos

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.
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. Aula 1.8.
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.

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. 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.