Alimentare Arduino con batteria: pila 9V, AA, 18650 e pin Vin

Alimentare Arduino con una batteria è il primo passo per liberare il tuo progetto dal cavo USB del computer e trasformarlo in una macchinina robot, in un sensore in giardino o in un dispositivo da tenere in tasca. La risposta breve: il modo più sicuro per far funzionare un Arduino Uno a batteria è collegare un pacco da 7–12 V (6×AA oppure due celle 18650 in serie) al jack DC o al pin Vin, oppure inserire un power bank nella porta USB. Il pin 5V va usato solo con una sorgente a 5 V pulita che hai misurato e regolato, perché questo pin scavalca completamente il regolatore e le protezioni della scheda.

Un'alimentazione sbagliata è la causa di molti problemi misteriosi che incontrano i principianti: una scheda che si riavvia ogni volta che il servo si muove, una pila da 9V scarica in poche ore, un power bank che si spegne dopo qualche secondo o un regolatore che scotta al tatto. In questa guida scoprirai ogni ingresso da cui puoi alimentare Arduino, quale batteria collegare dove, perché i motori hanno bisogno di una sorgente propria e come calcolare consumo e autonomia. Alla fine vedremo anche cosa cambia quando si alimentano a batteria un ESP32 e un Raspberry Pi Pico.

5 modi per alimentare Arduino

Dentro Arduino Uno ci sono due percorsi di alimentazione separati. I 5 V che arrivano dall'USB passano attraverso un fusibile ripristinabile da 500 mA (polyfuse) e un piccolo interruttore MOSFET, poi vanno direttamente sulla linea 5 V della scheda. La tensione del jack DC passa prima per un diodo di protezione contro l'inversione di polarità, a quel punto si trova sul pin Vin e poi un regolatore LDO della famiglia 1117 la porta a 5 V. I 3,3 V si ottengono da questa linea a 5 V con un secondo regolatore più piccolo. Un comparatore sulla scheda controlla Vin: quando Vin supera circa 6,6 V, scollega automaticamente l'alimentazione USB, così le sorgenti non si ostacolano anche se alimentatore e USB sono collegati insieme.

Alimentazione via USB: il limite di 500 mA

L'USB è il modo più semplice e più protetto per alimentare Arduino. Una porta USB 2.0 del computer fornisce al massimo 500 mA; il polyfuse dell'Uno si scalda e interrompe il circuito quando la corrente totale supera quel valore, poi si ripristina da solo raffreddandosi. La scheda da sola consuma circa 45–50 mA, quindi restano circa 400 mA da dividere tra sensori, LED e moduli. Un caricatore del telefono o un power bank si usano dalla stessa porta USB; l'unica differenza è che con cavi sottili e lunghi la tensione può scendere fino a 4,6 V. Mentre la scheda è alimentata via USB, ogni milliampere che prelevi dal pin 5V esce da quel budget di 500 mA. Per questo collegare un servo o una striscia LED all'alimentazione USB fa intervenire il fusibile, e anche la porta del computer può interrompere la connessione per proteggersi.

Jack DC e pin Vin: perché 7–12 V?

Il regolatore 5 V della scheda è un LDO lineare e per funzionare bene vuole in ingresso circa 1–1,2 V in più rispetto all'uscita. Aggiungi la caduta di 0,7–1 V del diodo di protezione sul jack e ti servono almeno 7 V sul jack perché i 5 V restino stabili. Con una sorgente da 6 V la linea 5 V scende a 4,2–4,5 V; la scheda sembra funzionare, ma le letture analogiche si spostano e i moduli si comportano in modo strano. All'estremo superiore il problema è il calore: un regolatore lineare trasforma la tensione in eccesso in calore. La potenza dissipata è P = (Vin − 5 V) × I. Come regola, non far dissipare al regolatore più di 1 W; oltre, il piccolo contenitore SOT-223 diventa troppo caldo da toccare e alla fine si spegne da solo.

