Deep sleep de l'ESP32 : faire fonctionner un capteur sur batterie pendant des mois

5 min de lecture

Un ESP32 qui reste éveillé toute la journée avec le Wi-Fi actif consomme beaucoup. Il videra une petite batterie en quelques jours. L'astuce pour les projets sur batterie est simple : dormir presque tout le temps, se réveiller, mesurer, envoyer la valeur, et se rendormir.

C'est le rôle du deep sleep. Ce guide explique son fonctionnement et donne deux exemples qui marchent : Arduino et ESPHome.

Un cycle de deep sleep : courtes périodes d'éveil, longs sommeils

Ce que fait le deep sleep

En deep sleep, le processeur, la plus grande partie de la RAM et les périphériques numériques sont éteints. La documentation d'Espressif indique que seuls le contrôleur RTC, les périphériques RTC et les mémoires RTC peuvent rester alimentés (modes de veille ESP-IDF). Le Wi-Fi et le Bluetooth sont aussi coupés, et les connexions ne sont pas maintenues.

Un réveil du deep sleep ressemble donc à un redémarrage complet : setup() s'exécute de nouveau depuis le début. Les variables sont perdues, sauf si vous les stockez dans la mémoire RTC.

Façons de se réveiller

La puce se réveille quand une source activée se déclenche. Les principales sources sur l'ESP32 sont :

  • Minuteur : réveil après une durée fixée. Le choix le plus courant.
  • Broches externes (ext0, ext1) : réveil sur un appui de bouton ou un capteur de porte.
  • Pastilles tactiles : réveil au toucher.
  • Coprocesseur ULP : un petit processeur qui peut surveiller des capteurs pendant que le reste dort.

La liste et les puces prises en charge figurent dans la documentation des modes de veille d'ESP-IDF. Les sources de réveil varient entre l'ESP32 et l'ESP32-S3 : consultez la page pour votre puce.

Exemple Arduino : se réveiller chaque minute

#include <Arduino.h>

// Survives deep sleep: stored in RTC memory
RTC_DATA_ATTR int bootCount = 0;

const uint64_t SLEEP_SECONDS = 60;

void setup() {
  Serial.begin(115200);
  delay(200);

  bootCount++;
  Serial.printf("Wake-up number %d\n", bootCount);

  // 1. Read your sensor here
  // 2. Connect to Wi-Fi and send the value here

  esp_sleep_enable_timer_wakeup(SLEEP_SECONDS * 1000000ULL);
  Serial.println("Going to sleep");
  Serial.flush();
  esp_deep_sleep_start();
}

void loop() {
  // never reached: the board restarts after each sleep
}

Points clés :

  • RTC_DATA_ATTR conserve une variable d'un sommeil à l'autre.
  • esp_sleep_enable_timer_wakeup() prend des microsecondes, d'où la multiplication.
  • Serial.flush() garantit que le dernier message est envoyé avant l'arrêt de la puce.
  • Faites votre travail dans setup(), puisque loop() ne s'exécute jamais.

Exemple ESPHome

ESPHome possède un composant deep_sleep. Cette configuration se réveille toutes les 10 minutes, reste éveillée 30 secondes pour que le Wi-Fi se connecte et que les valeurs soient envoyées, puis se rendort :

deep_sleep:
  run_duration: 30s
  sleep_duration: 10min

sensor:
  - platform: dht
    pin: GPIO4
    model: DHT22
    update_interval: 15s
    temperature:
      name: "Garage temperature"
    humidity:
      name: "Garage humidity"

run_duration et sleep_duration sont décrits dans la documentation ESPHome du deep sleep. Ajoutez cela aux blocs Wi-Fi, API et OTA habituels de notre tutoriel DHT22. Pendant que la carte dort, elle ne peut rien recevoir, et Home Assistant affiche ses entités comme indisponibles jusqu'au prochain réveil. C'est normal.

Un avertissement pratique : avec un run_duration très court, il ne reste presque pas de temps pour envoyer une mise à jour du firmware par Wi-Fi. Gardez un moyen d'arrêter le sommeil, comme un interrupteur ou une première exécution longue, pendant le développement.

Erreurs qui vident la batterie

  1. Les cartes de développement gaspillent de l'énergie. La puce USB-série, la LED d'alimentation et le régulateur de tension continuent de consommer même quand la puce ESP32 dort. Le chiffre de la fiche technique de la puce n'est pas ce qu'atteint un DevKit. Pour une vraie autonomie, utilisez un régulateur à faible courant de repos et une carte conçue pour cela.
  2. Rester éveillé trop longtemps. Se connecter au Wi-Fi prend des secondes. Utilisez une IP fixe et gardez le temps d'éveil court. Moins de temps éveillé, c'est plus d'autonomie.
  3. Des capteurs qui restent alimentés. Alimentez le capteur depuis une GPIO, ou choisissez-en un avec un mode veille.
  4. Des broches flottantes et des résistances de rappel qui laissent fuir du courant.
  5. Une mauvaise batterie pour l'usage. Une batterie faible chute pendant le pic d'émission Wi-Fi et provoque des redémarrages.

Combien de temps tiendra-t-elle ?

Cela dépend de votre carte, de votre batterie, du temps d'éveil et de la fréquence des réveils. Mesurez : placez un multimètre ou un profileur de consommation en série avec la batterie, et mesurez les courants d'éveil et de sommeil. Le calcul est alors : courant moyen = (courant éveillé x temps éveillé + courant en sommeil x temps en sommeil) / durée du cycle, et autonomie = capacité / courant moyen.

Quelle carte ?

Pour un premier test, l'ESP32 DevKit est parfait : c'est celui de nos autres tutoriels. Pour un produit final sur batterie, cherchez une carte conçue pour la basse consommation.

Une carte ESP32 DevKit

Conclusion

Le deep sleep transforme l'ESP32, gros consommateur, en capteur capable de tourner longtemps sur batterie. Gardez le temps d'éveil court, stockez ce qu'il faut en mémoire RTC, et mesurez votre consommation réelle. Sans code, ESPHome donne le même résultat en quatre lignes.

Le sketch Arduino n'a pas été compilé ici ; la configuration ESPHome a été validée avec esphome config. Mesurez votre propre montage avant de promettre une autonomie à qui que ce soit.

Sources