Que signifie mAh ? Capacité d'une batterie, Wh et autonomie

Que signifie mAh ? En bref, le mAh (milliampère-heure) est l'unité de capacité qui indique la quantité de charge électrique stockée par une pile ou une batterie. 1 mAh correspond à un courant de 1 milliampère pendant 1 heure : une batterie de 2000 mAh peut donc, en théorie, alimenter un circuit qui consomme 20 mA pendant 100 heures, ou un circuit de 200 mA pendant 10 heures. Mais cette valeur seule ne suffit pas : la tension de la batterie, le courant consommé, la température et le régulateur placé entre la batterie et le circuit modifient fortement l'autonomie réelle.

Quand tu construis un projet sur batterie avec un Arduino, un ESP32 ou un Raspberry Pi Pico, la première question est toujours la même : combien d'heures ou de jours va tenir cette batterie ? Dans ce guide, tu vas apprendre ce que signifient mAh et Wh, la capacité réelle des piles AA, 9V, 18650 et LiPo, comment mesurer la consommation de ton projet avec un multimètre et un INA219, comment calculer l'autonomie avec une formule, comment brancher des batteries en série et en parallèle, ce qu'est le taux C et pourquoi la pile 9V est un mauvais choix, le tout avec des chiffres réels.

Que signifie mAh ? La capacité d'une batterie expliquée

Le courant se mesure en ampères (A) et la capacité en ampères-heures (Ah). Pour les petites batteries, on utilise le milliampère-heure, mille fois plus petit : 1 Ah = 1000 mAh. En physique, c'est une charge électrique ; 1 mAh vaut 3,6 coulombs. Les fabricants mesurent la capacité avec un courant de décharge précis jusqu'à une tension de coupure précise. Plus le courant est élevé, plus la tension chute dans la résistance interne, plus la réaction chimique peine à suivre, et plus la tension de coupure arrive tôt : la même pile fournit donc moins de mAh à fort courant. Le froid réduit aussi la capacité ; les piles alcalines faiblissent nettement sous 0 °C. Le tableau ci-dessous montre, d'après les données d'Energizer, comment le courant consommé modifie la capacité d'une pile AA alcaline (jusqu'à 0,8 V, à 21 °C).

La différence est frappante : si tu multiplies le courant par 20, la durée n'est pas divisée par 20, mais par 40. Considère donc les mAh de l'étiquette comme le meilleur cas possible. Dans un vrai projet, une autre perte s'ajoute : le circuit s'arrête avant que la batterie soit complètement vide. Le régulateur de l'Arduino Uno ne peut plus maintenir 5 V dès que son entrée descend sous 7 V, et un accu lithium seul doit être coupé vers 3,0–3,3 V pour ne pas réduire sa durée de vie. L'énergie qui reste alors dans la batterie n'est jamais utilisée.

Que signifie Wh ? Différence entre mAh et Wh

Les mAh indiquent seulement la quantité de charge ; pour connaître l'énergie d'une batterie, il faut multiplier par la tension. L'unité d'énergie est le wattheure (Wh), et la formule est : Wh = mAh × V / 1000. Par exemple, un accu 18650 de 3,7 V et 3000 mAh stocke 3,7 × 3 = 11,1 Wh. Une pile AA de 2500 mAh donne sur le papier 1,5 × 2,5 = 3,75 Wh, mais comme la tension moyenne d'une alcaline descend à 1,2–1,3 V pendant la décharge, la valeur réelle tourne autour de 3 Wh. C'est pourquoi comparer des batteries de tensions différentes uniquement par leurs mAh est trompeur : une pile 9V de 550 mAh paraît bien plus petite qu'une AA de 2500 mAh, mais avec environ 4 Wh elle contient même un peu plus d'énergie. Laquelle tiendra le plus longtemps dans ton projet dépend du type de régulateur entre les deux ; tu le verras dans la partie sur le calcul de l'autonomie. Pour calculer rapidement la relation entre puissance et courant (P = U × I), tu peux utiliser le calculateur de loi d'Ohm.

Tableau comparatif des piles AA, 9V, 18650 et LiPo