Il pin Vin è sia un ingresso sia un'uscita. Quando alimenti la scheda dal jack, su Vin trovi la tensione del jack meno circa 0,7–1 V, e da lì puoi alimentare un piccolo carico a 9–12 V. Ma dato che sul percorso della corrente c'è un diodo di protezione da 1 A, i carichi grandi come i motori vanno alimentati direttamente dalla sorgente, non da Vin. Se colleghi un portabatterie al pin Vin, quel diodo di protezione viene escluso: il regolatore funziona ancora, ma se inverti positivo e negativo niente protegge più la scheda. Sui nuovi Uno R4 Minima e R4 WiFi, jack e Vin accettano 6–24 V e usano un convertitore switching (buck) al posto di un regolatore lineare, quindi non scaldano nemmeno a 12 V. Trovi i dettagli in Arduino Uno R4.

Pin 5V: quando si può scavalcare il regolatore in sicurezza?

Il pin 5V è collegato direttamente alla linea di alimentazione dell'ATmega328P e degli altri chip della scheda. Alimentando da questo pin scavalchi il regolatore, il diodo contro l'inversione di polarità e il fusibile USB. Per questo anche la documentazione ufficiale di Arduino sconsiglia di alimentare dai pin 5V e 3.3V. Fatto bene, però, ha dei vantaggi: senza caduta di tensione e calore nel regolatore la batteria dura di più e puoi dare più corrente ai moduli. C'è una sola condizione: la sorgente deve essere stabilizzata e misurata. L'ATmega328P è progettato per funzionare al massimo a 5,5 V, e 6 V è il suo limite assoluto; anche un breve istante oltre può danneggiare il chip per sempre.

