eeBud

KTWF - 0001 (Wi-Fi)

Ce module basé sur un module ESP32 est conçu pour une fonctionnalité autonome.

L’avantage du protocole Wi-Fi est que le module peut être débranché sans poser problème dans le réseau, car il n’y a pas de maillage. Idéal pour la gestion d’un petit arrosage d’extérieur, qui sera débranché en hiver.

Grace à ses cellules 18650 et ses panneaux solaires, il ne nécessite pas d’alimentation externe, et est totalement autonome.

Nous pouvons donc l’imaginer dans un montage extérieur pour la réalisation d’une station météo, d’un système d’arrosage, d’une lampe, etc…

Contenu de la page

Schémas et descriptifs

  1. Emplacement des deux cellules 18650 3.6V.
  2. Module de rechargement (5V 1A). Peut être branché avec un chargeur type-c standard.
  3. Broches de programmation. La programmation de ce module nécessite un adaptateur USB – Série UART. Il faut croiser les broches RX-TX pour la programmation.
  4. Boutons de programmation. Pour activer le mode de programmation, maintenir le bouton RST appuyé, et presser le bouton PRG. Relâchez ensuite RST, puis PRG. Le module est maintenant en mode de programmation. Après programmation, réaliser un reset avec le bouton RST. (Non nécessaire pour programmation OTA)
  5. LED de témoin d’alimentation. Pour garder un maximum d’autonomie, ne pas l’utiliser.
  6. Connecteurs pour la gestion de modules externes (Température, humidité, relais, etc…) De gauche à droite étant: +3,3V – Broche GPIO (IO2, IO26, IO33) – GND.
  7. Connecteur de mise sous tension du module. (N’influence pas la recharge du module) Si non utilisé, doit être shunté avec un dispositif supportant 6V 2A.
  8. Lorsque la broche IO23 de l’ESP est activée, ce connecteur laisse passer une tension directe depuis des cellules 18650 (4.2V à une recharge maximale) (+/-) 2A max!
  9. Connecteurs pour des boutons (GPIO Internal pull-up/-)
  10. 2 Connecteurs pour utilisation I2C (Ecrans, Capteur de luminosité BH1750, PAJ7620U2, etc…) (+3,3V/-/IO21/IO22).
  11. Entrée des cellules photovoltaïques 6V 1A max. (+/-)

Exemple d'adaptateur USB - Série UART

Nomenclature

RepèreDésignationQuantité
BAT1Support cellules 186501
C2,C3Condensateur 47u3
C4N/A1
C5Condensateur 10u1
IO2,IO26,IO33Connecteur JST XH triple3

SW,TB23,IO25,

IO14,PH,I2C

Connecteur JST XH double7
LEDLED 3MM1
PRG,RSTBouton poussoir 6x6x62
Q2Transistor 2N2222A1
R1,R4,R6Résistance 220R3
R2Résistance 100R1
R3Résistance 10K1
U1Module Charge TP40561
U2TPMCP1700T-3302E/TT1
U3ESP32-WROOM-PCB1

Exemple de programmation pour un module d'arrosage avec sonde d'humidité du sol.

Pour la gestion de la connexion Wifi, j’utilise ma bibliothèque: eeBudServerManager

La bibliothèque gère les mises à jour OTA (A distance). Celle-ci ne nécessite pas de passer en Mode de programmation.

				
					#include <eeBudServerManager.h>

eeBudServerManager Serveur("Arrosage");

#define Capteur_Niveau_Eau 33
#define Capteur_Tension 32
#define Pompe 23
#define Bouton_Pompe 25
#define Lumiere_Bouton_Pompe 14

int Serveur_Event;
int Serveur_Heure;
int Serveur_Niveu_Eau;
int Serveur_Niveu_Batterie;
int Serveur_Voltage;
int Serveur_Voltage_Analog;
int Serveur_Pompe_ON;
int Serveur_Pompe_OFF;
int Serveur_Auto_ON;
int Serveur_Auto_OFF;
int Serveur_curseur;

String SPIFFS_URL_Etat;
String SPIFFS_URL_Pourcentage;
String SPIFFS_URL_Voltage;
float Coeff_Voltage = 1.05;

const float Tension_Ref = 4.05;
const float Tension_Ref_Reel = 2.78;
const float Valeur_Analogique_Ref = 3330;
const float Valeur_Montante_Pour_Consideration = 0.05;