En lisant le tableau, retiens ceci : les cellules lithium comme les 18650 et les LiPo stockent le plus d'énergie par rapport à leur poids ; un seul accu 18650 contient presque autant d'énergie que quatre piles AA alcalines réunies, pour environ la moitié du poids. Les piles alcalines conviennent aux appareils à faible consommation qui restent longtemps en stock, car elles ne perdent que quelques pour cent de capacité par an ; sous de fortes charges comme des moteurs ou des servos, en revanche, leur tension s'effondre vite. Les accus NiMH fournissent sans difficulté de forts courants malgré leurs 1,2 V, et les modèles à faible autodécharge (LSD) restent chargés pendant des mois. La pile bouton CR2032 est réservée aux modules d'horloge et aux capteurs en veille qui fonctionnent au niveau du microampère ; elle ne pourra jamais alimenter un ESP32 qui se connecte au Wi-Fi.

Pourquoi la pile 9V est-elle un mauvais choix ?

La pile 9V rectangulaire est fréquente dans les kits de démarrage, car son connecteur à pression se branche directement sur la prise jack de l'Arduino, mais c'est l'une des pires options pour un projet Arduino sur batterie. Elle contient six petites cellules en série, d'où une capacité de seulement 400–600 mAh. D'après les données d'Energizer, une pile 9V alcaline déchargée jusqu'à 4,8 V fournit environ 600 mAh à 10 mA, 570 mAh à 25 mA et seulement 450 mAh à 50 mA. Or le régulateur de l'Arduino Uno a besoin d'au moins 7 V sur la prise jack ; en charge, la tension de la pile passe sous cette limite en quelques heures et le reste de l'énergie est perdu. C'est pourquoi un Uno qui consomme environ 50 mA ne fonctionne en général que quelques heures sur une pile 9V, souvent entre 4 et 8 heures.

• Faible capacité : seulement 400–600 mAh contre 2000–2500 mAh pour un pack de 6×AA, soit plus de quatre fois moins d'autonomie à la même tension de 9 V.
• Résistance interne élevée : quand un servo démarre ou qu'un relais colle, la tension chute d'un coup et l'Arduino redémarre.
• Pertes dans le régulateur : le régulateur linéaire de l'Uno transforme en chaleur les 4 V d'écart entre 9 V et 5 V ; à 50 mA, environ 0,2 W des 0,45 W tirés de la pile sont gaspillés.
• Énergie chère : son coût par Wh est nettement plus élevé que celui des piles AA, et les accus 9V NiMH rechargeables tombent à seulement 170–300 mAh.
• Où elle convient : dans un détecteur de fumée, un multimètre ou un appareil qui consomme quelques mA et reste longtemps au repos, la pile 9V convient très bien. Pour un Arduino, préfère un pack de 6×AA, un pack 2S de 18650 ou une batterie externe ; les détails sont dans Alimenter un Arduino sur pile ou batterie.

Mesurer la consommation de ton projet Arduino

Pour calculer l'autonomie, tu dois d'abord savoir combien de courant consomme ton projet. Mesurer vaut mieux que deviner, car la consommation propre de la carte, les LED d'alimentation et les régulateurs consomment souvent plus que les capteurs. Le plus simple est de brancher un multimètre en série entre la batterie et le circuit. Pour les projets avec des cycles de veille et de réveil, un capteur de courant comme l'INA219 donne de meilleurs résultats, car il capte les pics de courant brefs et la vraie moyenne. Pour tout savoir sur les calibres et les douilles du multimètre, consulte Comment utiliser un multimètre.

1. Coupe l'alimentation du circuit ; branche la pointe rouge sur la douille mA du multimètre et la noire sur COM. Si le courant risque de dépasser 200 mA, commence avec la douille 10A.
2. Tourne le sélecteur sur courant continu (A⎓) et, si l'appareil n'est pas à calibre automatique, sur le calibre 200 mA.
3. Débranche le fil positif de la batterie du circuit ; pose la pointe rouge sur le positif de la batterie et la noire sur l'entrée positive du circuit. Ainsi, tout le courant passe par le multimètre.
4. Mets le circuit en marche et lis la valeur. Mesure aussi séparément pendant qu'un servo bouge, que le Wi-Fi se connecte ou qu'un relais est collé, et note le courant de chaque état.
5. Si le courant de veille est de l'ordre du microampère, passe au calibre µA. Sur ce calibre, la carte peut ne pas recevoir assez de courant pour démarrer ; relie les pointes avec un fil de pontage au démarrage et retire-le quand la carte passe en veille.
6. Reporte les courants mesurés, avec la durée de chaque état, dans la formule du courant moyen présentée plus bas.

