Arrosage automatique connecté

Le module WeMos D1 R1 mini et son grand frère (Qui est identique, avec quelques E/S en plus)
Schéma du montage. (Cliquez sur l'image pour l'agrandir) Poulie dont l'axe est le potentiomètre multitours
La page d’accueil (Allez sur l'adresse IP du serveur ou tapez "arrosage" dans la barre d'adresse
Le code source et les pages Html du serveur web sont téléchargeables ici : (Télécharger le fichier zip du code source). Le code est réalisé sous Visual studio code et Platform IO (Éditeurs gratuits), et utilise des librairies gratuites. Les langages de programmation sont : le C++ compatible Arduino (ESP8266), l'HTML 5 (pour le serveur web), le CSS (pour la mise en page du serveur web), le JavaScript (utilisant notamment le mécanisme Ajax) pour échanger les données entre le serveur et votre téléphone ou PC !
Les fichiers de l'archive que vous avez téléchargé (sans inclure les bibliothèques ESP8266) sont :
Puis viennent les 7 fichiers créant la page web (Vous trouverez des tonnes d'exemples pour les transférer dans la mémoire SPIFFS ou LittleFS de l'ESP.)
Si vous utilisez l'IDE Visual Studio Code, ces librairies seront automatiquement téléchargées lors de la compilation de main.cpp
/////////////////////////////////////////////////////////////////////////////////
//                  MAIN.CPP              ARROSAGE AUTOMATIQUE
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
//                                INCLUDES
/////////////////////////////////////////////////////////////////////////////////
#include <Arduino.h>      
#include <ArduinoOTA.h>            // Pour programmer via le wifi (MAJ du firmware)

#include <spi.h>                   // Bus SPI pour un écran ou autre chose fonctionnant en SPI
#include <wire.h>                  // Bus I²C pour un écran ou autre chose fonctionnant en I²C

#include <Adafruit_GFX.h>          // Librairie pour l'afficheur OLEDS
#include <Adafruit_SSD1306.h>      // Librairie pour l'afficheur OLEDS

#ifdef ESP32                       // Si l'on compile pour un microcontrolleur ESP32
#include <WiFi.h>                  // Bibliothèque Wifi sous l'ESP32
#include <AsyncTCP.h>              // Bibliothèque TCP asynchrone sous l'ESP32
#include <SPIFFS.h>                // Accès aux fichiers en mémoire flash du ESP32
#elif defined(ESP8266)             // Si l'on compile pour un microcontrolleur ESP8266
#include <ESP8266WiFi.h>           // Bibliothèque Wifi sous l'ESP8266 https://github.com/esp8266/Arduino
#include <ESPAsyncTCP.h>           // Bibliothèque TCP asynchrone sous l'ESP8266
#include "FS.h"                    // Accès aux fichiers en mémoire flash du ESP8266
#endif

#include <ESPAsyncWebServer.h>     // Serveur web tournant sur le microcontrolleur
#include <ESPAsyncWiFiManager.h>   // Permet de configurer le Wifi via un portail d'accès  https://github.com/tzapu/WiFiManager
#include <NTPClient.h>             // Client NTP pour récupérer l'heure d'internet
#include <EEPROM.h>                // Gestion EEPROM pour sauvegarder les paramètres en cas de coupure de courant


/////////////////////////////////////////////////////////////////////////////////
//                      E/S , CONSTANTES & OPTIONS DE COMPILATION
/////////////////////////////////////////////////////////////////////////////////
#define SORTIE_RELAIS_INVERSEES    // Commenter ce code si vos relais sont en logique inverse (Marche = 0V)

//#define __DEBUG_RTC__            // Décommenter cette ligne pour accélérer l'horloge temps réel (pour débug)
//#define DEBUG_VERBOSE            // Décommenter cette ligne pour afficher des infos de débuggage dans la console RS232

//E/S
#define PIN_POTAGER      16        // Relais 1  D0
#define PIN_JARDIN       14        // Relais 2  D5
#define PIN_AVANT         2        // Relais 3  D4 & LED bleue
#define PIN_CUVE_EAU      0        // Relais 4  D3
#define PIN_ANALOG_0     17        // Entrée analogique ESP8266 : Niveau d'eau dans la cue eau de pluie
#define GAIN_ANALOG_0    4.0       // Gain voie analogique 0

#ifdef SORTIE_RELAIS_INVERSEES     // Logique de commande des relais
#define _HIGH  LOW
#define _LOW   HIGH
#endif

// Point d'accès portail de configuration du réseau
#define SSID_AP        "Wifi_Arrosage"    // Nom du réseau wifi sur le quel se connecter pour configurer la connexion Wifi à un routeur via WifiManager
#define SSID_MDP_AP    "ilflotte!!"       // Mot de passe du réseau wifi de configuration. Peut être laissé vide

// Heure internet
#define SERVEUR_NTP     "pool.ntp.org"    // URL du serveur NTP à utiliser (Par ex: "europe.pool.ntp.org" ou "pool.ntp.org")
#define UTC_OFFSET_S   7200               // Nombre de secondes par rapport à UTC, dépends du fuseau horaire: UTC+2 = 2 heures = 7200 s

// Divers
#define HISTO_SIZE      400               // Nombre de points à mémoriser pour les graphes
#define HISTO_INTERVAL  12 * 3600         // Intervalle entre 2 enregistrements dans Niveau_cuve_eau[] tableau envoyé pour créer le graphe sur index.html (doit correspondre à intervalle définit dans index.tml)
#define EEPROM_ADR_CFG    0               // Adresse en EEPROM ou est stockée la structure Config
#define SEUIL_CUVE_BAS   50               // Sous cette valeur (en litres) lance un remplissage de la cuve à eau de pluie avec l'eau de la ville
#define DUREE_PAUSE_CYCL 60               // Durée de pause entre 2 cycle d'arrosage pour réinitialisation des pieuvres (sélecteurs) (si il y en a)

#define OLED_X          128               // Taille X en pixels de l'écran OLED
#define OLED_Y           64               // Taille Y en pixels de l'écran OLED

/////////////////////////////////////////////////////////////////////////////////
//                     VARIABLES GLOBALES
/////////////////////////////////////////////////////////////////////////////////

// Instancie les classes
AsyncWebServer Serveur_web(80);                   // Serveur web tournant sur le microcontrolleur sur le port 80 (Html)
DNSServer      Dns;                               // Serveur DNS
WiFiUDP        NtpUDP;                            // UDP pour le client NTP

Adafruit_SSD1306 display(OLED_X, OLED_Y);         // Initialise l'écran I²C OLEDS de 128 X 64 pixels

NTPClient      timeClient(NtpUDP, SERVEUR_NTP, UTC_OFFSET_S); // Client NTP

unsigned long  Up_time = 0;                       // Nombre de secondes depuis le boot

time_t         Secondes_epoch;                    // Nombre de secondes depuis le 1/1/1970

struct tm*     Ti;                                // Structure de format date/heure

struct sConfig                                    // Structure contenant les paramètres à sauver en EEPROM (Ces données sont paramétrables dans le formulaire web)
  {
  unsigned short heure_arrosage;                  // Heure:minutes de démarrage de l'arrosage (de préférence la nuit)
  unsigned short minute_arrosage;                 // Heure:minutes de démarrage de l'arrosage (de préférence la nuit)
  bool           mode_auto;                       // Spécifie si l'arrosage est en mode automatique: 1 ou arrêté: 0
  unsigned short nb_cyles_potager;                // Nombre de fois ou l'on active le circuit potager (Mettre 6 dans l cas d'une utilisation de distributeur type pieuvre)
  unsigned short nb_cyles_avant;                  // Nombre de fois ou l'on active le circuit avant (Mettre 6 dans l cas d'une utilisation de distributeur type pieuvre)
  unsigned short nb_cyles_arriere;                // Nombre de fois ou l'on active le circuit arrière (Mettre 6 dans l cas d'une utilisation de distributeur type pieuvre)
  unsigned int   duree_arrosage_avant;            // Durée (en secondes) d'un cycle d'arrosage de l'avant (une pause de 1 minute est insérée entre 2 cycles)
  unsigned int   duree_arrosage_arriere;          // Durée (en secondes) d'un cycle d'arrosage de l'arrière (une pause de 1 minute est insérée entre 2 cycles)
  unsigned int   duree_arrosage_potager;          // Durée (en secondes) d'un cycle d'arrosage du potager (une pause de 1 minute est insérée entre 2 cycles)
  unsigned short duree_remplissage_cuve;          // Durée (en minute) de remplissage de la cuve d'eau de pluie avec l'eau de la ville (Mettre le minimum pour ne pas gaspiller de l'eau de la ville)
  unsigned int   capacite_cuve;                   // Capacité de la cuve à eau de pluie en litres
  bool           auto_rempliss_cuve;              // Si vrai, le système rempliera durant duree_remplissage_cuve secondes la cuve si le niveau d'eau passe sous un seuil bas
  }                                               // Une fois ce remplissage effectué, si le niveau est toujours trops bas, auto_rempliss_cuve sera mis à faux pour prévenir une panne de capteur
  ; 
  
sConfig Config;

struct sVal_actuelles                             // Structure contenant les valeurs actuelles 
  {
  unsigned int   pause_entre_cycles;              // Compteur du délais à attendre entre 2 cycles (pour temps de réinitialisation des sélecteurs hydrauliques (pieuvres))  
  unsigned short nb_cyles_potager;                // Compte le nombre de fois ou l'on a activé dans la journée le circuit potager
  unsigned short nb_cyles_avant;                  // Compte le nombre de fois ou l'on a activé dans la journée le circuit avant
  unsigned short nb_cyles_arriere;                // Compte le nombre de fois ou l'on a activé dans la journée le circuit arrière
  unsigned int   duree_arrosage_avant;            // Comptage de la durée écoulée (en secondes) du cycle d'arrosage actuel de l'avant
  unsigned int   duree_arrosage_arriere;          // Comptage de la durée écoulée (en secondes) du cycle d'arrosage actuel de l'arrière
  unsigned int   duree_arrosage_potager;          // Comptage de la durée écoulée (en secondes) du cycle d'arrosage actuel du potager
  unsigned int   duree_remplissage_cuve;          // Comptage de la durée écoulée (en secondes) du remplissage actuel de la cuve d'eau de pluie avec l'eau de la ville
  unsigned int   capacite_cuve;                   // Capacité de la cuve à eau de pluie en litres
  unsigned short jeton_arrosage;                  // Définie la machine d'état: Quelle voie d'arrosage doit t'on activer (cadencement des arrosages)
  }; 
  
sVal_actuelles Val_actu;

unsigned int   Niveau_cuve_eau[HISTO_SIZE] = {0,};// Tableau du nombre de litres d'eau restant dans la cuve à eau de pluie



/////////////////////////////////////////////////////////////////////////////////
// void Charger_config_eeprom(sConfig* _config)         
// Remplie la structure (@ passée en argument) avec les données présentes
// en EEPROM et mets des valeurs par défaut si besoin (si EEPROM vierge par ex)
/////////////////////////////////////////////////////////////////////////////////
void Charger_config_eeprom(sConfig* _config)
{
EEPROM.begin(128);                  // charge 128 octet mémoire eeprom en RAM  (Pour les ESPxxxx)

#ifdef DEBUG_VERBOSE
Serial.println("Taille EEPROM: " + String(EEPROM.length()));  // vérification taille EEPROM affecté ( devrait affiché 128 )
#endif  
EEPROM.get(EEPROM_ADR_CFG, *_config); // Mise en mémoire pour écriture par la méthode EEPROM.put
EEPROM.end();                         // Libère la mémoire  

// Si des paramètres luts depus l'EEPROM sont invalies (EEPRM vierge par exemple), on remplace par des valeurs par défaut
if (_config->heure_arrosage         >  23)    _config->heure_arrosage         = 23;   // Valeur par défaut (EEPROM VIERGE)
if (_config->minute_arrosage        >  59)    _config->minute_arrosage        =  0;   // Valeur par défaut (EEPROM VIERGE)
if (_config->mode_auto              >   1)    _config->mode_auto              =  1;   // Valeur par défaut (EEPROM VIERGE)
if (_config->nb_cyles_potager       >  99)    _config->nb_cyles_potager       =  6;   // Valeur par défaut (EEPROM VIERGE)
if (_config->nb_cyles_arriere       >  99)    _config->nb_cyles_arriere       =  6;   // Valeur par défaut (EEPROM VIERGE)
if (_config->nb_cyles_avant         >  99)    _config->nb_cyles_avant         =  1;   // Valeur par défaut (EEPROM VIERGE)
if (_config->duree_arrosage_potager > 999)    _config->duree_arrosage_potager = 60;   // Valeur par défaut (EEPROM VIERGE)
if (_config->duree_arrosage_arriere > 999)    _config->duree_arrosage_arriere = 60;   // Valeur par défaut (EEPROM VIERGE)
if (_config->duree_arrosage_avant   > 999)    _config->duree_arrosage_avant   = 60;   // Valeur par défaut (EEPROM VIERGE)
if (_config->duree_remplissage_cuve > 128)    _config->duree_remplissage_cuve = 40;   // Valeur par défaut (EEPROM VIERGE)
if (_config->capacite_cuve          > 100000) _config->capacite_cuve          = 4000; // Valeur par défaut (EEPROM VIERGE)
if (_config->auto_rempliss_cuve     > 1  )    _config->auto_rempliss_cuve     = false;// Valeur par défaut (EEPROM VIERGE)

#ifdef DEBUG_VERBOSE
// affiche les valeurs EEPROM lues
Serial.println("Lecture des paramètres sauvegardés dans l'EEPROM:");
Serial.println("Horaire programmée d'arrosage: " + String(_config->heure_arrosage) + ":" + String(_config->minute_arrosage));
Serial.println("Arrosage automatique ?: " + String(_config->mode_auto));
Serial.println("Nombre de cycles arrosage potager: " + String(_config->nb_cyles_potager));
Serial.println("Nombre de cycles arrosage massifs arrière: " + String(_config->nb_cyles_arriere));
Serial.println("Nombre de cycles arrosage massifs avant: " + String(_config->nb_cyles_avant));
Serial.println("Durée d'un cycle arrosage du potager: " + String(_config->duree_arrosage_potager) + " s");
Serial.println("Durée d'un cycle arrosage massifs arrière: " + String(_config->duree_arrosage_arriere) + " s");
Serial.println("Durée d'un cycle arrosage massifs avant: " + String(_config->duree_arrosage_avant) + " s");
Serial.println("Durée remplissasge cuve eau de pluie: " + String(_config->duree_remplissage_cuve) + " min");
Serial.println("Capacité de la cuve à eau de pluie: " + String(_config->capacite_cuve) + " L");
Serial.println("Remplissage auto de la cuve si niveau d'eau bas ?: " + String(_config->auto_rempliss_cuve));
#endif  
}


/////////////////////////////////////////////////////////////////////////////////
// void Sauver_config_eeprom(sConfig* _config)            
// Copie en EEPROM les données de la structure (@ passée en argument) 
/////////////////////////////////////////////////////////////////////////////////
void Sauver_config_eeprom(sConfig* _config)
{
EEPROM.begin(128);                  // charge 128 octet memoire eeprom en RAM  (Pour les ESPxxxx)

#ifdef DEBUG_VERBOSE
Serial.println("Taille EEPROM: " + String(EEPROM.length()));  // verification taille EEPROM affecté ( devrait affiché 128 )
#endif  

EEPROM.put(EEPROM_ADR_CFG, *_config); // Mise en mémoire pour ecriture par la methode put
EEPROM.commit();                      // Copie le cache mémoire en EEPROM ( l'écriture se fait à ce nomment la )
EEPROM.end();                         // Libère la memoire  
}


/////////////////////////////////////////////////////////////////////////////////
// void confOTA() Fonction de programmation OTA 
// Permet la mise à jour du firmware via le WiFi, sans utiliser de cable !
/////////////////////////////////////////////////////////////////////////////////
void confOTA() 
{
char char_hostname[32];
WiFi.hostname().toCharArray(char_hostname, 32);       // Récupère le nom du système sur le réseau
ArduinoOTA.setPort(8266);                             // Configure le numero de port utilisé pour la mise à jour du code
ArduinoOTA.setHostname(char_hostname);                // Configure le nom du système utilisé pour la mise à jour du code
ArduinoOTA.setPassword((const char *)SSID_MDP_AP);    // Configure un mot de passe pour autoriser la mise à jour du code 

ArduinoOTA.onStart([]() 
  {
  Serial.println("/!\\ Maj OTA");
  // Coupe les sorties pendant la mise à jour (sécurité anti-innondation !)
  Val_actu.jeton_arrosage         = 0;
  Val_actu.duree_arrosage_arriere = 0;
  Val_actu.duree_arrosage_avant   = 0;
  Val_actu.duree_arrosage_potager = 0;
  Val_actu.duree_remplissage_cuve = 0;
  digitalWrite(PIN_POTAGER,  _LOW);  
  digitalWrite(PIN_JARDIN,   _LOW);   
  digitalWrite(PIN_AVANT,    _LOW);    
  digitalWrite(PIN_CUVE_EAU, _LOW);
  });

ArduinoOTA.onEnd([]()   {Serial.println("\n/!\\ MaJ terminee");});
ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {Serial.printf("Progression: %u%%\r", (progress / (total / 100)));});
ArduinoOTA.onError([](ota_error_t error) 
  {
  Serial.printf("Error[%u]: ", error);
  if      (error == OTA_AUTH_ERROR)    Serial.println("Probleme d'autentifcation");
  else if (error == OTA_BEGIN_ERROR)   Serial.println("Probleme au debut de la procedure");
  else if (error == OTA_CONNECT_ERROR) Serial.println("Impossible de se connecter");
  else if (error == OTA_RECEIVE_ERROR) Serial.println("Impossible de recevoir les donnees");
  else if (error == OTA_END_ERROR)     Serial.println("Probleme a la fin de la procedure");
  });
ArduinoOTA.begin();
}


