Cosa significa mAh? Capacità della batteria, Wh e autonomia

Cosa significa mAh? In breve, il mAh (milliampere-ora) è l'unità di capacità che indica quanta carica elettrica immagazzina una pila o una batteria. 1 mAh corrisponde a una corrente di 1 milliampere che scorre per 1 ora: una batteria da 2000 mAh può quindi, in teoria, alimentare un circuito che assorbe 20 mA per 100 ore, oppure uno da 200 mA per 10 ore. Questo valore da solo però non basta: la tensione della batteria, la corrente assorbita, la temperatura e il regolatore tra batteria e circuito cambiano moltissimo l'autonomia reale.

Quando realizzi un progetto a batteria con Arduino, ESP32 o Raspberry Pi Pico, la prima domanda è sempre la stessa: quante ore o quanti giorni durerà questa batteria? In questa guida imparerai cosa significano mAh e Wh, qual è la capacità reale delle pile AA, 9V, 18650 e LiPo, come misurare il consumo del tuo progetto con un multimetro e un INA219, come calcolare l'autonomia con una formula, come collegare le batterie in serie e in parallelo, cos'è il tasso C e perché la pila da 9V è una cattiva scelta, il tutto con numeri reali.

Cosa significa mAh? La capacità della batteria spiegata

La corrente si misura in ampere (A) e la capacità in ampere-ora (Ah). Per le batterie piccole si usa il milliampere-ora, un millesimo dell'ampere-ora: 1 Ah = 1000 mAh. In fisica corrisponde a una carica elettrica; 1 mAh equivale a 3,6 coulomb. I produttori misurano la capacità con una determinata corrente di scarica fino a una determinata tensione di fine scarica. Più la corrente è alta, più tensione si perde sulla resistenza interna, la reazione chimica non riesce a stare al passo e la tensione di fine scarica arriva prima; per questo la stessa pila fornisce meno mAh con correnti elevate. Anche il freddo riduce la capacità: le pile alcaline si indeboliscono parecchio sotto 0 °C. La tabella mostra, in base ai dati Energizer, come cambia la capacità di una pila AA alcalina in funzione della corrente (fino a 0,8 V, a 21 °C).

La differenza è notevole: se moltiplichi la corrente per 20, la durata non si riduce di 20 volte ma di 40. Considera quindi i mAh dell'etichetta come il caso migliore. Nei progetti reali c'è anche un'altra perdita: il circuito si ferma prima che la batteria sia completamente scarica. Il regolatore di Arduino Uno non riesce più a mantenere i 5 V quando l'ingresso scende sotto i 7 V, e una singola cella al litio va interrotta intorno a 3,0–3,3 V per non ridurne la vita utile. L'energia che resta nella batteria in quel momento non viene mai usata.

Cosa significa Wh? Differenza tra mAh e Wh

I mAh indicano solo la quantità di carica; per conoscere l'energia di una batteria bisogna moltiplicare per la tensione. L'unità di energia è il wattora (Wh) e la formula è: Wh = mAh × V / 1000. Per esempio, una cella 18650 da 3,7 V e 3000 mAh accumula 3,7 × 3 = 11,1 Wh. Una pila AA da 2500 mAh sulla carta vale 1,5 × 2,5 = 3,75 Wh, ma poiché la tensione media di un'alcalina scende a 1,2–1,3 V durante la scarica, il valore reale è intorno ai 3 Wh. Ecco perché confrontare batterie con tensioni diverse solo in base ai mAh è fuorviante: una pila da 9V da 550 mAh sembra molto più piccola di una AA da 2500 mAh, ma con circa 4 Wh contiene persino un po' più di energia. Quale durerà di più nel tuo progetto dipende dal tipo di regolatore in mezzo; lo vedrai nella sezione sul calcolo dell'autonomia. Per calcolare velocemente il rapporto tra potenza e corrente (P = V × I) puoi usare il calcolatore della legge di Ohm.

