oui et vérifier partout que vous en tenez compte
cela fonctionne il envoie bien toute les 10 seconde
Merci j'aurais appris que le chiffre a coté de la variable était le nombre d'entrée
il est temps de passer un peu de temps sur une formation C++ 
oui cela serait bien et cela m'intéresse mais le temps est rare de nos jour entre le travail les enfants la maison etc bref 
si je peut abuser 
aurait tu une idée (piste pourquoi il n'écoute pas les topic souscrit avec callback
void callback(char* topic, byte* payload, unsigned int length) {
String Str;
Serial.print(F("**** Message arrivé depuis MQTT broker **** -> [ "));
Serial.print(topic);
Serial.print(F(" ] -> ' "));
for (int i = 0; i < length; i++) { //ici le lenght c'est la variable de la fonction callback
Serial.print((char)payload[i]);
Str = Str + (char)payload[i];
}
Serial.println(F(" '"));
char* Canal_Switch_Virtuel = "Arduino_Chauffage/Relais/RelaisK3";
int valeur_Canal = strcmp(topic, Canal_Switch_Virtuel);
if (valeur_Canal == 0 && Str == "1") {
Serial.println(F("Retour d'etat K3 à 1"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK3/Etat", "1");
digitalWrite(RelaisK3, HIGH);
Serial.println(F("RelaisK3 ON"));
} else if (valeur_Canal == 0 && Str == "0") {
Serial.println(F("Retour d'etat K3 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK3/Etat", "0");
digitalWrite(RelaisK3, LOW);
Serial.println(F("RelaisK3 OFF"));
}
}
commencez par juste mettre
void callback(char* topic, byte* payload, unsigned int length) {
Serial.print(F("**** Message arrivé depuis MQTT broker **** -> [ "));
Serial.print(topic);
Serial.println(F("]"));
}
êtes vous sûr qu'il y a des notifications?
Je reviens au nouvelle et sa fonctionne 
J'ai essayer de tester votre code d'essaie mes celui-ci ne fonctionnait pas.
Je suis donc retourner sur mon code, 
et j'ai souscrit a 1 seul topic celui du relais k3 et cela fonctionnait.
Je pense que le problème était que j'essayai de souscrire au topic k3,k4,k5,k6 etc. alors que je n'avais que k3 de crée
En créant le topic k4 en plus, et en inscrivant le code pour la lecture du résultat action sur ce topic cela fonctionne.
J'ai donc en fonctionnement un envoie des température tout les 10 seconde et un contrôle des relais k3 & k4 par jeedom 
Je te remercie pour le temps que tu a passer pour m'aider me reste plus qua ajouter les 10 autre relais
et essayer de passer l'envoie des infos toute les 60 voir 120 seconde j'espère que cela ne bloquera pas la boucle de réception des message sur les topic entre ces envoie
Merci encore et bonne soirée
Je posterai le code sur le forum ci sa peut aider quelqu'un qui souhaite un projet similaire au mien
Très bien - bonne continuation
Bonjour
Finalement sa marche pas comme prévu, 2 petit soucie
Je précise que le code fonctionne mais …..
1er si je passe les relevée & envoie a 60 seconde j'ai comme l'impression que il ne traite pas les message arriver sur les topic pendant ce temps et donc n'exécute pas d'action
même en mettant 10 seconde je trouve que parfois sa manque de fluidité j'ai l'impression que si l'action arrive a 8-10 seconde ses instantanée mais si sa arrive alors que je suis au début de boucle genre 4-5 seconde alors j'ai un retard de 5-6 seconde
es possible avec le principe de mon code ?
2eme on va dire que les relevées fonctionne a 10seconde donc ok il reçoie l'ordre certes avec parfois un peut de retard mais après l'exécution de l'action il redémarre quasiment a chaque fois depuis 0 car il repasse par le setup et ne fait pas juste une reconnexion broker
19:48:37.826 -> Arduino Chauffage (Températures + Relais)
19:48:42.529 -> Ethernet configuré via DHCP
19:48:42.529 -> IP address: 192.168.2.70
19:48:42.576 -> Client MQTT configuré !
19:48:42.623 -> Connexion au serveur avec l'ID 'Arduino_Chauffage'
19:48:42.670 -> La connection a été établie
19:49:42.444 -> Temperatures : 29.8°C / 30.8°C / 23.0°C / 31.6°C / 25.1°C
19:49:42.491 -> Publication MQTT effectuée
19:50:40.559 -> **** Message arrivé depuis MQTT broker **** -> [
Arduino_Chauffage/Relais/RelaisK3 ] -> ' 1 '
19:50:40.651 -> La fermeture V3V est bien OFF
19:50:40.651 -> Retour d'etat K3 à 1
19:50:40.687 -> RelaisK3 ON
19:50:45.683 -> Retour d'etat K3 à 0
19:50:45.683 -> RelaisK3 OFF
19:50:47.951 -> Arduino Chauffage (Températures + Relais)
19:50:48.654 -> Ethernet configuré via DHCP
19:50:48.654 -> IP address: 192.168.2.70
19:50:48.694 -> Client MQTT configuré !
19:50:48.694 -> Connexion au serveur avec l'ID 'Arduino_Chauffage'
19:50:48.787 -> La connection a été établie
es un problème de mémoire ou de conception de code ?
Le croquis utilise 28736 octets (11%) de l'espace de stockage de programmes. Le maximum est de 253952 octets.
Les variables globales utilisent 1851 octets (22%) de mémoire dynamique, ce qui laisse 6341 octets pour les variables locales. Le maximum est de 8192 octets.
pour finir voici le code finale
/*
* Ce programme tourne sur arduino Mega
* Il permet de lire les données de :
* 5 capteurs de températures DS18B20
* 1 Capteur de pression
* 12 Relais
* Publier les valeurs sur le réseau Ethernet en MQTT.
* Recevoir l'état de 12 switch virtuel
*/
/* Inclusion des librairies */
#include <OneWire.h> // Librairie pour le bus 1-Wire
#include <Ethernet.h> // Librairie pour Ethernet
#include <PubSubClient.h> // Librairie pour MQTT
#include <avr/wdt.h> // Librairie pour le watchdog
/* Déclarations des PINS */
#define BROCHE_ONEWIRE 23
#define PRESSION A0
#define RelaisK3 22
#define RelaisK4 24
#define RelaisK5 26
#define RelaisK6 28
#define RelaisK7 2
#define RelaisK8 3
#define RelaisK9 4
#define RelaisK10 5
#define RelaisK11 6
#define RelaisK12 7
#define RelaisK13 8
#define RelaisK14 9
/* Déclarations des Variable & Constante */
uint8_t mac[6] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x06 }; // Adresse MAC de la carte Ethernet
int PRESSIONvalue = 0; // Remise a zero de la valeur
float temperature[5]; // Stockage de 5 Valeur dans float
char buf[4]; // Taille duBuffer de stockage de la valeur de Pression
const char* MQTTserver = "192.168.2.85"; // Adresse IP du broket MQTT (VM-Mosquitto)
/* Initialisation des objects */
EthernetClient ethClient; // Objets Ethernet
PubSubClient mqttClient(ethClient); // Object MQTT
/* Liste des fonctions DS18B20 */
enum DS18B20_RCODES {
READ_OK,
NO_SENSOR_FOUND,
INVALID_ADDRESS,
INVALID_SENSOR
};
OneWire ds(BROCHE_ONEWIRE);
void setup() {
Serial.begin(9600); // Initialisation du port série
Serial.println(F("Arduino Chauffage (Températures + Relais)"));
/* Atribution des Mode PINS & Les Etat */
pinMode(RelaisK3, OUTPUT);
pinMode(RelaisK4, OUTPUT);
pinMode(RelaisK5, OUTPUT);
pinMode(RelaisK6, OUTPUT);
pinMode(RelaisK7, OUTPUT);
pinMode(RelaisK8, OUTPUT);
pinMode(RelaisK9, OUTPUT);
pinMode(RelaisK10, OUTPUT);
pinMode(RelaisK11, OUTPUT);
pinMode(RelaisK12, OUTPUT);
pinMode(RelaisK13, OUTPUT);
pinMode(RelaisK14, OUTPUT);
digitalWrite(RelaisK3, HIGH);
digitalWrite(RelaisK4, HIGH);
digitalWrite(RelaisK5, HIGH);
digitalWrite(RelaisK6, HIGH);
digitalWrite(RelaisK7, HIGH);
digitalWrite(RelaisK8, HIGH);
digitalWrite(RelaisK9, HIGH);
digitalWrite(RelaisK10, HIGH);
digitalWrite(RelaisK11, HIGH);
digitalWrite(RelaisK12, HIGH);
digitalWrite(RelaisK13, HIGH);
digitalWrite(RelaisK14, HIGH);
wdt_enable(WDTO_8S); // Watchdog timer with 8 Seconds time out
if (Ethernet.begin(mac) == 0) { // Si Pas d'adresse MAC on attend
Serial.println(F("Impossible de configurer Ethernet via serveur DHCP !"));
for (;;)
;
}
Serial.println(F("Ethernet configuré via DHCP"));
Serial.print(F("IP address: "));
Serial.println(Ethernet.localIP());
mqttClient.setServer(MQTTserver, 1883); // On Configure l'adresse du serveur depuiis la variable
Serial.println(F("Client MQTT configuré !"));
Serial.println(F("Connexion au serveur avec l'ID 'Arduino_Chauffage'"));
if (mqttClient.connect("core-mosquitto", "Idt", "Mdp")) { // On essaie de se connecter avec les identifiant et MDP
Serial.println(F("La connection a été établie"));
} else {
Serial.println(F("Le serveur ne répond pas"));
}
/* Je publie sur les topic afin de les crée si il n'existe pas a voir si on peut enlever
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK3", "1");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK4", "1");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK5", "1");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK6", "1");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK7", "1");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK8", "1");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK9", "1");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK10", "1");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK11", "1");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK12", "1");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK13", "1");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK14", "1");
*/
mqttClient.setCallback(callback);
delay(2000);
}
void loop() {
static unsigned long prevMillis100ms = 0; // Déclaration d'une variable pour la temporisation publication mqtt
static unsigned long prevMillis10s = 0; // Déclaration d'une variable pour la temporisation publication mqtt
unsigned long curMillis = millis();
/* Souscription au topic */
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK3");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK4");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK5");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK6");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK7");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK8");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK9");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK10");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK11");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK12");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK13");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK14");
mqttClient.loop();
if (!mqttClient.connected()) { // permet de reconnecter l'arduino au broker en cas de crash de celui-ci.
reconnect();
}
if (curMillis - prevMillis10s >= 60000) { // on lit les valeurs des capteurs et on les publie toutes les 10s
prevMillis10s = curMillis;
if (getTemperature(&temperature[0], true) != READ_OK) {
Serial.println(F("Erreur de lecture du capteur 1"));
return;
}
if (getTemperature(&temperature[1], false) != READ_OK) {
Serial.println(F("Erreur de lecture du capteur 2"));
return;
}
if (getTemperature(&temperature[2], false) != READ_OK) {
Serial.println(F("Erreur de lecture du capteur 3"));
return;
}
if (getTemperature(&temperature[3], false) != READ_OK) {
Serial.println(F("Erreur de lecture du capteur 4"));
return;
}
if (getTemperature(&temperature[4], false) != READ_OK) {
Serial.println(F("Erreur de lecture du capteur 5"));
return;
}
// On va print les valeurs dans le moniteur serie
affValeurs();
// On Publie les valeur sur les topics associer
//mqttClient.publish("Arduino_Chauffage/Pression", itoa(PRESSIONvalue, buf, 10));
mqttClient.publish("Arduino_Chauffage/Temperatures/Capteur1", itoa((temperature[0] * 10), buf, 10));
mqttClient.publish("Arduino_Chauffage/Temperatures/Capteur2", itoa((temperature[1] * 10), buf, 10));
mqttClient.publish("Arduino_Chauffage/Temperatures/Capteur3", itoa((temperature[2] * 10), buf, 10));
mqttClient.publish("Arduino_Chauffage/Temperatures/Capteur4", itoa((temperature[3] * 10), buf, 10));
mqttClient.publish("Arduino_Chauffage/Temperatures/Capteur5", itoa((temperature[4] * 10), buf, 10));
Serial.println(F("Publication MQTT effectuée"));
}
wdt_reset();
}
//----------------------- début de la fonction lecture de la température d'un capteur DS18B20 : ---------------------
byte getTemperature(float* temperature, byte reset_search) {
byte data[9], addr[8]; // data[] : Données lues depuis le scratchpad; addr[] : Adresse du module 1-Wire détecté
/* Reset le bus 1-Wire ci nécessaire (requis pour la lecture du premier capteur) */
if (reset_search) {
ds.reset_search();
}
/* Recherche le prochain capteur 1-Wire disponible */
if (!ds.search(addr)) { // Pas de capteur
return NO_SENSOR_FOUND;
}
/* Vérifie que l'adresse a été correctement reçue */
if (OneWire::crc8(addr, 7) != addr[7]) { // Adresse invalide
return INVALID_ADDRESS;
}
/* Vérifie qu'il s'agit bien d'un DS18B20 */
if (addr[0] != 0x28) { // Mauvais type de capteur
return INVALID_SENSOR;
}
/* Reset le bus 1-Wire et sélectionne le capteur */
ds.reset();
ds.select(addr);
/* Lance une prise de mesure de température et attend la fin de la mesure */
ds.write(0x44, 1);
unsigned long prevDSMillis = millis();
unsigned long curDSMillis = millis();
while (curDSMillis - prevDSMillis < 800) {
mqttClient.loop();
curDSMillis = millis();
}
/* Reset le bus 1-Wire, sélectionne le capteur et envoie une demande de lecture du scratchpad */
ds.reset();
ds.select(addr);
ds.write(0xBE);
/* Lecture du scratchpad */
for (byte i = 0; i < 9; i++) {
data[i] = ds.read();
}
/* Calcul de la température en degré Celsius */
*temperature = (int16_t)((data[1] << 8) | data[0]) * 0.0625;
return READ_OK; // Pas d'erreur
}
//----------------------- fin de la fonction lecture de la température d'un capteur DS18B20 : ---------------------
//-------- début de la fonction qui permet de se reconnecter au broker MQTT : ----------
void reconnect() {
while (!mqttClient.connected()) {
if (mqttClient.connect("core-mosquitto", "Idt", "Mdp")) {
Serial.println();
Serial.println("Reconnecté au broker !");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK3");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK4");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK5");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK6");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK7");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK8");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK9");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK10");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK11");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK12");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK13");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK14");
} else {
Serial.print(F("Broker MQTT indisponible. Status : rc="));
Serial.print(mqttClient.state());
Serial.println(F(" , tentative de reconnexion dans 3 secondes..."));
delay(3000);
}
}
}
//-------- fin de la fonction qui permet de se reconnecter au broker MQTT : ----------
//-------- début de la fonction qui permet de traiter les messages qui arrivent depuis le broker MQTT : ----------
/* Cette fonction est automatiquement appelée lorsque le broquer MQTT envoie un message à l'arduino
* (ou plutôt lorsque l'arduino lit un message)
*/
void callback(char* topic, byte* payload, unsigned int length) {
String Str;
Serial.print(F("**** Message arrivé depuis MQTT broker **** -> [ "));
Serial.print(topic);
Serial.print(F(" ] -> ' "));
for (int i = 0; i < length; i++) { //ici le lenght c'est la variable de la fonction callback
Serial.print((char)payload[i]);
Str = Str + (char)payload[i];
}
Serial.println(F(" '"));
// On cree les variable des relais
char* Canal_RelaisK3_Virtuel = "Arduino_Chauffage/Relais/RelaisK3";
char* Canal_RelaisK4_Virtuel = "Arduino_Chauffage/Relais/RelaisK4";
char* Canal_RelaisK5_Virtuel = "Arduino_Chauffage/Relais/RelaisK5";
char* Canal_RelaisK6_Virtuel = "Arduino_Chauffage/Relais/RelaisK6";
char* Canal_RelaisK7_Virtuel = "Arduino_Chauffage/Relais/RelaisK7";
char* Canal_RelaisK8_Virtuel = "Arduino_Chauffage/Relais/RelaisK8";
char* Canal_RelaisK9_Virtuel = "Arduino_Chauffage/Relais/RelaisK9";
char* Canal_RelaisK10_Virtuel = "Arduino_Chauffage/Relais/RelaisK10";
char* Canal_RelaisK11_Virtuel = "Arduino_Chauffage/Relais/RelaisK11";
char* Canal_RelaisK12_Virtuel = "Arduino_Chauffage/Relais/RelaisK12";
char* Canal_RelaisK13_Virtuel = "Arduino_Chauffage/Relais/RelaisK13";
char* Canal_RelaisK14_Virtuel = "Arduino_Chauffage/Relais/RelaisK14";
// On Atribut les valeur des variables
int valeur_CanalK3 = strcmp(topic, Canal_RelaisK3_Virtuel);
int valeur_CanalK4 = strcmp(topic, Canal_RelaisK4_Virtuel);
int valeur_CanalK5 = strcmp(topic, Canal_RelaisK5_Virtuel);
int valeur_CanalK6 = strcmp(topic, Canal_RelaisK6_Virtuel);
int valeur_CanalK7 = strcmp(topic, Canal_RelaisK7_Virtuel);
int valeur_CanalK8 = strcmp(topic, Canal_RelaisK8_Virtuel);
int valeur_CanalK9 = strcmp(topic, Canal_RelaisK9_Virtuel);
int valeur_CanalK10 = strcmp(topic, Canal_RelaisK10_Virtuel);
int valeur_CanalK11 = strcmp(topic, Canal_RelaisK11_Virtuel);
int valeur_CanalK12 = strcmp(topic, Canal_RelaisK12_Virtuel);
int valeur_CanalK13 = strcmp(topic, Canal_RelaisK13_Virtuel);
int valeur_CanalK14 = strcmp(topic, Canal_RelaisK14_Virtuel);
// On test les variables
if (valeur_CanalK3 == 0 && Str == "1") {
if (digitalRead(RelaisK4) == HIGH) {
Serial.println(F("La fermeture V3V est bien OFF"));
Serial.println(F("Retour d'etat K3 à 1"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK3/Etat", "1");
digitalWrite(RelaisK3, LOW);
Serial.println(F("RelaisK3 ON"));
delay(5000);
Serial.println(F("Retour d'etat K3 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK3/Etat", "0");
digitalWrite(RelaisK3, HIGH);
Serial.println(F("RelaisK3 OFF"));
}
else {
Serial.println(F("La fermeture V3V est ON anulation de l'action"));
Serial.println(F("Retour d'etat K3 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK3/Etat", "0");
digitalWrite(RelaisK3, HIGH);
Serial.println(F("RelaisK3 OFF"));
}
}else if (valeur_CanalK3 == 0 && Str == "0") {
Serial.println(F("Retour d'etat K3 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK3/Etat", "0");
digitalWrite(RelaisK3, HIGH);
Serial.println(F("RelaisK3 OFF"));
}
if (valeur_CanalK4 == 0 && Str == "1") {
if (digitalRead(RelaisK3) == HIGH) {
Serial.println(F("L'ouverture V3V est bien OFF"));
Serial.println(F("Retour d'etat K4 à 1"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK4/Etat", "1");
digitalWrite(RelaisK4, LOW);
Serial.println(F("RelaisK4 ON"));
delay(5000);
Serial.println(F("Retour d'etat K4 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK4/Etat", "0");
digitalWrite(RelaisK4, HIGH);
Serial.println(F("RelaisK4 OFF"));
}
else {
Serial.println(F("L'ouverture V3V est ON anulation de l'action"));
Serial.println(F("Retour d'etat K4 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK4/Etat", "0");
digitalWrite(RelaisK4, HIGH);
Serial.println(F("RelaisK4 OFF"));
}
}else if (valeur_CanalK4 == 0 && Str == "0") {
Serial.println(F("Retour d'etat K4 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK4/Etat", "0");
digitalWrite(RelaisK4, HIGH);
Serial.println(F("RelaisK4 OFF"));
}
if (valeur_CanalK5 == 0 && Str == "1") {
Serial.println(F("Retour d'etat K5 à 1"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK5/Etat", "1");
digitalWrite(RelaisK5, LOW);
Serial.println(F("RelaisK5 ON"));
} else if (valeur_CanalK5 == 0 && Str == "0") {
Serial.println(F("Retour d'etat K5 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK5/Etat", "0");
digitalWrite(RelaisK5, HIGH);
Serial.println(F("RelaisK5 OFF"));
}
if (valeur_CanalK6 == 0 && Str == "1") {
Serial.println(F("Retour d'etat K6 à 1"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK6/Etat", "1");
digitalWrite(RelaisK6, LOW);
Serial.println(F("RelaisK6 ON"));
} else if (valeur_CanalK6 == 0 && Str == "0") {
Serial.println(F("Retour d'etat K6 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK6/Etat", "0");
digitalWrite(RelaisK6, HIGH);
Serial.println(F("RelaisK6 OFF"));
}
if (valeur_CanalK7 == 0 && Str == "1") {
Serial.println(F("Retour d'etat K7 à 1"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK7/Etat", "1");
digitalWrite(RelaisK7, LOW);
Serial.println(F("RelaisK7 ON"));
} else if (valeur_CanalK7 == 0 && Str == "0") {
Serial.println(F("Retour d'etat K7 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK7/Etat", "0");
digitalWrite(RelaisK7, HIGH);
Serial.println(F("RelaisK7 OFF"));
}
if (valeur_CanalK8 == 0 && Str == "1") {
Serial.println(F("Retour d'etat K8 à 1"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK8/Etat", "1");
digitalWrite(RelaisK8, LOW);
Serial.println(F("RelaisK8 ON"));
} else if (valeur_CanalK8 == 0 && Str == "0") {
Serial.println(F("Retour d'etat K8 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK8/Etat", "0");
digitalWrite(RelaisK8, HIGH);
Serial.println(F("RelaisK8 OFF"));
}
if (valeur_CanalK9 == 0 && Str == "1") {
Serial.println(F("Retour d'etat K9 à 1"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK9/Etat", "1");
digitalWrite(RelaisK9, LOW);
Serial.println(F("RelaisK9 ON"));
} else if (valeur_CanalK9 == 0 && Str == "0") {
Serial.println(F("Retour d'etat K9 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK9/Etat", "0");
digitalWrite(RelaisK9, HIGH);
Serial.println(F("RelaisK9 OFF"));
}
if (valeur_CanalK10 == 0 && Str == "1") {
Serial.println(F("Retour d'etat K10 à 1"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK10/Etat", "1");
digitalWrite(RelaisK10, LOW);
Serial.println(F("RelaisK10 ON"));
} else if (valeur_CanalK10 == 0 && Str == "0") {
Serial.println(F("Retour d'etat K10 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK10/Etat", "0");
digitalWrite(RelaisK10, HIGH);
Serial.println(F("RelaisK10 OFF"));
}
if (valeur_CanalK11 == 0 && Str == "1") {
Serial.println(F("Retour d'etat K11 à 1"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK11/Etat", "1");
digitalWrite(RelaisK11, LOW);
Serial.println(F("RelaisK11 ON"));
} else if (valeur_CanalK11 == 0 && Str == "0") {
Serial.println(F("Retour d'etat K11 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK11/Etat", "0");
digitalWrite(RelaisK11, HIGH);
Serial.println(F("RelaisK11 OFF"));
}
if (valeur_CanalK12 == 0 && Str == "1") {
Serial.println(F("Retour d'etat K12 à 1"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK12/Etat", "1");
digitalWrite(RelaisK12, LOW);
Serial.println(F("RelaisK12 ON"));
} else if (valeur_CanalK12 == 0 && Str == "0") {
Serial.println(F("Retour d'etat K12 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK12/Etat", "0");
digitalWrite(RelaisK12, HIGH);
Serial.println(F("RelaisK12 OFF"));
}
if (valeur_CanalK13 == 0 && Str == "1") {
Serial.println(F("Retour d'etat K13 à 1"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK13/Etat", "1");
digitalWrite(RelaisK13, LOW);
Serial.println(F("RelaisK13 ON"));
} else if (valeur_CanalK13 == 0 && Str == "0") {
Serial.println(F("Retour d'etat K13 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK13/Etat", "0");
digitalWrite(RelaisK13, HIGH);
Serial.println(F("RelaisK13 OFF"));
}
if (valeur_CanalK14 == 0 && Str == "1") {
Serial.println(F("Retour d'etat K14 à 1"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK14/Etat", "1");
digitalWrite(RelaisK14, LOW);
Serial.println(F("RelaisK14 ON"));
} else if (valeur_CanalK14 == 0 && Str == "0") {
Serial.println(F("Retour d'etat K14 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK14/Etat", "0");
digitalWrite(RelaisK14, HIGH);
Serial.println(F("RelaisK14 OFF"));
}
}
//-------- fin de la fonction qui permet de traiter les messages qui arrivent depuis le broker MQTT : ----------
// //----------------------- début de la fonction affichage temp : ---------------------
void affValeurs() {
Serial.print(F("Temperatures : "));
Serial.print(temperature[0], 1);
Serial.print(F("°C / "));
Serial.print(temperature[1], 1);
Serial.print(F("°C / "));
Serial.print(temperature[2], 1);
Serial.print(F("°C / "));
Serial.print(temperature[3], 1);
Serial.print(F("°C / "));
Serial.print(temperature[4], 1);
Serial.println(F("°C"));
// LDRValue = analogRead(LDR);
// Serial.print(F("LDR : "));
// Serial.print(LDRValue);
// Serial.println(F("mV"));
}
//----------------------- fin de la fonction affichage temp ---------------------
Je pense avoir trouver pourquoi il reboot quasiment a chaque fois car dans l'action k3 j'ai un Delay de 5s et le watchdog est de 8 seconde en mettant un reset watchdog juste avant le Delay de k3 et k4 sa parait fonctionner
Par contre j'ai pas résolue le loop en pause le temps des 60 seconde d'intervalle
pourquoi utilisez vous le watchdog?
car il était dans le sketch de base que je me suis inspirer mais je pense que je vais le supprimer
vous pouvez faire tourner ce code sur votre Mega et me monter ce qui est affiché dans la console
/* ============================================
code is placed under the MIT license
Copyright (c) 2020 J-M-L
For the Arduino Forum : https://forum.arduino.cc/u/j-m-l
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
===============================================
*/
// I manually added in diagram.json the attribute "deviceID": "xxxxxxxxxxxx" (6 hex bytes)
// for each sensor. Tthat will form the base of the address (adding 0x10 in front and the crc8 at the end for 8 bytes)
#include <OneWire.h>
constexpr byte oneWirePin = 23; // <== pick the right pin
OneWire onewire(oneWirePin);
void setup(void) {
byte addr[8];
byte ds18b20Count = 0;
Serial.begin(115200);
onewire.reset_search(); // start fresh
Serial.println(F("struct Ds18b20 {\n const char * name;\n const uint8_t address[8];\n};"));
Serial.println(F("constexpr Ds18b20 sensors[] = {"));
while (onewire.search(addr)) {
if (OneWire::crc8( addr, 7) != addr[7]) continue; // CRC is not valid
if (addr[0] != 0x10) continue; // Device is not a DS18S20 family device
// valid DS18S20, record the address
Serial.print(F(" {\"sensor")); Serial.print(ds18b20Count); Serial.print(F("\", {"));
for (byte i = 0; i < 8; i++) {
Serial.print(F("0x"));
if (addr[i] < 0x10) Serial.write('0');
Serial.print(addr[i], HEX);
if (i < 7) Serial.print(F(", ")); else Serial.println(F("}},"));
}
ds18b20Count++;
}
Serial.print(F("};\nconstexpr byte sensorCount = sizeof sensors / sizeof * sensors; // "));
Serial.println(ds18b20Count);
}
void loop(void) {}
votre montage des sondes doit ressembler à cela avec la résistance de 4.7KΩ
c'est testable sur wokwi
Ca devrait vous donner les adresses des 5 capteurs un truc du genre
struct Ds18b20 {
const char * name;
const uint8_t address[8];
};
constexpr Ds18b20 sensors[] = {
{"sensor0", {0x10, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x62}},
{"sensor1", {0x10, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x3B}},
{"sensor2", {0x10, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x9B}},
{"sensor3", {0x10, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x02}},
{"sensor4", {0x10, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x5B}},
};
constexpr byte sensorCount = sizeof sensors / sizeof * sensors; // 5
(c'est un de mes vieux code qui générait une structure que j'utilisais ensuite)
idéalement vous ajouteriez un par un les capteurs pour pouvoir les identifier et les nommer avec un nom parlant comme chambre, salon, etc.
voici le resultat de votre sketch
11:23:54.037 -> struct Ds18b20 {
11:23:54.037 -> const char * name;
11:23:54.037 -> const uint8_t address[8];
11:23:54.037 -> };
11:23:54.037 -> constexpr Ds18b20 sensors[] = {
11:23:54.130 -> };
11:23:54.130 -> constexpr byte sensorCount = sizeof sensors / sizeof * sensors; // 0
avec ce sketch que j'avais tester
/**
* Scanner 1-Wire (Dallas) pour cartes Arduino et compatible.
*/
/* Dépendances */
#include <OneWire.h>
/** Broche pour le bus 1-Wire */
const byte ONEWIRE_BUS_PIN = 23;
/** L'object OneWire pour communiquer via le protocole 1-Wire sur la broche spécifiée */
OneWire ds(ONEWIRE_BUS_PIN);
/** Fonction setup() */
void setup(void) {
/* Initialise le port série */
Serial.begin(115200);
Serial.println(F("~~ Scanner 1-Wire ~~"));
}
/** Fonction loop() */
void loop(void) {
byte address[8];
/* Cherche un module 1-Wire sur le bus */
if (!ds.search(address)) {
Serial.println(F("End of Scan."));
ds.reset_search();
for(;;);
}
/* Module 1-Wire découvert ! */
Serial.print(F("Found "));
for(byte i = 0; i < 8; ++i) {
if (address[i] < 0x10) Serial.write('0');
Serial.print(address[i], HEX);
Serial.write(' ');
}
/* Vérifie si l'adresse est valide */
if (OneWire::crc8(address, 7) != address[7]) {
Serial.print(F("(CRC invalid)"));
}
/* Fin de ligne */
Serial.println();
}
J'ai bien ladresse des sondes
11:27:52.378 -> ~~ Scanner 1-Wire ~~
11:27:52.378 -> Found 28 88 0A A7 B0 22 06 F6
11:27:52.378 -> Found 28 84 B2 74 B1 22 09 99
11:27:52.378 -> Found 28 0D 61 BA B0 22 06 33
11:27:52.425 -> Found 28 0F 2B AC B0 22 06 38
11:27:52.425 -> Found 28 8F DE 6A B1 22 07 63
11:27:52.425 -> End of Scan.
vous penser que si je travail direct par adresse au lieu de faire une recherche sur le bus a chaque fois je gagnerai en rapidité et je pourrait passer en envoie toute les 60 seconde sans bloquer la réceptions des message mqtt
oui le mieux serait de travailler par adresse, ne serait-ce que pour savoir où est le module que vous intérrogez...
le parcours n'est pas forcément toujours dans le même ordre, suivant comment les modules répondent
c'est bizarre qu'il ne voie rien. essayez en enlevant le
onewire.reset_search(); // start fresh
du setup?
d'autre part votre code doit être réarchitecturé pour ne pas avoir a attendre comme je l'expliquais précédemment. Il ne doit rien y avoir de bloquant.
le capteurs ds18B20 savent travailler en tâche de fond et vous dire quand le résultat est prêt. Donc c'est le mode qu'il faut utiliser. Je recommande de passer à la bibliothèque DallasTemperature
J'ai reconstruit mon sketch avec adressage des sonde cela fonctionne il print bien et envoie bien tout les 10 seconde
mais je reçoit les ordre que très rarement certainement encore a cause de la boucle de blocage mais je ne voie pas comment faire autrement
voici le code
/*
* Ce programme tourne sur arduino Mega
* Il permet de lire les données de :
* 5 capteurs de températures DS18B20
* 1 Capteur de pression
* 12 Relais
* Publier les valeurs sur le réseau Ethernet en MQTT.
* Recevoir l'état de 12 switch virtuel
*/
/* Inclusion des librairies */
#include <OneWire.h> // Librairie pour le bus 1-Wire
#include <Ethernet.h> // Librairie pour Ethernet
#include <PubSubClient.h> // Librairie pour MQTT
#include <SPI.h> // Librairie de comunication Capteur
#include <DallasTemperature.h>
/* Déclarations des PINS */
#define BROCHE_ONEWIRE 23
#define PRESSION A0
#define RelaisK3 22
#define RelaisK4 24
#define RelaisK5 26
#define RelaisK6 28
#define RelaisK7 2
#define RelaisK8 3
#define RelaisK9 4
#define RelaisK10 5
#define RelaisK11 6
#define RelaisK12 7
#define RelaisK13 8
#define RelaisK14 9
/* Déclarations des Variable & Constante */
byte mac[] = { 0xDE, 0xED, 0xBA, 0xFE, 0xFE, 0xED }; // Adresse MAC de la carte Ethernet
int PRESSIONvalue = 0; // Remise a zero de la valeur
float temperature[5]; // Stockage de 5 Valeur dans float
char buf[4]; // Taille duBuffer de stockage de la valeur de Pression
const char* MQTTserver = "192.168.2.85"; // Adresse IP du broket MQTT (VM-Mosquitto)
/* Initialisation des objects */
EthernetClient ethClient; // Objets Ethernet
PubSubClient mqttClient(ethClient); // Object MQTT
OneWire oneWire(BROCHE_ONEWIRE); // Object One Wire
/* Passage de One-Wire a Dallas */
DallasTemperature sensors(&oneWire);
/* Adressage des capteurs) */
DeviceAddress Capteur1 = { // Départ Plancher Chauffant
0x28, 0x8F, 0xDE, 0x6A, 0xB1, 0x22, 0x07, 0x63 };
DeviceAddress Capteur2 = { // Retour Plancher Chauffant
0x28, 0x0D, 0x61, 0xBA, 0xB0, 0x22, 0x06, 0x33 };
DeviceAddress Capteur3 = { // Départ Radiateur
0x28, 0x0F, 0x2B, 0xAC, 0xB0, 0x22, 0x06, 0x38 };
DeviceAddress Capteur4 = { // Retour Radiateur
0x28, 0x88, 0x0A, 0xA7, 0xB0, 0x22, 0x06, 0xF6 };
DeviceAddress Capteur5 = { // Départ Bouteille Decouplage
0x28, 0x84, 0xB2, 0x74, 0xB1, 0x22, 0x09, 0x99 };
void setup() {
Serial.begin(9600); // Initialisation du port série
Serial.println(F("Arduino Chauffage (Températures + Relais)"));
/* Atribution des Mode PINS & Les Etat */
pinMode(RelaisK3, OUTPUT);
pinMode(RelaisK4, OUTPUT);
pinMode(RelaisK5, OUTPUT);
pinMode(RelaisK6, OUTPUT);
pinMode(RelaisK7, OUTPUT);
pinMode(RelaisK8, OUTPUT);
pinMode(RelaisK9, OUTPUT);
pinMode(RelaisK10, OUTPUT);
pinMode(RelaisK11, OUTPUT);
pinMode(RelaisK12, OUTPUT);
pinMode(RelaisK13, OUTPUT);
pinMode(RelaisK14, OUTPUT);
digitalWrite(RelaisK3, HIGH);
digitalWrite(RelaisK4, HIGH);
digitalWrite(RelaisK5, HIGH);
digitalWrite(RelaisK6, HIGH);
digitalWrite(RelaisK7, HIGH);
digitalWrite(RelaisK8, HIGH);
digitalWrite(RelaisK9, HIGH);
digitalWrite(RelaisK10, HIGH);
digitalWrite(RelaisK11, HIGH);
digitalWrite(RelaisK12, HIGH);
digitalWrite(RelaisK13, HIGH);
digitalWrite(RelaisK14, HIGH);
if (Ethernet.begin(mac) == 0) { // Si Pas d'adresse MAC on attend
Serial.println(F("Impossible de configurer Ethernet via serveur DHCP !"));
for (;;)
;
}
Serial.println(F("Ethernet configuré via DHCP"));
Serial.print(F("IP address: "));
Serial.println(Ethernet.localIP());
mqttClient.setServer(MQTTserver, 1883); // On Configure l'adresse du serveur depuiis la variable
Serial.println(F("Client MQTT configuré !"));
Serial.println(F("Connexion au serveur avec l'ID 'Arduino_Chauffage'"));
if (mqttClient.connect("core-mosquitto", "Idt", "Mdp")) { // On essaie de se connecter avec les identifiant et MDP
Serial.println(F("La connection a été établie"));
} else {
Serial.println(F("Le serveur ne répond pas"));
}
// Je publie sur les topic la remise a zero des pins et reboot effectuée
mqttClient.publish("Arduino_Chauffage/Reboot", "1");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK3/Etat", "0");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK4/Etat", "0");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK5/Etat", "0");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK6/Etat", "0");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK7/Etat", "0");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK8/Etat", "0");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK9/Etat", "0");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK10/Etat", "0");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK11/Etat", "0");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK12/Etat", "0");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK13/Etat", "0");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK14/Etat", "0");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisHall/Etat", "0");
mqttClient.setCallback(callback);
sensors.begin();
// Reglage de la precision des températures a 0.5
int resolution = 12;
sensors.setResolution(Capteur1, resolution);
sensors.setResolution(Capteur2, resolution);
sensors.setResolution(Capteur3, resolution);
sensors.setResolution(Capteur4, resolution);
sensors.setResolution(Capteur5, resolution);
delay(2000);
}
void loop() {
mqttClient.loop();
static unsigned long prevMillis100ms = 0; // Déclaration d'une variable pour la temporisation publication mqtt
static unsigned long prevMillis10s = 0; // Déclaration d'une variable pour la temporisation publication mqtt
unsigned long curMillis = millis();
/* Souscription au topic */
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK3");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK4");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK5");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK6");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK7");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK8");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK9");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK10");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK11");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK12");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK13");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK14");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisHall");
mqttClient.loop();
if (!mqttClient.connected()) { // permet de reconnecter l'arduino au broker en cas de crash de celui-ci.
reconnect();
}
if (curMillis - prevMillis10s >= 10000) { // on lit les valeurs des capteurs et on les publie toutes les 60s
prevMillis10s = curMillis;
printTemperature(sensors, Capteur1, "Arduino_Chauffage/Temperatures/Capteur1", 0);
printTemperature(sensors, Capteur2, "Arduino_Chauffage/Temperatures/Capteur2", 0);
printTemperature(sensors, Capteur3, "Arduino_Chauffage/Temperatures/Capteur3", 0);
printTemperature(sensors, Capteur4, "Arduino_Chauffage/Temperatures/Capteur4", 0);
printTemperature(sensors, Capteur5, "Arduino_Chauffage/Temperatures/Capteur5", 0);
}
if (curMillis - prevMillis10s >= 10000) { // on lit les valeurs des capteurs et on les Print toutes les 10s
prevMillis10s = curMillis;
// On va print les valeurs dans le moniteur serie
// affValeurs();
}
mqttClient.loop();
mqttClient.setCallback(callback);
}
/* Fonction de Callback */
void callback(char* topic, byte* payload, unsigned int length) {
String Str;
Serial.print(F("**** Message arrivé depuis MQTT broker **** -> [ "));
Serial.print(topic);
Serial.print(F(" ] -> ' "));
for (int i = 0; i < length; i++) { //ici le lenght c'est la variable de la fonction callback
Serial.print((char)payload[i]);
Str = Str + (char)payload[i];
}
Serial.println(F(" '"));
// On cree les variable des relais
char* Canal_RelaisK3_Virtuel = "Arduino_Chauffage/Relais/RelaisK3";
char* Canal_RelaisK4_Virtuel = "Arduino_Chauffage/Relais/RelaisK4";
char* Canal_RelaisK5_Virtuel = "Arduino_Chauffage/Relais/RelaisK5";
char* Canal_RelaisK6_Virtuel = "Arduino_Chauffage/Relais/RelaisK6";
char* Canal_RelaisK7_Virtuel = "Arduino_Chauffage/Relais/RelaisK7";
char* Canal_RelaisK8_Virtuel = "Arduino_Chauffage/Relais/RelaisK8";
char* Canal_RelaisK9_Virtuel = "Arduino_Chauffage/Relais/RelaisK9";
char* Canal_RelaisK10_Virtuel = "Arduino_Chauffage/Relais/RelaisK10";
char* Canal_RelaisK11_Virtuel = "Arduino_Chauffage/Relais/RelaisK11";
char* Canal_RelaisK12_Virtuel = "Arduino_Chauffage/Relais/RelaisK12";
char* Canal_RelaisK13_Virtuel = "Arduino_Chauffage/Relais/RelaisK13";
char* Canal_RelaisK14_Virtuel = "Arduino_Chauffage/Relais/RelaisK14";
char* Canal_RelaisHall_Virtuel = "Arduino_Chauffage/Relais/RelaisHall";
// On Atribut les valeur des variables
int valeur_CanalK3 = strcmp(topic, Canal_RelaisK3_Virtuel);
int valeur_CanalK4 = strcmp(topic, Canal_RelaisK4_Virtuel);
int valeur_CanalK5 = strcmp(topic, Canal_RelaisK5_Virtuel);
int valeur_CanalK6 = strcmp(topic, Canal_RelaisK6_Virtuel);
int valeur_CanalK7 = strcmp(topic, Canal_RelaisK7_Virtuel);
int valeur_CanalK8 = strcmp(topic, Canal_RelaisK8_Virtuel);
int valeur_CanalK9 = strcmp(topic, Canal_RelaisK9_Virtuel);
int valeur_CanalK10 = strcmp(topic, Canal_RelaisK10_Virtuel);
int valeur_CanalK11 = strcmp(topic, Canal_RelaisK11_Virtuel);
int valeur_CanalK12 = strcmp(topic, Canal_RelaisK12_Virtuel);
int valeur_CanalK13 = strcmp(topic, Canal_RelaisK13_Virtuel);
int valeur_CanalK14 = strcmp(topic, Canal_RelaisK14_Virtuel);
int valeur_CanalHall = strcmp(topic, Canal_RelaisHall_Virtuel);
// On test les variables
if (valeur_CanalK3 == 0 && Str == "1") {
if (digitalRead(RelaisK4) == HIGH) {
Serial.println(F("La fermeture V3V est bien OFF"));
Serial.println(F("Retour d'etat K3 à 1"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK3/Etat", "1");
digitalWrite(RelaisK3, LOW);
Serial.println(F("RelaisK3 ON"));
delay(5000);
Serial.println(F("Retour d'etat K3 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK3/Etat", "0");
digitalWrite(RelaisK3, HIGH);
Serial.println(F("RelaisK3 OFF"));
}
else {
Serial.println(F("La fermeture V3V est ON anulation de l'action"));
Serial.println(F("Retour d'etat K3 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK3/Etat", "0");
digitalWrite(RelaisK3, HIGH);
Serial.println(F("RelaisK3 OFF"));
}
}else if (valeur_CanalK3 == 0 && Str == "0") {
Serial.println(F("Retour d'etat K3 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK3/Etat", "0");
digitalWrite(RelaisK3, HIGH);
Serial.println(F("RelaisK3 OFF"));
}
if (valeur_CanalK4 == 0 && Str == "1") {
if (digitalRead(RelaisK3) == HIGH) {
Serial.println(F("L'ouverture V3V est bien OFF"));
Serial.println(F("Retour d'etat K4 à 1"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK4/Etat", "1");
digitalWrite(RelaisK4, LOW);
Serial.println(F("RelaisK4 ON"));
delay(5000);
Serial.println(F("Retour d'etat K4 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK4/Etat", "0");
digitalWrite(RelaisK4, HIGH);
Serial.println(F("RelaisK4 OFF"));
}
else {
Serial.println(F("L'ouverture V3V est ON anulation de l'action"));
Serial.println(F("Retour d'etat K4 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK4/Etat", "0");
digitalWrite(RelaisK4, HIGH);
Serial.println(F("RelaisK4 OFF"));
}
}else if (valeur_CanalK4 == 0 && Str == "0") {
Serial.println(F("Retour d'etat K4 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK4/Etat", "0");
digitalWrite(RelaisK4, HIGH);
Serial.println(F("RelaisK4 OFF"));
}
if (valeur_CanalK5 == 0 && Str == "1") {
Serial.println(F("Retour d'etat K5 à 1"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK5/Etat", "1");
digitalWrite(RelaisK5, LOW);
Serial.println(F("RelaisK5 ON"));
} else if (valeur_CanalK5 == 0 && Str == "0") {
Serial.println(F("Retour d'etat K5 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK5/Etat", "0");
digitalWrite(RelaisK5, HIGH);
Serial.println(F("RelaisK5 OFF"));
}
if (valeur_CanalK6 == 0 && Str == "1") {
Serial.println(F("Retour d'etat K6 à 1"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK6/Etat", "1");
digitalWrite(RelaisK6, LOW);
Serial.println(F("RelaisK6 ON"));
} else if (valeur_CanalK6 == 0 && Str == "0") {
Serial.println(F("Retour d'etat K6 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK6/Etat", "0");
digitalWrite(RelaisK6, HIGH);
Serial.println(F("RelaisK6 OFF"));
}
if (valeur_CanalK7 == 0 && Str == "1") {
Serial.println(F("Retour d'etat K7 à 1"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK7/Etat", "1");
digitalWrite(RelaisK7, LOW);
Serial.println(F("RelaisK7 ON"));
} else if (valeur_CanalK7 == 0 && Str == "0") {
Serial.println(F("Retour d'etat K7 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK7/Etat", "0");
digitalWrite(RelaisK7, HIGH);
Serial.println(F("RelaisK7 OFF"));
}
if (valeur_CanalK8 == 0 && Str == "1") {
Serial.println(F("Retour d'etat K8 à 1"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK8/Etat", "1");
digitalWrite(RelaisK8, LOW);
Serial.println(F("RelaisK8 ON"));
} else if (valeur_CanalK8 == 0 && Str == "0") {
Serial.println(F("Retour d'etat K8 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK8/Etat", "0");
digitalWrite(RelaisK8, HIGH);
Serial.println(F("RelaisK8 OFF"));
}
if (valeur_CanalK9 == 0 && Str == "1") {
Serial.println(F("Retour d'etat K9 à 1"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK9/Etat", "1");
digitalWrite(RelaisK9, LOW);
Serial.println(F("RelaisK9 ON"));
} else if (valeur_CanalK9 == 0 && Str == "0") {
Serial.println(F("Retour d'etat K9 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK9/Etat", "0");
digitalWrite(RelaisK9, HIGH);
Serial.println(F("RelaisK9 OFF"));
}
if (valeur_CanalK10 == 0 && Str == "1") {
Serial.println(F("Retour d'etat K10 à 1"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK10/Etat", "1");
digitalWrite(RelaisK10, LOW);
Serial.println(F("RelaisK10 ON"));
} else if (valeur_CanalK10 == 0 && Str == "0") {
Serial.println(F("Retour d'etat K10 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK10/Etat", "0");
digitalWrite(RelaisK10, HIGH);
Serial.println(F("RelaisK10 OFF"));
}
if (valeur_CanalK11 == 0 && Str == "1") {
Serial.println(F("Retour d'etat K11 à 1"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK11/Etat", "1");
digitalWrite(RelaisK11, LOW);
Serial.println(F("RelaisK11 ON"));
} else if (valeur_CanalK11 == 0 && Str == "0") {
Serial.println(F("Retour d'etat K11 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK11/Etat", "0");
digitalWrite(RelaisK11, HIGH);
Serial.println(F("RelaisK11 OFF"));
}
if (valeur_CanalK12 == 0 && Str == "1") {
Serial.println(F("Retour d'etat K12 à 1"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK12/Etat", "1");
digitalWrite(RelaisK12, LOW);
Serial.println(F("RelaisK12 ON"));
} else if (valeur_CanalK12 == 0 && Str == "0") {
Serial.println(F("Retour d'etat K12 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK12/Etat", "0");
digitalWrite(RelaisK12, HIGH);
Serial.println(F("RelaisK12 OFF"));
}
if (valeur_CanalK13 == 0 && Str == "1") {
Serial.println(F("Retour d'etat K13 à 1"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK13/Etat", "1");
digitalWrite(RelaisK13, LOW);
Serial.println(F("RelaisK13 ON"));
} else if (valeur_CanalK13 == 0 && Str == "0") {
Serial.println(F("Retour d'etat K13 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK13/Etat", "0");
digitalWrite(RelaisK13, HIGH);
Serial.println(F("RelaisK13 OFF"));
}
if (valeur_CanalK14 == 0 && Str == "1") {
Serial.println(F("Retour d'etat K14 à 1"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK14/Etat", "1");
digitalWrite(RelaisK14, LOW);
Serial.println(F("RelaisK14 ON"));
} else if (valeur_CanalK14 == 0 && Str == "0") {
Serial.println(F("Retour d'etat K14 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK14/Etat", "0");
digitalWrite(RelaisK14, HIGH);
Serial.println(F("RelaisK14 OFF"));
}
if (valeur_CanalHall == 0 && Str == "1") {
Serial.println(F("Retour d'etat Hall à 1"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisHall/Etat", "1");
digitalWrite(RelaisK7, LOW);
digitalWrite(RelaisK8, LOW);
digitalWrite(RelaisK9, LOW);
digitalWrite(RelaisK10, LOW);
Serial.println(F("RelaisHall ON"));
} else if (valeur_CanalHall == 0 && Str == "0") {
Serial.println(F("Retour d'etat Hall à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisHall/Etat", "0");
digitalWrite(RelaisK7, HIGH);
digitalWrite(RelaisK8, HIGH);
digitalWrite(RelaisK9, HIGH);
digitalWrite(RelaisK10, HIGH);
Serial.println(F("RelaisHall OFF"));
}
}
/* Liste des fonctions DS18B20 */
/*enum DS18B20_RCODES {
READ_OK,
NO_SENSOR_FOUND,
INVALID_ADDRESS,
INVALID_SENSOR
};*/
//OneWire ds(BROCHE_ONEWIRE);
void reconnect() {
while (!mqttClient.connected()) {
if (mqttClient.connect("core-mosquitto", "Idt", "Mdp")) {
Serial.println();
Serial.println("Reconnecté au broker !");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK3");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK4");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK5");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK6");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK7");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK8");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK9");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK10");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK11");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK12");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK13");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK14");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisHall");
mqttClient.setCallback(callback);
} else {
Serial.print(F("Broker MQTT indisponible. Status : rc="));
Serial.print(mqttClient.state());
Serial.println(F(" , tentative de reconnexion dans 3 secondes..."));
delay(3000);
}
}
}
void printTemperature(DallasTemperature sensors, DeviceAddress deviceAddress, char* topic, int ctr){
sensors.requestTemperatures();
delay(1000);
float tempC = sensors.getTempC(deviceAddress);
if (tempC == -127.00 or tempC < -15 or tempC > 59) {
if (ctr < 3){
printTemperature(sensors, deviceAddress, topic, ++ctr);
}
else
{
Serial.println(String("Error reading:").concat(topic));
}
}
else {
Serial.println(topic);
Serial.println(tempC);
char buffer[12];
char outstr[15];
dtostrf(tempC,4, 2, outstr);
mqttClient.publish(topic, outstr);
}
}
Il faut tout reprendre, utiliser des tableaux pour grouper tout ce qui va ensemble …
Vous gagnerez du temps à passer 2 ou 3h sur les bases du c++ plutôt que d’essayer de trouver des bouts de code qui ressemblent à ce que vous voulez essayer de faire.
Utilisez aussi des bibliothèques de plus haut niveau ça vous simplifiera la vie.
Pour ne pas avoir de delay le plus simple est de faire une machine à états
@J-M-L a raison ton code comporte beaucoup de répétition qui le rend indigeste et long à modifier.
A partir du moment ou tu dupliques des variables en leur rajoutant un numéro, c'est que tu peux passer par un tableau.
de la même façon, si tu dupliques du code pour ne changer que des variables comportant un numéro, c'est que tu peux passer par une fonction.
Par exemple le code suivant peut être mis en fonction.
if (valeur_CanalK4 == 0 && Str == "1") {
if (digitalRead(RelaisK3) == HIGH) {
Serial.println(F("L'ouverture V3V est bien OFF"));
Serial.println(F("Retour d'etat K4 à 1"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK4/Etat", "1");
digitalWrite(RelaisK4, LOW);
Serial.println(F("RelaisK4 ON"));
delay(5000);
Serial.println(F("Retour d'etat K4 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK4/Etat", "0");
digitalWrite(RelaisK4, HIGH);
Serial.println(F("RelaisK4 OFF"));
} else {
Serial.println(F("L'ouverture V3V est ON anulation de l'action"));
Serial.println(F("Retour d'etat K4 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK4/Etat", "0");
digitalWrite(RelaisK4, HIGH);
Serial.println(F("RelaisK4 OFF"));
}
} else if (valeur_CanalK4 == 0 && Str == "0") {
Serial.println(F("Retour d'etat K4 à 0"));
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK4/Etat", "0");
digitalWrite(RelaisK4, HIGH);
Serial.println(F("RelaisK4 OFF"));
}
Bonjour a tous
Me revoila avec mon sketch améliorer , certainement pas parfait et digne d'un pro mais j'ai travailler avec des tableaux, je procède a un envoie des températures que si celle ci change par rapport a la dernière lecture et j'ai surtout mit en place une vérification d'état connexion car voila le problème :
Le sketch fonctionne mais cesse de fonctionner au bout d'un certain temps aléatoirement.
Il ne répond plus au ping et n'envoie plus les températures etc.
Apres un reboot celui ci repart pour quelque heure.
il y a t'il une raison a cela ou une solution de vérification a inclure (cela m'embête de remettre le Watch garde car a chaque reboot les relais passe a l'état 0)
voici le code
/*
* Ce programme tourne sur arduino Mega
* Il permet de lire les données de :
* 5 capteurs de températures DS18B20
* 1 Capteur de pression
* 12 Relais
* Publier les valeurs sur le réseau Ethernet en MQTT.
*/
/* Inclusion des librairies */
#include <OneWire.h> // Librairie pour le bus 1-Wire
#include <Ethernet.h> // Librairie pour Ethernet
#include <PubSubClient.h> // Librairie pour MQTT
#include <SPI.h> // Librairie de comunication Capteur
#include <DallasTemperature.h> // Librairie pour sonde DS18B20
/* Déclarations des PINS */
#define BROCHE_ONEWIRE 23
/* Déclarations des Variables & Constantes & Tableaux */
/* Tableau des relais */
const byte relaisK[12] = {22, 24, 26, 28, 2, 3, 4, 5, 6, 7, 8, 9};
/* relaisK[0]=22; // Relais K3 Ouverture V3V
relaisK[1]=24; // Relais K4 Fermeture V3V
relaisK[2]=26; // Relais K5 Circulateur Plancher
relaisK[3]=28; // Relais K6 Circulateur Chauffage
relaisK[4]=2; // Relais K7 Vanne Circuit Salon Nord
relaisK[5]=3; // Relais K8 Vanne Circuit Salon Sud
relaisK[6]=4; // Relais K9 Vanne Circuit Salle a Manger
relaisK[7]=5; // Relais K10 Vanne Circuit Cuisine
relaisK[8]=6; // Relais K11 Vanne Circuit Bureau
relaisK[9]=7; // Relais K12 Vanne Circuit Salle de Bain Rdc
relaisK[10]=8; // Relais K13 Vanne Circuit Chambre Rdc
relaisK[11]=9; // Relais K14 Vanne Non Utiliser (Arriere-Cuisine)
*/
/* Initialisation des objects */
EthernetClient ethClient; // Objets Ethernet
PubSubClient mqttClient(ethClient); // Object MQTT
OneWire oneWire(BROCHE_ONEWIRE); // Object One Wire
/* Passage de One-Wire a Dallas */
DallasTemperature sensors(&oneWire);
/* Tableau d'adresse des Capteurs */
DeviceAddress capteurAddr[5] = {
{ 0x28, 0x8F, 0xDE, 0x6A, 0xB1, 0x22, 0x07, 0x63 }, // Départ Plancher Chauffant
{ 0x28, 0x0D, 0x61, 0xBA, 0xB0, 0x22, 0x06, 0x33 }, // Retour Plancher Chauffant
{ 0x28, 0x0F, 0x2B, 0xAC, 0xB0, 0x22, 0x06, 0x38 }, // Départ Radiateur
{ 0x28, 0x88, 0x0A, 0xA7, 0xB0, 0x22, 0x06, 0xF6 }, // Retour Radiateur
{ 0x28, 0x84, 0xB2, 0x74, 0xB1, 0x22, 0x09, 0x99 } // Départ Bouteille Decouplage
};
/* Tableau & Constantes des temperatures */
float capteurTemp[5];
float derTemp1;
float derTemp2;
float derTemp3;
float derTemp4;
float derTemp5;
char tempString1[6];
char tempString2[6];
char tempString3[6];
char tempString4[6];
char tempString5[6];
int TEMPERATURE_PRECISION = 12;
/* Configuration shield Ethernet */
byte mac[] = { 0xDE, 0xDB, 0xDF, 0xEE, 0xEB, 0xFF };
IPAddress ip(192,168,2,70);
char erreurEthernet = 0;
/* Constante Serveur MQTT */
const char* MQTTserver = "192.168.2.85"; // Adresse IP du broket MQTT (VM-Mosquitto)
void setup() {
Serial.begin(9600); // Initialisation du port série
Serial.println(F("Arduino Chauffage (Températures, Pression + Relais)"));
erreurEthernet = Ethernet.begin(mac); // Demarrage du shield Ethernet via DHCP
if (erreurEthernet == 0) {
Serial.println("Erreur DHCP , Parametrage avec IP fixe");
Ethernet.begin(mac, ip);
}
Serial.println("Initialisation Ethernet");
delay(1000); // Donne une seconde au shield pour s'initialiser
Serial.println("Connection Ethernet Ok");
Serial.println(F("Ethernet configuré via DHCP"));
Serial.print(F("IP address: "));
Serial.println(Ethernet.localIP());
mqttClient.setServer(MQTTserver, 1883); // On Configure l'adresse du serveur depuis la variable
Serial.println(F("Client MQTT configuré !"));
Serial.println(F("Connexion au serveur avec l'ID 'chauffage'"));
if (mqttClient.connect("chauffage", "idt", "mdp")) { // On essaie de se connecter avec les identifiant et MDP
Serial.println(F("La connection a été établie"));
} else {
Serial.println(F("Le serveur ne répond pas"));
}
/* Publication sur les topics la remise a zero des pins et reboot effectuée */
mqttClient.publish("Arduino_Chauffage/Reboot", "1");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK3/Etat", "0");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK4/Etat", "0");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK5/Etat", "0");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK6/Etat", "0");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK7/Etat", "0");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK8/Etat", "0");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK9/Etat", "0");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK10/Etat", "0");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK11/Etat", "0");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK12/Etat", "0");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK13/Etat", "0");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK14/Etat", "0");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisHall/Etat", "0");
/* Initialisation de la fonction ecoute MQTT */
mqttClient.setCallback(callback);
/* Initialisation Capteur Temperature */
sensors.begin();
/* Déclaration de l'etat des PINS et mise a 0 des etats */
for (int i = 0; i <= 11; i++) {
pinMode(relaisK[i], OUTPUT); // Toutes les pins relais sont commutées en sortie
digitalWrite(relaisK[i], HIGH); // Toutes les pins relais ont pour valeur 0
} // Fin de la boucle for
/* Reglage de la precision des températures a 0.5 */
for (int i = 0; i <= 11; i++) {
sensors.setResolution(capteurAddr[i], TEMPERATURE_PRECISION);
}
/* Souscription au topic */
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK3");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK4");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK5");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK6");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK7");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK8");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK9");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK10");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK11");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK12");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK13");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK14");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisHall");
delay(2000);
}
void loop() {
static unsigned long prevMillis60s = 0; // Déclaration d'une variable pour la temporisation publication mqtt
unsigned long curMillis = millis();
if (!mqttClient.connected()) { // permet de reconnecter l'arduino au broker en cas de crash de celui-ci.
reconnect();
}
/* Lecture des sondes + Conversion en numeriques et stockages dans variable */
sensors.requestTemperatures();
delay(100);
(capteurTemp[0]) = sensors.getTempC(capteurAddr[0]);
(capteurTemp[1]) = sensors.getTempC(capteurAddr[1]);
(capteurTemp[2]) = sensors.getTempC(capteurAddr[2]);
(capteurTemp[3]) = sensors.getTempC(capteurAddr[3]);
(capteurTemp[4]) = sensors.getTempC(capteurAddr[4]);
dtostrf(capteurTemp[0], 2, 2, tempString1);
dtostrf(capteurTemp[1], 2, 2, tempString2);
dtostrf(capteurTemp[2], 2, 2, tempString3);
dtostrf(capteurTemp[3], 2, 2, tempString4);
dtostrf(capteurTemp[4], 2, 2, tempString5);
/* Print et envoie mqtt si changement Valeur Température départ Plancher Chauffant */
if (capteurTemp[0] - derTemp1 >= 0.1 || derTemp1 - capteurTemp[0] >= 0.1) { // On test la valeur si changement de +/- que 0.2 on print/publie
Serial.println("");
Serial.print("Température Départ Plancher Chauffant: ");
Serial.print(capteurTemp[0]);
Serial.println("°");
mqttClient.publish("Arduino_Chauffage/Temperatures/Capteur1", (tempString1));
delay(100);
derTemp1 = capteurTemp[0];
}
/* Print et envoie mqtt si changement Valeur Température Retour Plancher Chauffant */
if (capteurTemp[1] - derTemp2 >= 0.3 || derTemp2 - capteurTemp[1] >= 0.3) { // On test la valeur si changement de +/- que 0.2 on print/publie
Serial.println("");
Serial.print("Température Retour Plancher Chauffant: ");
Serial.print(capteurTemp[1]);
Serial.println("°");
mqttClient.publish("Arduino_Chauffage/Temperatures/Capteur2", (tempString2));
delay(100);
derTemp2 = capteurTemp[1];
}
/* Print et envoie mqtt si changement Valeur Température Départ Chauffage */
if (capteurTemp[2] - derTemp3 >= 0.3 || derTemp3 - capteurTemp[2] >= 0.3) { // On test la valeur si changement de +/- que 0.2 on print/publie
Serial.println("");
Serial.print("Température Départ Chauffage: ");
Serial.print(capteurTemp[2]);
Serial.println("°");
mqttClient.publish("Arduino_Chauffage/Temperatures/Capteur3", (tempString3));
delay(100);
derTemp3 = capteurTemp[2];
}
/* Print et envoie mqtt si changement Valeur Température Retour Chauffage */
if (capteurTemp[3] - derTemp4 >= 0.3 || derTemp4 - capteurTemp[3] >= 0.3) { // On test la valeur si changement de +/- que 0.2 on print/publie
Serial.println("");
Serial.print("Température Retour Chauffage: ");
Serial.print(capteurTemp[3]);
Serial.println("°");
mqttClient.publish("Arduino_Chauffage/Temperatures/Capteur4", (tempString4));
delay(100);
derTemp4 = capteurTemp[3];
}
/* Print et envoie mqtt si changement Valeur Température Départ Bouteille Découplage */
if (capteurTemp[4] - derTemp5 >= 0.5 || derTemp5 - capteurTemp[4] >= 0.5) { // On test la valeur si changement de +/- que 0.2 on print/publie
Serial.println("");
Serial.print("Température Départ Bouteille Découplage: ");
Serial.print(capteurTemp[4]);
Serial.println("°");
mqttClient.publish("Arduino_Chauffage/Temperatures/Capteur5", (tempString5));
delay(100);
derTemp5 = capteurTemp[4];
}
/* Verification réseau toute les 60 sec */
if (curMillis - prevMillis60s >= 60000) { // On test la connection Ethernet toute les 60sec
prevMillis60s = curMillis;
if (ethClient.connected()) {
Serial.println("");
Serial.println("Connection Réseau Ok");
}
if (!ethClient.connected()) {
Serial.println("");
Serial.println("Pas conectée au réseau");
Serial.println("Tentative de reconection");
Ethernet.begin(mac); // Demarrage du shield Ethernet via DHCP
erreurEthernet = Ethernet.begin(mac);
if (erreurEthernet == 0) {
Serial.println("Erreur DHCP , Paramétrage avec IP fixe");
Ethernet.begin(mac, ip);
}
Serial.println("Initialisation Ethernet");
delay(1000); // Donne une seconde au shield pour s'initialiser
Serial.println("Connection Ethernet Ok");
Serial.println(F("Ethernet configuré via DHCP"));
Serial.print(F("IP address: "));
Serial.println(Ethernet.localIP());
reconnect();
}
}
mqttClient.loop();
mqttClient.setCallback(callback);
}
void reconnect() {
while (!mqttClient.connected()) {
if (mqttClient.connect("chauffage", "idt", "mdp")) {
Serial.println();
Serial.println("Reconnecté au broker !");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK3");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK4");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK5");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK6");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK7");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK8");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK9");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK10");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK11");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK12");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK13");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisK14");
mqttClient.subscribe("Arduino_Chauffage/Relais/RelaisHall");
mqttClient.setCallback(callback);
} else {
Serial.print(F("Broker MQTT indisponible. Status : rc="));
Serial.print(mqttClient.state());
Serial.println(F(" , tentative de reconnexion dans 3 secondes..."));
delay(5000);
}
}
}
void callback(char* topic, byte* payload, unsigned int length) {
/* Conversion du topic en variable string */
String topicStr = topic;
//EJ: Note: the "topic" value gets overwritten everytime it receives confirmation (callback) message from MQTT
/* Affichage du topic dans le moniteur serie */
Serial.println("Message reçu de Mqtt");
Serial.print("Topic: ");
Serial.println(topicStr);
/* Topic relais K3 */
if (topicStr == "Arduino_Chauffage/Relais/RelaisK3")
{
boolean etatRelaisK4=digitalRead(relaisK[1]);
if(payload[0] == '1'){ // Si le relais K3=0 on verifie K4=0 Si ok on passe K3->1 et on confirme l'etat
if (digitalRead(relaisK[1]) == HIGH) {
digitalWrite(relaisK[0],LOW);
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK3/Etat", "1");
delay(5000);
digitalWrite(relaisK[0],HIGH);
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK3/Etat", "0");
}
}
else if (payload[0] == '0'){ // Si le relais est a 1 on le passe a 0 et on comfime l'etat
digitalWrite(relaisK[0],HIGH);
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK3/Etat", "0");
}
}
/* Topic relais K4 */
if (topicStr == "Arduino_Chauffage/Relais/RelaisK4")
{
boolean etatRelaisK3=digitalRead(relaisK[0]);
if(payload[0] == '1'){ // Si le relais K4=0 on verifie K3=0 Si ok on passe K4->1 et on confirme l'etat
if (digitalRead(relaisK[0]) == HIGH) {
digitalWrite(relaisK[1], LOW);
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK4/Etat", "1");
delay(5000);
digitalWrite(relaisK[1], HIGH);
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK4/Etat", "0");
}
}
else if (payload[0] == '0'){ // Si le relais est a 1 on le passe a 0 et on comfime l'etat
digitalWrite(relaisK[1], HIGH);
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK4/Etat", "0");
}
}
/* Topic relais K5 */
if (topicStr == "Arduino_Chauffage/Relais/RelaisK5")
{
if(payload[0] == '1'){ // Si le relais est a 0 on le passe a 1 et on confirme l'etat
digitalWrite(relaisK[2], LOW);
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK5/Etat", "1");
}
else if (payload[0] == '0'){ // Si le relais est a 1 on le passe a 0 et on comfime l'etat
digitalWrite(relaisK[2], HIGH);
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK5/Etat", "0");
}
}
/* Topic relais K6 */
if (topicStr == "Arduino_Chauffage/Relais/RelaisK6")
{
if(payload[0] == '1'){ // Si le relais est a 0 on le passe a 1 et on confirme l'etat
digitalWrite(relaisK[3], LOW);
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK6/Etat", "1");
}
else if (payload[0] == '0'){ // Si le relais est a 1 on le passe a 0 et on comfime l'etat
digitalWrite(relaisK[3], HIGH);
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK6/Etat", "0");
}
}
/* Topic relais K7 */
if (topicStr == "Arduino_Chauffage/Relais/RelaisK7")
{
if(payload[0] == '1'){ // Si le relais est a 0 on le passe a 1 et on confirme l'etat
digitalWrite(relaisK[4], LOW);
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK7/Etat", "1");
}
else if (payload[0] == '0'){ // Si le relais est a 1 on le passe a 0 et on comfime l'etat
digitalWrite(relaisK[4], HIGH);
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK7/Etat", "0");
}
}
/* Topic relais K8 */
if (topicStr == "Arduino_Chauffage/Relais/RelaisK8")
{
if(payload[0] == '1'){ // Si le relais est a 0 on le passe a 1 et on confirme l'etat
digitalWrite(relaisK[5], LOW);
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK8/Etat", "1");
}
else if (payload[0] == '0'){ // Si le relais est a 1 on le passe a 0 et on comfime l'etat
digitalWrite(relaisK[5], HIGH);
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK8/Etat", "0");
}
}
/* Topic relais K9 */
if (topicStr == "Arduino_Chauffage/Relais/RelaisK9")
{
if(payload[0] == '1'){ // Si le relais est a 0 on le passe a 1 et on confirme l'etat
digitalWrite(relaisK[6], LOW);
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK9/Etat", "1");
}
else if (payload[0] == '0'){ // Si le relais est a 1 on le passe a 0 et on comfime l'etat
digitalWrite(relaisK[6], HIGH);
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK9/Etat", "0");
}
}
/* Topic relais K10 */
if (topicStr == "Arduino_Chauffage/Relais/RelaisK10")
{
if(payload[0] == '1'){ // Si le relais est a 0 on le passe a 1 et on confirme l'etat
digitalWrite(relaisK[7], LOW);
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK10/Etat", "1");
}
else if (payload[0] == '0'){ // Si le relais est a 1 on le passe a 0 et on comfime l'etat
digitalWrite(relaisK[7], HIGH);
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK10/Etat", "0");
}
}
/* Topic relais K11 */
if (topicStr == "Arduino_Chauffage/Relais/RelaisK11")
{
if(payload[0] == '1'){ // Si le relais est a 0 on le passe a 1 et on confirme l'etat
digitalWrite(relaisK[8], LOW);
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK11/Etat", "1");
}
else if (payload[0] == '0'){ // Si le relais est a 1 on le passe a 0 et on comfime l'etat
digitalWrite(relaisK[8], HIGH);
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK11/Etat", "0");
}
}
/* Topic relais K12 */
if (topicStr == "Arduino_Chauffage/Relais/RelaisK12")
{
if(payload[0] == '1'){ // Si le relais est a 0 on le passe a 1 et on confirme l'etat
digitalWrite(relaisK[9], LOW);
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK12/Etat", "1");
}
else if (payload[0] == '0'){ // Si le relais est a 1 on le passe a 0 et on comfime l'etat
digitalWrite(relaisK[9], HIGH);
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK12/Etat", "0");
}
}
/* Topic relais K13 */
if (topicStr == "Arduino_Chauffage/Relais/RelaisK13")
{
if(payload[0] == '1'){ // Si le relais est a 0 on le passe a 1 et on confirme l'etat
digitalWrite(relaisK[10], LOW);
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK13/Etat", "1");
}
else if (payload[0] == '0'){ // Si le relais est a 1 on le passe a 0 et on comfime l'etat
digitalWrite(relaisK[10], HIGH);
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK13/Etat", "0");
}
}
/* Topic relais Hall */
if (topicStr == "Arduino_Chauffage/Relais/RelaisHall")
{
if(payload[0] == '1'){ // Si le relais est a 0 on le passe a 1 et on confirme l'etat
digitalWrite(relaisK[4], LOW);
digitalWrite(relaisK[5], LOW);
digitalWrite(relaisK[6], LOW);
digitalWrite(relaisK[7], LOW);
mqttClient.publish("Arduino_Chauffage/Relais/RelaisHall/Etat", "1");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK7/Etat", "1");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK8/Etat", "1");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK9/Etat", "1");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK10/Etat", "1");
}
else if (payload[0] == '0'){ // Si le relais est a 1 on le passe a 0 et on comfime l'etat
digitalWrite(relaisK[4], HIGH);
digitalWrite(relaisK[5], HIGH);
digitalWrite(relaisK[6], HIGH);
digitalWrite(relaisK[7], HIGH);
mqttClient.publish("Arduino_Chauffage/Relais/RelaisHall/Etat", "0");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK7/Etat", "0");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK8/Etat", "0");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK9/Etat", "0");
mqttClient.publish("Arduino_Chauffage/Relais/RelaisK10/Etat", "0");
}
}
}
Merci a ceux qui vont prendre le temps de m'aider
Bonne journée