Bonjour !
J'avance dans mon projet de mini-station météo (merci encore à terwal et J-L-M qui m'ont bien aidé).
Mon module ESP32 déporté alimenté par batterie consommant pas mal, je lui ai programmé un deep sleep entre les mesures, et cela fonctionne.
A ce sujet :
Mon projet utilise une minuscule carte XIAO ESP32-C3 de chez Seeed qui embarque de quoi charger une batterie, et j'ai eu l'agréable surprise qu'elle ne consomme qu'environ 40 µA en deep sleep alimentée sur batterie.
Par contre comme je le craignais, j'ai maintenant un problème avec l'OTA qui fonctionnait très bien avant que je ne programme le deep sleep. (L'IDE Arduino me propose toujours le port réseau pour uploader)
Vu que la carte est ON pendant juste 2 à 3 secondes, le temps de se connecter, d'envoyer sa requête, et de repartir en deep sleep, ça ne marche plus même si pour l'instant je n'ai mis que 15 secondes de sommeil, et que la carte se réveille plusieurs fois pendant que l'IDE Arduino envoie l'invitation à l'adresse IP de la carte après la compilation.
Bien sûr je peux toujours reprogrammer la carte en mode boot en USB.
Je vous mets le programme, au cas où...
Pour info, j'ai aussi essayé en plaçant les deux lignes qui sont dans loop() à la fin du setup, mais cela n'a rien changé.
/* Station de mesure de température et d'hygrométrie avec envoi des données par un HHTP_GET sur un serveur
* et une mise à jour par OTA, autour d'un Seeed XIAO ESP32C3 */
#include <WiFi.h>
#include <HTTPClient.h>
#include <ArduinoOTA.h> // Librairie permettant la mise à jour OTA du croquis par le Wifi
#include <ESPmDNS.h> // Librairie nécessaire pour le fonctionnement de la précédente
#include <WiFiUdp.h> // Aussi nécessaire pour le fonctionnement de ArduinoOTA.h
#include "DHT.h" // Bibliothèque pour sondes DHT
#define DHTTYPE DHT11 // Type de capteur DHT utilisé
#define uS_TO_S_FACTOR 1000000 // Conversion des µsecondes en secondes
#define TIME_TO_SLEEP 15 // Time ESP32 will go to sleep (in seconds)
const char* ssid = "xxxx";
const char* mdp = "yyyy";
const int LedPin = 20; // GPIO de la led de signalisation
const int TimeOut_connexion =40; // Nb d'essais de connexion au Wifi
int timeOut_counter =0; // Compteur de nombre d'essais de connexion.
bool Blink = false;
unsigned long prevBlinkMillis;
float Temp;
int Hum;
uint32_t Vbat;
float Vbatf;
float Vstop = 3.4; // Tension à laquelle la carte se met en deep sleep
uint8_t DHTPin = 7; // GPIO attribué au capteur DHT
DHT dht(DHTPin, DHTTYPE); // Initialisation du capteur
WiFiClient client;
void setup()
{
setCpuFrequencyMhz(80); // réglage de la fréquence de la CPU à 80 Mhz, en dessous le WiFi ne marche pas
pinMode(A1, INPUT); // Positionne le GPIO de l'entrée analogique A1 en entrée
pinMode(LedPin, OUTPUT); // Positionne le GPIO de la led en sortie
pinMode(DHTPin, INPUT); // Positionne le GPIO de la sonde en entrée
dht.begin();
vbat(); // Mise en deep sleep si batterie trop faible
WiFi.begin(ssid, mdp); // Etablissement de la connexion WiFi
while (WiFi.status() != WL_CONNECTED) // Boucle de vérification de l'établissement de la liaison
{
delay(250);
timeOut_counter++; // redémarrage de l'ESP si pas de connexion pendant 10 sec
if (timeOut_counter > TimeOut_connexion) ESP.restart();
}
initOTA(); // Renvoie à la routine de mise à jour du croquis par le Wifi (OTA)
envoi(); // Renvoie vers la fonction d'envoi des données par HTTP_GET
for(int i = 0; i < 5; i++) // clignotement led avant d'aller en deep sleep
{Blink =!Blink; digitalWrite(LedPin, Blink); delay(100);}
}
void loop()
{
ArduinoOTA.handle(); // Surveillance des demandes de mise à jour OTA (au début de loop)
Sleep_ESP();
}
void envoi()
{
Temp = dht.readTemperature()-0.8; // Lecture de la température avec correction
Hum = dht.readHumidity(); // Lecture de l'humidité
vbat(); // vers la routine de mesure de Vbat
String mon_url = "http://192.168.1.152/get?data=" + String(Vbatf) + "-" + String(Hum) + "-" + String(Temp);
HTTPClient http;
http.begin(mon_url);
int httpResponseCode = http.GET();
http.end();
}
void vbat() // Routine de mesure de la tension de la batterie
{
Vbat = 0;
for(int i = 0; i < 10; i++) // 10 boucles de mesure pour moyenner la valeur
{ // Lecture des millivolts présents sur l'entrée, la commande
delay(20); // "analogReadMilliVolts" utilise une table de correction intégrée à la puce
Vbat += analogReadMilliVolts(A1); // Délai de 20 msec entre mesures et addition des valeurs
}
Vbatf = Vbat *2 /10/977.0; // calcul de la tension en volts, le x2 à cause du pont diviseur par 2
// le 977 devrait être en théorie 1000, mais tolérances des résistances
if (Vbatf<Vstop) esp_deep_sleep_start(); // met l'ESP en sommeil profond si la batterie descend sous Vstop
}
void Sleep_ESP()
{
WiFi.disconnect(true);
esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);
esp_deep_sleep_start();
}
/********************* Partie du programme qui permet la mise à jour du sketch au travers du WiFi *****************
*
* Port defaults to 3232
* ArduinoOTA.setPort(3232);
*
* Hostname defaults to esp3232-[MAC]
* ArduinoOTA.setHostname("myesp32");
*
* No authentication by default
* ArduinoOTA.setPassword("admin");
*
* Password can be set with it's md5 value as well
* MD5(admin) = 21232f297a57a5a743894a0e4a801fc3
* ArduinoOTA.setPasswordHash("21232f297a57a5a743894a0e4a801fc3");
*/
void initOTA()
{
ArduinoOTA
.onStart([]() {
String type;
if (ArduinoOTA.getCommand() == U_FLASH)
type = "sketch";
else // U_SPIFFS
type = "filesystem";
// NOTE: if updating SPIFFS this would be the place to unmount SPIFFS using SPIFFS.end()
Serial.println("Start updating " + type);
})
.onEnd([]() {
Serial.println("\nEnd");
})
.onProgress([](unsigned int progress, unsigned int total) {
Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
})
.onError([](ota_error_t error) {
Serial.printf("Error[%u]: ", error);
if (error == OTA_AUTH_ERROR) Serial.println("Auth Failed");
else if (error == OTA_BEGIN_ERROR) Serial.println("Begin Failed");
else if (error == OTA_CONNECT_ERROR) Serial.println("Connect Failed");
else if (error == OTA_RECEIVE_ERROR) Serial.println("Receive Failed");
else if (error == OTA_END_ERROR) Serial.println("End Failed");
});
ArduinoOTA.begin();
Serial.println();
Serial.println("Maj OTA paramétrée !");
// Serial.print("IP address: ");
// Serial.println(WiFi.localIP());
}
Si jamais quelqu'un a une idée, merci !
Roland
