O que é um resistor de pull-up? Pull-down, INPUT_PULLUP e valores
O que são resistores de pull-up e pull-down e por que uma entrada flutuante dá problema? INPUT_PULLUP, resistores internos do ESP32 e do Pico, pull-ups no I2C e por que escolher 10k.
Um resistor de pull-up é um resistor, geralmente de cerca de 10 kΩ, que liga uma entrada do microcontrolador à tensão de alimentação (VCC) quando nada mais está controlando essa entrada, mantendo o pino em um nível HIGH estável. Um resistor de pull-down faz o mesmo trabalho ao contrário: puxa o pino para o terra (GND) e o mantém em LOW. Esses pequenos resistores são o segredo para que um botão, uma chave ou uma chave reed dê uma leitura estável no seu Arduino, em vez de ficar pulando aleatoriamente. Na maioria das placas, o resistor já vem dentro do chip; no Arduino, basta escrever INPUT_PULLUP para ativá-lo.
Neste post você vai aprender, passo a passo, por que uma entrada flutuante produz valores aleatórios, a diferença entre pull-up e pull-down, os resistores internos do Arduino Uno, do ESP32 e do Raspberry Pi Pico, como calcular o valor certo do resistor e por que o barramento I2C não funciona sem pull-ups. Cada seção traz medições reais, fórmulas e código que você pode carregar diretamente.