const float Tension_Min = 3.3;  //2.27;  //tension min
const float Tension_Max = 4.0;  //2.85;  //tension max

const float Tension_Min_Reel = 2.27;  //tension min
const float Tension_Max_Reel = 2.67;

float Voltage_Descendant_Mesure = 9999;
float Voltage_Montant_Mesure = -9999;

int Valeur_Analogique;
int Niveau_Eau = 0;

bool State_Pompe = false;

unsigned long Moment_Present = 0;
unsigned long Moment_Memorise = 0;
int Mesure_Interval = 500;

int Seuil_Eau = 0;
bool Auto = false;


void setup() {
  Serial.begin(115200);
  Serial.println("------Arrosage------");
  Serveur.Debug(true);
  Serveur.Init();
  
  Serveur.AddParamText("Coefficient Voltage", String(Coeff_Voltage));
  Coeff_Voltage = Serveur.GetParamText("Coefficient Voltage").toFloat();
  Serveur.AddParamText("URL d'envoi de l'état", "");
  SPIFFS_URL_Etat = Serveur.GetParamText("URL d'envoi de l'état");
  Serveur.AddParamText("URL d'envoi du voltage", "");
  SPIFFS_URL_Voltage = Serveur.GetParamText("URL d'envoi du voltage");
  Serveur.AddParamText("URL d'envoi du pourcentage", "");
  SPIFFS_URL_Pourcentage = Serveur.GetParamText("URL d'envoi du pourcentage");
  
  Serveur.IndexTileStart("600px", "", "");  
  int *Bouton = Serveur.IndexAddToogle("Pompe", "Off", "On", "Off");
  Serveur_Pompe_OFF = Bouton[0];
  Serveur_Pompe_ON = Bouton[1];

  Bouton = Serveur.IndexAddToogle("Auto", "Off", "On", "Off");
  Serveur_Auto_OFF = Bouton[0];
  Serveur_Auto_ON = Bouton[1];
  Serveur.IndexTileFinish();

  Serveur.IndexTileStart("600px", "", "");
  Serveur.IndexAddTitle("Paramètres","50");
  Serveur_curseur = Serveur.IndexAddRange("Seuil d'arrosage", 0, 100, Seuil_Eau);
  Serveur_Niveu_Eau = Serveur.IndexAddInfo("Eau", "", "40");
  Serveur_Niveu_Batterie = Serveur.IndexAddInfo("Batterie", "%", "40");
  Serveur_Voltage = Serveur.IndexAddInfo("Voltage", "V", "40");
  Serveur_Voltage_Analog = Serveur.IndexAddInfo("Analogique", "", "30");
  Serveur.IndexTileFinish();

  pinMode(Capteur_Niveau_Eau, INPUT);
  pinMode(Capteur_Tension, INPUT);
  pinMode(Pompe, OUTPUT);  
  pinMode(Bouton_Pompe, INPUT_PULLUP);
  pinMode(Lumiere_Bouton_Pompe, OUTPUT);
  
  Pompe_Off();
}

void loop() {

  Serveur_Event = Serveur.IndexGetEvent();

  //Boutons
  if (digitalRead(Bouton_Pompe) == 0 && State_Pompe == false) {
    Pompe_On();
    delay(500);

  } else if (digitalRead(Bouton_Pompe) == 0 && State_Pompe == true) {
    Pompe_Off();
    delay(500);
  }

  // Serveur
  if (Serveur_Event == Serveur_Pompe_ON) {
    Pompe_On();
    Serveur.IndexResetEvent();

  } else if (Serveur_Event == Serveur_Pompe_OFF) {
    Pompe_Off();
    Serveur.IndexResetEvent();
  } else if (Serveur_Event == Serveur_Auto_ON) {
    Auto = true;
    Serveur.IndexResetEvent();
  } else if (Serveur_Event == Serveur_Auto_OFF) {
    Auto = false;
    Serveur.IndexResetEvent();
  } else if (Serveur_Event == Serveur_curseur) {

    Seuil_Eau = Serveur.IndexGetRange(Serveur_curseur);
    Serveur.IndexResetEvent();
  }

  Moment_Present = millis();
  if (Moment_Present - Moment_Memorise >= Mesure_Interval) {
    Moment_Memorise = millis();
    Niveau_Eau = analogRead(Capteur_Niveau_Eau) / 10;

    if (Niveau_Eau < Seuil_Eau && Auto == true) {
      Pompe_On();
    } else if (Niveau_Eau >= Seuil_Eau && Auto == true) {

      Pompe_Off();
    }

    //Niveau d'eau
    Serveur.IndexSetInfo(Serveur_Niveu_Eau, String(Niveau_Eau));

    Voltage_Pourcentage();
  }
}