Tabella comparativa di pile AA, 9V, 18650 e LiPo

Leggendo la tabella, ricorda: le celle al litio come le 18650 e le LiPo immagazzinano più energia in rapporto al loro peso; una sola 18650 contiene quasi la stessa energia di quattro pile AA alcaline insieme, con circa metà del peso. Le pile alcaline vanno bene per dispositivi a basso consumo che restano a lungo in magazzino, perché perdono solo una piccola percentuale di capacità all'anno; con carichi impegnativi come motori o servo, invece, la loro tensione crolla in fretta. Le pile ricaricabili NiMH forniscono correnti elevate senza problemi nonostante i loro 1,2 V, e i modelli a bassa autoscarica (LSD) restano carichi per mesi. La pila a bottone CR2032 è adatta solo a moduli orologio e sensori in sospensione che lavorano nell'ordine dei microampere; non potrà mai alimentare un ESP32 che si connette al Wi-Fi.

Perché la pila da 9V è una cattiva scelta?

La pila rettangolare da 9V compare spesso nei kit per principianti perché il suo connettore a clip si inserisce direttamente nel jack DC di Arduino, ma è una delle peggiori opzioni per un progetto Arduino a batteria. Al suo interno ci sono sei piccole celle in serie, quindi la capacità è di soli 400–600 mAh. Secondo i dati Energizer, una pila alcalina da 9V scaricata fino a 4,8 V fornisce circa 600 mAh a 10 mA, 570 mAh a 25 mA e solo 450 mAh a 50 mA. Il regolatore di Arduino Uno, invece, richiede almeno 7 V sul jack DC; sotto carico la tensione della pila scende sotto questo limite in poche ore e il resto dell'energia resta inutilizzato. Per questo un Uno che assorbe circa 50 mA di solito funziona solo poche ore con una pila da 9V, spesso tra 4 e 8 ore.

• Capacità ridotta: solo 400–600 mAh contro i 2000–2500 mAh di un pacco 6×AA, cioè un'autonomia più di quattro volte inferiore alla stessa tensione di 9 V.
• Resistenza interna elevata: quando un servo inizia a muoversi o un relè scatta, la tensione crolla di colpo e Arduino si riavvia.
• Perdite nel regolatore: il regolatore lineare di Uno trasforma in calore i 4 V di differenza tra 9 V e 5 V; a 50 mA circa 0,2 W dei 0,45 W prelevati dalla pila vanno sprecati.
• Energia costosa: il costo per Wh è nettamente più alto di quello delle pile AA, e le pile ricaricabili NiMH da 9V scendono a soli 170–300 mAh.
• Dove va bene: nei rilevatori di fumo, nei multimetri o nei dispositivi che assorbono pochi mA e restano a lungo inattivi, la pila da 9V è perfetta. Per Arduino scegli invece un pacco 6×AA, un pacco 2S di 18650 o un power bank; trovi i dettagli in Alimentare Arduino a batteria.

Misurare il consumo di corrente del tuo progetto Arduino

Per calcolare l'autonomia devi prima sapere quanta corrente assorbe il tuo progetto. Misurare è meglio che stimare, perché il consumo della scheda stessa, i LED di alimentazione e i regolatori spesso assorbono più dei sensori. Il modo più semplice è collegare un multimetro in serie tra la batteria e il circuito. Nei progetti con cicli di sospensione e risveglio, un sensore di corrente come l'INA219 dà risultati migliori, perché coglie i brevi picchi di corrente e la vera media. Per saperne di più su portate e boccole del multimetro, leggi Come usare il multimetro.