• Prima misura: controlla l'uscita della sorgente con il multimetro prima di collegarla ad Arduino; deve essere tra 4,8 e 5,2 V.
• Niente pile dirette: 4 pile AA alcaline nuove arrivano a 6,4 V e superano il limite. Collega al pin 5V solo l'uscita di un regolatore o di un modulo buck o boost.
• Attenzione all'USB insieme: se colleghi l'USB mentre alimenti dal pin 5V, due sorgenti a 5 V si trovano collegate attraverso la scheda; la cosa più sicura è staccare l'alimentazione esterna durante il caricamento dello sketch.
• Aggiungi un condensatore: un condensatore elettrolitico da 100–470 µF sulla linea 5 V esterna, vicino alla scheda, attenua i cali durante gli assorbimenti improvvisi (cos'è un condensatore?).
• Soluzioni pronte: i moduli regolatori con 7805 (regolatore di tensione 7805), un LM2596 impostato a 5,0 V o, per la breadboard, il modulo di alimentazione MB102 forniscono 5 V puliti.

Pin 3.3V: quanta corrente puoi prelevare?

Il pin 3.3V dell'Uno non è un ingresso di alimentazione, ma l'uscita di un piccolo regolatore, e il suo limite ufficiale è di 50 mA. Basta per moduli che non superano qualche decina di milliampere, come un BME280, un MPU6050 o un lettore RFID RC522. I moduli con picchi di corrente elevati però lo mettono in crisi: l'nRF24L01+PA+LNA con antenna supera i 100 mA in trasmissione, il modulo Wi-Fi ESP-01 assorbe picchi di diverse centinaia di milliampere e il SIM800L richiede impulsi fino a 2 A. Per l'nRF24L01+PA+LNA e l'ESP-01 usa un modulo regolatore AMS1117 a 3,3 V separato, alimentato dalla linea 5 V. Il SIM800L invece non funziona a 3,3 V ma a 3,4–4,4 V e supera il limite di 1 A dell'AMS1117; alimentalo con una sola cella Li-ion o con un modulo buck impostato a 4,0 V in grado di fornire almeno 2 A. Su Arduino Nano e sui suoi cloni il pin 3.3V spesso arriva dall'interno del chip USB-seriale ed è ancora più debole che sull'Uno; anche lì è più sicuro un regolatore a parte. Trovi altri dettagli sull'alimentazione dei moduli wireless nella guida all'nRF24L01.

Opzioni di batteria: pila 9V, AA, 18650 e power bank

La classica pila da 9V è l'opzione più consigliata grazie alla clip con spinotto per il jack, ma è anche la meno efficiente. Al suo interno ci sono sei celle minuscole, quindi la capacità è di soli 400–600 mAh circa e la resistenza interna è alta; aggiungi un servo o qualche LED ai 50 mA dell'Uno e la tensione scende presto sotto i 7 V, e la scheda comincia a riavviarsi. Su una scheda con regolatore lineare sono i mAh della batteria a determinare direttamente l'autonomia, mentre i volt in più diventano solo calore. Per questo un portabatterie 6×AA, che dà gli stessi 9 V, dura circa quattro volte più di una pila da 9V. Spieghiamo nel dettaglio le unità di capacità in cosa significa mAh?.

Le pile stilo AA costano poco e si trovano ovunque, ma bisogna scegliere il numero giusto. L'errore più comune è usare 4×AA: 6 V non bastano per il jack, perché dopo le cadute del diodo e del regolatore sulla linea 5 V arrivano solo circa 4,2 V, mentre collegare lo stesso pacco al pin 5V significa 6,4 V con pile nuove, oltre il limite. Le combinazioni giuste sono un pacco 6×AA (9 V) nel jack DC e un pacco 3×AA (4,5 V) direttamente sul pin 5V. Un Uno a 16 MHz con 3×AA diventa instabile quando ogni pila scende sotto 1,25 V, quindi non puoi sfruttare tutta la capacità. Le ricaricabili NiMH danno 1,2 V per cella, perciò anche 4×NiMH (4,8 V) è una scelta diffusa per il pin 5V, ma le celle appena caricate possono superare 5,5 V nei primi minuti.

Batteria Li-ion 18650 e convertitore boost

La 18650 è una cella ricaricabile agli ioni di litio, di 18 mm di diametro e 65 mm di lunghezza, quella usata nelle batterie dei portatili e nei power bank. La sua tensione nominale è 3,7 V; carica misura 4,2 V, scarica circa 3,0 V. La capacità reale è tra 2000 e 3500 mAh; le celle con scritto 6800 o 9900 mAh sono quasi sempre false. Una singola 18650 si usa con Arduino in due modi: alzare i 3,7 V a 5 V con un convertitore boost (step-up, per esempio un modulo MT3608 o una scheda power bank 18650 già pronta) e alimentare l'USB o il pin 5V, oppure collegare due celle in serie e inserire il pacco 2S (7,4 V) nel jack DC. La seconda è l'opzione più equilibrata per l'Uno: partendo da 8,4 V, la tensione resta nella zona comoda del regolatore finché non scende a 3,5 V per cella (7 V in totale). Se usi un boost, ricorda che la corrente prelevata dalla batteria è maggiore di quella in uscita: un circuito che chiede 200 mA a 5 V assorbe circa 307 mA da una cella da 3,7 V con un'efficienza dell'88 per cento.

• La protezione è obbligatoria: scaricare una cella Li-ion sotto i 3,0 V ne accorcia la vita e può essere pericoloso. Usa celle protette o una scheda di protezione (BMS).
• Il TP4056 è per una sola cella: il modulo TP4056 carica una sola cella (1S) fino a 4,2 V. Non caricare mai un pacco 2S in serie con un TP4056; usa un circuito di ricarica con BMS 2S o un caricabatterie bilanciatore. I collegamenti sono spiegati in modulo di ricarica TP4056.
• Attenzione ai cortocircuiti: una 18650 in cortocircuito può erogare decine di ampere; non lasciare fili scoperti e aggiungi un fusibile e un interruttore sulla linea della batteria.
• Regolazione del boost: non collegare ad Arduino moduli regolabili come l'MT3608 prima di aver impostato l'uscita a 5,0 V.
• Non mescolare le celle: in un pacco in serie usa celle della stessa marca, capacità e livello di carica.

Perché il power bank si spegne da solo?

Un power bank è un pacco già pronto con celle al litio, caricatore, protezione e boost a 5 V, quindi è il modo più comodo per far funzionare Arduino a batteria: basta collegare il cavo USB. La maggior parte dei power bank però controlla la corrente in uscita per spegnersi quando il telefono è carico, e taglia l'uscita entro 10–60 secondi quando la corrente scende sotto i 50–100 mA. Un Nano che assorbe 20 mA o un Uno che ne assorbe 50 restano sotto questa soglia, così la scheda funziona per un po' e poi si spegne senza avvisare. Le soluzioni sono due: scegliere un power bank con modalità a bassa corrente (su alcuni modelli si attiva premendo due volte il pulsante) oppure far assorbire ad Arduino un breve carico a intervalli regolari. Per il secondo metodo, collega una resistenza da 47 Ω, 1 W tra la linea 5V e il collettore di un transistor NPN (BC337 o 2N2222), l'emettitore a GND e la base al pin D7 tramite una resistenza da 1 kΩ. Quando il transistor conduce, la resistenza assorbe circa 5 V / 47 Ω ≈ 106 mA e il power bank vede un carico. Puoi verificare i valori con il calcolatore della legge di Ohm.

1// Powerbank uyanık tutma / powerbank keep-alive
2// D7 -> 1 kΩ -> NPN beyzi, kolektör -> 47 Ω -> 5V / D7 -> 1 kΩ -> NPN base, collector -> 47 Ω -> 5V
3const int LOAD_PIN = 7;
4const unsigned long PERIOD_MS = 8000;  // her 8 saniyede bir / every 8 seconds
5const unsigned long PULSE_MS = 300;    // 300 ms yük / 300 ms of load
6
7unsigned long pulseStart = 0;
8bool loadOn = false;
9
10void setup() {
11  pinMode(LOAD_PIN, OUTPUT);
12  digitalWrite(LOAD_PIN, LOW);
13}
14
15void loop() {
16  unsigned long now = millis();
17  if (!loadOn && now - pulseStart >= PERIOD_MS) {
18    digitalWrite(LOAD_PIN, HIGH);   // ~106 mA çek / draw ~106 mA
19    loadOn = true;
20    pulseStart = now;
21  }
22  if (loadOn && now - pulseStart >= PULSE_MS) {
23    digitalWrite(LOAD_PIN, LOW);    // yükü kapat / switch the load off
24    loadOn = false;
25  }
26  // projenin kodu burada, delay() kullanmadan / your project code here, without delay()
27}

Dato che il codice usa millis() invece di delay(), non blocca il resto del progetto; spieghiamo questo approccio nel dettaglio in millis() invece di delay(). Assorbire 106 mA per 300 ms ogni 8 secondi significa in media solo circa 4 mA in più. Se il tuo power bank si spegne ancora, riduci il periodo a 5 secondi o allunga l'impulso a 500 ms; ogni modello usa una soglia e un tempo di attesa diversi.

Alimentazione separata per motori e servo, massa comune

Motori e servo sono i carichi che creano più problemi quando alimenti Arduino a batteria. Un servo assorbe un picco di diverse centinaia di milliampere nell'istante in cui parte, e i motori DC chiedono più volte la loro corrente normale all'avvio o quando si bloccano. Quel picco può far crollare per un istante la linea 5 V; se la tensione scende abbastanza, interviene la protezione da sottotensione (brown-out) dell'ATmega328P e la scheda si riavvia da sola. Inoltre il rumore delle spazzole dei motori disturba le letture dei sensori. La regola è semplice: dal pin 5V di Arduino alimenta al massimo un servo piccolo, e fai funzionare tutti gli altri motori con una sorgente separata. Per capire come funzionano servo e motori DC, leggi servomotore e controllo dei motori DC con L298N.

1. Scegli una sorgente separata per i motori: 5–6 V per i servo (4×AA NiMH o un LM2596 impostato a 5–6 V) e, per i motori DC, un pacco adatto alla loro tensione (per esempio 2S 18650).
2. Collega il positivo di questa sorgente solo ai fili rossi dei servo o all'ingresso di potenza del driver motori; non collegarlo al pin 5V di Arduino.
3. Alimenta Arduino dal suo ingresso: puoi collegare lo stesso pacco 2S anche al jack DC, purché la corrente dei motori non passi dal regolatore di Arduino.
4. Collega il negativo (GND) della sorgente al pin GND di Arduino. Senza massa comune il segnale di controllo non funziona.
5. Collega il filo di segnale arancione o giallo del servo a un pin digitale di Arduino (per esempio D9); la libreria Servo funziona anche sui pin senza il segno PWM.
6. Aggiungi un condensatore elettrolitico da 470–1000 µF sull'alimentazione dei servo, vicino ai servo stessi; rispetta la polarità.
7. Se usi un L298N, porta l'alimentazione dei motori al morsetto 12V; se supera i 12 V, togli il jumper 5V-EN e alimenta Arduino con la sua sorgente.

Come si calcolano consumo e autonomia?

In un progetto a batteria la vera domanda è "quanto durerà?". La formula di base è semplice: Autonomia (ore) = Capacità (mAh) × 0,85 / Corrente media (mA). Il fattore 0,85 tiene conto del fatto che una batteria non fornisce mai tutta la capacità nominale: con correnti alte e al freddo la capacità cala, il circuito si ferma prima che la batteria sia del tutto scarica e i convertitori aggiungono perdite. Per le pile la cui tensione cala presto, come la 9V, è più realistico usare 0,7. Se il tuo progetto passa la maggior parte del tempo in sleep, calcola prima la corrente media: Corrente media = (Corrente attiva × tempo attivo + Corrente in sleep × tempo in sleep) / tempo totale. Invece di fare i conti a mano, puoi usare il calcolatore di durata della batteria: inserisci capacità, correnti da sveglio e in sleep e l'intervallo di risveglio, e ti restituisce l'autonomia in ore, giorni o mesi.

Misurare è sempre meglio che stimare. Imposta il multimetro sulla portata di corrente (mA) e collegalo in serie tra batteria e circuito per vedere il consumo reale; ti mostriamo come in come usare il multimetro. Se il valore è più alto del previsto, guarda prima il consumo della scheda stessa: sull'Uno il chip USB-seriale (ATmega16U2), il LED di alimentazione e il regolatore assorbono più di 30 mA anche con l'ATmega328P in sleep. Per questo i progetti che richiedono lunga autonomia preferiscono schede senza chip USB come l'Arduino Pro Mini; un Pro Mini senza LED di alimentazione e regolatore scende a pochi microampere in modalità sleep.

Passo dopo passo: fai funzionare il tuo progetto a batteria

1. Con il progetto alimentato via USB, misura con il multimetro la corrente media e quella di picco, anche mentre il servo o il motore si muovono.
2. Separa i carichi ad alta corrente come motori, servo e strisce LED, e prevedi per loro una sorgente separata.
3. Scegli l'ingresso della scheda: per l'Uno, un pacco da 7–12 V nel jack DC o 5 V stabilizzati sull'USB o sul pin 5V; per il Pico, 1,8–5,5 V su VSYS.
4. Calcola la capacità necessaria per l'autonomia che vuoi, oppure usa il calcolatore di durata della batteria.
5. Aggiungi un interruttore di accensione sulla linea positiva della batteria; assicurati che i pacchi Li-ion abbiano una scheda di protezione (BMS).
6. Carica lo sketch via USB, poi stacca l'USB e prova a batteria; controlla con il multimetro la tensione sul pin 5V mentre il servo si muove.
7. Monitora la tensione della batteria nel codice e avvisa quando scende sotto un certo valore (codice qui sotto).

Misurare la tensione della batteria con Arduino

Invece di indovinare quando la batteria si scaricherà, puoi misurarne la tensione. Gli ingressi analogici di Arduino leggono al massimo 5 V, quindi non puoi collegare direttamente ad A0 un pacco 2S che arriva a 8,4 V: ti serve un partitore di tensione. Due resistenze da 100 kΩ e 10 kΩ dividono la tensione per 11: 8,4 V diventano circa 0,76 V su A0. Dato che la linea 5 V della scheda può spostarsi quando la batteria si indebolisce, è più preciso misurare con il riferimento interno da 1,1 V, che non dipende dalla tensione di alimentazione. Puoi scegliere i valori delle resistenze per il tuo pacco con il calcolatore del partitore di tensione e approfondire in partitore di tensione.

1// 2S Li-ion paket gerilimini ölçme / measuring a 2S Li-ion pack voltage
2// Pil+ -> 100k -> A0 -> 10k -> GND / pack+ -> 100k -> A0 -> 10k -> GND
3const int BAT_PIN = A0;
4const int LED_PIN = 13;      // pil zayıf uyarısı / low-battery warning
5const float R1 = 100000.0;   // üst direnç / top resistor
6const float R2 = 10000.0;    // alt direnç / bottom resistor
7const float VREF = 1.1;      // dahili referans, multimetreyle düzelt / internal reference, calibrate with a multimeter
8const float LOW_V = 6.6;     // 2S için alt sınır (3,3 V/hücre) / low limit for 2S (3.3 V per cell)
9
10void setup() {
11  Serial.begin(9600);
12  pinMode(LED_PIN, OUTPUT);
13  analogReference(INTERNAL);   // 1,1 V referans (Uno/Nano) / 1.1 V reference (Uno/Nano)
14  analogRead(BAT_PIN);         // ilk ölçümü at / discard the first reading
15  delay(10);
16}
17
18void loop() {
19  long sum = 0;
20  for (int i = 0; i < 16; i++) {   // 16 ölçümün ortalaması / average of 16 readings
21    sum += analogRead(BAT_PIN);
22    delay(2);
23  }
24  float pinV = (sum / 16.0) * VREF / 1024.0;
25  float batV = pinV * (R1 + R2) / R2;
26
27  Serial.print("Pil / Battery: ");
28  Serial.print(batV, 2);
29  Serial.println(" V");
30
31  digitalWrite(LED_PIN, batV < LOW_V ? HIGH : LOW);   // zayıfsa LED yanar / LED on when low
32  delay(2000);
33}

Collega l'estremo superiore del partitore al positivo della batteria dopo l'interruttore, così il partitore non scarica la batteria quando il dispositivo è spento. Il riferimento interno da 1,1 V può variare di circa ±10% da chip a chip: confronta la tensione misurata con il multimetro con quella del monitor seriale e correggi VREF di conseguenza (per esempio 1,08). Il partitore assorbe sempre circa 76 µA, un valore che praticamente non incide sull'autonomia. Il codice è per Uno e Nano; sul Mega il riferimento si chiama INTERNAL1V1. La soglia di 6,6 V corrisponde a 3,3 V per cella; a quel punto le celle sono quasi scariche, e scendere sotto 3,0 V per cella le danneggia. Se il pacco alimenta il jack DC, la linea 5 V comincia a calare verso i 7 V, quindi ha senso anche impostare LOW_V a 7,0.

Alimentare un ESP32 a batteria

Le schede di sviluppo ESP32 funzionano a 3,3 V e si possono alimentare in tre modi: dalla porta USB, dal pin 5V (VIN su alcune schede) o direttamente dal pin 3V3. Espressif chiede esplicitamente di non usarli insieme, ma di sceglierne uno solo. La tensione sul pin 5V passa per il regolatore LDO a 3,3 V della scheda (un AMS1117 sulla maggior parte dei cloni), mentre il pin 3V3 accetta solo 3,0–3,6 V stabilizzati. In trasmissione Wi-Fi l'ESP32 assorbe picchi fino a 240 mA, quindi serve una sorgente in grado di fornire almeno 500 mA; altrimenti si riavvia con l'errore "Brownout detector was triggered" (dettagli in errore brownout). Non collegare una 18650 direttamente al pin 3V3: carica a 4,2 V supera il limite. Nemmeno il pin 5V va bene, perché l'AMS1117 richiede una caduta di circa 1,1 V e, man mano che la tensione della cella cala, l'uscita scende sotto i 3,3 V. Le soluzioni giuste sono una 18650 con boost a 5 V sul pin 5V, un regolatore a 3,3 V a bassa caduta (LDO) da almeno 500 mA o una scheda ESP32 con caricatore Li-ion integrato. Ciò che decide davvero l'autonomia, però, è che l'ESP32 passi la maggior parte del tempo in deep sleep; in questa modalità il chip assorbe circa 10 µA, ma il chip USB-seriale, il LED e il regolatore delle schede di sviluppo possono portare il valore ai milliampere. Da qui viene la differenza tra 3 mesi e 18 giorni nella tabella sopra; per i dettagli leggi ESP32 deep sleep.

1// ESP32: 18650 gerilimini ölç, sonra derin uykuya geç / measure the 18650, then deep sleep
2// Pil+ -> 100k -> GPIO34 -> 100k -> GND / cell+ -> 100k -> GPIO34 -> 100k -> GND
3const int BAT_PIN = 34;                         // yalnız giriş, ADC1 / input-only, ADC1
4const uint64_t SLEEP_US = 60ULL * 1000000ULL;   // 60 saniye / 60 seconds
5
6void setup() {
7  Serial.begin(115200);
8  uint32_t mv = 0;
9  for (int i = 0; i < 16; i++) {
10    mv += analogReadMilliVolts(BAT_PIN);        // kalibre milivolt / calibrated millivolts
11  }
12  float batV = (mv / 16.0) * 2.0 / 1000.0;      // bölücü yarıya indirir / the divider halves it
13  Serial.printf("Pil / Battery: %.2f V\n", batV);
14
15  if (batV < 3.3) {
16    Serial.println("Pil zayif / Battery low");  // işi atla, pili koru / skip the work, protect the cell
17  } else {
18    // sensörü oku, Wi-Fi ile gönder / read the sensor, send over Wi-Fi
19  }
20
21  esp_sleep_enable_timer_wakeup(SLEEP_US);      // 60 sn sonra uyan / wake up after 60 s
22  Serial.flush();
23  esp_deep_sleep_start();                       // loop() hiç çalışmaz / loop() never runs
24}
25
26void loop() {
27}

A ogni risveglio il codice misura la tensione della batteria, svolge il suo compito e torna a dormire con un timer di 60 secondi; dato che l'ESP32 riparte dall'inizio del programma quando esce dal deep sleep, loop() non viene mai eseguito. GPIO 34 è un pin di solo ingresso dell'ADC1 e funziona anche con il Wi-Fi attivo, mentre i pin dell'ADC2 non si possono usare insieme al Wi-Fi. analogReadMilliVolts() usa la calibrazione di fabbrica del chip e restituisce direttamente i millivolt. Il partitore da 100 kΩ + 100 kΩ porta 4,2 V a 2,1 V e assorbe solo 21 µA; se la lettura è rumorosa, aggiungi un condensatore da 100 nF tra GPIO 34 e GND. Per i tuoi primi passi con l'ESP32, cos'è l'ESP32? è un buon punto di partenza.

Alimentare un Raspberry Pi Pico a batteria

Il Raspberry Pi Pico è una delle schede più comode da usare a batteria, perché al posto di un regolatore lineare monta un regolatore switching buck-boost. Dai al pin VSYS una tensione qualsiasi tra 1,8 e 5,5 V e la scheda la converte in modo efficiente in 3,3 V; continua a funzionare anche quando l'ingresso scende sotto i 3,3 V. Così puoi collegare 2 o 3 pile AA, una sola 18650 o una LiPo a una cella direttamente tra VSYS e GND, senza moduli aggiuntivi. L'unica cosa a cui fare attenzione è l'uso insieme all'USB: i 5 V dell'USB (VBUS) arrivano a VSYS tramite un diodo Schottky; se la batteria è collegata direttamente a VSYS e inserisci l'USB, l'USB prova a spingere corrente nella batteria. La soluzione consigliata da Raspberry Pi è collegare la batteria a VSYS tramite un suo diodo Schottky (per esempio un 1N5817). Il pin 3V3 fornisce ai circuiti esterni al massimo circa 300 mA, e portare a GND il pin 3V3_EN spegne il regolatore e quindi tutta la scheda. Per una panoramica della scheda, leggi cos'è il Raspberry Pi Pico?.

1from machine import ADC, Pin
2import time
3
4vsys = ADC(29)            # VSYS/3 ölçer (Pico) / measures VSYS/3 (Pico)
5usb = Pin(24, Pin.IN)     # USB takılıysa 1 / 1 when USB is connected
6CONV = 3.3 / 65535        # ham değeri volta çevir / raw value to volts
7
8while True:
9    total = 0
10    for _ in range(16):   # 16 ölçümün ortalaması / average of 16 readings
11        total += vsys.read_u16()
12    volts = total / 16 * CONV * 3   # kart içindeki bölücü 3'e böler / on-board divider divides by 3
13    source = "USB" if usb.value() else "Pil / Battery"
14    print("{}: VSYS = {:.2f} V".format(source, volts))
15    if not usb.value() and volts < 3.3:   # 3xAA ya da 18650 için alt sınır / low limit for 3xAA or a 18650
16        print("Pil zayif! / Battery low!")
17    time.sleep(5)

Sul Pico, GP29 misura un terzo di VSYS tramite un partitore sulla scheda, mentre GP24 legge 1 quando l'USB è collegato. Così, senza componenti in più, sai sia la tensione della batteria sia se la scheda è alimentata dall'USB o dalla batteria. Se hai collegato la batteria tramite un diodo Schottky come consigliato, VSYS risulta circa 0,2–0,3 V più bassa della tensione della batteria. La misura presuppone un riferimento ADC di 3,3 V; grazie al regolatore buck-boost, questo riferimento resta stabile anche quando la batteria si indebolisce. Sul Pico W, GP29 e GP24 sono condivisi con il chip wireless, quindi questo codice non funziona così com'è; lì lo stato dell'USB si legge con Pin("WL_GPIO2"). Per allungare l'autonomia, usa machine.lightsleep() invece di time.sleep() tra una misura e l'altra.

Idee di progetti a batteria

• Macchinina robot comandata via Bluetooth: alimenta motori e Arduino con un pacco 2S di 18650; i dettagli sono in costruire una macchinina con Arduino.
• Robot che evita gli ostacoli: evita i riavvii alimentando i motori tramite l'L298N su una linea separata e Arduino dal jack DC (robot evita ostacoli).
• Voltmetro con indicatore di batteria: mostra su un LCD il valore misurato con un partitore di tensione (costruire un voltmetro con Arduino).
• Stazione di umidità per il giardino: tieni un ESP32 in deep sleep, misura l'umidità del terreno una volta all'ora e fallo funzionare per mesi con una sola 18650.
• Registratore GPS portatile: registra il percorso delle tue escursioni con un GPS NEO-6M e un power bank.
• Luce notturna con Pico a pile: un Pico alimentato da 3×AA tramite VSYS accende i LED quando fa buio.

Errori comuni e soluzioni

Un'alimentazione corretta è metà del lavoro per un progetto stabile: scegli l'ingresso giusto, alimenta i motori a parte, collega le masse e calcola l'autonomia fin dall'inizio. Quando sei pronto a costruire un progetto a batteria, dai un'occhiata nell'app BlueGrays alla macchinina Bluetooth con L298N, al robot che evita gli ostacoli, alla stazione di irrigazione intelligente, al voltmetro digitale con LCD e al progetto di risparmio energetico con deep sleep dell'ESP32; ognuno spiega passo dopo passo schema, collegamenti e codice.