Partitore di tensione: formula, resistenze ed esempi Arduino

Un partitore di tensione è il circuito più semplice per ridurre una tensione a un valore più piccolo e facilmente calcolabile usando due resistenze in serie. La tensione di uscita si ricava con Vout = Vin × R2 / (R1 + R2): R1 è collegata alla sorgente, R2 a massa (GND) e l'uscita si preleva dal punto centrale in cui si incontrano. Per esempio, due resistenze da 10 kΩ dividono 12 V esattamente a metà, cioè 6 V. Queste due resistenze sono alla base di innumerevoli circuiti: dalla misura di una batteria da 12 V con Arduino all'adattamento di un segnale a 5 V ai pin a 3,3 V di un ESP32, fino alla lettura di sensori come la fotoresistenza (LDR) e il termistore NTC.

In questa guida vedrai, con numeri reali, da dove nasce la formula, come scegliere i valori delle resistenze e perché l'uscita cala quando colleghi qualcosa al partitore (l'effetto del carico). Poi costruiremo passo passo il codice che misura la tensione di una batteria con Arduino Uno, ESP32 e Raspberry Pi Pico, sceglieremo le coppie di resistenze giuste per passare da 5 V a 3,3 V e leggeremo una LDR e un NTC con un partitore. Infine spiegheremo perché un partitore di tensione non va mai usato al posto di un alimentatore.

Cos'è un partitore di tensione e come funziona?

La formula del partitore di tensione deriva direttamente dalla legge di Ohm. In R1 e R2, collegate in serie tra la sorgente e massa, scorre la stessa corrente: I = Vin / (R1 + R2). La tensione ai capi di R2, cioè l'uscita, è questa corrente moltiplicata per R2: Vout = I × R2 = Vin × R2 / (R1 + R2). In breve, la tensione della sorgente si ripartisce tra le resistenze in proporzione ai loro valori; alla resistenza più grande spetta la quota maggiore. L'uscita è sempre più bassa dell'ingresso, perché il rapporto R2 / (R1 + R2) è minore di 1. Trovi più dettagli su come si ripartisce la tensione in un circuito in serie in Calcolo delle resistenze in serie e in parallelo.

Puoi ragionare anche al contrario: se vuoi portare 12 V a 3,3 V e hai scelto 10 kΩ per R2, ottieni R1 = 10 × (12 / 3,3 − 1) ≈ 26,4 kΩ. Questo valore non esiste in commercio, quindi scegli il valore standard immediatamente superiore, 27 kΩ, e l'uscita diventa 12 × 10 / 37 ≈ 3,24 V. Arrotondare R1 per eccesso abbassa leggermente l'uscita, il che va a favore della sicurezza del pin. Anche un potenziometro è in realtà un partitore di tensione regolabile: il cursore divide la pista resistiva in R1 e R2. Se non vuoi fare il calcolo a mano, il calcolatore del partitore di tensione ti dà subito l'uscita in base alla tensione di ingresso e alle resistenze. In elettronica il partitore di tensione si usa soprattutto per questi compiti:

• Misurare tensioni più alte: portare sorgenti come una batteria da 12 V o un pacco al litio da 7,4 V nell'intervallo che un ingresso analogico può misurare.
• Abbassare il livello logico: rendere un segnale a 5 V sicuro per gli ingressi a 3,3 V di ESP32 e Raspberry Pi Pico.
• Leggere sensori resistivi: trasformare in tensione la variazione di resistenza di componenti come LDR, NTC, sensori di flessione e sensori di forza (FSR).
• Leggere molti pulsanti con un solo pin: una scala di resistenze assegna a ogni pulsante una tensione diversa, così cinque pulsanti possono condividere un unico pin analogico.
• Retroazione dei regolatori: regolatori come l'LM317 e l'LM2596 regolabile mantengono stabile l'uscita misurandola tramite un partitore; nell'LM317 vale Vout = 1,25 × (1 + R2 / R1).
• Creare una tensione di riferimento: ricavare metà della tensione di alimentazione come riferimento nei circuiti con amplificatori operazionali.

Come scegliere i valori delle resistenze