1. Togli l'alimentazione al circuito; inserisci il puntale rosso nella boccola mA del multimetro e quello nero in COM. Se pensi che la corrente possa superare i 200 mA, inizia dalla boccola 10A.
2. Porta il selettore su corrente continua (A⎓) e, se il multimetro non ha la portata automatica, sulla portata da 200 mA.
3. Scollega dal circuito il filo positivo della batteria; appoggia il puntale rosso sul positivo della batteria e quello nero sull'ingresso positivo del circuito. Così tutta la corrente passa attraverso il multimetro.
4. Accendi il circuito e leggi il valore. Misura anche separatamente mentre un servo si muove, mentre il Wi-Fi si connette o mentre un relè è eccitato, e annota la corrente di ogni stato.
5. Se la corrente in sospensione è nell'ordine dei microampere, passa alla portata µA. In questa portata la scheda potrebbe non ricevere abbastanza corrente per avviarsi; all'accensione cortocircuita i puntali con un cavetto jumper e toglilo quando la scheda va in sospensione.
6. Inserisci le correnti misurate, insieme alla durata di ogni stato, nella formula della corrente media che trovi più avanti.

Misurare corrente e mAh consumati con l'INA219

L'INA219 è un piccolo modulo I2C per misurare corrente e tensione. Misura con una risoluzione di 12 bit la caduta di tensione sullo shunt da 0,1 Ω della scheda e legge correnti fino a circa ±3,2 A in circuiti fino a 26 V, con una risoluzione di circa 0,1 mA. Il suo indirizzo I2C predefinito è 0x40. Il modulo va collegato in serie sulla linea positiva del circuito da misurare: il positivo della batteria va a Vin+ e Vin− va all'ingresso positivo del circuito. L'Arduino che misura è alimentato via USB e il suo GND è collegato al GND del circuito misurato. Ti basta installare la libreria Adafruit INA219 dal Gestore librerie dell'Arduino IDE. L'INA219 non riesce a risolvere le correnti di sospensione nell'ordine dei microampere; quelle vanno misurate con la portata µA di un multimetro.

1// INA219 ile akım, harcanan mAh ve pil ömrü / current, used mAh and battery life with INA219
2#include <Wire.h>
3#include <Adafruit_INA219.h>
4
5Adafruit_INA219 ina219;                    // varsayılan adres 0x40 / default address 0x40
6
7const float CAPACITY_MAH = 2500.0;         // pilin etiket kapasitesi / rated battery capacity
8const float USABLE = 0.85;                 // kullanılabilir oran / usable share
9
10float usedMah = 0;                         // toplam harcanan yük / total charge used
11float secMaMs = 0;                         // son saniyenin mA x ms toplamı / mA x ms of the last second
12unsigned long startMs, lastSample, lastPrint;
13
14void setup() {
15  Serial.begin(9600);
16  if (!ina219.begin()) {
17    Serial.println(F("INA219 bulunamadi / INA219 not found"));
18    while (true) {}
19  }
20  ina219.setCalibration_32V_1A();          // 1 A'e kadar ince ölçüm / finer steps up to 1 A
21  startMs = lastSample = lastPrint = millis();
22}
23
24void loop() {
25  unsigned long now = millis();
26
27  if (now - lastSample >= 10) {            // 10 ms'de bir örnek / one sample every 10 ms
28    float mA = ina219.getCurrent_mA();
29    secMaMs += mA * (now - lastSample);    // akım x süre / current x time
30    lastSample = now;
31  }
32
33  if (now - lastPrint >= 1000) {           // saniyede bir rapor / report once a second
34    lastPrint = now;
35    usedMah += secMaMs / 3600000.0;        // mA x ms -> mAh
36    secMaMs = 0;
37    float avgMa = usedMah / ((now - startMs) / 3600000.0);   // ortalama akım / average current
38    float volts = ina219.getBusVoltage_V() + ina219.getShuntVoltage_mV() / 1000.0;   // pil gerilimi / battery voltage
39
40    Serial.print(F("Pil / Battery: "));
41    Serial.print(volts, 2);
42    Serial.print(F(" V | Ort / Avg: "));
43    Serial.print(avgMa, 1);
44    Serial.print(F(" mA | Harcanan / Used: "));
45    Serial.print(usedMah, 2);
46    Serial.print(F(" mAh"));
47    if (avgMa > 0.5) {
48      Serial.print(F(" | Sure / Runtime: "));
49      Serial.print(CAPACITY_MAH * USABLE / avgMa, 1);   // saat / hours
50      Serial.print(F(" h"));
51    }
52    Serial.println();
53  }
54}

