Serveur Web ESP32 : graphiques avec statistiques de température

Serveur Web ESP32 : graphiques avec statistiques de température

Ce projet s’appuie sur notre projet précédent, dans lequel nous avons créé un enregistreur de données ESP32 à l’aide d’un capteur BME280. Dans cette nouvelle version, nous avons ajouté plusieurs nouvelles fonctionnalités, notamment des statistiques de température telles que la température maximale et minimale dans une plage de temps sélectionnée, la durée pendant laquelle la température reste au-dessus ou en dessous d’une certaine valeur, le temps nécessaire pour atteindre la température maximale, et bien plus encore.

L’ESP32 prend des mesures de température, d’humidité et de pression et enregistre ces valeurs avec un horodatage dans un fichier .csv sur une carte microSD. Ensuite, ces relevés de capteurs sont affichés sur un serveur Web avec des graphiques en temps réel. De plus, la page Web comporte une section dédiée au calcul des statistiques de température. La carte ESP32 est programmée à l’aide de l’IDE Arduino.

Graphiques du serveur Web ESP32 avec statistiques de température

Vous aimerez peut-être lire : Construire un serveur Web ESP32 : le guide complet pour les débutants (Arduino IDE).

Aperçu du projet

L’image suivante montre la page Web que vous allez créer pour ce projet. La capture d’écran suivante montre le haut de la page Web avec la vue graphique.

Graphiques et statistiques de température du serveur Web ESP32 BME280

Si vous faites défiler vers le bas, vous trouverez la section statistiques de température :

Aperçu des graphiques et statistiques de température du serveur Web ESP32 BME280

Voici les principales caractéristiques de ce projet :

  • L’ESP32 est équipé d’un capteur BME280 qui prend des mesures toutes les 60 secondes et les stocke sur une carte microSD dans un fichier .csv ;
  • L’ESP32 héberge une page Web qui affiche 3 graphiques en temps réel : température, humidité et pression ;
  • Sur la page Web, vous pouvez télécharger ou supprimer le fichier .csv ;
  • Les graphiques peuvent être zoomés et mettre en évidence chaque valeur ;
  • La page Web est entièrement réactive, elle s’exécute donc sur n’importe quelle taille d’écran ;
  • Il existe une section dédiée aux statistiques de température où nous affichons des informations telles que :
    • Température maximale et minimale au cours des dernières 24 heures et 7 jours ;
    • Temps au-dessus ou en dessous de certains seuils ;
    • Temps entre la température minimale et la température maximale et entre la température maximale et la température minimale ;
    • Variations quotidiennes de température au cours des 7 derniers jours ;
    • Modèle de température diurne. C’est un graphique montrant la température moyenne par heure de la journée.

Pour plus de simplicité, nous stockerons le HTML et le CSS de la page Web dans une variable du croquis Arduino, mais vous pouvez utiliser le système de fichiers LittleFS si vous souhaitez des fichiers séparés.

Conditions préalables

Avant de poursuivre ce tutoriel, vous devez avoir installé les cartes ESP32 dans votre IDE Arduino :

Vous pourriez également trouver utile de lire ces autres guides :

Pièces requises

Pour ce tutoriel, vous avez besoin des pièces suivantes :

Vous pouvez utiliser les liens précédents ou vous rendre directement sur MakerAdvisor.com/tools pour trouver toutes les pièces pour vos projets au meilleur prix !

1793813829 945 Serveur Web ESP32 graphiques avec statistiques de temperature

Diagramme schématique – ESP32 avec BME280 et carte MicroSD

Nous allons utiliser la communication I2C avec le module capteur BME280 et SPI pour la carte microSD.

Câblez le capteur et le module de carte microSD à l’aide du schéma suivant (ou utilisez les tableaux ci-dessous pour vérifier l’affectation des broches).

Diagramme ESP32 du serveur Web Arduino IDE Schéma de circuit de câblage Carte MicroSD BME280

Connectez le capteur BME280 aux broches I2C par défaut de l’ESP32 :

BME280 ESP32
SCK (broche SCL) GPIO22
SDI (broche SDA) GPIO21