Mesurer le courant et les mAh consommés avec un INA219

L'INA219 est un petit module I2C de mesure de courant et de tension. Il mesure avec une résolution de 12 bits la chute de tension aux bornes de la résistance shunt de 0,1 Ω de la carte et lit des courants jusqu'à environ ±3,2 A dans des circuits jusqu'à 26 V, avec une résolution d'environ 0,1 mA. Son adresse I2C par défaut est 0x40. Tu le branches en série sur la ligne positive du circuit à mesurer : le positif de la batterie va sur Vin+, et Vin− va vers l'entrée positive du circuit. L'Arduino qui mesure est alimenté par USB et sa GND est reliée à la GND du circuit mesuré. Il te suffit d'installer la bibliothèque Adafruit INA219 depuis le gestionnaire de bibliothèques de l'Arduino IDE. L'INA219 ne sait pas résoudre les courants de veille de l'ordre du microampère ; mesure-les avec le calibre µA d'un multimètre.

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}

Le code lit le courant toutes les 10 millisecondes et additionne les produits courant × temps pour obtenir les mAh consommés ; ainsi, les impulsions de courant brèves, comme une émission Wi-Fi ou le mouvement d'un servo, sont aussi prises en compte dans la moyenne. Une fois par seconde, il affiche dans le moniteur série la tension de la batterie, le courant moyen jusque-là, la capacité consommée et l'autonomie estimée sur la base de 85 % de la capacité nominale. Laisse la mesure tourner au moins pendant un cycle de fonctionnement complet, par exemple assez longtemps pour couvrir un cycle entier de veille et de réveil. Pour des charges de plus de 1 A, utilise setCalibration_32V_2A(). Le même code fonctionne sans modification sur l'ESP32 avec les GPIO 21 et 22 ; pour l'utilisation du moniteur série, consulte Moniteur série Arduino.

Calcul de l'autonomie : capacité / courant × rendement

Quand tu connais le courant moyen, la formule de base est simple : Autonomie (heures) = Capacité (mAh) / Courant moyen (mA) × Rendement. Un facteur de 0,85 est un bon point de départ ; il tient compte de la capacité perdue à fort courant et par temps froid, de l'arrêt du circuit avant la décharge complète et du vieillissement de la batterie. Cette formule s'applique quand il n'y a pas de régulateur entre la batterie et le circuit, ou un régulateur linéaire (le régulateur 5 V de l'Uno, l'AMS1117, le 7805), car dans un régulateur linéaire le courant d'entrée est égal au courant de sortie et l'écart de tension part en chaleur. Si tu utilises un convertisseur à découpage, élévateur (boost) ou abaisseur (buck), calcule avec l'énergie : Autonomie (heures) = Énergie de la batterie (Wh) × Rendement / Puissance de la charge (W). Ici, le rendement est le produit des 85–90 % du convertisseur par la part utilisable de la batterie ; 0,75–0,8 est réaliste.

Pour les projets qui se mettent en veille et se réveillent, il faut d'abord le courant moyen : Courant moyen = (Courant éveillé × Durée éveillée + Courant de veille × Durée de veille) / Durée totale. Par exemple, un module ESP32 seul qui se réveille toutes les 10 minutes pendant 5 secondes en consommant 120 mA, puis dort les 595 secondes restantes à 10 µA (0,01 mA), consomme en moyenne (120 × 5 + 0,01 × 595) / 600 ≈ 1,01 mA. Avec un 18650 de 3000 mAh, cela donne 3000 / 1,01 × 0,85 ≈ 2520 heures, soit environ 3,5 mois. Si le même code tourne sur une carte de développement qui consomme 5 mA en veille, la moyenne passe à 5,96 mA et l'autonomie tombe à environ 18 jours. Plutôt que de calculer à la main, tu peux utiliser le calculateur d'autonomie de batterie : il suffit d'entrer la capacité, les courants en éveil et en veille et l'intervalle de réveil. Quand le courant moyen descend sous 0,1 mA, l'autodécharge de la batterie devient elle aussi déterminante : un accu lithium-ion perd environ 2–3 % de sa capacité par mois.