/////////////////////////////////////////////////////////////////////////////////
// String IpAddress2String(const IPAddress& ipAddress) 
// Formatte une adresse IP en une chaine de caractères 
/////////////////////////////////////////////////////////////////////////////////
String IpAddress2String(const IPAddress& ipAddress)
{
  return String(ipAddress[0]) + String(".") +\
  String(ipAddress[1]) + String(".") +\
  String(ipAddress[2]) + String(".") +\
  String(ipAddress[3])  ;
}


/////////////////////////////////////////////////////////////////////////////////
// void notFound404(AsyncWebServerRequest *request) 
// Apelle la page Erreur 404 si un lien pointe sur une page inexistante
/////////////////////////////////////////////////////////////////////////////////
void notFound404(AsyncWebServerRequest *request) 
  {
  Serial.println("Appelle page err404.html");   
  request->send(SPIFFS, "/err404.html", "text/html"); 
  }
 

/////////////////////////////////////////////////////////////////////////////////
// String processor(const String& var)
// Si appelée par la ligne : "request->send(SPIFFS, "/index.html", String(), false, processor);"
// Cette fonction remplace la balise %VALEURS% dans le code index.html par 
// un tableau de HISTO_SIZE données pour alimenter le graphique
///////////////////////////////////////////////////////////////////////////////// 
String processor(const String& _token)
{
if(_token == "VALEURS")
  {
  String txt;
   for (int i = 0; i < HISTO_SIZE; i++)
     {
    txt+= String(Niveau_cuve_eau[i]); // Créé dans index.html un tableau de données utilsés dans le graphes). Composé de valeurs entières séparées par des espaces
    if (i < HISTO_SIZE-1) txt+= ",";   
     }
  return txt; 
  } 

// Prépositionne (précharge) le formulaire avec les paramètres de la structure Config
if(_token == "DEF_HEURE_PRG")
  {
  String a = "", b = "";  
  if (Config.heure_arrosage < 10)  a = "0"; 
  if (Config.minute_arrosage < 10) b = "0";  
  return (String(a) + String(Config.heure_arrosage) + ":" + String(b) + String(Config.minute_arrosage)); 
  }
if(_token == "DEF_NB_CYCL_POT")   return String(Config.nb_cyles_potager); 
if(_token == "DEF_NB_CYCL_ARR")   return String(Config.nb_cyles_arriere); 
if(_token == "DEF_NB_CYCL_AV")    return String(Config.nb_cyles_avant); 
if(_token == "DEF_DUR_CYCL_POT")  return String(Config.duree_arrosage_potager); 
if(_token == "DEF_DUR_CYCL_ARR")  return String(Config.duree_arrosage_arriere); 
if(_token == "DEF_DUR_CYCL_AV")   return String(Config.duree_arrosage_avant); 
if(_token == "DEF_DUR_REMPL_CUV") return String(Config.duree_remplissage_cuve); 
if(_token == "DEF_CAPA_CUV")      return String(Config.capacite_cuve); 
if(_token == "DEF_REMPLISS_AUTO") {if (Config.auto_rempliss_cuve == true) return "checked"; else return "";}

return String();
}