Le module de carte microSD communique à l’aide du protocole de communication SPI. Vous pouvez le connecter à l’ESP32 en utilisant les broches SPI par défaut.

Module de carte MicroSD ESP32
3V3 3,3 V
CS GPIO5
MOSI GPIO23
CLK GPIO18
MISO GPIO19
GND GND

Le circuit final devrait ressembler à ceci :

Graphique ESP32 Serveur Web Arduino IDE Graphique historique CSV Log Data File Circuit

Avant de poursuivre le didacticiel, assurez-vous de formater votre carte microSD en FAT32 (en savoir plus sur notre guide de la carte microSD). Ensuite, insérez la carte microSD dans le module.

Installer les bibliothèques requises dans l’IDE Arduino

Pour ce projet, vous devez installer les bibliothèques suivantes :

Vous pouvez installer ces bibliothèques dans Arduino Library Manager. Ouvrez le gestionnaire de bibliothèque en cliquant sur l’icône Bibliothèque dans la barre latérale gauche.

Recherchez ESPAsyncWebServer et installez ESPAsyncWebServer par ESP32Async.

Installation de l'IDE Arduino ESPAsyncWebServer ESP32

Recherchez AsyncTCP et installez AsyncTCP par ESP32Async.

Installation de l'IDE Arduino AsyncTCP ESP32

Recherchez Adafruit BME280 et installez la bibliothèque :

Installation de la bibliothèque de capteurs Adafruit BME280 Arduino IDE

Enfin, recherchez Adafruit Unified Sensor et installez cette bibliothèque.

Installation de l'IDE Arduino de la bibliothèque de capteurs unifiées Adafruit

Arduino Sketch – Graphiques du serveur Web ESP32 avec statistiques de température

Le code suivant crée un serveur Web qui dessert une page Web qui charge les données du capteur stockées dans le fichier .csv de la carte microSD dans des graphiques en temps réel et calcule diverses statistiques de température.

/*
  Rui Santos & Sara Santos - Raspberryme.com
  Complete project details at https://Raspberryme.com/esp32-web-server-charts-statistics/
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.  
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*/
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

// REPLACE WITH YOUR NETWORK CREDENTIALS
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

// BME280 GPIOs
#define SDA_PIN 21
#define SCL_PIN 22

// MicroSD Card Module GPIOs
#define SD_CS   5
#define SD_MOSI 23
#define SD_MISO 19
#define SD_SCK  18

// NTP server
const char* ntpServer = "pool.ntp.org";
const long gmtOffset_sec = 3600;      // Change to your timezone
const int daylightOffset_sec = 0;

// Timer to take new readings
unsigned long previousMillis = 0;
const long interval = 60000;  // 60 seconds

// CSV filename
const char* dataFile = "/bme280_log.csv";

// AsyncWebServer Web Server
AsyncWebServer server(80);
// BME280
Adafruit_BME280 bme;

// Get Time
String getTimeStr() {
  struct tm timeinfo;
  if (!getLocalTime(&timeinfo)) return "00:00:00";
  char buf[9]; sprintf(buf, "%02d:%02d:%02d", timeinfo.tm_hour, timeinfo.tm_min, timeinfo.tm_sec);
  return String(buf);
}

// Get Date
String getDateStr() {
  struct tm timeinfo;
  if (!getLocalTime(&timeinfo)) return "1970-01-01";
  char buf[11]; sprintf(buf, "%04d-%02d-%02d", timeinfo.tm_year+1900, timeinfo.tm_mon+1, timeinfo.tm_mday);
  return String(buf);
}

// Initialize MicroSD Card and create the .csv file
void initSD() {
  SPI.begin(SD_SCK, SD_MISO, SD_MOSI, SD_CS);
  if (!SD.begin(SD_CS)) { Serial.println("SD Card Failed"); return; }
  
  if (!SD.exists(dataFile)) {
    File f = SD.open(dataFile, FILE_WRITE);
    if (f) { f.println("temp_c,temp_f,humidity,pressure,time,day"); f.close(); }
  }
}