La formula guarda solo il rapporto: 1 kΩ + 1 kΩ e 100 kΩ + 100 kΩ dividono allo stesso modo, esattamente a metà. Nella pratica però contano anche i valori assoluti. Resistenze piccole fanno scorrere molta corrente nel partitore; quella corrente è energia sprecata e nei progetti a batteria la scarica inutilmente. Resistenze grandi assorbono pochissima corrente, ma la loro uscita è debole: un carico collegato o il condensatore di campionamento dell'ingresso analogico alterano facilmente la tensione di uscita, e il rumore captato dai fili entra più facilmente. La scelta giusta è un equilibrio tra questi due estremi:

1. Stabilisci la tensione di ingresso massima. Una batteria al piombo da 12 V può arrivare a 14,4 V durante la carica; considera il caso peggiore della tensione da misurare e aggiungi un margine del 10%.
2. Stabilisci la tensione massima ammessa dal pin. 5 V su Arduino Uno, 3,3 V su ESP32 e Pico; come obiettivo sicuro scegli circa 4,5 V sull'Uno, 2,5 V sull'ESP32 e 3,0 V sul Pico.
3. Calcola il rapporto: k = uscita desiderata / ingresso massimo. Per esempio 4,5 / 14,4 ≈ 0,31.
4. Scegli R2 (10 kΩ è un buon punto di partenza nella maggior parte dei casi) e trova R1 con R1 = R2 × (1 / k − 1). Arrotonda il risultato al valore superiore tra i valori standard delle resistenze.
5. Controlla corrente e potenza: I = Vin / (R1 + R2) e P = Vin² / (R1 + R2). Nei progetti a batteria cerca di restare nell'ordine dei microampere.
6. Controlla la resistenza di uscita: R1 × R2 / (R1 + R2) dovrebbe stare sotto i 10 kΩ per Arduino Uno; altrimenti aggiungi un condensatore da 100 nF tra il pin analogico e GND.
7. Scrivi nel codice il rapporto reale: ricalcola il rapporto con i valori standard scelti, poi misura con il multimetro a circuito montato e calibra.

Effetto del carico: cosa succede se colleghi qualcosa al partitore?

La formula presuppone che dall'uscita non venga prelevata corrente. Appena colleghi un carico, questo si trova in parallelo a R2, la resistenza equivalente del ramo inferiore diminuisce e la tensione di uscita cala. Il modo più semplice per calcolarlo è considerare il partitore come il suo equivalente di Thévenin: una sorgente con la tensione misurata a vuoto (Vth) e una resistenza interna Rth = R1 × R2 / (R1 + R2). Con un carico RL l'uscita diventa Vth × RL / (Rth + RL). La tabella mostra una sorgente da 10 V divisa con 10 kΩ + 10 kΩ (Vth = 5 V, Rth = 5 kΩ) e diversi carichi sull'uscita:

La regola pratica: se la resistenza del carico è almeno 100 volte la resistenza di uscita del partitore (Rth), l'errore resta sotto l'1%. Se il carico è più piccolo, riduci le resistenze oppure inserisci un inseguitore di tensione (buffer) con un operazionale. L'ingresso analogico di un microcontrollore ha di per sé una resistenza molto alta, ma al suo interno c'è un piccolo condensatore di campionamento che si carica a ogni conversione (circa 14 pF nell'ATmega328P). Per questo il datasheet consiglia una resistenza di uscita della sorgente di circa 10 kΩ o meno. Se usi un partitore con valori più alti, aggiungi un condensatore da 100 nF tra il pin analogico e GND: tiene pronta la carica necessaria al momento del campionamento. E se leggi più pin analogici in sequenza, scartare la prima lettura di ogni pin elimina l'errore lasciato dal cambio di canale.

Perché un partitore di tensione non si usa come alimentatore

La trappola più comune per chi inizia è ricavare 5 V da un alimentatore da 12 V con due resistenze e provare ad alimentarci un Arduino o un modulo. Sulla carta un partitore da 7 kΩ e 5 kΩ fornisce esattamente 5 V a partire da 12 V, ma solo finché dall'uscita non si preleva corrente. Una scheda che assorbe 50 mA si comporta come un carico di circa 100 Ω; in parallelo ai 5 kΩ di R2, il ramo inferiore scende a 98 Ω e l'uscita crolla a 0,17 V. Se riduci le resistenze a 70 Ω e 50 Ω, il circuito assorbe 100 mA e produce 1,2 W di calore anche senza nulla collegato; con il carico l'uscita scende comunque a 3,9 V e ogni volta che cambia l'assorbimento della scheda (Wi-Fi, servo, relè) varia anche la tensione. Inoltre, quando il carico viene scollegato la tensione risale e può danneggiare i componenti sensibili.

Misurare una batteria da 12 V e le pile con Arduino

Gli ingressi analogici di Arduino Uno leggono al massimo 5 V; collegare direttamente una batteria da 12 V brucerebbe il pin. La soluzione è un partitore da 22 kΩ (R1) e 10 kΩ (R2): con un rapporto di 0,3125, i 14,4 V di carica arrivano al pin come 4,5 V e il circuito può misurare fino a 16 V. A 12 V il partitore assorbe solo 0,375 mA e la sua resistenza di uscita di 6,9 kΩ è sotto il limite consigliato di 10 kΩ. L'ADC a 10 bit distingue circa 4,9 mV per passo; con il partitore questo corrisponde a una risoluzione di circa 15,6 mV in ingresso. Poiché ESP32 e Pico lavorano a 3,3 V, su queste schede usiamo una R1 più grande (56 kΩ):

1// 12 V akü gerilimini gerilim bölücüyle ölçme / Measuring a 12 V battery with a voltage divider
2// Kaynak + -> 22k (R1) -> A0 -> 10k (R2) -> GND / Source + -> 22k (R1) -> A0 -> 10k (R2) -> GND
3// Kaynağın eksisi Arduino GND'sine bağlı / Source minus is tied to the Arduino GND
4const int VIN_PIN = A0;
5const float VREF = 5.0;      // 5V pininde ölçtüğün gerilim / voltage you measured on the 5V pin
6const float R1 = 22000.0;    // üst direnç (ohm) / top resistor (ohms)
7const float R2 = 10000.0;    // alt direnç (ohm) / bottom resistor (ohms)
8const float CAL = 1.000;     // kalibrasyon: gerçek / okunan / calibration: real / measured
9const float LOW_V = 11.8;    // düşük akü eşiği (V) / low battery threshold (V)
10
11float readInputVoltage() {
12  analogRead(VIN_PIN);                        // ilk okumayı at / discard the first reading
13  long sum = 0;
14  for (int i = 0; i < 16; i++) {              // 16 ölçümün ortalaması / average of 16 readings
15    sum += analogRead(VIN_PIN);
16    delay(2);
17  }
18  float vPin = (sum / 16.0) * VREF / 1024.0;  // pindeki gerilim / voltage at the pin
19  return vPin * (R1 + R2) / R2 * CAL;         // bölücüden önceki gerilim / voltage before the divider
20}
21
22void setup() {
23  Serial.begin(9600);
24  pinMode(LED_BUILTIN, OUTPUT);
25}
26
27void loop() {
28  float v = readInputVoltage();
29  Serial.print(F("Giris / Input: "));
30  Serial.print(v, 2);
31  Serial.println(F(" V"));
32  digitalWrite(LED_BUILTIN, v < LOW_V ? HIGH : LOW);  // akü zayıfsa LED yanar / LED on when the battery is low
33  delay(1000);
34}

Il codice scarta la prima lettura per far assestare il condensatore di campionamento dell'ADC, poi fa la media di 16 letture per ridurre il rumore. Il numero letto viene prima convertito nella tensione sul pin (dividiamo per 1024 perché, secondo il datasheet dell'ATmega328P, ADC = Vin × 1024 / Vref) e poi moltiplicato per (R1 + R2) / R2 = 3,2 per ottenere la tensione prima del partitore. La principale fonte di errore è Vref: il pin 5V di un Uno alimentato via USB si trova spesso tra 4,7 e 5,1 V. Misura quindi il pin 5V con il multimetro e scrivi il valore in VREF; poi misura con il multimetro la tensione reale della batteria, confrontala con il valore nel monitor seriale e inserisci nel codice CAL = reale / misurato. Questo solo passaggio corregge insieme gli errori di Vref e della tolleranza delle resistenze. Se colleghi il partitore dopo l'interruttore di accensione del dispositivo, a dispositivo spento non assorbe nulla; 0,375 mA fanno circa 9 mAh al giorno, niente per la batteria di un'auto ma un consumo percepibile per una batteria piccola. Ecco coppie di resistenze adatte ad altre sorgenti:

Misurare la tensione con l'ESP32

Sull'ESP32 l'ADC è a 12 bit (0–4095), ma ha due differenze importanti. La prima: i pin dell'ADC2 non si possono leggere con il Wi-Fi attivo, quindi collega sempre il partitore a un pin dell'ADC1, GPIO 32–39 (i GPIO 34–39 sono solo ingressi e perfetti per questo). La seconda: l'ADC non è lineare agli estremi; con l'attenuazione predefinita di 11 dB, Espressif consiglia circa 150–2450 mV come intervallo più accurato. Il pin mostra valori fino a circa 3,1 V, ma in quella zona l'errore cresce. Per questo abbiamo scelto un partitore da 56 kΩ + 10 kΩ: 14,4 V arrivano al pin come 2,18 V e restano nella zona accurata. Al posto dell'analogRead() grezzo usiamo analogReadMilliVolts(), che restituisce direttamente i millivolt sfruttando i dati di calibrazione scritti nel chip in fabbrica:

1// ESP32: 56k + 10k bölücüyle 12 V ölçme / ESP32: measuring 12 V with a 56k + 10k divider
2const int VIN_PIN = 34;        // ADC1_CH6, Wi-Fi açıkken de çalışır / ADC1_CH6, works with Wi-Fi on
3const float R1 = 56000.0;      // üst direnç (ohm) / top resistor (ohms)
4const float R2 = 10000.0;      // alt direnç (ohm) / bottom resistor (ohms)
5const float CAL = 1.000;       // multimetreyle ayarla / tune with a multimeter
6
7void setup() {
8  Serial.begin(115200);
9  analogReadResolution(12);    // 0-4095 (varsayılan / default)
10}
11
12void loop() {
13  uint32_t mv = 0;
14  for (int i = 0; i < 32; i++) {
15    mv += analogReadMilliVolts(VIN_PIN);     // kalibre edilmiş milivolt / calibrated millivolts
16  }
17  float vPin = mv / 32.0 / 1000.0;           // pindeki gerilim (V) / voltage at the pin (V)
18  float vIn = vPin * (R1 + R2) / R2 * CAL;   // bölücüden önceki gerilim / voltage before the divider
19  Serial.printf("Pin: %.3f V  Giris / Input: %.2f V\n", vPin, vIn);
20  delay(1000);
21}

Misurare la tensione con il Raspberry Pi Pico (MicroPython)

Sul Raspberry Pi Pico gli ingressi analogici sono GP26, GP27 e GP28 (ADC0–ADC2). La funzione read_u16() di MicroPython scala la lettura a 12 bit nell'intervallo 0–65535, e il riferimento è ADC_VREF, che deriva dai 3,3 V della scheda. Poiché l'ADC del Pico misura fino a 3,3 V, con 56 kΩ + 10 kΩ arrivi a circa 21 V. Un dettaglio curioso: il Pico stesso usa un partitore di tensione. Un partitore sulla scheda divide per tre la tensione di alimentazione VSYS e la porta su GP29 (ADC3); moltiplicando per 3 la tensione letta con ADC(29) vedi la tensione di alimentazione della scheda (sul Pico W GP29 è condiviso con il chip wireless, quindi così non funziona direttamente).

