Aziz Bench

Calcul de l’autonomie de batterie pour ESP32 et Arduino

Estimez l’autonomie d’un nœud ESP32, Arduino ou nRF qui dort en veille profonde (deep sleep) et se réveille pour mesurer et transmettre. Partez d’un préréglage, puis remplacez les valeurs par celles que vous mesurez sur votre circuit.

Autonomie estimée
6,1mois
≈ 187 jours · réveil toutes les 15 min
Courant moyen
379 µA
Consommation par jour
9,1 mAh
Réveils par charge
18 000
Profil de courant · un cycle
Microcontrôleur et radio
µA

La puce ou le module seul. Le régulateur et le reste de la carte se comptent dans les consommations permanentes.

Cycle de réveil
Phase active · CPU et capteurs
mA
ms
Émission · radio allumée
mA
ms
Consommations permanentes
µA
µA

Capteurs en veille, LED, pont diviseur pour lire la batterie. Un pont 100k + 100k sur une LiPo chargée consomme environ 21 µA.

Batterie
mAh
%
%/mois

La part utilisable est la partie de la charge que votre circuit peut consommer avant que la tension ne descende sous son minimum.

Où va la charge

    Ce qu’il faut améliorer

    Autonomie selon l’intervalle de réveil

    La ligne en pointillés est le plafond fixé par le courant de veille, les consommations permanentes et l’autodécharge. Plus vous vous en approchez, moins il est utile d’allonger l’intervalle.

    Texte brut prêt à coller dans un message de forum ou une issue.

    Le modèle travaille en mAh et suppose un régulateur linéaire (LDO), où le courant tiré de la batterie est à peu près égal à celui du circuit. Avec un convertisseur à découpage, l’autonomie réelle est en général meilleure. La température et le vieillissement de la batterie ne sont pas pris en compte.

    Comment fonctionne l’estimation

    Un nœud sur batterie passe presque toute sa vie à dormir. Il se réveille à intervalles de quelques minutes, lit ses capteurs, allume la radio pour envoyer les données et se rendort. L’autonomie dépend du courant moyen sur un cycle complet, pas des pics.

    I_moy = (I_actif × t_actif + I_radio × t_radio + I_veille × t_veille) / T
            + I_régulateur + I_périphériques + I_autodécharge
    
    autonomie = capacité utilisable / I_moy

    L’autodécharge est convertie en un courant constant équivalent. Une LiPo de 2 000 mAh qui perd environ 2 % par mois se comporte comme une charge supplémentaire de 55 µA, plus de cinq fois ce que consomme un ESP32 en veille profonde.

    Avec le préréglage par défaut (module ESP32 nu, régulateur HT7333, LiPo de 2 000 mAh, un réveil toutes les 15 minutes avec 2 secondes de Wi-Fi), le courant moyen est d’environ 379 µA et la batterie tient à peu près 6 mois. Le Wi-Fi représente 70 % de la charge : raccourcir la connexion est donc le changement le plus efficace.

    Courants typiques en veille profonde

    PuceModeCourant typique
    ESP32Deep sleep, timer RTC≈ 10 µA
    ESP32-C3Deep sleep≈ 5 µA
    ESP32-S3Deep sleep, timer RTC≈ 8 µA
    ATmega328P (Uno, Nano, Pro Mini)Power-down avec watchdog≈ 4 µA
    nRF52840System ON avec RTC≈ 2–3 µA
    RP2040 (carte Raspberry Pi Pico)Dormant≈ 0,8 mA

    Valeurs indicatives pour la puce seule, tirées des datasheets des fabricants, à environ 3,3 V et à température ambiante. Une carte de développement ajoute son régulateur, ses LED et sa puce USB-série, souvent des centaines de fois plus.

    Pourquoi une carte de développement ESP32 vide la batterie en veille profonde

    La puce ESP32 descend à environ 10 µA, mais un DevKit typique continue de consommer plusieurs milliampères. Le régulateur AMS1117 consomme à lui seul environ 5 mA de courant de repos, la LED d’alimentation reste allumée et la puce USB-série reste alimentée. Sur une LiPo de 2 000 mAh, l’autonomie passe de plusieurs mois à environ une semaine.

    Choisissez le préréglage « ESP32 DevKit tel quel » ci-dessus pour voir la différence. Pour un usage sur batterie, passez à un module nu ou à une carte conçue pour la basse consommation, avec un régulateur à faible courant de repos comme le MCP1700 ou le HT7333.

    Questions fréquentes

    Combien de temps un ESP32 tient-il sur batterie ?

    Cela dépend surtout de la fréquence des réveils et du temps pendant lequel le Wi-Fi reste allumé. Un module ESP32 nu avec un régulateur à faible courant de repos, qui se réveille toutes les 15 minutes pour environ 2 secondes de Wi-Fi, tient environ 6 mois sur une LiPo de 2 000 mAh, et plus d’un an s’il se réveille une fois par heure. Une carte de développement utilisée telle quelle tient environ une semaine.

    Peut-on alimenter un ESP32 avec une pile bouton CR2032 ?

    Pas de façon fiable avec le Wi-Fi. Les pics d’émission dépassent 200 mA, alors qu’une CR2032 est conçue pour des charges de quelques milliampères : la tension s’effondre et la puce redémarre. Avec une pile bouton, utilisez une puce BLE comme le nRF52, ou passez à une LiPo ou à des piles AA.

    Quel régulateur de tension utiliser pour un ESP32 sur batterie ?

    Un régulateur à faible chute (LDO) avec un faible courant de repos, comme le MCP1700 (environ 1,6 µA) ou le HT7333 (environ 4 µA). Vérifiez que son courant de sortie maximal convient aux pics du Wi-Fi et ajoutez un condensateur réservoir près du module. Évitez l’AMS1117 présent sur beaucoup de cartes : il consomme environ 5 mA même sans charge.

    Comment mesurer le courant en veille profonde ?

    Un multimètre en série sur le calibre µA convient pour le courant de veille, mais son shunt peut faire chuter assez de tension pour faire redémarrer la carte à son réveil. Un profileur de consommation comme le PPK2 de Nordic enregistre tout le cycle, des microampères aux centaines de milliampères, et ses valeurs peuvent être saisies directement dans ce calculateur.

    Pourquoi l’autodécharge de la batterie compte-t-elle ?

    Avec de longs intervalles entre les réveils, le courant moyen devient si faible que les pertes de la batterie elle-même deviennent le poste principal. Une LiPo qui perd 2 % par mois équivaut à environ 55 µA sur 2 000 mAh. Pour une autonomie de plusieurs années, une pile au lithium primaire Li-SOCl₂ perd environ 1 % par an.