Oui, il est possible de mettre l’ESP32 en mode sleep tout en utilisant SPIFFS et un serveur web, mais il y a certaines limitations et des considérations importantes à garder à l’esprit.
Explication et Considérations pour le Mode Sleep avec un Serveur Web et SPIFFS
L'ESP32 dispose de plusieurs modes de veille (sleep modes), mais dès qu'il est en veille, la plupart des fonctionnalités (y compris le Wi-Fi) sont désactivées. Cela signifie que si l'ESP32 est mis en veille, il ne pourra pas servir de page web tant qu’il ne se réveillera pas.
Voici les modes de veille principaux et comment ils affectent le fonctionnement de votre serveur web et SPIFFS :
-
Mode Light Sleep :
- Dans ce mode, le processeur peut être mis en veille pour économiser de l’énergie, mais le Wi-Fi peut rester connecté (bien que sa consommation soit réduite).
- Avantages : Le périphérique reste connecté au réseau, et le réveil est rapide.
- Inconvénients : Ce mode économise moins d’énergie comparé aux autres modes de veille.
- Utilisation : Vous pourriez utiliser le mode Light Sleep entre les requêtes, en sortant de la veille uniquement quand il y a une nouvelle requête.
-
Mode Deep Sleep :
- Dans ce mode, l’ESP32 désactive pratiquement tout, y compris le Wi-Fi et le processeur, ce qui réduit énormément la consommation d’énergie.
- Avantages : Consommation minimale, idéal pour les projets à très faible énergie.
- Inconvénients : Le Wi-Fi doit se reconnecter chaque fois que le périphérique sort de la veille, ce qui prend du temps et consomme un peu plus d’énergie pour chaque réveil.
- Utilisation : Si vous voulez utiliser le Deep Sleep tout en ayant un serveur web, l’ESP32 doit se réveiller périodiquement ou en réponse à un événement (comme un timer ou un capteur) pour se reconnecter au réseau et répondre aux requêtes. Cela convient mieux aux systèmes où les requêtes sont peu fréquentes.
Exemple de Configuration avec Light Sleep
Pour mettre l’ESP32 en mode Light Sleep entre les requêtes, vous pouvez configurer un intervalle d’inactivité où, si aucune requête n’est reçue, l’ESP32 passe en Light Sleep jusqu'à ce qu’une interruption (comme une nouvelle requête ou un timer) le réveille.
Voici un exemple simple de Light Sleep avec un délai d’inactivité :
#include <SPIFFS.h>
#include <ESPAsyncWebServer.h>
#include <WiFi.h>
AsyncWebServer server(80);
unsigned long lastRequestTime = 0;
const unsigned long sleepDelay = 10000; // Temps avant Light Sleep (10 secondes d'inactivité)
void setup() {
Serial.begin(115200);
// Initialiser SPIFFS
if (!SPIFFS.begin(true)) {
Serial.println("Erreur lors du montage SPIFFS");
return;
}
// Connecter au Wi-Fi
WiFi.begin("SSID", "password");
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("Connecté au Wi-Fi");
// Configurer le serveur pour servir un fichier depuis SPIFFS
server.on("/alarme.log", HTTP_GET, [](AsyncWebServerRequest *request) {
lastRequestTime = millis(); // Réinitialiser le délai d'inactivité
request->send(SPIFFS, "/alarme.log", "text/plain");
});
server.begin();
}
void loop() {
// Si le délai d'inactivité est dépassé, entrer en Light Sleep
if (millis() - lastRequestTime > sleepDelay) {
Serial.println("Inactivité détectée, passage en Light Sleep.");
esp_light_sleep_start(); // Mettre l'ESP32 en Light Sleep
Serial.println("Réveil du Light Sleep."); // Message imprimé après réveil
lastRequestTime = millis(); // Réinitialiser le compteur
}
}
Utilisation du Deep Sleep
Si vous souhaitez utiliser le Deep Sleep, l'ESP32 doit être réveillé périodiquement ou par un événement externe. Par exemple, vous pouvez configurer un timer pour réveiller l’ESP32 toutes les minutes pour vérifier les requêtes, ou un capteur pour déclencher le réveil.
Voici un exemple d'utilisation du Deep Sleep avec un réveil par timer :
#include <SPIFFS.h>
#include <ESPAsyncWebServer.h>
#include <WiFi.h>
AsyncWebServer server(80);
void setup() {
Serial.begin(115200);
// Initialiser SPIFFS
if (!SPIFFS.begin(true)) {
Serial.println("Erreur lors du montage SPIFFS");
return;
}
// Connecter au Wi-Fi
WiFi.begin("SSID", "password");
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("Connecté au Wi-Fi");
// Configurer le serveur pour servir un fichier depuis SPIFFS
server.on("/alarme.log", HTTP_GET, [](AsyncWebServerRequest *request) {
request->send(SPIFFS, "/alarme.log", "text/plain");
});
server.begin();
// Configurer le timer pour le Deep Sleep (réveil toutes les 60 secondes)
esp_sleep_enable_timer_wakeup(60 * 1000000); // 60 secondes en microsecondes
Serial.println("Passage en Deep Sleep pour 60 secondes");
esp_deep_sleep_start(); // Mettre l'ESP32 en Deep Sleep
}
void loop() {
// Le code de loop() ne sera pas exécuté car l'ESP32 redémarre après Deep Sleep
}
Points Importants à Prendre en Compte
- Wi-Fi Reconnexion : Dans le mode Deep Sleep, chaque réveil nécessite une reconnexion au Wi-Fi, ce qui peut entraîner un délai de réponse plus long pour la première requête après chaque réveil.
- Économie d’Énergie : Le Deep Sleep est plus économe en énergie, mais nécessite une logique de réveil par timer ou événement pour répondre aux requêtes. Le Light Sleep permet de conserver la connexion Wi-Fi mais avec une économie d’énergie moindre.
- Gestion des Requêtes : Si les requêtes sont fréquentes, le Light Sleep peut être plus approprié, mais si elles sont rares, le Deep Sleep avec un réveil périodique pourrait être préférable.
Le choix entre ces options dépend de votre application et de vos besoins en énergie.
En mode Light Sleep, l'ESP32 peut en effet perdre temporairement la connexion MQTT. Bien que ce mode soit conçu pour réduire la consommation d’énergie tout en permettant de conserver une connexion Wi-Fi active, il n’est pas toujours fiable pour maintenir les connexions réseau stables, notamment celles basées sur des protocoles nécessitant une connexion continue, comme MQTT.
Explication
Le mode Light Sleep met le processeur principal en veille, mais il garde le module Wi-Fi actif. Cependant :
- Pauses de communication : Le Light Sleep entraîne de petites pauses dans les communications réseau lorsque le processeur est en veille. Cela peut poser des problèmes avec les protocoles qui nécessitent une communication continue (comme MQTT), surtout si le serveur MQTT s'attend à des signaux réguliers de la part de l’ESP32 pour maintenir la connexion active.
- Timeout et déconnexions : Certaines configurations de serveurs MQTT déconnectent les clients après un certain temps d'inactivité. Avec le Light Sleep, il est probable que l’ESP32 ne réponde pas assez fréquemment, entraînant une déconnexion de la part du serveur.
Solution pour le Light Sleep avec MQTT
- Maintien de la Connexion MQTT : Vous pouvez tenter de configurer des
keep-alive
(paquets envoyés périodiquement pour maintenir la connexion) très courts (par exemple, 5 à 10 secondes) pour essayer de conserver la connexion. Cela pourrait aider dans certains cas, mais ce n’est pas garanti, car le Light Sleep peut tout de même introduire des interruptions. - Reconnecter après le réveil : Une autre solution consiste à détecter la perte de connexion MQTT dans le code, puis à essayer de reconnecter le client MQTT dès que l’ESP32 sort de Light Sleep.
Alternatives
Pour des connexions stables avec MQTT, il est souvent recommandé :
- Soit de désactiver le Light Sleep pendant que la connexion MQTT est nécessaire, puis de le réactiver après la déconnexion.
- Soit d'utiliser Deep Sleep avec des réveils périodiques. Dans ce cas, l’ESP32 se réveille, se reconnecte au serveur MQTT, envoie les données nécessaires (ou écoute les messages), puis retourne en Deep Sleep.
Exemple de Code : Reconnexion MQTT après le Light Sleep
Un exemple simplifié pour reconnecter MQTT après un Light Sleep, en détectant les déconnexions et en essayant de rétablir la connexion :
#include <WiFi.h>
#include <PubSubClient.h>
WiFiClient espClient;
PubSubClient client(espClient);
const char* ssid = "SSID";
const char* password = "PASSWORD";
const char* mqtt_server = "broker.hivemq.com";
void setup() {
Serial.begin(115200);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
client.setServer(mqtt_server, 1883);
// Connecter au serveur MQTT
reconnectMQTT();
}
void loop() {
// Si déconnecté, essayer de se reconnecter
if (!client.connected()) {
reconnectMQTT();
}
// Garder la connexion MQTT active
client.loop();
// Exemple de passage en Light Sleep si inactif pendant 10 secondes
delay(10000);
esp_light_sleep_start(); // L'ESP32 sort de Light Sleep sur une interruption
}
void reconnectMQTT() {
while (!client.connected()) {
Serial.print("Tentative de connexion MQTT...");
if (client.connect("ESP32Client")) {
Serial.println("connecté");
client.subscribe("topic/test");
} else {
Serial.print("échec, code erreur= ");
Serial.print(client.state());
delay(5000);
}
}
}
Dans cet exemple, le programme essaie de reconnecter le client MQTT chaque fois qu'il détecte une déconnexion. Cela permet de restaurer la connexion après chaque Light Sleep.