//3330 = 4.05 = 2.78
void Voltage_Pourcentage() {
  Valeur_Analogique = analogRead(Capteur_Tension);
  Serveur.IndexSetInfo(Serveur_Voltage_Analog, String(Valeur_Analogique));

  float Voltage = (Valeur_Analogique * Tension_Ref_Reel) / Valeur_Analogique_Ref;
  Voltage = ((Voltage * Tension_Ref) / Tension_Ref_Reel) * Coeff_Voltage;

  //Voltage descendant
  if (Voltage_Descendant_Mesure > Voltage) {
    Voltage_Descendant_Mesure = Voltage;
    Affichage_Voltage(Voltage);    
  }

  //Voltage montant
  if (Voltage_Montant_Mesure == -9999) Voltage_Montant_Mesure = Voltage;
  if ((Voltage - Voltage_Montant_Mesure) >= Valeur_Montante_Pour_Consideration) {    
    Voltage_Descendant_Mesure = Voltage;
    Voltage_Montant_Mesure = Voltage;
    Affichage_Voltage(Voltage);
  }
}

void Affichage_Voltage(float Voltage) {
  
  Serveur.IndexSetInfo(Serveur_Voltage, String(Voltage));
  if (SPIFFS_URL_Voltage != "") {
    String Temporaire = SPIFFS_URL_Voltage;
    Temporaire.replace("#value#", String(Voltage));
    Serveur.HTTPPost(Temporaire);
    delay(500);
  }

  int Pourcentage_Batterie = ((Voltage - Tension_Min) * 100) / (Tension_Max - Tension_Min);
  if (Pourcentage_Batterie < 0) Pourcentage_Batterie = 0;
  else if (Pourcentage_Batterie > 100) Pourcentage_Batterie = 100;
  Serveur.IndexSetInfo(Serveur_Niveu_Batterie, String(Pourcentage_Batterie));
  if (SPIFFS_URL_Pourcentage != "") {
    String Temporaire = SPIFFS_URL_Pourcentage;
    Temporaire.replace("#value#", String(Pourcentage_Batterie));
    Serveur.HTTPPost(Temporaire);
    delay(500);
  }
}

void Pompe_Off() {
  State_Pompe = false;
  Serveur.IndexSetToogle(Serveur_Pompe_OFF);
  digitalWrite(Pompe, LOW);
  digitalWrite(Lumiere_Bouton_Pompe, LOW);
  if (SPIFFS_URL_Etat != "") {
    String Temporaire = SPIFFS_URL_Etat;
    Temporaire.replace("#value#", "0");
    Serveur.HTTPPost(Temporaire);
    delay(500);
  }
}

void Pompe_On() {
  State_Pompe = true;
  Serveur.IndexSetToogle(Serveur_Pompe_ON);
  digitalWrite(Pompe, HIGH);
  digitalWrite(Lumiere_Bouton_Pompe, HIGH);
  if (SPIFFS_URL_Etat != "") {
    String Temporaire = SPIFFS_URL_Etat;
    Temporaire.replace("#value#", "1");
    Serveur.HTTPPost(Temporaire);
    delay(500);
  }
}

				
			

Une fois ce programme transféré dans le module avec par exemple l’IDE Arduino, il faut:

  1. Se connecter au réseau Wi-Fi ouvert qui se crée.
  2. Renseigner un mot de passe, et paramétrer un réseau local.
  3. Une fois le module redémarré, se rendre à l’adresse IP de l’appareil.

Seuil d’arrosage permet de lancer l’arrosage lorsque ce seuil est franchi. (Mode Auto activé)

 

Dans les paramètres du module, les URL permettent d’envoyer les informations à un serveur domotique, via des requêtes HTTP.

 

Exemple de paramétrage dans Jeedom.

0 0 votes
Évaluation
S’abonner
Notification pour
0 Commentaires
Commentaires en ligne
Afficher tous les commentaires
Retour en haut