// Log BME280 data on the MicroSD Card
void logData() {
  float tempC = bme.readTemperature();
  float tempF = tempC * 9.0 / 5.0 + 32.0;
  float hum = bme.readHumidity();
  float press = bme.readPressure() / 100.0F;

  File file = SD.open(dataFile, FILE_APPEND);
  if (file) {
    file.printf("%.2f,%.2f,%.2f,%.2f,%s,%s\n", 
                tempC, tempF, hum, press, getTimeStr().c_str(), getDateStr().c_str());
    file.close();
  }
}

void setup() {
  Serial.begin(115200);
  
  // Initialize BME280 Sensor
  Wire.begin(SDA_PIN, SCL_PIN);
  if (!bme.begin(0x76)) { 
    Serial.println("BME280 not found!");
    while(1); 
  }

  // Start the Wi-Fi connection
  WiFi.begin(ssid, password);
  Serial.print("Connecting to Wi-Fi");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nWi-Fi Connected!");
  // Print the ESP32 IP Address
  Serial.print("Access ESP32 IP Address: http://");
  Serial.println(WiFi.localIP());

  // Configure NTP time
  configTime(gmtOffset_sec, daylightOffset_sec, ntpServer);
  delay(2000);

  // Initialize MicroSD Card
  initSD();

  // Root URL handler for the mains HTML web page
  server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
  String html = R"rawliteral(



  ESP32 BME280: Charts & Stats
  
  
  
  
  
  


  
    
    

New readings are added to your chart automatically, you don't need to refresh the web page.

Refresh Charts Download CSV Delete All Data Reset All Zoom

Humidity

Pressure

Latest Reading

No data logged yet.

Not enough data yet to compute statistics.

Last 24 Hours

Last 7 Days

Time Above / Below Thresholds (Last 7 Days)

Estimated by adding up the time spent in each temperature band between consecutive readings. Gaps without readings longer than 15 minutes are ignored.

Time to Max / Time to Min

Daily Temperature Swing (Last 7 Days)

Diurnal Pattern (Average by Hour of Day)

Average of all loaded readings, grouped by hour of day (0 to 23). Uses the full log history that is stored in the .csv file.

)rawliteral"; request->send(200, "text/html; charset=UTF-8", html); }); // Download .csv file stored on MicroSD Card server.on("/download", HTTP_GET, [](AsyncWebServerRequest *request){ request->send(SD, dataFile, "text/csv", true); }); // Delete .csv file stored on MicroSD Card server.on("/delete", HTTP_POST, [](AsyncWebServerRequest *request){ if (SD.exists(dataFile)) SD.remove(dataFile); File f = SD.open(dataFile, FILE_WRITE); if (f) { f.println("temp_c,temp_f,humidity,pressure,time,day"); f.close(); } request->send(200); }); server.begin(); Serial.println("ESP32 BME280 Web Server: Charts & Stats Ready!"); } void loop() { // Timer if (millis() - previousMillis >= interval) { previousMillis = millis(); logData(); } delay(10); }

Afficher le code brut

Avec les bibliothèques mentionnées précédemment installées dans votre IDE Arduino, il vous suffit d’insérer vos informations d’identification réseau dans les lignes suivantes du code, et cela fonctionnera immédiatement.

const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_SSID";

Comment fonctionne le code

Continuez à lire pour découvrir comment fonctionne le code ou passez à la section Démonstration.

Y compris les bibliothèques

Tout d’abord, incluez les bibliothèques requises pour vous connecter au Wi-Fi, créer le serveur Web, lire le capteur BME280 et communiquer avec la carte SD.

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

Informations d’identification réseau

Insérez vos informations d’identification réseau dans les variables suivantes afin que l’ESP32 se connecte à votre réseau.

// REPLACE WITH YOUR NETWORK CREDENTIALS
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_SSID";

GPIO

Définissez les GPIO qui seront utilisés pour la communication I2C avec le capteur BME280 et la communication SPI avec le module de carte microSD.

// BME280 GPIOs
#define SDA_PIN 21
#define SCL_PIN 22

// MicroSD Card Module GPIOs
#define SD_CS   5
#define SD_MOSI 23
#define SD_MISO 19
#define SD_SCK  18