/////////////////////////////////////////////////////////////////////////////////
// void setup() 
// Première fonction appelée. Appelée une seule fois à la mise en route
/////////////////////////////////////////////////////////////////////////////////
void setup() 
{
#if defined(ESP8266)
WiFi.hostname("Arrosage");      // Nom d'hote sur le réseau cas du ESP8266
#else 
WiFi.setHostname("Arrosage");   // Nom d'hote sur le réseau cas du ESP32
#endif
WiFi.mode(WIFI_STA);            // Demarre le wifi en mode station (seconnectant à une box ou un routeur (pas en mode point d'accès)

Serial.begin(4800);             // Initialise le port série entre autre pour messages de débug

// Définie le sens des E/S
pinMode(PIN_POTAGER,  OUTPUT);  // Relais commandant l'électrovanne arrosage du potager
pinMode(PIN_JARDIN,   OUTPUT);  // Relais commandant l'électrovanne arrosage du jardin (arbres et massifs)
pinMode(PIN_AVANT,    OUTPUT);  // Relais commandant l'électrovanne arrosage des massifs à l'avant de la maison
pinMode(PIN_CUVE_EAU, OUTPUT);  // Relais commandant l'électrovanne de remplissage de la cuve à eau de pluie
pinMode(PIN_ANALOG_0, INPUT);   // Mesure analogique niveau de la cuve à eau de pluie

// Initialise les variables globales et les sortie (Commence système arrêté => Sécurité)
digitalWrite(PIN_POTAGER,  _LOW);  
digitalWrite(PIN_JARDIN,   _LOW);   
digitalWrite(PIN_AVANT,    _LOW);    
digitalWrite(PIN_CUVE_EAU, _LOW);

// Instancie un gestionnaire wifimanager pour se connecter/paramétrer la connection à une box ou un routeur
AsyncWiFiManager wm(&Serveur_web, &Dns);

//  wm.resetSettings();  // ==> Décommentez cette ligne pour effacer les identifants de connection (sauvegardés en flash)

// Connection automatique au réseau dont les identifiant ont été sauvegardés en flash avec WifiManager
// Si la connection échoue (mauvais mot de passe, box ou routeur innacessible...) démarre un
// point d'accès avec comme SSID WiFi le nom défini dans la constante SSID_AP.
// Si on se se connecte pas au portail de configuration au bout de n secondes, on continue le programme
wm.setConfigPortalTimeout(300);  

// Adrresse IP et masque de sous réseau du portail de configuration
wm.setAPStaticIPConfig(IPAddress(192,168,1,1), IPAddress(192,168,1,1), IPAddress(255,255,255,0));

// Démarre le gestionnaire WifiManager
bool res = wm.autoConnect(SSID_AP, SSID_MDP_AP); // SSID et Mot de passe du point d'accès (portail) de configuration WiFi

if(!res) 
  {
  Serial.println("\n\nImpossible de se connecter au réseau local !");
  // ESP.restart(); // ==> Décommentez cette ligne pour rebooter le microcontrôlleur
  } 
else 
  {
  Serial.println("\n\nConnecté au réseau local !");
  }  

Serial.print("\n\nLancement du programme Arrosage automatique version : ");
Serial.println(__DATE__);

delay(100);

//---------------------- Teste et monte le système de fichiers SPIFFS -------------------------
Serial.print("\n- Liste les fichiers présents dans la mémoire flash SPIFFS... ");

SPIFFS.begin();      // Démarage du gestionnaire de fichier du microcontrôlleur

// SPIFFS.format();  // ==> Décommentez cette ligne si il y a besoin de formater le système de fichier SPIFFS du microcontrolleur

// Liste des fichiers (et affiche leur taille) présents dans la mémoire flash du microcontrolleur
String str = "\n";
Dir dir = SPIFFS.openDir("/");
while (dir.next())  
  {
  str += dir.fileName();
  str += "\t";
  str += dir.fileSize();
  str += " octets\n";
  }
Serial.print(str);

delay(100);

//------------------- Configuration mise à jour à distance (OTA) --------------

confOTA();

//---------------------- Configuration du serveur web -------------------------
Serial.print("\n- Démarrage du server web... ");

// Définie les actions du serveur en fonction des requêtes envoyées par le navigateur internet

// Gestion des appels de page demandés au server
Serveur_web.onNotFound(notFound404);                                 // Demande au serveur d'envoyer err404.html

Serveur_web.on("/", HTTP_GET, [](AsyncWebServerRequest *request)
  {
  Serial.println("Appelle page index.html");
  request->send(SPIFFS, "/index.html", String(), false, processor);  // Envoie index.html
  });

Serveur_web.on("/test.html", HTTP_GET, [](AsyncWebServerRequest *request)
  {
  Serial.println("Appelle page test.html");
  request->send(SPIFFS, "/test.html", "text/html");                  // Demande au serveur d'envoyer index.html
  });

Serveur_web.on("/config.html", HTTP_GET, [](AsyncWebServerRequest *request)
  {
  Serial.println("Appelle page config.html");
  request->send(SPIFFS, "/config.html", String(), false, processor); // Demande au serveur d'envoyer config.html
  });  

Serveur_web.on("/w3.css", HTTP_GET, [](AsyncWebServerRequest *request)
  {
  request->send(SPIFFS, "/w3.css", "text/css");                      // Demande au serveur d'envoyer w3.css
  });

Serveur_web.on("/script.js", HTTP_GET, [](AsyncWebServerRequest *request)
  {
  request->send(SPIFFS, "/script.js", "text/javascript");            // Demande au serveur d'envoyer script.js
  });

Serveur_web.on("/highcharts.js", HTTP_GET, [](AsyncWebServerRequest *request)
  {
  request->send(SPIFFS, "/highcharts.js", "text/javascript");        // Demande au serveur d'envoyer highcharts.js
  });


// Fonction appelée lorsque l'on vient de cliquer sur "Valider" dans le formulaire de la page config.html
Serveur_web.on("/valider", HTTP_POST, [](AsyncWebServerRequest *request)  
  {
  // Gestion du formulaire de configuration
  AsyncWebParameter* param;
  unsigned short nb_param = request->params();  // Combien de données à t'on récupérés du formulaire ?
  Serial.print(nb_param);
  Serial.println(" donnée recues");

  unsigned int hh, mn;

  // Récupère les valeurs du formulaire et mets à jour la structure Config avec les nouvelles valeurs
  param = request->getParam(0);  
  sscanf(param->value().c_str(), "%d:%d", &hh, &mn); 
  Config.heure_arrosage  = hh;
  Config.minute_arrosage = mn;

  param = request->getParam(1);
  Config.nb_cyles_potager = param->value().toInt();
  param = request->getParam(2);
  Config.nb_cyles_arriere = param->value().toInt();
  param = request->getParam(3);
  Config.nb_cyles_avant   = param->value().toInt();  
  param = request->getParam(4);
  Config.duree_arrosage_potager = param->value().toInt();    
  param = request->getParam(5);
  Config.duree_arrosage_arriere = param->value().toInt();   
  param = request->getParam(6);
  Config.duree_arrosage_avant = param->value().toInt();   
  param = request->getParam(7);
  Config.duree_remplissage_cuve = param->value().toInt();  
  param = request->getParam(8);
  Config.capacite_cuve = param->value().toInt(); 
  param = request->getParam(9);

  // Si la case à cocher (checkbox) dans le formulaire de la page Config.html n'est pas cochée lorsque le formulaire est envoyé,
  // (Appuit sur la touche "Valider") aucune valeur n'est envoyée au serveur pour indiquer cet état 
  // (autrement dit, le client n'envoie pas quelque chose comme value=unchecked)
  // aucune valeur n'est transmise au serveur
  if (param == 0)  Config.auto_rempliss_cuve = false; 
  else                Config.auto_rempliss_cuve = true;


  Serial.println("Données lues depuis le formulaire:");
  Serial.print  ("Arrosage prévu à: " + String(Config.heure_arrosage));
  Serial.println(" h " + String(Config.minute_arrosage));  
  Serial.println("Données de config récupérées du formulaire :");
  Serial.println("Nb cycles arrosage potager: " + String(Config.nb_cyles_potager));
  Serial.println("Nb cycles arrosage arrière: " + String(Config.nb_cyles_arriere));
  Serial.println("Nb cycles arrosage avant: " + String(Config.nb_cyles_avant));
  Serial.println("Durée cycle arrosage potager: " + String(Config.duree_arrosage_potager));
  Serial.println("Durée cycle arrosage massifs arrière: " + String(Config.duree_arrosage_arriere));
  Serial.println("Durée cycle arrosage massifs avant: " + String(Config.duree_arrosage_avant));
  Serial.println("Durée remplissage cuve " + String(Config.duree_remplissage_cuve));
  Serial.println("Capacité cuve " + String(Config.capacite_cuve));
  Serial.println("Remplissage auto de la cuve si niveau d'eau bas ?: " + String(Config.auto_rempliss_cuve));
 
  Sauver_config_eeprom(&Config);  // Sauvegarde des paramètres en EEPROM
 
  
  request->send(SPIFFS, "/index.html", String(), false, processor); // Demande au serveur d'envoyer index.html
  });


// Réponses aux requètes Ajax:
// Obsolète
Serveur_web.on("/lire_graphes", HTTP_GET, [](AsyncWebServerRequest *request)
  {
  // Affichage des données
  //String txt;
   // for (int i = 0; i < 40; i++)
   //   {
    //  txt+= String(Niveau_cuve_eau[i]); // Formate le tableau de données (graphes) en chaine séparée par des espaces
   //   txt+= " ";   
    //  }    
  request->send(204, "text/plain", "");
  });

  // Fonction appelée toute les secondes lorsque l'on est sur la page Index.html
  Serveur_web.on("/lire_aff_index_1hz", HTTP_GET, [](AsyncWebServerRequest *request)
    {
    // Affichage sur index.html l'heure courante'
    Ti = localtime (&Secondes_epoch); // Copie dans la structure Ti la date et l'heure
    String txt;
    txt+= String(Ti->tm_hour);
    txt+= ":";  // Délimiteur
    if (Ti->tm_min < 10)  txt+= "0";  // Ajoute un zéro non significatif pour plus de clartée
    txt+= String(Ti->tm_min);
    txt+= ":";  // Délimiteur
     if (Ti->tm_sec < 10) txt+= "0";  // Ajoute un zéro non significatif pour plus de clartée   
    txt+= String(Ti->tm_sec);
    txt+= "~";  // Délimiteur entre l'heure et l'uptime
    // Affichage sur index.html l'uptime du système
    txt+= String(Up_time); 
    txt+= "~";  // Délimiteur entre l'uptime et le mode en cours

    // Affichage sur index.html le mode (Automatique ou OFF) 
    if (Config.mode_auto)  txt+= "(Automatique) "; else txt+= "(arrêté - Off) ";

    // Affiche sur index.html le texte imminent si l'on s'aprète à démarrer un cycle
    if (Val_actu.pause_entre_cycles > 0)    txt+= " cycle imminent... "; else txt+= "";
   
    // Affichage sur index.html les voies actives
    if (digitalRead(PIN_AVANT)    == _HIGH) txt+= "Arrosage massifs avant: "   + String(Val_actu.duree_arrosage_avant)   + " s (" + String(Val_actu.nb_cyles_avant+1)    + "/" + String(Config.nb_cyles_avant)   + "), ";
    if (digitalRead(PIN_CUVE_EAU) == _HIGH) txt+= "Remplissage cuve: "         + String(Val_actu.duree_remplissage_cuve) + " s, ";
    if (digitalRead(PIN_JARDIN)   == _HIGH) txt+= "Arrosage massifs arrière: " + String(Val_actu.duree_arrosage_arriere) + " s (" + String(Val_actu.nb_cyles_arriere+1)  + "/" + String(Config.nb_cyles_arriere) + "), ";
    if (digitalRead(PIN_POTAGER)  == _HIGH) txt+= "Arrosage potager: "         + String(Val_actu.duree_arrosage_potager) + " s (" + String(Val_actu.nb_cyles_potager+1)  + "/" + String(Config.nb_cyles_potager) + "), ";
  
    // Affiche sur index.html le texte indiquant l'autonomie restante
    txt+= "~";  // Délimiteur entre le mode en cours et l'info sur le niveau d'eau courant :

    // Affichage sur index.html du niveau d'eau courant :
    txt+= String(Niveau_cuve_eau[HISTO_SIZE-1]);
    txt+= "~";  // Délimiteur entre  niveau d'eau courant et l'info sur l'autonomie :

    int conso_jour = (Config.nb_cyles_potager * Config.duree_arrosage_potager + Config.nb_cyles_arriere * Config.duree_arrosage_arriere + Config.nb_cyles_avant * Config.duree_arrosage_avant) * 0.3529;
    txt+= String(conso_jour);
    txt+= "~";
    if (conso_jour > 0)  txt+= String(int(Niveau_cuve_eau[HISTO_SIZE-1]/conso_jour)); else txt+= "+oo";
    txt+= "~";
    if (conso_jour > 0)  txt+= String(int(Config.capacite_cuve/conso_jour));          else txt+= "+oo";
    
    // Affichage sur index.html le mode remplissage automatique de la cuve ou non 
    if (Config.auto_rempliss_cuve) txt+= "~activé"; else txt+= "~désactivé";

    request->send(200, "text/plain", txt); // Envoie les valeurs à la page HTML
    });

  // Fonction appelée toute les secondes lorsque l'on est sur la page Test.html
  Serveur_web.on("/lire_aff_test_1hz", HTTP_GET, [](AsyncWebServerRequest *request)
    {
    // Affichage des données
    String txt;

    if (digitalRead(PIN_AVANT)    == _HIGH) txt+= "En cours " + String(Val_actu.duree_arrosage_avant  ) + " s~"; else txt+= "Off~";
    if (digitalRead(PIN_CUVE_EAU) == _HIGH) txt+= "En cours " + String(Val_actu.duree_remplissage_cuve) + " s~"; else txt+= "Off~";
    if (digitalRead(PIN_JARDIN)   == _HIGH) txt+= "En cours " + String(Val_actu.duree_arrosage_arriere) + " s~"; else txt+= "Off~";
    if (digitalRead(PIN_POTAGER)  == _HIGH) txt+= "En cours " + String(Val_actu.duree_arrosage_potager) + " s~"; else txt+= "Off~";    
  
    request->send(200, "text/plain", txt); // Envoie les valeurs à la page HTML
    });

// Fonction appelée suite à appuit sur le boutons "Auto" de la page Index.html
Serveur_web.on("/auto", HTTP_GET, [](AsyncWebServerRequest *request)
  {
  // Au départ: Remet les compteurs d'arrosage à zéro
  Val_actu.nb_cyles_arriere       = 0;
  Val_actu.nb_cyles_avant         = 0;
  Val_actu.nb_cyles_potager       = 0;
  Val_actu.duree_arrosage_arriere = 0;
  Val_actu.duree_arrosage_avant   = 0;
  Val_actu.duree_arrosage_potager = 0;
  Val_actu.duree_remplissage_cuve = 0;
  Val_actu.jeton_arrosage         = 0;
  Config.mode_auto = true;          // Active le mode automatique  
  Sauver_config_eeprom(&Config);    // Sauvegarde des paramètres en EEPROM
  request->send(204);
  });

// Fonction appelée suite à appuit sur le boutons "Off" de la page Index.html
Serveur_web.on("/off", HTTP_GET, [](AsyncWebServerRequest *request)
  {
  // Au départ: Remet les compteurs d'arrosage à zéro
  Val_actu.nb_cyles_arriere       = 0;
  Val_actu.nb_cyles_avant         = 0;
  Val_actu.nb_cyles_potager       = 0;
  Val_actu.duree_arrosage_arriere = 0;
  Val_actu.duree_arrosage_avant   = 0;
  Val_actu.duree_arrosage_potager = 0;
  Val_actu.duree_remplissage_cuve = 0;
  Val_actu.jeton_arrosage         = 0;
  Config.mode_auto  = false;        // Désactive l'arrosage automatique  
  Sauver_config_eeprom(&Config);    // Sauvegarde des paramètres en EEPROM
  request->send(204);
  });  

// Exécute les ordres suite aux appuits sur les boutons de la page Test.html
Serveur_web.on("/testAvantOn",      HTTP_GET, [](AsyncWebServerRequest *request)  {Val_actu.duree_arrosage_avant   =  99; request->send(200);});    
Serveur_web.on("/testAvantOff",     HTTP_GET, [](AsyncWebServerRequest *request)  {Val_actu.duree_arrosage_avant   =   0; request->send(200);}); 
Serveur_web.on("/testPotagerOn",    HTTP_GET, [](AsyncWebServerRequest *request)  {Val_actu.duree_arrosage_potager =  99; request->send(200);});    
Serveur_web.on("/testPotagerOff",   HTTP_GET, [](AsyncWebServerRequest *request)  {Val_actu.duree_arrosage_potager =   0; request->send(200);}); 
Serveur_web.on("/testJardinOn",     HTTP_GET, [](AsyncWebServerRequest *request)  {Val_actu.duree_arrosage_arriere =  99; request->send(200);});    
Serveur_web.on("/testJardinOff",    HTTP_GET, [](AsyncWebServerRequest *request)  {Val_actu.duree_arrosage_arriere =   0; request->send(200);}); 
Serveur_web.on("/testRemplCuveOn",  HTTP_GET, [](AsyncWebServerRequest *request)  {Val_actu.duree_remplissage_cuve =  99; request->send(200);});    
Serveur_web.on("/testRemplCuveOff", HTTP_GET, [](AsyncWebServerRequest *request)  {Val_actu.duree_remplissage_cuve =   0; request->send(200);}); 

Serveur_web.begin();                                                  // Démarre le serveur Web 
Serial.println("OK");

Serial.print("\n\nUtilisez cette adresse URL pour la connexion : ");  // Affichage de l'adresse IP du serveur
Serial.print("http://");
Serial.print(WiFi.localIP());
Serial.println("/");


timeClient.update();                                                  // Récupère l'heure internet
Secondes_epoch = timeClient.getEpochTime();
Serial.println("Synchro heure internet");

Charger_config_eeprom(&Config);    // Charge la config stockée en EEPROM dans la structure Config


display.begin(SSD1306_SWITCHCAPVCC, 0x3C);  // Initialise l'écran OLEDS (voir l'instanciation de la variable display pour spécifier sa taille en pixels)
display.clearDisplay();                     // Efface l'afficheur
display.display();                          // Mets à jour l'afficheur
display.setTextColor(WHITE);
}