O que é uma entrada flutuante e por que ela é um problema?
Um pino de entrada digital é uma porta de impedância muito alta (centenas de megaohms) que apenas detecta tensão e quase não consome corrente. Se não houver nada ligado ao pino, ou se o pino ficar sem ligação nenhuma enquanto o botão está aberto, sua tensão fica indefinida. Isso se chama entrada flutuante (floating). Um pino assim funciona como uma pequena antena: capta fios próximos, o campo de 50 Hz da rede elétrica e até o seu dedo se aproximando, e a leitura alterna entre 0 e 1 dezenas de vezes por segundo.
Para entender o problema, é preciso olhar os limites lógicos. Quando o ATmega328P do Arduino Uno funciona em 5 V, ele considera qualquer valor acima de 3 V (60% do VCC) como HIGH garantido e qualquer valor abaixo de 1,5 V (30% do VCC) como LOW garantido. A região entre eles é indefinida, e um pino flutuante muitas vezes passeia justamente por ali. O resultado: um LED acendendo sem você apertar o botão, um contador aumentando aleatoriamente ou uma interrupção disparando o tempo todo. Para ver isso com seus próprios olhos, ligue apenas um jumper solto ao D2, ainda sem botão, carregue o código abaixo e toque na ponta do fio com o Monitor Serial aberto:
1void setup() {
2 Serial.begin(9600);
3 pinMode(2, INPUT); // pull direnci yok, pin havada / no pull resistor, pin is floating
4}
5
6void loop() {
7 Serial.println(digitalRead(2)); // rastgele 0 ve 1 görürsün / you will see random 0s and 1s
8 delay(100);
9}O que são resistores de pull-up e pull-down e como eles funcionam?
Na montagem com pull-up, uma ponta do resistor vai ao pino de entrada e a outra ao VCC, enquanto o botão fica entre o pino e o GND. Com o botão aberto, quase nenhuma corrente passa pelo pino, então não há queda de tensão no resistor e o pino vê o VCC, ou seja, HIGH. Quando você aperta o botão, o pino é ligado diretamente ao GND e lê LOW. Nesse momento, uma pequena corrente passa pelo resistor: pela lei de Ohm, I = V / R, o que dá 0,5 mA com 5 V e 10 kΩ. Se você tivesse ligado o pino direto ao VCC em vez de usar um resistor, apertar o botão colocaria a alimentação em curto; o resistor puxa o pino para cima e também evita esse curto-circuito. Você encontra rapidamente a corrente para outros valores com a calculadora da lei de Ohm.
A montagem com pull-down é a imagem espelhada: o resistor fica entre o pino e o GND, e o botão entre o pino e o VCC. Com o botão aberto, o pino é puxado para o terra pelo resistor e lê LOW; ao apertar, o pino é ligado ao VCC e lê HIGH. Isso parece mais natural para iniciantes, porque apertado significa 1 e solto significa 0. Porém, o chip do Arduino Uno não tem pull-down interno; se você quiser um pull-down no Uno, precisa de um resistor externo de 10 kΩ. O ESP32 e o Raspberry Pi Pico têm os dois resistores internamente.
| Característica | Pull-up | Pull-down |
|---|---|---|
| Onde fica o resistor? | Entre o pino e o VCC | Entre o pino e o GND |
| Onde fica o botão? | Entre o pino e o GND | Entre o pino e o VCC |
| Botão solto | HIGH (1) | LOW (0) |
| Botão apertado | LOW (0) | HIGH (1) |
| Tipo de lógica | Ativo em LOW | Ativo em HIGH |
| Suporte interno | Uno, ESP32, Pico | ESP32, Pico |
| Uso típico | Botões, I2C, linha de reset | Gates de MOSFET, saídas de sensores |
Resistores internos de pull-up e pull-down: Arduino Uno, ESP32 e Pico
| Característica | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Nível lógico | 5 V | 3,3 V | 3,3 V |
| Pull-up interno | Sim, 20–50 kΩ | Sim, cerca de 45 kΩ | Sim, 50–80 kΩ |
| Pull-down interno | Não tem | Sim, cerca de 45 kΩ | Sim, 50–80 kΩ (problemático no Pico 2) |
| Como ativar no código | INPUT_PULLUP | INPUT_PULLUP / INPUT_PULLDOWN | Pin.PULL_UP / Pin.PULL_DOWN |
| Botão com pull-up (pino – GND) | D2 | GPIO 18 | GP2 |
| Botão com pull-down (pino – VCC) | D3 + 10 kΩ externo | GPIO 19 (ao 3V3) | GP3 (ao 3V3) |
| Pinos sem resistores internos | Nenhum | GPIO 34–39 | Nenhum |
| Pinos I2C (SDA / SCL) | A4 / A5 | GPIO 21 / GPIO 22 | GP4 / GP5 |
Como usar INPUT_PULLUP no Arduino, passo a passo
- Ligue um terminal do primeiro botão ao D2 e o terminal diagonalmente oposto ao GND; esse botão não precisa de resistor, porque será usado o pull-up interno.
- Ligue um terminal do segundo botão ao D3 e o terminal diagonalmente oposto ao 5V.
- Coloque um resistor de pull-down externo de 10 kΩ entre o D3 e o GND (faixas de cor marrom-preto-laranja).
- Carregue o código, abra o Monitor Serial em 9600 baud e aperte os dois botões, um de cada vez.
- Confira se os botões soltos mostram 0 e os apertados mostram 1; o LED integrado no D13 acende quando qualquer um dos botões é apertado.
1const int BTN_PULLUP = 2; // buton D2 - GND, dahili pull-up / button D2 - GND, internal pull-up
2const int BTN_PULLDOWN = 3; // buton D3 - 5V, harici 10k D3 - GND / button D3 - 5V, external 10k D3 - GND
3const int LED_PIN = 13; // dahili LED / built-in LED
4
5void setup() {
6 Serial.begin(9600);
7 pinMode(BTN_PULLUP, INPUT_PULLUP); // dahili pull-up açık / internal pull-up enabled
8 pinMode(BTN_PULLDOWN, INPUT); // Uno'da dahili pull-down yok / Uno has no internal pull-down
9 pinMode(LED_PIN, OUTPUT);
10}
11
12void loop() {
13 bool a = (digitalRead(BTN_PULLUP) == LOW); // pull-up: basınca LOW / pull-up: LOW when pressed
14 bool b = (digitalRead(BTN_PULLDOWN) == HIGH); // pull-down: basınca HIGH / pull-down: HIGH when pressed
15 digitalWrite(LED_PIN, (a || b) ? HIGH : LOW);
16 Serial.print(a ? 1 : 0);
17 Serial.print(' ');
18 Serial.println(b ? 1 : 0);
19 delay(50);
20}A linha pinMode(BTN_PULLUP, INPUT_PULLUP) ativa o resistor de 20–50 kΩ dentro do chip, então o D2 lê HIGH quando o botão não está apertado e LOW quando está. Já o D3 foi configurado como um INPUT comum, porque o resistor externo de 10 kΩ o puxa para baixo. No código, usamos comparações para dar o mesmo significado às duas lógicas diferentes: o botão com pull-up conta como apertado quando está em LOW, e o botão com pull-down quando está em HIGH. O padrão antigo do Arduino, pinMode(pin, INPUT) seguido de digitalWrite(pin, HIGH), ativa o mesmo pull-up interno; INPUT_PULLUP é simplesmente a versão mais legível.
INPUT_PULLUP e INPUT_PULLDOWN no ESP32
Quase todos os pinos GPIO do ESP32 têm um resistor de pull-up e um de pull-down de cerca de 45 kΩ. No core do Arduino, você os ativa com as constantes INPUT_PULLUP e INPUT_PULLDOWN, que são as mesmas no ESP32 Arduino core 2.x e 3.x. Como o ESP32 funciona em 3,3 V, você deve ligar a outra ponta do botão com pull-down ao pino 3V3, não ao 5V; os pinos GPIO não toleram 5 V. No exemplo abaixo, o botão do GPIO 18 vai ao GND e o botão do GPIO 19 vai ao 3V3, sem precisar de nenhum resistor externo.
1const int BTN_PULLUP = 18; // buton GPIO18 - GND / button GPIO18 - GND
2const int BTN_PULLDOWN = 19; // buton GPIO19 - 3V3 / button GPIO19 - 3V3
3const int LED_PIN = 2; // çoğu kartta dahili LED / built-in LED on most boards
4
5void setup() {
6 Serial.begin(115200);
7 pinMode(BTN_PULLUP, INPUT_PULLUP); // dahili pull-up / internal pull-up
8 pinMode(BTN_PULLDOWN, INPUT_PULLDOWN); // dahili pull-down / internal pull-down
9 pinMode(LED_PIN, OUTPUT);
10}
11
12void loop() {
13 bool a = (digitalRead(BTN_PULLUP) == LOW); // pull-up: basınca LOW / pull-up: LOW when pressed
14 bool b = (digitalRead(BTN_PULLDOWN) == HIGH); // pull-down: basınca HIGH / pull-down: HIGH when pressed
15 digitalWrite(LED_PIN, (a || b) ? HIGH : LOW);
16 Serial.print(a ? 1 : 0);
17 Serial.print(' ');
18 Serial.println(b ? 1 : 0);
19 delay(50);
20}Pin.PULL_UP e Pin.PULL_DOWN no Raspberry Pi Pico
O chip RP2040 do Raspberry Pi Pico tem resistores internos de pull-up e pull-down de aproximadamente 50–80 kΩ em cada GPIO. No MicroPython, basta passar Pin.PULL_UP ou Pin.PULL_DOWN como terceiro parâmetro ao criar o objeto do pino. No código abaixo, o botão do GP2 vai ao GND e o botão do GP3 vai ao 3V3; quando qualquer um deles é apertado, o LED integrado da placa acende.
1from machine import Pin
2import time
3
4btn_up = Pin(2, Pin.IN, Pin.PULL_UP) # buton GP2 - GND / button GP2 - GND
5btn_down = Pin(3, Pin.IN, Pin.PULL_DOWN) # buton GP3 - 3V3 / button GP3 - 3V3
6led = Pin(25, Pin.OUT) # dahili LED, Pico W'de LED adini kullan / onboard LED, use the LED name on Pico W
7
8while True:
9 a = btn_up.value() == 0 # pull-up: basinca 0 / pull-up: 0 when pressed
10 b = btn_down.value() == 1 # pull-down: basinca 1 / pull-down: 1 when pressed
11 led.value(1 if (a or b) else 0)
12 time.sleep_ms(20)Como escolher o valor do resistor de pull-up?
Quanto menor o resistor de pull, mais forte ele puxa o pino, mas mais corrente desperdiça quando o botão está apertado. Quanto maior, menos corrente ele consome, mas o pino fica mais vulnerável a ruído e as mudanças de tensão ficam mais lentas. A fórmula da corrente é simples: I = VCC / R. Em 5 V, 1 kΩ significa 5 mA por botão apertado; 10 kΩ significa 0,5 mA; e 100 kΩ significa apenas 0,05 mA, ou seja, 50 µA. Em dispositivos a bateria, em que um botão pode ficar apertado por muito tempo, essa diferença afeta diretamente a autonomia da bateria.
Dois fatores definem o limite superior. O primeiro é a corrente de fuga: uma entrada do ATmega328P tem fuga de no máximo cerca de 1 µA; em um pull-up de 100 kΩ, isso causa uma queda de apenas 0,1 V e não é problema, mas com 1 MΩ a queda sobe para 1 V e o pino se aproxima do limite. O segundo é a velocidade: o resistor forma um circuito RC com a capacitância do pino e do fio, com constante de tempo τ = R × C. Com 10 kΩ e um fio de 100 pF, τ = 1 µs, o que é rápido de sobra para um botão. A regra geral é: 10 kΩ para botões, 1–4,7 kΩ para fios longos e ruidosos e 47–100 kΩ onde for preciso economizar bateria. Você pode usar a ferramenta Código de cores para decifrar as faixas de cor de um resistor.
| Aplicação | Valor recomendado | Motivo |
|---|---|---|
| Botão, chave, chave reed | 10 kΩ (ou interno) | 0,5 mA em 5 V, um pull forte o suficiente |
| Botão com fio maior que 1 m | 1–4,7 kΩ | Pull mais forte contra ruído |
| Dispositivo a bateria | 47–100 kΩ | Apenas cerca de 50–100 µA com o botão apertado |
| Gate de MOSFET (pull-down) | 10–100 kΩ | Evita que o motor ligue sozinho ao energizar |
| I2C, 100 kHz | 4,7 kΩ | O tempo de subida fica abaixo do limite de 1000 ns |
| I2C, 400 kHz | 2,2 kΩ | Valor menor para atender ao limite de 300 ns |
Resistores de pull-up no barramento I2C
No barramento I2C, resistores de pull-up não são opcionais, são obrigatórios. Os dispositivos nas linhas SDA e SCL usam saídas de dreno aberto (open-drain): eles só conseguem puxar a linha para o GND, nunca levá-la a HIGH. A única coisa que traz a linha de volta para HIGH são os resistores de pull-up. Assim, mesmo que dois dispositivos tentem falar ao mesmo tempo, não ocorre curto-circuito; quando um puxa a linha para LOW, o outro simplesmente percebe isso. Sem pull-ups, o scanner I2C não encontra nenhum dispositivo ou o programa trava nas funções da Wire. Para detalhes do protocolo, veja O que é I2C.
No Arduino Uno, a biblioteca Wire ativa os pull-ups internos ao iniciar, mas 20–50 kΩ é fraco demais para o I2C e só funciona por sorte com fios curtos. Felizmente, a maioria dos módulos prontos, como um OLED, um BME280 ou um LCD I2C, já tem pull-ups de 4,7 kΩ ou 10 kΩ soldados na placa. Um ponto muitas vezes esquecido é a ligação em paralelo: se você liga ao mesmo barramento três módulos, cada um com pull-up de 10 kΩ, a resistência equivalente cai para 3,3 kΩ, e com seis módulos para 1,7 kΩ, o que dificulta para os dispositivos puxar a linha para LOW. No cálculo, a resistência mínima é Rmin = (VCC − 0,4 V) / 3 mA, cerca de 1 kΩ em 3,3 V; a resistência máxima é obtida com Rmax = tr / (0,8473 × Cb). Em 400 kHz (tr = 300 ns) e com 100 pF de capacitância no barramento, Rmax fica em cerca de 3,5 kΩ. Você encontra facilmente valores em paralelo com a calculadora Série / paralelo.
| Modo | Velocidade | Tempo de subida máximo | Pull-up típico (3,3 V) |
|---|---|---|---|
| Modo padrão (Standard mode) | 100 kHz | 1000 ns | 4,7–10 kΩ |
| Modo rápido (Fast-mode) | 400 kHz | 300 ns | 2,2–4,7 kΩ |
| Fast-mode Plus | 1 MHz | 120 ns | 1–1,5 kΩ |
Onde você vai precisar de resistores de pull? Ideias de projetos
- Leitura de botões e chaves: todo botão precisa de um resistor de pull; isso é explicado junto com o debounce no guia de ligação de botões.
- Sensor de porta e janela: uma chave reed fecha quando um ímã se aproxima; com INPUT_PULLUP, ela pode ser lida com um único fio.
- Fechadura com senha: a biblioteca do teclado matricial usa pull-ups internos nos pinos das linhas, então um teclado 4x4 não precisa de resistores extras.
- Acionamento de motores e fitas de LED: um pull-down de 10 kΩ no gate de um MOSFET impede que o motor gire enquanto o Arduino está iniciando e o pino ainda não foi configurado.
- Resposta instantânea com interrupções: se os pinos de interrupção ficarem flutuando, eles disparam o tempo todo; um pull-up os deixa estáveis.
- Encoder rotativo: as saídas do encoder rotativo são lidas com pull-ups; em encoders avulsos, sem módulo, você precisa ativar o pull-up interno.
- Barramento de sensores e displays: ao colocar módulos I2C como um display OLED, um BME280 e um RTC no mesmo barramento, calcule o valor total de pull-up.
Erros comuns e como resolvê-los
| Sintoma | Causa provável | Solução |
|---|---|---|
| O LED pisca sem apertar o botão | Pino flutuando, sem resistor de pull | Use INPUT_PULLUP ou adicione um resistor externo de 10 kΩ |
| A leitura muda quando você aproxima a mão | Entrada flutuante, fio longo funcionando como antena | Use um resistor de pull menor (4,7 kΩ) e encurte o fio |
| O botão parece estar sempre apertado | Lógica de pull-up interpretada ao contrário | Considere LOW como apertado ou use !digitalRead |
| O pino fica entre 1–2 V ao apertar | Pull-up interno e pull-down externo ativos ao mesmo tempo | Use só um; configure o pinMode como INPUT |
| INPUT_PULLUP não funciona no GPIO 35 do ESP32 | Os GPIO 34–39 não têm resistores internos | Adicione um pull-up externo de 10 kΩ |
| O ESP32 não inicia ou fica reiniciando | Pull-up no GPIO 12 ou pull-down no GPIO 0 | Mude o botão para um GPIO que não seja pino de strapping |
| Dispositivo I2C não encontrado ou a Wire trava | Sem pull-ups, ou resistores de módulos demais em paralelo | Adicione 4,7 kΩ ou remova os resistores dos módulos extras |
| Os pinos I2C do ESP32 ou do Pico se danificam | Pull-ups ligados ao 5 V | Ligue os pull-ups ao 3,3 V e use um conversor de nível lógico se necessário |
| Várias contagens em um só aperto | Repique do botão (debounce), sem relação com o pull | Aplique um debounce de 20–50 ms no software |
Os resistores de pull-up e pull-down são pequenos, mas estão entre os blocos de construção mais usados na eletrônica; depois que você entende a lógica, botões, sensores e linhas I2C deixam de trazer surpresas. Para fixar o que aprendeu, confira no app BlueGrays os projetos de LED com botão, controle de LED com botão no ESP32 e comparação de debounce no Pico; cada um vem com esquema do circuito passo a passo e código pronto.
Perguntas frequentes
Quantos ohms deve ter um resistor de pull-up?
O valor mais comum para botões e chaves é 10 kΩ; ele consome apenas 0,5 mA quando apertado em 5 V e é forte o suficiente contra ruído. Em fios longos, você pode descer até 4,7 kΩ, e em circuitos a bateria, subir até 47–100 kΩ. No barramento I2C, prefere-se 4,7 kΩ para 100 kHz e 2,2 kΩ para 400 kHz.
Qual é a diferença entre INPUT e INPUT_PULLUP?
Um pino em modo INPUT apenas lê a tensão e não é puxado para nenhum lado; sem um resistor externo, o pino fica flutuando. INPUT_PULLUP ativa o resistor de 20–50 kΩ dentro do chip e liga o pino ao VCC. Assim, basta ligar o botão entre o pino e o GND e ler LOW quando ele estiver apertado.
O Arduino Uno tem resistor de pull-down interno?
Não. Os chips AVR do Uno, do Nano e do Mega têm apenas pull-ups internos, e a constante INPUT_PULLDOWN não está definida nessas placas. Se precisar de um pull-down, ligue um resistor externo de 10 kΩ entre o pino e o GND. Já o ESP32 e o Raspberry Pi Pico têm suporte a pull-downs internos.
Preciso de resistores de pull-up para o I2C?
Sim. Como os dispositivos I2C só conseguem puxar as linhas para LOW, os resistores de pull-up que levam SDA e SCL a HIGH são essenciais. A maioria dos módulos prontos tem resistores de 4,7 kΩ ou 10 kΩ na placa, então com um único módulo você não precisa de nada extra. Se estiver usando um chip de sensor avulso ou se o barramento for longo, adicione 4,7 kΩ nas duas linhas.
Devo usar pull-up ou pull-down?
Na maioria dos casos, o pull-up é mais prático: ele existe internamente em todas as placas, e ligar o botão ao GND é mais seguro do que levar a linha de alimentação por aí com um fio. O pull-down é preferido quando você quer ler 1 ao apertar ou em linhas que precisam ficar em LOW ao energizar, como o gate de um MOSFET. Qualquer que seja a escolha, basta montar a lógica do seu código de acordo.
O que acontece se eu ligar um botão sem resistor de pull-up?
Com o botão aberto, o pino não está ligado a nada, então fica flutuando e capta ruído elétrico do ambiente. Aí o digitalRead retorna 0s e 1s aleatórios, o LED pisca sozinho ou uma interrupção dispara o tempo todo. Para resolver, basta usar INPUT_PULLUP ou adicionar um resistor externo.
Projetos para montar depois desta leitura
Ver todos os projetos
Controle de LED com botão (momentâneo)
É como uma campainha: a luz fica acesa enquanto você pressiona o botão e apaga quando você solta.