Serveur NTP

Nous demanderons l’heure à pool.ntp.org, qui est un cluster de serveurs de temps que tout le monde peut utiliser pour demander l’heure (lisez notre guide Client-Serveur NTP ESP32 : Obtenir la date et l’heure).

const char* ntpServer = "pool.ntp.org";
const long gmtOffset_sec = 3600;      // Change to your timezone
const int daylightOffset_sec = 0;

Minuteur

Cette minuterie prendra de nouvelles lectures toutes les 60 secondes ; vous pouvez augmenter ce nombre pour une application réelle. À des fins de test et pour collecter plus de valeurs dans un court laps de temps, cette durée est définie sur 60 secondes.

unsigned long previousMillis = 0;
const long interval = 60000;  // 60 seconds

Fichier CSV

Le fichier stocké sur la carte microSD porte le nom suivant : bme280_log.csv.

const char* dataFile = "/bme280_log.csv";

Création d’un objet serveur

Créez un objet AsyncWebServer appelé serveur sur le port 80.

AsyncWebServer server(80);

Création d’un objet BME280

Le BME280 lira les valeurs à l’aide du protocole de communication I2C. Il vous suffit de créer un objet Adafruit_BME280 appelé bme comme suit.

Adafruit_BME280 bme;

installation()

Dans le setup(), nous commençons par initialiser le moniteur série et initialiser le capteur BME280.

Serial.begin(115200);
  
// Initialize BME280 Sensor
Wire.begin(SDA_PIN, SCL_PIN);
if (!bme.begin(0x76)) { 
  Serial.println("BME280 not found!");
  while(1); 
}

Démarrez la connexion Wi-Fi et imprimez l’adresse IP ESP32 dans le moniteur série. Vous en aurez besoin plus tard pour accéder au serveur Web.

WiFi.begin(ssid, password);
Serial.print("Connecting to Wi-Fi");
while (WiFi.status() != WL_CONNECTED) {
  delay(500);
  Serial.print(".");
}
Serial.println("\nWi-Fi Connected!");
// Print the ESP32 IP Address
Serial.print("Access ESP32 IP Address: http://");
Serial.println(WiFi.localIP());

Configurez l’heure avec les paramètres que vous avez définis précédemment :

configTime(gmtOffset_sec, daylightOffset_sec, ntpServer);

Appelez la fonction pour initialiser la carte microSD.

initSD();

Voici la fonction initSD() :

void initSD() {
  SPI.begin(SD_SCK, SD_MISO, SD_MOSI, SD_CS);
  if (!SD.begin(SD_CS)) { Serial.println("SD Card Failed"); return; }
  
  if (!SD.exists(dataFile)) {
    File f = SD.open(dataFile, FILE_WRITE);
    if (f) { f.println("temp_c,temp_f,humidity,pressure,time,day"); f.close(); }
  }
}

URL root /

Ensuite, gérez le serveur Web. Lorsque vous recevez une requête sur l’URL root (/) (cela se produit lorsque vous accédez à l’adresse IP ESP), envoyez le texte HTML stocké dans la variable html String pour afficher la page Web :

server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
  (...)
  request->send(200, "text/html; charset=UTF-8", html);
});

La variable html contient le texte avec le HTML, CSS et JavaScript pour créer la page Web.

Expliquer tout le HTML, JavaScript et CSS va au-delà de l’objectif de ce projet. Nous avons essayé d’organiser la page Web de manière simple et facile à comprendre. De plus, toutes les fonctions ont des noms explicites, il est donc simple de comprendre ce qu’elles font.

Pour créer les graphiques, nous utilisons la bibliothèque Chart.js. Vous pouvez trouver tout sur la création et la personnalisation de vos graphiques ici : chartjs.org




  ESP32 BME280: Charts & Stats

Certains paramètres peuvent être personnalisés. Par défaut, dans cet exemple, les graphiques afficheront un maximum de 1 200 points de données. Notez que si vous augmentez cette valeur de manière significative, le chargement de toutes les données dans les graphiques peut prendre plus de temps. Vous pouvez modifier cela dans la ligne suivante.