1from machine import ADC
2import time
3
4adc = ADC(26)            # GP26 = ADC0 (pin 31)
5VREF = 3.3               # ADC_VREF; multimetreyle ölçüp düzelt / measure and correct with a multimeter
6R1 = 56000               # üst direnç (ohm) / top resistor (ohms)
7R2 = 10000               # alt direnç (ohm) / bottom resistor (ohms)
8CAL = 1.000              # kalibrasyon katsayısı / calibration factor
9
10
11def read_input_voltage(samples=32):
12    total = 0
13    for _ in range(samples):
14        total += adc.read_u16()                  # 0-65535
15    v_pin = total / samples * VREF / 65535       # pindeki gerilim / voltage at the pin
16    return v_pin * (R1 + R2) / R2 * CAL          # bölücüden önceki gerilim / voltage before the divider
17
18
19while True:
20    v_in = read_input_voltage()
21    print("Giris / Input: {:.2f} V".format(v_in))
22    time.sleep(1)

Abbassare un segnale da 5 V a 3,3 V (per ESP32 e Pico)

I pin di ESP32 e Pico non tollerano i 5 V. Se l'uscita ECHO dell'HC-SR04, il pin TX di un Arduino Uno o l'uscita digitale di un modulo alimentato a 5 V vengono collegati direttamente a queste schede, i diodi di protezione dell'ingresso vengono sollecitati e il pin può guastarsi col tempo. Per i segnali in una sola direzione la soluzione più economica è un partitore di tensione. L'obiettivo è una tensione che non superi mai 3,3 V ma che sia abbastanza alta da essere letta come HIGH: l'ESP32 considera il 75% dell'alimentazione (circa 2,5 V) come livello alto minimo, l'RP2040 del Pico 2,0 V. Un'uscita tra 3,0 e 3,3 V lascia quindi un margine comodo su entrambe le schede. È anche il metodo consigliato nella guida al sensore di distanza HC-SR04 per collegare il pin ECHO alle schede a 3,3 V.

Insieme alla capacità del pin, il partitore forma un piccolo filtro RC. I 6,7 kΩ di resistenza di uscita di un partitore da 10 kΩ + 20 kΩ, con circa 15 pF tra pin e breadboard, danno una costante di tempo di circa 100 ns; a una UART a 115200 baud (8,7 µs per bit) non cambia nulla, ma i fronti dei segnali SPI a qualche MHz si arrotondano. Sulle linee veloci preferisci 1 kΩ + 2 kΩ. Ricorda anche che un partitore funziona in una sola direzione, dalla tensione più alta a quella più bassa. Nel verso opposto di solito non serve nulla: Arduino Uno considera HIGH tutto ciò che supera 3,0 V, quindi può leggere l'uscita a 3,3 V dell'ESP32, anche se con poco margine. Sulle linee bidirezionali come l'I2C invece il partitore non serve; lì si usa un convertitore di livello logico a MOSFET.

Leggere una LDR e un NTC con un partitore di tensione

I microcontrollori non misurano direttamente la resistenza, ma solo la tensione. Quando metti un sensore resistivo come una LDR o un NTC in serie a una resistenza fissa formando un partitore di tensione, la variazione di resistenza diventa una variazione di tensione nel punto centrale. Il valore della resistenza fissa determina la sensibilità. Per ottenere la massima escursione di tensione, la resistenza fissa deve essere la media geometrica tra la resistenza minima e massima del sensore nell'intervallo che ti interessa: R = √(Rmin × Rmax). Per una LDR da 1 kΩ in piena luce e 100 kΩ in penombra si ottiene √(1 k × 100 k) = 10 kΩ. A 5 V, con 10 kΩ l'uscita varia di 4,09 V, mentre con 1 kΩ o 100 kΩ l'escursione scende a 2,45 V. Ecco perché i kit di base includono resistenze da 10 kΩ. C'è un altro vantaggio: poiché partitore e ADC sono alimentati dagli stessi 5 V, la resistenza calcolata non dipende dalla tensione di alimentazione (misura raziometrica), quindi il codice qui sotto non ha nemmeno bisogno del valore di Vref.