ESP32 : mesurer la durée d'éveil pour estimer l'autonomie

La consommation de l'ESP32 varie d'un facteur mille selon son mode de fonctionnement. D'après la fiche technique d'Espressif, la puce consomme jusqu'à 240 mA en émission Wi-Fi, environ 100 mA en réception, 20–68 mA avec le Wi-Fi coupé (modem sleep), environ 0,8 mA en light sleep et seulement 10 µA en deep sleep. C'est donc le temps passé éveillé qui détermine vraiment l'autonomie : la connexion au Wi-Fi prend souvent 1 à 3 secondes, et l'énergie dépensée pendant ces quelques secondes dépasse celle de plusieurs heures de veille. Le code ci-dessous enregistre dans la mémoire RTC la durée d'éveil à chaque réveil et, avec les courants que tu as mesurés, calcule le courant moyen et l'autonomie estimée.

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}

Au premier réveil, il enregistre seulement la durée ; à chaque réveil suivant, il calcule et affiche le courant moyen et l'autonomie en jours à partir de la durée d'éveil précédente. Mesure ACTIVE_MA et SLEEP_MA sur ta propre carte avec un multimètre et reporte-les dans le code. millis() ne compte pas le temps du bootloader au démarrage ; ajouter une marge de 0,1–0,3 seconde à la durée d'éveil donne un résultat plus réaliste. Pour les détails sur les modes de veille et les sources de réveil, consulte ESP32 deep sleep, et pour les redémarrages qui peuvent survenir sur batterie, Erreur brownout de l'ESP32.

Brancher des piles et batteries en série et en parallèle