const displayData = allData.slice(-1200);

Vous pouvez également ajuster vos valeurs de seuil maximum et minimum dans les lignes suivantes :

const HOT_THRESHOLD_C = 25;
const COLD_THRESHOLD_C = 15;

Ces valeurs sont utilisées pour calculer le temps inférieur ou supérieur aux seuils.

Dans la fonction updateStats(), vous pouvez modifier la variable suivante du nombre 7 à 14. Ce seul changement modifierait techniquement tous les calculs de statistiques de 7 jours à 14 jours :

const cutoff7d  = new Date(lastTs.getTime() - 7*24*60*60*1000);

Ensuite, vous devrez modifier le texte qui apparaîtra visuellement sur la page Web comme :

  • Sous-section « 7 derniers jours » intitulée « 14 derniers jours »
  • Étiquettes de la carte « Max Temp (7D) » sur « Max Temp (14D) »
  • (…)

Toute la logique de calcul réelle est effectuée à l’aide de la variable cutoff7d, mais il serait alors recommandé d’apporter ces modifications au texte pour refléter réellement le nouveau délai de calcul.

Télécharger le fichier CSV /télécharger

Cette route envoie le fichier .csv stocké sur la carte microSD au client connecté (pour charger les données pour créer les graphiques).

server.on("https://www.raspberryme.com/download", HTTP_GET, [](AsyncWebServerRequest *request){
  request->send(SD, dataFile, "text/csv", true);
});

Supprimer le fichier CSV/supprimer

Cette route supprime le fichier .csv stocké dans la carte microSD.

server.on("/delete", HTTP_POST, [](AsyncWebServerRequest *request){
    if (SD.exists(dataFile)) SD.remove(dataFile);
    File f = SD.open(dataFile, FILE_WRITE);
    if (f) { f.println("temp_c,temp_f,humidity,pressure,time,day"); f.close(); }
    request->send(200);
  });

Initialiser le serveur

Enfin, appelez la méthode Begin() sur l’objet serveur pour initialiser le serveur.

server.begin();

boucle()

Dans la fonction loop(), nous avons une minuterie qui appelle la fonction logData() pour obtenir de nouvelles lectures à chaque valeur d’intervalle (par défaut toutes les 60 secondes).

if (millis() - previousMillis >= interval) {
  previousMillis = millis();
  logData();
}

La fonction logData() prend de nouvelles lectures du capteur BME280 et les stocke dans des variables auxiliaires avec un horodatage du serveur NTP. Enfin, il ajoute ces lectures à la dernière ligne du fichier .csv.

void logData() {
  float tempC = bme.readTemperature();
  float tempF = tempC * 9.0 / 5.0 + 32.0;
  float hum = bme.readHumidity();
  float press = bme.readPressure() / 100.0F;

  File file = SD.open(dataFile, FILE_APPEND);
  if (file) {
    file.printf("%.2f,%.2f,%.2f,%.2f,%s,%s\n", 
                tempC, tempF, hum, press, getTimeStr().c_str(), getDateStr().c_str());
    file.close();
  }
}

Démonstration

Après avoir inséré vos informations d’identification réseau, téléchargez le code sur la carte ESP32. Après le téléchargement, ouvrez le moniteur série à une vitesse de transmission de 115 200 bauds et appuyez sur le bouton ESP32 RST.

Ouvrir le moniteur série Arduino 2

L’adresse IP de l’ESP32 sera imprimée dans le moniteur série.

Graphique ESP32 Serveur Web Démarrer le moniteur série Arduino IDE

Ouvrez n’importe quel navigateur sur votre réseau local et entrez l’adresse IP ESP32. En haut de la page web, vous disposez de 4 boutons :

  • Actualiser les graphiques : les graphiques sont mis à jour en temps réel, vous n’avez donc pas besoin d’utiliser ce bouton. Cependant, en cas d’échec du chargement du fichier .csv depuis la carte microSD, vous pouvez utiliser ce bouton ;
  • Télécharger CSV : télécharge le fichier .csv stocké sur votre carte microSD ;
  • Supprimer toutes les données : supprime toutes les données stockées dans le fichier .csv ;
  • Réinitialiser tout le zoom : vous pouvez zoomer sur les graphiques pour voir les valeurs plus clairement et vous pouvez utiliser ce bouton pour effectuer un zoom arrière et revenir à la première vue.