Il codice legge la corrente ogni 10 millisecondi e somma i prodotti corrente × tempo per ottenere i mAh consumati; in questo modo anche i brevi impulsi di corrente, come una trasmissione Wi-Fi o il movimento di un servo, entrano nella media. Una volta al secondo scrive sul Monitor seriale la tensione della batteria, la corrente media fino a quel momento, la capacità consumata e l'autonomia stimata sull'85 % della capacità nominale. Lascia la misura attiva per almeno un ciclo di funzionamento completo, per esempio abbastanza a lungo da coprire un intero ciclo di sospensione e risveglio. Con carichi superiori a 1 A usa setCalibration_32V_2A(). Lo stesso codice funziona senza modifiche sull'ESP32 con i GPIO 21 e 22; per l'uso del Monitor seriale leggi Monitor seriale di Arduino.

Calcolo dell'autonomia: capacità / corrente × efficienza

Quando conosci la corrente media, la formula di base è semplice: Autonomia (ore) = Capacità (mAh) / Corrente media (mA) × Efficienza. Un fattore di 0,85 è un buon punto di partenza; tiene conto della capacità persa con correnti elevate e al freddo, dello spegnimento del circuito prima della scarica completa e dell'invecchiamento della batteria. Questa formula vale quando tra batteria e circuito non c'è alcun regolatore oppure c'è un regolatore lineare (il regolatore a 5 V di Uno, l'AMS1117, il 7805), perché in un regolatore lineare la corrente in ingresso è uguale a quella in uscita e la differenza di tensione diventa calore. Se usi un convertitore switching, come un boost (step-up) o un buck (step-down), calcola con l'energia: Autonomia (ore) = Energia della batteria (Wh) × Efficienza / Potenza del carico (W). Qui l'efficienza è il prodotto dell'85–90 % del convertitore per la quota utilizzabile della batteria; 0,75–0,8 è un valore realistico.

Nei progetti che vanno in sospensione e si risvegliano, prima ti serve la corrente media: Corrente media = (Corrente da sveglio × Tempo da sveglio + Corrente in sospensione × Tempo in sospensione) / Tempo totale. Per esempio, un modulo ESP32 nudo che si sveglia ogni 10 minuti per 5 secondi assorbendo 120 mA e dorme i restanti 595 secondi a 10 µA (0,01 mA) ha una media di (120 × 5 + 0,01 × 595) / 600 ≈ 1,01 mA. Con una 18650 da 3000 mAh fanno 3000 / 1,01 × 0,85 ≈ 2520 ore, cioè circa 3,5 mesi. Se lo stesso codice gira su una scheda di sviluppo che in sospensione assorbe 5 mA, la media sale a 5,96 mA e l'autonomia scende a circa 18 giorni. Invece di fare il conto a mano puoi usare il calcolatore di durata della batteria: basta inserire capacità, corrente da sveglio e in sospensione e intervallo di risveglio. Quando la corrente media scende sotto 0,1 mA, diventa determinante anche l'autoscarica della batteria: una cella agli ioni di litio perde circa il 2–3 % della capacità al mese.

ESP32: misurare il tempo di veglia per stimare l'autonomia

Il consumo dell'ESP32 varia di migliaia di volte a seconda della modalità di funzionamento. Secondo il datasheet di Espressif, il chip assorbe fino a 240 mA quando trasmette in Wi-Fi, circa 100 mA in ricezione, 20–68 mA con il Wi-Fi spento (modem sleep), circa 0,8 mA in light sleep e solo 10 µA in deep sleep. Per questo ciò che determina davvero l'autonomia è il tempo trascorso da sveglio: la connessione al Wi-Fi richiede spesso 1–3 secondi e l'energia di quei pochi secondi supera quella di ore di sospensione. Il codice seguente salva nella memoria RTC quanto è rimasto sveglio a ogni risveglio e, con le correnti che hai misurato, calcola la corrente media e l'autonomia stimata.

