Modérateur : Francois
Code : Tout sélectionner
/*
Station météo à base d'un ESP8266, et envoi des données vers Domoticz via MQTT.
Dépot Github : https://github.com/DomoticDIY/.........
Chaine YouTube du Tuto Vidéo : https://www.youtube.com/c/DomoticDIY
Bibliothéques nécessaires, et version utilisées :
- pubsubclient v2.7.0 : https://github.com/knolleary/pubsubclient
- ArduinoJson v6.15.0 : https://github.com/bblanchon/ArduinoJson
- ESP8266Wifi v1.0.0
- ArduinoOTA v1.0.0
- Adafruit unified sensor v 1.1.2
- Adafruit BME280 v2.0.2
Installer le gestionnaire de carte ESP8266 version 2.7.1
Si besoin : URL à ajouter pour le Bord manager : http://arduino.esp8266.com/stable/package_esp8266com_index.json
Adaptation pour reconnaissance dans Domoticz :
Dans le fichier PubSubClient.h : La valeur du paramètre "MQTT_MAX_PACKET_SIZE" doit être augmentée à 512 octets. Cette définition se trouve à la ligne 26 du fichier.
Sinon cela ne fonctionne pas avec Domoticz
Pour prise en compte du matériel :
Installer si besoin le Driver USB CH340G : https://wiki.wemos.cc/downloads
dans Outils -> Type de carte : generic ESP8266 module
Flash mode 'QIO' (régle générale, suivant votre ESP, si cela ne fonctionne pas, tester un autre mode.
Flash size : 1M (no SPIFFS)
Port : Le port COM de votre ESP vu par windows dans le gestionnaire de périphériques.
*/
const char* ssid = "SFR_xxxx"; // SSID du réseau Wifi
const char* password = "resa4jfxxxxxxxb83"; // Mot de passe du réseau Wifi.
const char* mqtt_server = "192.168.1.xx"; // Adresse IP ou DNS du Broker.
const int mqtt_port = 1883; // Port du Brocker MQTT
const char* mqtt_login = "mqtt"; // Login de connexion à MQTT.
const char* mqtt_password = "pass2mqtt"; // Mot de passe de connexion à MQTT.
// ------------------------------------------------------------
// Variables de configuration :
const char* topicIn = "domoticz/out"; // Nom du topic envoyé par Domoticz
const char* topicOut = "domoticz/in"; // Nom du topic écouté par Domoticz
// ------------------------------------------------------------
// Variables et constantes utilisateur :
String nomModule = "Moulins58_Meteo"; // Nom usuel de ce module. Sera visible uniquement dans les Log Domoticz.
unsigned long t_lastActionCapteur = 0; // enregistre le Time de la dernière intérogation.
const long t_interoCapteur = 60000; // Valeur de l'intervale entre 2 relevés.
// Variables utilisateur. ( Mettre IDX = 0 si pas de device)
int idxBME280 =237; // index du capteur BME280.
int idxPA =0; // Index du capteur BMP280, uniquement pour pression atmosphèrique.
int correctionBME280 =6; // correction de la PA en fonction de l'altitude du capteur (+ 1hPA tous les 8m.)
int idxAltitude =0; // Index du Device de distance.
// On intégre les bibliothéques necessaire à la mise à jour via OTA.
#include <ESP8266mDNS.h>
#include <WiFiUdp.h>
#include <ArduinoOTA.h>
// On intégre les librairies necessaires à la connexion Wifi, au MQTT, et à JSON, necessaire pour le MQTT.
#include <PubSubClient.h>
#include <ArduinoJson.h>
// On intégre les librairies necessaires aux Capteurs.
#include <Wire.h>
#include <Adafruit_BME280.h>
// Initialisation du Wifi et du MQTT.
WiFiClient espClient;
PubSubClient client(espClient);
// Initialisation du BME280
Adafruit_BME280 bme;
// float temperature, humidity, pressure, altitude;
#define SEALEVELPRESSURE_HPA (1013.25)
void setup() {
Serial.begin(115200); // On initialise la vitesse de transmission de la console.
setup_wifi(); // Connexion au Wifi
initOTA(); // Initialisation de l'OTA
client.setServer(mqtt_server, mqtt_port); // On défini la connexion MQTT
init_capteurs(); // Initialisation des Capteurs de relevés
}
void loop() {
ArduinoOTA.handle(); // On verifie si une mise a jour OTA nous est envoyée. Si OUI, la lib ArduinoOTA se charge de faire la MAJ.
unsigned long currentMillis = millis(); // On enregistre le Time courant
// On s'assure que MQTT est bien connecté.
if (!client.connected()) {
// MQTT déconnecté, on reconnecte.
Serial.println("MQTT déconnecté, on reconnecte !");
reconnect();
} else {
// On vérifie que l'intervale de relevé des capteurs est atteint.
if (currentMillis - t_lastActionCapteur >= t_interoCapteur) {
// MQTT connecté, on exécute les traitements
getDataBME280(); // Relevé des données du BME280, et envoi à Domoticz
// Traitement effectué, on met à jour la valeur du dernier traitement.
t_lastActionCapteur = currentMillis;
}
}
}
// INITIALISATION des Capteurs
// ***************************
void init_capteurs() {
bme.begin(0x76); // 0x76 = I2C adresse
}
/*
* ************** */
/* Les Fonctions
* ************** */
void getDataBME280() {
// Relevé et envoi du BM280 (Pression atmosphérique)
String temperature = String(bme.readTemperature());
String humidity = String(bme.readHumidity());
int pressure = (bme.readPressure() / 100.0F) + correctionBME280;
String altitude = String(bme.readAltitude(SEALEVELPRESSURE_HPA) * 100);
int bar_for = 0;
// Calcul de BAR_FOR (0 = No info; 1 = Soleil; 6 = Partiellement nuageux; 3 = Variable; 4 = Pluie)
if (pressure < 980) { bar_for = 4; }
else if (pressure < 1000) { bar_for = 6; }
else if (pressure < 1020) { bar_for = 3; }
else if (pressure >= 1020) { bar_for = 1; }
else { bar_for = 0; }
// Envoi des données à Domoticz via MQTT
if ( idxBME280 != 0) {
String svalue = temperature + ";" + humidity + ";0;" + String(pressure) + ";" + String(bar_for); // svalue = TEMP;HUM;HUM_STAT;BAR;BAR_FOR;
Serial.print("BME280 : svalue = "); Serial.print(svalue); Serial.print(" (TEMP;HUM;HUM_STAT;BAR;BAR_FOR)"); // Message pour débug en console
SendData("udevice", idxBME280, 0, svalue);
}
if ( idxPA != 0) {
String svalue = String(pressure) + ";" + String(bar_for); // svalue = BAR;BAR_FOR
Serial.print("BME280 : svalue = "); Serial.print(svalue); Serial.print(" (BAR;BAR_FOR)"); // Message pour débug en console
SendData("udevice", idxPA, 0, svalue);
}
if ( idxAltitude != 0) {
Serial.print("Altitude : svalue = "); Serial.print(altitude); Serial.print(" (Distance en m)");
SendData("udevice", idxAltitude, 0, altitude);
}
}
// CONNEXION WIFI
// **************
void setup_wifi() {
// Connexion au réseau Wifi
delay(10);
Serial.println();
Serial.print("Connection au réseau : ");
Serial.println(ssid);
WiFi.mode(WIFI_STA); // Passage de la puce en mode client
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
// Tant que l'on est pas connecté, on boucle.
delay(500);
Serial.print(".");
}
// Initialise la séquence Random
randomSeed(micros());
Serial.println("");
Serial.println("WiFi connecté");
Serial.print("Addresse IP : ");
Serial.println(WiFi.localIP());
}
// INITIALISATION Arduino OTA
// **************************
void initOTA() {
/* Port par defaut = 8266 */
// ArduinoOTA.setPort(8266);
/* Hostname, par defaut = esp8266-[ChipID] */
ArduinoOTA.setHostname("Moulins58_Meteo");
/* Pas d'authentication par defaut */
// ArduinoOTA.setPassword("admin");
/* Le mot de passe peut également être défini avec sa valeur md5 */
// MD5(admin) = 21232f297a57a5a743894a0e4a801fc3
// ArduinoOTA.setPasswordHash("21232f297a57a5a743894a0e4a801fc3");
// code à exécuter au démarrage de la mise à jour
ArduinoOTA.onStart([]() {
String type;
if (ArduinoOTA.getCommand() == U_FLASH)
type = "sketch";
else // U_SPIFFS
type = "filesystem";
// NOTE: si vous mettez à jour SPIFFS, démonter SPIFFS à l'aide de SPIFFS.end ()
Serial.println("Début de update " + type);
});
// code à exécuter à la fin de la mise à jour
ArduinoOTA.onEnd([]() {
Serial.println("\nFin");
});
// code à exécuter pendant la mise à jour
ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
Serial.printf("Progression : %u%%\r", (progress / (total / 100)));
});
// code à exécuter en cas d'erreur de la mise à jour
ArduinoOTA.onError([](ota_error_t error) {
Serial.printf("Erreur[%u] : ", error);
if (error == OTA_AUTH_ERROR) Serial.println("Authentification Failed");
else if (error == OTA_BEGIN_ERROR) Serial.println("Exécution Failed");
else if (error == OTA_CONNECT_ERROR) Serial.println("Connexion Failed");
else if (error == OTA_RECEIVE_ERROR) Serial.println("Réception Failed");
else if (error == OTA_END_ERROR) Serial.println("Fin Failed");
});
ArduinoOTA.begin();
Serial.println("Prêt");
Serial.print("Adresse IP : ");
Serial.println(WiFi.localIP());
}
// CONNEXION MQTT
// **************
void reconnect() {
// Boucle jusqu'à la connexion MQTT
while (!client.connected()) {
Serial.print("Tentative de connexion MQTT...");
// Création d'un ID client aléatoire
String clientId = "ESP8266Client-";
clientId += String(random(0xffff), HEX);
// Tentative de connexion
if (client.connect(clientId.c_str(), mqtt_login, mqtt_password)) {
Serial.println("connecté");
// Connexion effectuée, publication d'un message...
String message = "Connexion MQTT de "+ nomModule + " réussi sous référence technique : " + clientId + ".";
// Création de la chaine JSON6
DynamicJsonDocument doc(256);
// On renseigne les variables.
doc["command"] = "addlogmessage";
doc["message"] = message;
// On sérialise la variable JSON
String messageOut;
serializeJson(doc, messageOut);
// Convertion du message en Char pour envoi dans les Log Domoticz.
char messageChar[messageOut.length()+1];
messageOut.toCharArray(messageChar,messageOut.length()+1);
client.publish(topicOut, messageChar);
// On souscrit (écoute)
client.subscribe("#");
} else {
Serial.print("Erreur, rc=");
Serial.print(client.state());
Serial.println(" prochaine tentative dans 2s");
// Pause de 2 secondes
delay(2000);
}
}
}
// ENVOI DES DATAS.
// ***************
void SendData (String command, int idxDevice, int nvalue, String svalue) {
// Création de la chaine JSON6
DynamicJsonDocument doc(256);
// On renseigne les variables.
doc["command"] = command;
doc["idx"] = idxDevice;
doc["nvalue"] = nvalue;
doc["svalue"] = svalue;
// On sérialise la variable JSON
String messageOut;
serializeJson(doc, messageOut);
// Convertion du message en Char pour envoi dans les Log Domoticz.
char messageChar[messageOut.length()+1];
messageOut.toCharArray(messageChar,messageOut.length()+1);
client.publish(topicOut, messageChar);
// Pause de 1 secondes
delay(1000);
Serial.println("\t -> Message envoyé à Domoticz");
}