Boutons du serveur Web ESP32 pour interagir avec les graphiques

Par défaut, le graphique de température affiche les valeurs en degrés Celsius. Il y a un bouton pour passer aux degrés Fahrenheit.

Graphique ESP32 Température du serveur Web Celsius Fahrenheit commutateur Arduino IDE

Avec votre curseur, vous pouvez sélectionner une section spécifique du graphique pour zoomer (cela fonctionne également sur les appareils dotés d’un écran tactile, et vous pouvez pincer pour zoomer).

Serveur Web graphique ESP32 Zoom avant la valeur Arduino IDE

Ensuite, ce graphique sera agrandi. Vous pouvez également sélectionner les valeurs pour voir toutes les informations mises en évidence comme illustré ci-dessous. Pour effectuer un zoom arrière, vous pouvez double-cliquer sur le graphique ou utiliser le bouton Réinitialiser tout le zoom en haut de la page Web.

Serveur Web de graphiques ESP32 Section agrandie mettant en surbrillance Valeur Arduino IDE

Ensuite, vous avez le tableau de pression. Vous pouvez ignorer les données, car je testais juste le projet pendant quelques jours en l’allumant/éteignant.

Graphique ESP32 Valeurs de pression du serveur Web Arduino IDE

Ensuite, quatre cartes affichent les dernières lectures du capteur ainsi que les horodatages correspondants.

Serveur Web ESP32 BME280 Dernières lectures de température

Cette section suivante affiche les valeurs de température maximale et minimale au cours des dernières 24 heures et 7 jours. Il indique également combien de temps la température est restée supérieure ou inférieure à certains seuils. Vous pouvez toujours basculer entre les degrés Celsius et Fahrenheit.

Serveur Web ESP32 BME280 Dernières statistiques de température

Vous disposez également d’un point de données intéressant montrant combien de temps il a fallu pour passer de la température minimale à la température maximale et vice versa au cours des dernières 24 heures et la moyenne des 7 derniers jours.

Statistiques de température du serveur Web ESP32 BME280, temps maximum et temps minimum

Dans le tableau suivant, vous pouvez voir les relevés quotidiens de température min/max au cours des 7 derniers jours et l’évolution quotidienne de la température.

Variation de température quotidienne du serveur Web ESP32 BME280 au cours des 7 derniers jours

Enfin, vous pouvez vérifier le modèle diurne, qui est la moyenne de toutes les lectures chargées, regroupées par heure de la journée (0 à 23). Il utilise l’historique complet des journaux stocké dans le fichier .csv.

ESP32 BME280 Statistiques de température du serveur Web moyenne diurne par heure

Conclusion

Dans ce didacticiel, vous avez appris à créer un projet qui enregistre les données de température, d’humidité et de pression avec des horodatages dans un fichier .csv sur une carte microSD. Vous avez appris à afficher ces valeurs sur une page Web desservie par l’ESP32 avec des statistiques de température intéressantes.

Si vous avez aimé ce projet, vous aimerez peut-être également ces autres tutoriels :

Si vous souhaitez en savoir plus sur la construction de serveurs web avec l’ESP32 à partir de zéro, nous vous recommandons de jeter un œil à notre eBook dédié à ce sujet :

Merci d’avoir lu.

Cette vidéo vous emmène dans l’histoire de Raspberry Pi :

  • 2 Pièces ESP32 NodeMCU USB C, Carte de Développement ESP32, Module WiFi 2,4 GHz Bluetooth Dual-Core avec Puce CH340, Compatible Arduino IDE, MicroPython et IoT pour Domotique, Capteurs, Automatisation
  • PintoHardware Lot de 2 ESP32 ESP-WROOM-32 Carte de Développement WiFi Bluetooth, USB-C, CP2102, 38 Broches, Microcontrôleur Double Cœur Compatible Arduino IDE, MicroPython, ESP-IDF, IoT