1// ESP32 derin uyku ve pil ömrü tahmini / ESP32 deep sleep and battery life estimate
2RTC_DATA_ATTR int bootCount = 0;               // derin uykuda silinmez / survives deep sleep
3RTC_DATA_ATTR unsigned long lastAwakeMs = 0;   // önceki uyanık süre / previous awake time
4
5const float ACTIVE_MA = 120.0;      // ölçtüğün uyanık akım / measured awake current
6const float SLEEP_MA = 0.01;        // ölçtüğün uyku akımı (10 µA) / measured sleep current (10 µA)
7const int SLEEP_S = 600;            // 10 dakika uyku / 10 minutes of sleep
8const float CAPACITY_MAH = 3000.0;  // 18650 kapasitesi / 18650 capacity
9const float USABLE = 0.85;          // kullanılabilir oran / usable share
10
11void setup() {
12  Serial.begin(115200);
13  bootCount++;
14
15  // Burada sensörü oku ve veriyi gönder / read the sensor and send the data here
16  delay(500);                       // örnek iş yükü / sample workload
17
18  if (lastAwakeMs > 0) {
19    float awakeS = lastAwakeMs / 1000.0;
20    float avgMa = (ACTIVE_MA * awakeS + SLEEP_MA * SLEEP_S) / (awakeS + SLEEP_S);
21    float days = CAPACITY_MAH * USABLE / avgMa / 24.0;
22    Serial.printf("Uyanis / Wake #%d, uyanik / awake: %.2f s\n", bootCount, awakeS);
23    Serial.printf("Ortalama / Average: %.3f mA, pil omru / battery life: %.0f gun / days\n", avgMa, days);
24  }
25
26  lastAwakeMs = millis();           // bu uyanışın süresi / duration of this wake
27  Serial.flush();
28  esp_sleep_enable_timer_wakeup((uint64_t)SLEEP_S * 1000000ULL);   // mikrosaniye / microseconds
29  esp_deep_sleep_start();           // loop() hiç çalışmaz / loop() never runs
30}
31
32void loop() {
33}

Al primo risveglio salva solo il tempo; a ogni risveglio successivo calcola e stampa la corrente media e l'autonomia in giorni usando il tempo di veglia precedente. Misura ACTIVE_MA e SLEEP_MA sulla tua scheda con un multimetro e inseriscili nel codice. millis() non conta il tempo del bootloader all'avvio, quindi aggiungere un margine di 0,1–0,3 secondi al tempo di veglia dà un risultato più realistico. Per i dettagli sulle modalità di sospensione e sulle sorgenti di risveglio leggi ESP32 deep sleep, mentre per i riavvii che possono comparire con l'alimentazione a batteria leggi Errore brownout dell'ESP32.

Collegare pile e batterie in serie e in parallelo

Quando colleghi le batterie in serie (il positivo di una al negativo della successiva), le tensioni si sommano e la capacità (mAh) resta invariata: quattro pile AA da 1,5 V e 2500 mAh in serie danno 6 V e 2500 mAh. Quando le colleghi in parallelo (tutti i positivi insieme e tutti i negativi insieme), la tensione resta invariata e le capacità si sommano: due 18650 da 3000 mAh in parallelo danno 3,7 V e 6000 mAh. In entrambi i casi l'energia totale (Wh) cresce con il numero di celle. Nei pacchi al litio questa disposizione si indica con le lettere S (serie) e P (parallelo); per esempio 2S2P è un pacco di quattro celle formato da due coppie in parallelo collegate in serie.