Quand tu branches des batteries en série (le positif de l'une sur le négatif de la suivante), les tensions s'additionnent et la capacité (mAh) reste la même : quatre piles AA de 1,5 V et 2500 mAh en série donnent 6 V et 2500 mAh. Quand tu les branches en parallèle (tous les positifs ensemble, tous les négatifs ensemble), la tension reste la même et les capacités s'additionnent : deux 18650 de 3000 mAh en parallèle donnent 3,7 V et 6000 mAh. Dans les deux cas, l'énergie totale (Wh) augmente avec le nombre de cellules. Pour les packs lithium, cette disposition s'écrit avec les lettres S (série) et P (parallèle) ; par exemple, 2S2P désigne un pack de quatre cellules formé de deux paires en parallèle montées en série.

• Utilise des cellules identiques : dans un pack en série ou en parallèle, prends des batteries de même marque, même capacité, même âge et même niveau de charge ; la cellule la plus faible se vide avant les autres et souffre.
• Égalise les tensions avant le parallèle : avant de relier des accus lithium-ion en parallèle, l'écart de tension entre eux ne doit pas dépasser 0,1 V ; sinon, l'accu plein envoie un courant fort et incontrôlé dans l'accu vide.
• Un pack lithium en série doit être protégé : à partir de 2S, utilise une carte BMS avec équilibrage qui surveille chaque cellule. Un pack en série ne se charge pas avec un module TP4056, qui ne charge qu'une seule cellule.
• Ne mélange pas piles et accus : ne mets pas des piles alcalines et des accus NiMH dans le même pack ; leurs tensions et leurs résistances internes diffèrent.
• Le parallèle partage la charge : dans un pack 1S2P, chaque cellule fournit la moitié du courant ; le pack tient donc plus longtemps et chauffe moins à fort courant.

Qu'est-ce que le taux C ?

Le taux C indique la vitesse à laquelle une batterie est déchargée ou chargée par rapport à sa capacité. 1C est le courant qui vide la batterie en 1 heure ; il est numériquement égal à sa capacité : pour une batterie de 2000 mAh, 1C = 2 A, 0,5C = 1 A et 20C = 40 A. Le calcul de la durée est simple aussi : à 2C, la batterie est vide en 30 minutes environ, à 0,2C en 5 heures. Les valeurs comme 25C ou 50C imprimées sur les LiPo de drones et de modèles RC indiquent le courant de décharge continu maximal ; une LiPo de 1000 mAh en 25C peut fournir 25 A. Sur les 18650, cette valeur est généralement donnée directement en ampères : les accus haute capacité de 3500 mAh fournissent 8–10 A, les accus haute décharge de 2500–3000 mAh 15–30 A en continu. Pour la charge, la règle est plus stricte : le courant de charge standard des cellules lithium tourne autour de 0,5C, et 1C au maximum. Un module TP4056 qui charge à 1 A convient à un 18650 de 2000 mAh, mais il pousse une petite LiPo de 300 mAh à environ 3C ; dans ce cas, il faut changer la résistance Rprog du module pour réduire le courant de charge.

Mesurer la capacité d'une batterie avec un Raspberry Pi Pico (MicroPython)

Les 18650 marqués 9900 mAh sont presque toujours des contrefaçons ; les vrais 18650 les plus performants du marché atteignent environ 3500–3600 mAh. La seule façon de connaître la capacité réelle d'une batterie est de la décharger dans une charge connue et d'additionner le courant au fil du temps. Avec un Raspberry Pi Pico, une résistance de charge et un MOSFET, tu peux construire un testeur de capacité simple : le Pico met la charge en service via le MOSFET, mesure la tension de la batterie à travers un pont diviseur, calcule le courant avec I = U / R et déconnecte la charge quand la tension atteint la valeur de coupure. Tu peux vérifier les valeurs du pont avec le calculateur de pont diviseur de tension et trouver les détails du câblage du MOSFET dans Utiliser 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

Toutes les 30 secondes, le code mesure la tension de la batterie en charge, calcule le courant et additionne les mAh et Wh consommés ; il affiche les résultats dans la console de Thonny et les enregistre aussi dans le fichier desarj.csv de la mémoire flash du Pico. Tu pourras ensuite ouvrir ce fichier dans Excel et tracer la courbe de décharge (Envoyer des données Arduino vers Excel). Avec la charge de 10 Ω, le test d'un 18650 de 3000 mAh dure environ 8 à 9 heures. Pour un résultat précis, mesure la résistance de charge au multimètre et reporte sa valeur dans R_LOAD, puis compare la tension de la batterie avec celle du multimètre et corrige le facteur DIV. Pour tester un accu AA NiMH, abaisse CUTOFF à 1,0 V et la résistance de charge à 4,7 Ω. À 4,2 V, la résistance de charge dissipe environ 1,8 W ; choisis-en une d'au moins 5 W, tiens-la à l'écart des surfaces inflammables et ne laisse pas le test sans surveillance. Si tu ne sais pas encore installer MicroPython sur le Pico, commence par Qu'est-ce que le Raspberry Pi Pico ?.

Idées de projets avec calcul d'autonomie

• Capteur de jardin qui tient des mois : garde un ESP32 en deep sleep, mesure l'humidité du sol une fois par heure et descends le courant moyen sous 1 mA.
• Voltmètre avec jauge de batterie : mesure la tension de la batterie et affiche-la en pourcentage sur un écran LCD (Fabriquer un voltmètre avec Arduino).
• Le bon pack pour une voiture robot : mesure le courant des moteurs et calcule combien de minutes tiendra un pack 2S de 18650 (Fabriquer une voiture robot Arduino).
• Enregistreur de consommation : écris les mesures de l'INA219 sur une carte SD pour établir le profil énergétique journalier d'un appareil (Module carte SD).
• Station de test de capacité 18650 : ajoute un écran OLED au testeur à Pico et affiche les mAh en direct.
• Station météo sur batterie : fais fonctionner pendant des mois, avec un seul 18650, un ESP32 qui envoie les données d'un DHT11 toutes les 10 minutes.

Erreurs fréquentes et solutions

Tu connais maintenant la différence entre mAh et Wh, tu sais mesurer le courant de ton projet et calculer combien d'heures ou de jours tiendra une batterie. Pour la suite, jette un œil à Alimenter un Arduino sur batterie et à Charger un 18650 avec le TP4056. Dans l'application BlueGrays, tu trouveras des projets sur batterie comme l'économie d'énergie avec le deep sleep de l'ESP32, un voltmètre numérique avec écran LCD, une voiture robot pilotée en Bluetooth et un robot éviteur d'obstacles, chacun avec des schémas de câblage et du code pas à pas.