Resistenza Pull-up: Cos'è, Pull-down e INPUT_PULLUP
Cos'è una resistenza pull-up e pull-down? Ingresso flottante, INPUT_PULLUP su Arduino, ESP32 e Pico, pull-up I2C e come scegliere il valore giusto (10k).
Una resistenza pull-up collega un ingresso del microcontrollore alla tensione di alimentazione (VCC) quando non è usato, mantenendo il pin stabile a livello HIGH; di solito vale 10 kΩ. La resistenza pull-down fa l'opposto: porta il pin a massa (GND) e lo tiene a LOW. Se colleghi a Arduino un pulsante, un interruttore o un reed e il valore letto non salta a caso, è merito di queste piccole resistenze. Sulla maggior parte delle schede sono già dentro il chip: su Arduino basta scrivere INPUT_PULLUP per attivarla.
In questo articolo scoprirai passo dopo passo perché un ingresso flottante (floating) genera valori casuali, la differenza tra pull-up e pull-down, le resistenze interne di Arduino Uno, ESP32 e Raspberry Pi Pico, come si calcola il valore giusto e perché il bus I2C non funziona senza pull-up. In ogni sezione trovi misure reali, formule e codice da caricare subito.

Cos'è un ingresso flottante e perché crea problemi?
Un pin d'ingresso digitale è solo una porta ad altissima impedenza (centinaia di megaohm) che rileva la tensione e quasi non assorbe corrente. Se al pin non è collegato nulla, o se a pulsante aperto non va da nessuna parte, la sua tensione resta indefinita. Questo stato si chiama ingresso flottante (floating). Il pin si comporta come una minuscola antenna: risente dei cavi vicini, del campo a 50 Hz della rete elettrica e perfino dell'avvicinarsi del tuo dito, e il valore letto oscilla tra 0 e 1 decine di volte al secondo.
Per capire il problema bisogna guardare le soglie logiche. Il chip ATmega328P di Arduino Uno a 5 V considera HIGH sicuro tutto ciò che supera 3 V (il 60% di VCC) e LOW sicuro tutto ciò che sta sotto 1,5 V (il 30% di VCC). La zona intermedia è incerta, e un pin flottante spesso vaga proprio lì. Il risultato: il LED si accende da solo senza premere il pulsante, il contatore sale a caso o l'interrupt scatta di continuo. Per vederlo con i tuoi occhi, collega a D2 solo un jumper libero, carica il codice qui sotto e, con il Monitor Seriale aperto, tocca la punta del cavo:
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}Cosa sono le resistenze pull-up e pull-down e come funzionano?
Nella configurazione pull-up un capo della resistenza va al pin d'ingresso e l'altro a VCC; il pulsante sta tra il pin e GND. A pulsante aperto dal pin non passa quasi corrente, quindi sulla resistenza non c'è caduta di tensione e il pin vede VCC, cioè HIGH. Quando premi, il pin va direttamente a GND e leggi LOW. Intanto nella resistenza passa una piccola corrente: per la legge di Ohm I = V / R, cioè 5 V e 10 kΩ danno 0,5 mA. Se collegassi il pin direttamente a VCC, premere il pulsante manderebbe in cortocircuito l'alimentazione; la resistenza sia tira su il pin sia evita il cortocircuito. Per altri valori puoi calcolare subito la corrente con il calcolatore della legge di Ohm.
La configurazione pull-down è la sua immagine speculare: la resistenza va tra il pin e GND, il pulsante tra il pin e VCC. A pulsante aperto il pin è tirato a massa dalla resistenza e legge LOW; premendo, va a VCC e legge HIGH. Per chi comincia è più naturale, perché premere significa 1 e rilasciare 0. Però il chip di Arduino Uno non ha pull-down interna: sull'Uno, se vuoi un pull-down, devi usare una resistenza esterna da 10 kΩ. ESP32 e Raspberry Pi Pico, invece, hanno entrambe le resistenze.
| Caratteristica | Pull-up | Pull-down |
|---|---|---|
| Dove va la resistenza? | Tra pin e VCC | Tra pin e GND |
| Dove va il pulsante? | Tra pin e GND | Tra pin e VCC |
| Pulsante a riposo | HIGH (1) | LOW (0) |
| Pulsante premuto | LOW (0) | HIGH (1) |
| Tipo di logica | Attiva bassa | Attiva alta |
| Supporto interno | Uno, ESP32, Pico | ESP32, Pico |
| Uso tipico | Pulsanti, I2C, linea di reset | Gate di MOSFET, uscite di sensori |
Pull-up e pull-down interne: Arduino Uno, ESP32 e Pico
| Caratteristica | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Livello logico | 5 V | 3,3 V | 3,3 V |
| Pull-up interna | Sì, 20–50 kΩ | Sì, circa 45 kΩ | Sì, 50–80 kΩ |
| Pull-down interna | No | Sì, circa 45 kΩ | Sì, 50–80 kΩ (problematica su Pico 2) |
| Come attivarla nel codice | INPUT_PULLUP | INPUT_PULLUP / INPUT_PULLDOWN | Pin.PULL_UP / Pin.PULL_DOWN |
| Pulsante pull-up (pin – GND) | D2 | GPIO 18 | GP2 |
| Pulsante pull-down (pin – VCC) | D3 + 10 kΩ esterna | GPIO 19 (a 3V3) | GP3 (a 3V3) |
| Pin senza resistenza interna | Nessuno | GPIO 34–39 | Nessuno |
| Pin I2C (SDA / SCL) | A4 / A5 | GPIO 21 / GPIO 22 | GP4 / GP5 |
Usare INPUT_PULLUP su Arduino passo dopo passo
- Collega un piedino del primo pulsante a D2 e il piedino diagonale a GND; per questo pulsante non serve resistenza, si usa la pull-up interna.
- Collega un piedino del secondo pulsante a D3 e il piedino diagonale a 5V.
- Inserisci una pull-down esterna da 10 kΩ tra D3 e GND (bande colorate marrone-nero-arancione).
- Carica il codice, apri il Monitor Seriale a 9600 baud e premi i due pulsanti uno dopo l'altro.
- Verifica che i pulsanti a riposo mostrino 0 e quelli premuti 1; il LED integrato su D13 si accende quando premi uno qualsiasi dei due.
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}La riga pinMode(BTN_PULLUP, INPUT_PULLUP) attiva la resistenza da 20–50 kΩ interna al chip; per questo D2 legge HIGH a pulsante rilasciato e LOW quando lo premi. D3 invece è impostato come semplice INPUT, perché la resistenza esterna da 10 kΩ lo tira verso il basso. Nel codice abbiamo usato un confronto per dare lo stesso significato a due logiche diverse: il pulsante pull-up è premuto quando è LOW, quello pull-down quando è HIGH. Lo schema pinMode(pin, INPUT) seguito da digitalWrite(pin, HIGH) che vedi nei vecchi sketch attiva la stessa pull-up interna; INPUT_PULLUP ne è la versione più leggibile.
INPUT_PULLUP e INPUT_PULLDOWN su ESP32
Quasi ogni GPIO dell'ESP32 ha sia una pull-up sia una pull-down da circa 45 kΩ. Nel core Arduino le attivi con le costanti INPUT_PULLUP e INPUT_PULLDOWN, identiche sia nelle versioni 2.x sia 3.x dell'Arduino core per ESP32. Poiché l'ESP32 lavora a 3,3 V, l'altro capo del pulsante pull-down va collegato al pin 3V3 e non a 5V: i GPIO non tollerano i 5 V. Nell'esempio seguente il pulsante sul GPIO 18 è collegato a GND, quello sul GPIO 19 a 3V3, e non serve nessuna resistenza esterna.
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 su Raspberry Pi Pico
Il chip RP2040 di Raspberry Pi Pico ha su ogni GPIO una pull-up e una pull-down interne da circa 50–80 kΩ. In MicroPython basta passare Pin.PULL_UP o Pin.PULL_DOWN come terzo parametro quando crei l'oggetto pin. Nel codice seguente il pulsante su GP2 è collegato a GND e quello su GP3 a 3V3; quando premi uno dei due si accende il LED sulla scheda.
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)Come scegliere il valore della resistenza pull-up?
Più piccola è la resistenza, più forte tira il pin, ma più corrente consuma quando premi il pulsante. Più è grande, meno corrente scorre, ma il pin diventa più debole contro i disturbi e le variazioni di tensione rallentano. La formula della corrente è semplice: I = VCC / R. A 5 V, 1 kΩ significa 5 mA per pulsante premuto; 10 kΩ 0,5 mA; 100 kΩ solo 0,05 mA, cioè 50 µA. Nei dispositivi a batteria in cui il pulsante può restare premuto a lungo, questa differenza incide direttamente sull'autonomia.
Il limite superiore dipende da due fattori. Il primo è la corrente di dispersione: un ingresso dell'ATmega328P perde al massimo circa 1 µA; su una pull-up da 100 kΩ questo causa solo 0,1 V di caduta e non è un problema, ma a 1 MΩ la caduta sale a 1 V e il pin si avvicina alla soglia. Il secondo è la velocità: la resistenza forma con la capacità del pin e del cavo un circuito RC con costante di tempo τ = R × C. Con 10 kΩ e un cavo da 100 pF, τ = 1 µs, più che veloce per un pulsante. Regola generale: 10 kΩ per i pulsanti, 1–4,7 kΩ per cavi lunghi e rumorosi, 47–100 kΩ dove serve risparmiare batteria. Per leggere le bande colorate puoi usare lo strumento codice colori delle resistenze.
| Applicazione | Valore consigliato | Motivo |
|---|---|---|
| Pulsante, interruttore, reed | 10 kΩ (o interna) | 0,5 mA a 5 V, trazione abbastanza forte |
| Pulsante con cavo più lungo di 1 m | 1–4,7 kΩ | Trazione più decisa contro i disturbi |
| Dispositivo a batteria | 47–100 kΩ | Solo 50–100 µA circa a pulsante premuto |
| Gate di MOSFET (pull-down) | 10–100 kΩ | Evita che il motore parta da solo all'accensione |
| I2C, 100 kHz | 4,7 kΩ | Il tempo di salita resta sotto il limite di 1000 ns |
| I2C, 400 kHz | 2,2 kΩ | Valore più basso per rispettare il limite di 300 ns |
Resistenze pull-up sul bus I2C
Sul bus I2C la pull-up non è un'opzione ma una necessità. I dispositivi collegati a SDA e SCL usano un'uscita open-drain: possono solo tirare la linea a GND, non portarla a HIGH. L'unica cosa che riporta la linea a HIGH sono le resistenze pull-up. Così, anche se due dispositivi provano a parlare insieme, non c'è cortocircuito: quando uno porta la linea a LOW, l'altro se ne accorge soltanto. Senza pull-up lo scanner I2C non trova nessun dispositivo, oppure il programma si blocca nelle funzioni Wire. Per i dettagli del protocollo leggi Cos'è l'I2C.
Su Arduino Uno la libreria Wire attiva le pull-up interne all'avvio; ma 20–50 kΩ sono deboli per l'I2C e funzionano per caso solo con cavi corti. Per fortuna la maggior parte dei moduli pronti, come OLED, BME280 o LCD I2C, ha già saldata sulla scheda una pull-up da 4,7 kΩ o 10 kΩ. Un punto spesso trascurato è il parallelo: se colleghi sulla stessa linea tre moduli con pull-up da 10 kΩ ciascuno, la resistenza equivalente scende a 3,3 kΩ, con sei moduli a 1,7 kΩ, e per i dispositivi diventa più difficile tirare la linea a LOW. Nel calcolo, la resistenza minima è Rmin = (VCC − 0,4 V) / 3 mA, circa 1 kΩ a 3,3 V; la massima si ricava da Rmax = tr / (0,8473 × Cb). A 400 kHz (tr = 300 ns) e con 100 pF di capacità di linea, Rmax vale circa 3,5 kΩ. Trovi facilmente i valori in parallelo con il calcolatore di resistenze in serie e parallelo.
| Modalità | Velocità | Tempo di salita massimo | Pull-up tipica (3,3 V) |
|---|---|---|---|
| Standard mode | 100 kHz | 1000 ns | 4,7–10 kΩ |
| Fast-mode | 400 kHz | 300 ns | 2,2–4,7 kΩ |
| Fast-mode Plus | 1 MHz | 120 ns | 1–1,5 kΩ |
Dove ti servono le resistenze pull? Idee per progetti
- Lettura di pulsanti e interruttori: ogni pulsante ha bisogno di una resistenza pull; insieme al debounce è spiegato nella guida al collegamento dei pulsanti.
- Sensore per porta e finestra: il reed è un interruttore che si chiude quando si avvicina un magnete; con INPUT_PULLUP lo leggi con un solo filo.
- Serratura a codice: la libreria Keypad usa le pull-up interne sulle righe, quindi una tastiera 4x4 non richiede resistenze aggiuntive.
- Pilotare motori e strisce LED: una pull-down da 10 kΩ sul gate di un MOSFET impedisce al motore di girare mentre Arduino si avvia e il pin non è ancora configurato.
- Reazione immediata con gli interrupt: i pin di interrupt lasciati flottanti scattano di continuo; con una pull-up diventano stabili.
- Encoder rotativo: le uscite di un encoder rotativo si leggono con pull-up; sugli encoder nudi, senza modulo, devi attivare la pull-up interna.
- Linea di sensori e display: quando riunisci sullo stesso bus moduli I2C come OLED, BME280 e RTC, calcola il valore totale delle pull-up.
Errori comuni e come risolverli
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Il LED lampeggia senza premere il pulsante | Pin flottante, nessuna resistenza pull | Usa INPUT_PULLUP o aggiungi una 10 kΩ esterna |
| Il valore cambia quando avvicini la mano | Ingresso flottante, il cavo lungo fa da antenna | Riduci la pull (4,7 kΩ) e accorcia il cavo |
| Il pulsante sembra sempre premuto | Logica pull-up interpretata al contrario | Considera premuto il valore LOW o usa !digitalRead |
| Premendo il pin resta tra 1 e 2 V | Pull-up interna e pull-down esterna attive insieme | Usane una sola; imposta pinMode su INPUT |
| INPUT_PULLUP non funziona sul GPIO 35 dell'ESP32 | I GPIO 34–39 non hanno resistenza interna | Aggiungi una pull-up esterna da 10 kΩ |
| L'ESP32 non si avvia o si resetta di continuo | Pull-up sul GPIO 12 o pull-down sul GPIO 0 | Sposta il pulsante su un GPIO che non sia di avvio |
| Dispositivo I2C non trovato o Wire si blocca | Nessuna pull-up, oppure troppe resistenze in parallelo | Aggiungi 4,7 kΩ o dissalda le resistenze dei moduli in eccesso |
| I pin I2C di ESP32 o Pico si danneggiano | Pull-up collegate a 5 V | Collega le pull-up a 3,3 V e, se serve, usa un convertitore di livello |
| Più conteggi con una sola pressione | Rimbalzo del pulsante (debounce), non c'entra la pull | Applica un debounce software di 20–50 ms |
Le resistenze pull-up e pull-down sono piccoli componenti ma tra i mattoni più usati dell'elettronica; una volta capita la logica, pulsanti, sensori e linee I2C non ti riserveranno più sorprese. Per consolidare quanto appreso, dai un'occhiata nell'app BlueGrays ai progetti accendere un LED con un pulsante, controllo pulsante con ESP32 e confronto debounce su Pico: in ognuno trovi schema del circuito passo dopo passo e codice pronto.
Domande frequenti
Quanti ohm deve avere una resistenza pull-up?
Per pulsanti e interruttori il valore più comune è 10 kΩ: a 5 V consuma solo 0,5 mA a pulsante premuto ed è abbastanza forte contro i disturbi. Con cavi lunghi puoi scendere a 4,7 kΩ, nei circuiti a batteria salire a 47–100 kΩ. Sul bus I2C si usano 4,7 kΩ a 100 kHz e 2,2 kΩ a 400 kHz.
Qual è la differenza tra INPUT e INPUT_PULLUP?
Un pin in modalità INPUT legge soltanto la tensione e non è tirato in nessuna direzione; senza resistenza esterna resta flottante. INPUT_PULLUP attiva la resistenza da 20–50 kΩ interna al chip e collega il pin a VCC. Così ti basta collegare il pulsante tra pin e GND e leggere LOW quando lo premi.
Arduino Uno ha una pull-down interna?
No, i chip AVR di Uno, Nano e Mega hanno solo la pull-up interna e la costante INPUT_PULLDOWN non è definita su queste schede. Se ti serve una pull-down, collega una resistenza esterna da 10 kΩ tra pin e GND. ESP32 e Raspberry Pi Pico supportano invece la pull-down interna.
Servono resistenze pull-up per l'I2C?
Sì, i dispositivi I2C possono solo tirare le linee a LOW, quindi le pull-up che portano SDA e SCL a HIGH sono indispensabili. La maggior parte dei moduli pronti ha già sulla scheda resistenze da 4,7 kΩ o 10 kΩ, perciò con un solo modulo non serve altro. Se usi un chip sensore nudo o la linea è lunga, aggiungi 4,7 kΩ su entrambe le linee.
Meglio usare pull-up o pull-down?
Nella maggior parte dei casi la pull-up è più pratica: è presente internamente su tutte le schede e collegare il pulsante a GND è più sicuro che far girare con un filo la linea di alimentazione. La pull-down si preferisce quando vuoi leggere 1 alla pressione o su linee che all'accensione devono restare LOW, come il gate di un MOSFET. Qualunque scegli, basta impostare di conseguenza la logica nel codice.
Cosa succede se collego un pulsante senza resistenza pull-up?
A pulsante aperto il pin non è collegato a nulla, resta flottante e raccoglie i disturbi elettrici dell'ambiente. digitalRead restituisce allora 0 e 1 a caso, il LED lampeggia da solo o l'interrupt scatta di continuo. Per risolvere basta usare INPUT_PULLUP o aggiungere una resistenza esterna.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Accendere un LED con un pulsante (Push)
Come un campanello: la luce resta accesa finché premi e si spegne quando lasci. L'Arduino ascolta il pulsante di continuo; mentre è premuto accende il LED, e appena togli il dito lo spegne.