/////////////////////////////////////////////////////////////////////////////////
// void loop() 
// Boucle principale (infinie) du programme
//
// ATTENTION A NE PAS UTILISER DE FONCTIONS BLOQUANTES DANS loop() Ex: delay()...
// CAR CELA PEUT EMPECHER LE FONCTIONNEMENT DE LA MISE A JOUR (OTA) DU 
// FIRMWARE A DISTANCE
/////////////////////////////////////////////////////////////////////////////////
void loop() 
{
static unsigned long old_loop_ms = 0;     // Mémorise le temps écoulé pour le cadencement de la boucle
ArduinoOTA.handle();                      // Appel de la fonction qui gère les mises à jour du firmware (OTA)
unsigned long loop_ms = millis();
if(loop_ms - old_loop_ms >= 1000)         // Code exécuté toute les secondes (comptage de l'heure)
  {
  Up_time++;                              // Incrémente le temps écoulé depuis la mise sous tension (Uptime)
  Secondes_epoch++; 
  old_loop_ms = millis();

  if ((Secondes_epoch % 36093) == 0)    {Serial.println("Synchro heure internet");  timeClient.update(); }   // Recalage RTC depuis l'heure internet toute les 10h et 93 secondes


  Niveau_cuve_eau[HISTO_SIZE-1] = analogRead(PIN_ANALOG_0) * GAIN_ANALOG_0;  // Mesure le niveau de la cuve à eau de pluie


  if ((Secondes_epoch % (HISTO_INTERVAL)) == 0)  // Même interval que dans index.html (Soit toutes les 12H)
    {
    for (int i = 0; i < (HISTO_SIZE-1); i++)  Niveau_cuve_eau[i] = Niveau_cuve_eau[i+1]; // Décale les données dans l'historique pour les envoyer périodiquement au graphe sur index.html
    }

  Ti = localtime (&Secondes_epoch);       // Copie dans la structure time la date et l'heure

  display.clearDisplay();                 // Efface l'afficheur
  display.setTextSize(1);
  display.setCursor(0,0);
  display.print("@ IP: ");
  display.print(WiFi.localIP());
  display.setTextSize(2);
  display.setCursor(0,12);
  if (Config.mode_auto) display.print("Mode auto"); else display.print(" - OFF -");
  display.setCursor(0,30);
  display.print("Cuve:");
  display.print(Niveau_cuve_eau[HISTO_SIZE-1]); 
  display.print("L");
  display.setCursor(10,48);                 
  display.print(Ti->tm_hour);               // Afficher l'heure   
  display.print(":");                       //  :  
  if (Ti->tm_min < 10)  display.print("0"); // Ajout zéro non significatif
  display.print(Ti->tm_min);                // Afficher les minutes   
  display.print(":");                       //  : 
  if (Ti->tm_sec < 10)  display.print("0"); // Ajout zéro non significatif                       
  display.println(Ti->tm_sec);              // Afficher les secondes 
  display.display();                        // Mets à jour l'afficheur


 
  if ((Ti->tm_hour == Config.heure_arrosage) && (Ti->tm_min == Config.minute_arrosage) && (Config.mode_auto == true) && (Val_actu.jeton_arrosage == 0))  // C'est l'heure de l'arrosage
    {
    Val_actu.jeton_arrosage         = 1;                        // Démarre une session d'arrosage automatique
    Val_actu.nb_cyles_arriere       = Config.nb_cyles_arriere;  // Charge le nombre de cycles à effecuer
    Val_actu.nb_cyles_avant         = Config.nb_cyles_avant;    // Charge le nombre de cycles à effecuer
    Val_actu.nb_cyles_potager       = Config.nb_cyles_potager;  // Charge le nombre de cycles à effecuer
    }

  // Besoin de remplir la cuve à eau de pluie (si on en a le droit) ?
  if ((Config.auto_rempliss_cuve == true) && (Niveau_cuve_eau[HISTO_SIZE-1] < SEUIL_CUVE_BAS))
    {
    // Si l'on à presque terminé la session de remplissage de la cuve (qui est en cours, il reste encore 10 secondes) et que le niveau lus de la cuve est toujours trop bas :  
    if ((digitalRead(PIN_CUVE_EAU) == _HIGH) && (Val_actu.duree_remplissage_cuve > 0) && (Val_actu.duree_remplissage_cuve < 10)) 
      {
      Config.auto_rempliss_cuve = false; // Désactive (par sécurité) le remplissage automatique de la cuve à eau car le niveau est toujours trop bas malgré une session de remplissage (problème de capteur ?)
      Sauver_config_eeprom(&Config);     // Sauvegarde en EEPROM ce paramètre désactivé
      }
    // Si l'on doit remmplir la cuve mais que cela n'a pas encore commencé, on initialise la temporisation de remplissage avec la valeur Config.duree_remplissage_cuve * 60  
    if (digitalRead(PIN_CUVE_EAU) == _LOW)  Val_actu.duree_remplissage_cuve = Config.duree_remplissage_cuve * 60;
    }
  


  // Machine d'état pour cadencement des arrosages
  switch (Val_actu.jeton_arrosage) 
    {
    case 1:
      {
      if (Val_actu.nb_cyles_potager > 0)  {Val_actu.nb_cyles_potager--; Val_actu.pause_entre_cycles = DUREE_PAUSE_CYCL; Val_actu.jeton_arrosage = 2;} // Démarre un nouveau cycle d'arrosage potager
      else                                 Val_actu.jeton_arrosage = 4;   // Tous les cycles de la voie arrosage potager sont effectués: On passe à la voie suivante 
      break;  
      }
    case 2:
      {
      if (Val_actu.pause_entre_cycles > 0) Val_actu.pause_entre_cycles--;  // Pause avant de démarrer le cycle arrosage potager
      else {Val_actu.duree_arrosage_potager = Config.duree_arrosage_potager;  Val_actu.jeton_arrosage = 3;}  // Charge la durée d'arrosage potager => Cela démarrera le cycle
      break;  
      }
    case 3:
      {
      if (Val_actu.duree_arrosage_potager == 0)  Val_actu.jeton_arrosage = 1;  // Fin d'un cycle arrosage potager on regarde si l'on peut en effectuer un autre
      break;   
      } 

    case 4:
      {
      if (Val_actu.nb_cyles_arriere > 0)  {Val_actu.nb_cyles_arriere--; Val_actu.pause_entre_cycles = DUREE_PAUSE_CYCL; Val_actu.jeton_arrosage = 5;} // Démarre un nouveau cycle d'arrosage des massifs arrière
      else                                 Val_actu.jeton_arrosage = 7;   // Tous les cycles de la voie arrosage massifs arrière sont effectués: On passe à la voie suivante 
      break;   
      } 
    case 5:
      {
      if (Val_actu.pause_entre_cycles > 0) Val_actu.pause_entre_cycles--;  // Pause avant de démarrer le cycle arrosage massifs arriere
      else {Val_actu.duree_arrosage_arriere = Config.duree_arrosage_arriere;  Val_actu.jeton_arrosage = 6;}  // Charge la durée d'arrosage massifs arrière => Cela démarrera le cycle
      break;  
      }      
    case 6:
      {
      if (Val_actu.duree_arrosage_arriere == 0)  Val_actu.jeton_arrosage = 4;  // Fin d'un cycle arrosage massifs arrière on regarde si l'on peut en effectuer un autre
      break; 
      } 

    case 7:
      {
      if (Val_actu.nb_cyles_avant > 0)  {Val_actu.nb_cyles_avant--; Val_actu.pause_entre_cycles = DUREE_PAUSE_CYCL; Val_actu.jeton_arrosage = 8;} // Démarre un nouveau cycle d'arrosage des massifs arrière
      else                                 Val_actu.jeton_arrosage = 0;   // Tous les cycles de la voie arrosage avant sont effectués: On passe à la voie suivante 
      break;   
      } 
    case 8:
      {
      if (Val_actu.pause_entre_cycles > 0) Val_actu.pause_entre_cycles--;  // Pause avant de démarrer le cycle arrosage massifs avant
      else {Val_actu.duree_arrosage_avant = Config.duree_arrosage_avant;  Val_actu.jeton_arrosage = 9;}  // Charge la durée d'arrosage massifs avant => Cela démarrera le cycle
      break;  
      }      
    case 9:
      {
      if (Val_actu.duree_arrosage_avant == 0)  Val_actu.jeton_arrosage = 7;  // Fin d'un cycle arrosage massifs avant, on regarde si l'on peut en effectuer un autre
      break; 
      }          
    }

  // Compteurs d'arrosage décrémenté toute les secondes
  if (Val_actu.duree_arrosage_potager > 0)  {Val_actu.duree_arrosage_potager--;  digitalWrite(PIN_POTAGER,  _HIGH);}  else digitalWrite(PIN_POTAGER,  _LOW); 
  if (Val_actu.duree_arrosage_arriere > 0)  {Val_actu.duree_arrosage_arriere--;  digitalWrite(PIN_JARDIN,   _HIGH);}  else digitalWrite(PIN_JARDIN,   _LOW);
  if (Val_actu.duree_arrosage_avant   > 0)  {Val_actu.duree_arrosage_avant--;    digitalWrite(PIN_AVANT,    _HIGH);}  else digitalWrite(PIN_AVANT,    _LOW);
  if (Val_actu.duree_remplissage_cuve > 0)  {Val_actu.duree_remplissage_cuve--;  digitalWrite(PIN_CUVE_EAU, _HIGH);}  else digitalWrite(PIN_CUVE_EAU, _LOW);
  

#ifdef DEBUG_VERBOSE
  Serial.print(Ti->tm_mday);        // Afficher le jour
  Serial.print("/");                // /
  Serial.print(Ti->tm_mon + 1);     // Afficher le mois
  Serial.print("/");                // /
  Serial.print(Ti->tm_year + 1900); // Afficher l'année 
  Serial.print("   ");              //    
  Serial.print(Ti->tm_hour);        // Afficher l'heure   
  Serial.print(":");                //  :  
  Serial.print(Ti->tm_min);         // Afficher les minutes   
  Serial.print(":");                //  :    
  Serial.println(Ti->tm_sec);       // Afficher les secondes 
#endif  
  }
}