1// LDR ve NTC'yi gerilim bölücüyle okuma / Reading an LDR and an NTC with voltage dividers
2// A0: 5V -> LDR -> A0 -> 10k -> GND
3// A1: 5V -> 10k -> A1 -> NTC 10k (B = 3950) -> GND
4const float R_FIXED = 10000.0;  // sabit dirençler (ohm) / fixed resistors (ohms)
5const float R0 = 10000.0;       // NTC'nin 25 °C direnci / NTC resistance at 25 °C
6const float BETA = 3950.0;      // NTC B katsayısı / NTC beta coefficient
7const float T0 = 298.15;        // 25 °C kelvin cinsinden / 25 °C in kelvin
8
9void setup() {
10  Serial.begin(9600);
11}
12
13void loop() {
14  analogRead(A0);                         // kanal değişti, ilk okumayı at / channel changed, discard first reading
15  int ldrRaw = analogRead(A0);
16  analogRead(A1);
17  int ntcRaw = analogRead(A1);
18  if (ldrRaw < 1) ldrRaw = 1;             // sıfıra bölmeyi önle / avoid division by zero
19
20  // Oransal ölçüm: besleme gerilimi hesaptan düşer / ratiometric: the supply voltage cancels out
21  float rLdr = R_FIXED * (1024.0 / ldrRaw - 1.0);
22  float rNtc = R_FIXED * ntcRaw / (1024.0 - ntcRaw);
23  float tempC = 1.0 / (1.0 / T0 + log(rNtc / R0) / BETA) - 273.15;  // Beta denklemi / Beta equation
24
25  Serial.print(F("LDR: "));
26  Serial.print(rLdr / 1000.0, 1);
27  Serial.print(F(" kOhm   NTC: "));
28  Serial.print(rNtc / 1000.0, 2);
29  Serial.print(F(" kOhm   "));
30  Serial.print(tempC, 1);
31  Serial.println(F(" C"));
32  delay(1000);
33}

Nel codice la LDR sta in alto, quindi la lettura aumenta quando la luce cresce; la sua resistenza è R = 10 kΩ × (1024 / ADC − 1). L'NTC sta in basso: quando la temperatura sale, la sua resistenza, e quindi la tensione letta, diminuisce. Per i comuni NTC da 10 kΩ a 25 °C con coefficiente B di 3950, la temperatura si ricava dall'equazione Beta: 1 / T = 1 / T0 + ln(R / R0) / B (temperature in kelvin). Poiché la resistenza fissa è uguale a quella dell'NTC a 25 °C, a temperatura ambiente l'uscita è esattamente metà dell'alimentazione, dove la sensibilità è massima. Per una precisione maggiore su un ampio intervallo di temperature, trattiamo l'equazione di Steinhart-Hart e l'autoriscaldamento dell'NTC nella guida al termistore NTC.

Idee di progetti con il partitore di tensione

• Monitor della batteria con allarme: controlla la batteria di un camper o di un impianto solare e fai suonare un buzzer quando scende sotto 11,8 V; per le opzioni di alimentazione nei progetti a batteria, vedi Alimentare Arduino a batteria.
• Voltmetro digitale: mostra la tensione misurata su un display LCD o OLED; i passaggi sono in Costruire un voltmetro con Arduino.
• Luce notturna automatica: con un partitore con LDR accendi LED o un relè quando fa buio.
• Inseguitore solare: confronta le tensioni di due partitori con LDR per orientare un pannello verso la luce (inseguitore solare).
• Cinque pulsanti su un pin: costruisci una scala di resistenze diverse e capisci dal valore analogico quale pulsante è premuto (collegare i pulsanti).
• Termostato: misura la temperatura con un partitore con NTC e accendi una ventola o un riscaldatore tramite relè alla temperatura impostata.

Errori comuni e come risolverli

Un partitore di tensione è fatto solo di due resistenze e una formula, eppure compare in quasi ogni progetto che misura qualcosa. Se scegli il rapporto con la formula e i valori assoluti bilanciando corrente e resistenza di uscita, tieni conto dell'effetto del carico e calibri il risultato con il multimetro, otterrai misure affidabili. Le basi della lettura analogica le trovi in Cos'è un ADC?. Nell'app BlueGrays trovi progetti come la lettura dell'intensità luminosa con una LDR, una luce notturna con LDR, un voltmetro digitale con LCD, la misura della temperatura con un NTC e un misuratore di distanza con ESP32 e HC-SR04, spiegati passo passo con schemi e codice.