• Usa celle identiche: in un pacco in serie o in parallelo usa batterie della stessa marca, capacità, età e livello di carica; la cella più debole si scarica prima delle altre e viene sollecitata.
• Pareggia le tensioni prima del parallelo: prima di collegare in parallelo celle agli ioni di litio, la differenza di tensione tra loro non deve superare 0,1 V; altrimenti la cella carica spinge una corrente forte e incontrollata in quella scarica.
• I pacchi al litio in serie vanno protetti: dal 2S in su usa una scheda BMS con bilanciamento che controlli ogni cella. Un pacco in serie non si ricarica con un modulo TP4056, che carica una sola cella.
• Non mescolare pile e batterie ricaricabili: non mettere pile alcaline e NiMH nello stesso pacco; tensioni e resistenze interne sono diverse.
• Il parallelo divide il carico: in un pacco 1S2P ogni cella fornisce metà della corrente, quindi il pacco dura di più e scalda meno con correnti elevate.

Cos'è il tasso C?

Il tasso C indica quanto velocemente una batteria viene scaricata o caricata rispetto alla sua capacità. 1C è la corrente che scarica completamente la batteria in 1 ora ed è numericamente uguale alla capacità: per una batteria da 2000 mAh, 1C = 2 A, 0,5C = 1 A e 20C = 40 A. Anche il tempo si calcola facilmente: a 2C la batteria si scarica in circa 30 minuti, a 0,2C in 5 ore. Valori come 25C o 50C stampati sulle LiPo per droni e modelli RC indicano la massima corrente di scarica continua; una LiPo da 1000 mAh e 25C può erogare 25 A. Sulle 18650 il dato di solito è espresso direttamente in ampere: le celle ad alta capacità da 3500 mAh erogano 8–10 A, quelle ad alta scarica da 2500–3000 mAh 15–30 A in continuo. Per la ricarica la regola è più severa: la corrente di carica standard per le celle al litio è di circa 0,5C, al massimo 1C. Un modulo TP4056 che carica a 1 A va bene per una 18650 da 2000 mAh, ma sollecita una piccola LiPo da 300 mAh a circa 3C; in questo caso devi cambiare la resistenza Rprog del modulo per ridurre la corrente di carica.

Misurare la capacità di una batteria con Raspberry Pi Pico (MicroPython)

Le 18650 con scritto 9900 mAh sono quasi sempre false; le vere 18650 con la capacità più alta in commercio arrivano a circa 3500–3600 mAh. L'unico modo per conoscere la capacità reale di una batteria è scaricarla su un carico noto e sommare la corrente nel tempo. Con un Raspberry Pi Pico, una resistenza di carico e un MOSFET puoi costruire un semplice tester di capacità: il Pico inserisce il carico tramite il MOSFET, misura la tensione della batteria con un partitore di tensione, calcola la corrente con I = V / R e scollega il carico quando la tensione raggiunge il valore di fine scarica. Puoi verificare i valori del partitore con il calcolatore del partitore di tensione e trovare i dettagli sul collegamento del MOSFET in Usare un MOSFET.