Ligar e desligar um LED com botão
Pressione o botão uma vez para acender a luz e outra vez para apagar, como o interruptor do seu quarto.

Controle de LED com botão no ESP32 (momentâneo)
O LED acende enquanto o botão está pressionado e apaga ao soltá-lo. Mostra como usar o pino de entrada digital e o resistor pull-up interno do ESP32. O modo INPUT_PULLUP dispensa um resistor externo.

Controle de LED com botão no ESP32 (alternância)
Cada vez que o botão é pressionado, o estado do LED muda: se estiver aceso, apaga; se estiver apagado, acende. É o padrão clássico de alternância. Com debounce, eliminamos o ruído mecânico dos contatos do botão para garantir uma única mudança a cada pressionamento.

Raspberry Pi Pico: LED controlado por botão (enquanto pressionado)
Primeiro projeto de entrada com o Pico — leitura de botão! O LED acende enquanto o botão está pressionado e apaga ao soltá-lo. O grande passo depois das animações com LEDs: entrada de sinais do mundo para o Pico. Aprenda a usar Pin.IN (modo de entrada), Pin.PULL_UP (pull-up interno — padrão para botões) e a leitura com button.value(). LED no GP14, botão no GP2. Pressionado = LOW (0), solto = HIGH (1) — essa lógica invertida confunde no início, mas é padrão da indústria.

Raspberry Pi Pico: ligar e desligar LED com botão
Botão + LED — próximo nível! Ao contrário do projeto básico de botão, não é preciso manter o botão pressionado. Pressione e solte → LED aceso. De novo → LED apagado (alternância). O circuito é o mesmo (LED no GP14, botão no GP2), mas o código muda bastante. Aprenda detecção de borda (o instante da queda 1→0), rastreamento de estado e debounce (filtro de repique). led.toggle() alterna o estado em uma linha. Base para projetos interativos com botões (seletor de modo, IRQ, clique duplo).

Raspberry Pi Pico: debounce de botão com IRQ ou consulta por software
Você pressiona o botão uma vez e o código conta 3 ou 4? A culpa é dos contatos metálicos, que oscilam várias vezes em microssegundos. Aqui o mesmo botão é contado de 2 formas, lado a lado no Monitor Serial: consulta sem filtro, que conta a mais, e IRQ + debounce por software (ticks_diff() > 50ms, Pin.irq() e IRQ_FALLING), que conta certo. A cada contagem correta, o LED também alterna entre aceso e apagado.

Leitura de uma chave reed
Você já teve curiosidade sobre a chave magnética dos alarmes de portas e janelas?
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