Accendere e spegnere un LED con un pulsante
Premi il pulsante una volta e la luce si accende, premilo di nuovo e si spegne, proprio come l'interruttore della tua stanza.

Controllo LED ESP32 con pulsante (Push)
Il LED si accende quando il pulsante viene premuto e si spegne quando viene rilasciato. Mostra come vengono utilizzati il pin di ingresso digitale dell'ESP32 e la resistenza di pull-up interna. Grazie alla modalità INPUT_PULLUP, non è necessaria alcuna resistenza esterna.

Controllo LED ESP32 con pulsante (Toggle)
Ogni volta che si preme il pulsante, lo stato del LED cambia: se è acceso si spegne, se è spento si accende. Classico schema toggle. Con il debounce puliamo il rumore meccanico del pulsante per garantire una singola commutazione con una sola pressione.

Raspberry Pi Pico LED Controllato da Pulsante (Push)
Primo progetto di input con Pico — lettura pulsante! LED si accende mentre il pulsante è premuto. Impara Pin.IN, Pin.PULL_UP e button.value(). GP14 LED, GP2 pulsante con PULL_UP interno. Premuto = 0, rilasciato = 1 — standard.

Raspberry Pi Pico Pulsante Toggle LED
Pulsante + LED — livello successivo! A differenza del progetto pulsante di base, non serve tenere premuto. Premi e rilascia → LED acceso. Premi di nuovo → LED spento (toggle). Stesso circuito, grande differenza di codice. Impara edge detection, state tracking e debounce.

Raspberry Pi Pico Pulsante Debounce: IRQ vs Software Polling
Una pressione e il codice conta 3-4? È contact bounce! Confronta 2 metodi di conteggio in Serial: polling RAW (cattura bounce, conta male) vs IRQ + software debounce (preciso). Impara fisica del bounce, software debounce, Pin.irq() interrupt, IRQ_FALLING trigger, ISR handler, sicurezza delle variabili globali ISR.

Lettura di un sensore reed
Ti sei mai chiesto come funziona l'interruttore magnetico degli allarmi per porte e finestre?
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