1from machine import ADC, Pin
2import time
3
4adc = ADC(26)                      # GP26: bölücünün orta noktası / divider midpoint
5load = Pin(15, Pin.OUT, value=0)   # GP15: MOSFET kapısı / MOSFET gate
6R_LOAD = 10.0                      # yük direnci, ohm (ölçüp yaz) / load resistor in ohms (measure it)
7DIV = 2.0                          # 100k + 100k bölücü / 100k + 100k divider
8CUTOFF = 3.0                       # Li-ion bitiş gerilimi / Li-ion end voltage
9CONV = 3.3 / 65535                 # ham değeri volta çevir / raw value to volts
10
11def battery_v():
12    total = 0
13    for _ in range(32):            # 32 ölçümün ortalaması / average of 32 readings
14        total += adc.read_u16()
15    return total / 32 * CONV * DIV
16
17mah = 0.0
18mwh = 0.0
19log = open("desarj.csv", "w")      # Pico'nun belleğine kaydedilir / saved to the Pico's flash
20log.write("dakika,volt,mA,mAh\n")
21load.value(1)                      # deşarjı başlat / start the discharge
22start = last = time.ticks_ms()
23
24while True:
25    time.sleep(30)
26    now = time.ticks_ms()
27    hours = time.ticks_diff(now, last) / 3600000
28    last = now
29    v = battery_v()                # yük altındaki gerilim / voltage under load
30    ma = v / R_LOAD * 1000         # I = V / R
31    mah += ma * hours
32    mwh += v * ma * hours
33    minutes = time.ticks_diff(now, start) / 60000
34    print("{:.0f} dk/min  {:.3f} V  {:.0f} mA  {:.0f} mAh  {:.2f} Wh".format(minutes, v, ma, mah, mwh / 1000))
35    log.write("{:.1f},{:.3f},{:.0f},{:.1f}\n".format(minutes, v, ma, mah))
36    log.flush()
37    if v <= CUTOFF:
38        load.value(0)              # yükü ayır, pili koru / disconnect the load, protect the cell
39        log.close()
40        print("Kapasite / Capacity: {:.0f} mAh, {:.2f} Wh".format(mah, mwh / 1000))
41        break

Ogni 30 secondi il codice misura la tensione della batteria sotto carico, calcola la corrente e somma i mAh e i Wh consumati; stampa i risultati nella console di Thonny e li salva anche nel file desarj.csv nella memoria flash del Pico. Puoi poi aprire quel file in Excel e disegnare la curva di scarica (Trasferire i dati di Arduino su Excel). Con il carico da 10 Ω, il test di una 18650 da 3000 mAh dura circa 8–9 ore. Per un risultato preciso misura la resistenza di carico con il multimetro e inserisci il valore in R_LOAD, poi confronta la tensione della batteria con quella del multimetro e correggi il fattore DIV. Per provare una AA NiMH abbassa CUTOFF a 1,0 V e la resistenza di carico a 4,7 Ω. A 4,2 V la resistenza di carico dissipa circa 1,8 W; scegline una da almeno 5 W, tienila lontana da superfici infiammabili e non lasciare il test senza sorveglianza. Se non sai ancora come installare MicroPython sul Pico, comincia da Cos'è il Raspberry Pi Pico?.

Idee di progetti con il calcolo della batteria

• Sensore da giardino che dura mesi: tieni un ESP32 in deep sleep, misura l'umidità del terreno una volta all'ora e porta la corrente media sotto 1 mA.
• Voltmetro con indicatore di carica: misura la tensione della batteria e mostrala in percentuale su un LCD (Costruire un voltmetro con Arduino).
• Il pacco giusto per un'auto robot: misura la corrente dei motori e calcola quanti minuti durerà un pacco 2S di 18650 (Costruire un'auto robot con Arduino).
• Registratore di consumi: salva le letture dell'INA219 su una scheda SD per ricavare il profilo energetico giornaliero di un dispositivo (Modulo scheda SD).
• Stazione di prova capacità per 18650: aggiungi un display OLED al tester con Pico e mostra i mAh in tempo reale.
• Stazione meteo a batteria: fai funzionare per mesi, con una sola 18650, un ESP32 che invia i dati del DHT11 ogni 10 minuti.

Errori comuni e soluzioni

Ora conosci la differenza tra mAh e Wh, sai come misurare la corrente del tuo progetto e come calcolare quante ore o quanti giorni durerà una batteria. Come passo successivo, dai un'occhiata ad Alimentare Arduino a batteria e a Ricaricare una 18650 con il TP4056. Nell'app BlueGrays trovi progetti a batteria come il risparmio energetico con il deep sleep dell'ESP32, un voltmetro digitale con LCD, un'auto robot comandata via Bluetooth e un robot che evita gli ostacoli, ciascuno con schemi elettrici e codice passo passo.