Bonjour, j'ai un programme d'arrosage pour Arduino uno qui me permet de géré 3 électrovannes et une pompe commune avec pour chaque vanne trois programmation horaire d'arrosage par vanne , avec la possibilité d'arroser 3 fois ou 2 ou 1 fois par jour, de définir le taux humidité pour déterminé si il pleut et de savoir si malgré la pluie il faux arrosé. Mais la je bloque sur comment déterminé les jours ou combien de jours et quel jours je dois arrosé. Si quelqu'un a une piste une idée, je suis preneur !
Il y a des moment ou il ne faut pas hésité à demandé de l'aide.
La meilleure façon de connaître le jour/la date/l'heure est d'utiliser une RTC (horloge en temps réel). Montrez votre code.
Post mis dans la mauvaise section, on parle anglais dans les forums généraux, je viens de déplacer le post dans la section francophone.
Merci de prendre en compte les recommandations listées dans "Les bonnes pratiques du Forum Francophone".
Pour gérer l'heure et la date il y a la librairie Time
Après, tu as effectivement entre autre le composant RTC, qui permet de sauvegarder la date et l'heure, même si tu éteins ton Arduino.
Tu es sur Uno, donc a moins que ce soit sur une MKR avec des fonctionnalité Wifi ou Ethernet, le RTC est le moyen le plus simple de garder la date et ne pas avoir l'heure qui dérive rapidement.
Pour faire des différences de jours, je crois qu'avec cette libraire il n'y a pas de fonction dédié, mais tu peux faire une différence de deux date et avoir la différence en seconde, il suffit alors de diviser ce nombre par (60 * 60 * 24=86400).
Tu peux aussi ajouter 86400 à la date du jours, pour savoir quand tu veux déclencher un nouvel arrosage.
Tu peux aussi t'aider d'une IA générative, pour te conseiller des méthodes possibles et lui demander de comparer différente approche.
Bonjour,
Avec un RTC DS3231 et le librairie qui va chaque jour de la semaine correspond à un numéro de 0à 7. Tu pourras facilement choisir tes jours d'arrosage. Prends bien un DS3231 et non un 1307. Les 1307 ont trop de dérive dans le temps
Nico
Merci !
1 Like
Merci salocin90 pour ta réactivité , je pense que par la suite je changerais mon module RTC 1307 par celui que tu me conseille.
Mais mon problème n'ai pas là, j'ai du mal expliqué, alors voici mon tableau de donné
for (int N_Vanne = 0; N_Vanne < QteVannes; N_Vanne++) {
switch (N_Vanne) {
case (0): // Vanne 1
Cfg_Vanne[N_Vanne][0] = 700; // 1 ère heure d'arrosage
Cfg_Vanne[N_Vanne][1] = 710; // 2 ème heure d'arrosage
Cfg_Vanne[N_Vanne][2] = 720; // 3 ème heure d'arrosage
Cfg_Vanne[N_Vanne][3] = 1; // Durée d'arrosage en minutes
Cfg_Vanne[N_Vanne][4] = 90; // Indice d'humidité pour définir si il 'pleut'
Cfg_Vanne[N_Vanne][5] = 0; // A 1 l'arrosage ce fait malgrée la pluie (ex plantes interieur)
Cfg_Vanne[N_Vanne][6] = 0; // Drapeau du Prog Horaire 1
Cfg_Vanne[N_Vanne][7] = 0; // Drapeau du Prog Horaire 2
Cfg_Vanne[N_Vanne][8] = 0; // Drapeau du Prog Horaire 3
Cfg_Vanne[N_Vanne][9] = (0,2,4,6); // N° des jours d'arrosage
break;
et la ligne qui m'intéresse est
Cfg_Vanne[N_Vanne][9] = (0,2,4,6);
qui correspond au jours ou je veux arrosé, à savoir qu'il y a 4 paramètres mais on aurait put que 2 ou 7 paramètres, parce que chaque plante ou potager ou etc est différent et que de ce fait l'arrosage aussi. mon idée est de crée un tableau tampon et de le passé par une boucle for en fonction du nombre de paramètre dans ma case et de comparer ensuite avec un if au numéro du jour
Merci terwal pour ces information, j'utilise déjà Time, mon programme fonctionne déjà pour tous les jours, et ce que je veux c'est programmer des jours différant pour chaque vanne.
Voici mon tableau de donné
switch (N_Vanne) {
case (0): // Vanne 1
Cfg_Vanne[N_Vanne][0] = 700; // 1 ère heure d'arrosage
Cfg_Vanne[N_Vanne][1] = 710; // 2 ème heure d'arrosage
Cfg_Vanne[N_Vanne][2] = 720; // 3 ème heure d'arrosage
Cfg_Vanne[N_Vanne][3] = 1; // Durée d'arrosage en minutes
Cfg_Vanne[N_Vanne][4] = 90; // Indice d'humidité pour définir si il 'pleut'
Cfg_Vanne[N_Vanne][5] = 0; // A 1 l'arrosage ce fait malgrée la pluie (ex plantes interieur)
Cfg_Vanne[N_Vanne][6] = 0; // Drapeau du Prog Horaire 1
Cfg_Vanne[N_Vanne][7] = 0; // Drapeau du Prog Horaire 2
Cfg_Vanne[N_Vanne][8] = 0; // Drapeau du Prog Horaire 3
Cfg_Vanne[N_Vanne][9] = (0,2,4,6); // N° des jours d'arrosage
break;
et la ligne qui m'intéresse est
Cfg_Vanne[N_Vanne][9] = (0,2,4,6);
qui correspond au jours ou je veux arrosé, à savoir qu'il y a 4 paramètres mais on aurait put que 2 ou 7 paramètres, parce que chaque plante ou potager ou etc est différent et que de ce fait l'arrosage aussi. mon idée est de crée un tableau tampon et de le passé par une boucle for en fonction du nombre de paramètre dans ma case et de comparer ensuite avec un if au numéro du jour
Cette ligne n'est pas correcte. Tu ne postes pas le code entier, donc on ne sait pas de quel type est le tableau Cfg. Je suppose que ce sont des int. Ca colle avec le reste, mais là ce n'est pas possible d'écrire ça.
Tu devrais utiliser une structure ou plutôt un tableau de structures. Par exemple :
struct ConfigVanne{
int heure1;
int heure2;
int heure3;
int duree;
int humidite;
bool forcer;
bool progH1;
bool progH2;
bool progH3;
int jours[7];
};
Tu l'utilises comme ceci :
struct ConfigVanne vanne[3];
vanne[0].heure1 = 700;
vanne[0].heure2 = 710;
etc.
A tester...
Merci LESEPT pour cette réponse, je pense pouvoir gagné quelque octets avec cette structures de tableau, le C est nouveau pour moi, j'ai l'impression d'écrire du basic, d'où la structure de mon code. Enfin malgré tout il fonctionne.
Alors voici mon code dans son intégralité, et si tu as d'autre idée sur des choses que j'aurais mal écris et qui pourrais m'aidé afin de pouvoir enrichir mon code avec d'autre fonction je suis preneur !
/*
Systeme d'arrosage sketch
*/
/*
Voir le schema de principe pour le système d'arrosage automatique de jardinière
09/04/2014 - Base Écrit par Michael Shiloh extrait du livre (Démarrez avec ARDUINO 3è édition)
02/07/2024 - Ré écrit par Carlos Moreira Da Silva
1) Lors de l'affichage des heures de MARCHE ,
sont convertir en heures et minutes : 12:37 ce lis => (12*60)+37 = 757 mn
2) Possibilité de configuré le seuil d'humidité pour chaque vanne
3) Mettre les broches numériques en sortie
4) fonction printSettings () a remplacer par la suite sur ecran LCD
5) Ajouté une sd card pour la programmation de l'arrosage.
*/
#include <Wire.h> // Wire library, used by RTC library
#include <RTClib.h> // RTC library
#include <DHT.h> // DHT temperature/humidity sensor library
//#include <SD.h> // Carte SD
//#include <SPI.h>
// -------------------------------------------------------
// Analog pin usage
// -------------------------------------------------------
//int BalplusPin = A0;
//int BalMoinsPin = A3;
const int RTC_5V_PIN = A4; // A3;
const int RTC_GND_PIN = A5; // A2;
// -------------------------------------------------------
// Digital pin usage
// -------------------------------------------------------
const int DHT_PIN = 2; // Capteur temperature/humidité relative
const int E_Vanne_1_PIN = 4; //8
const int E_Vanne_2_PIN = 5; //7
const int E_Vanne_3_PIN = 6; //4
const int Pompe_PIN = 7; //6?8
const int chipSelect = 10;
const int QteVannes = 3; // Nombre total de Vannes
const int QteHeuresProg = 3; // Quantité de cycles d'arrosage par vanne
const char *daysArray[] = {"Dimanche", "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi"};
// -------------------------------------------------------
// Tableau des heures MARCHE de chaque Vanne
// Stock les heures en minutes depuis 00:00
// Pour faciliter les calculs
// -------------------------------------------------------
int Cfg_Vanne[QteVannes][10]; // Cfg_Vanne[QteVannes][Nombre de parametre] = converti en minute : Hrs*60+mn
// 1ère heure,2ème heure,3ème heure, durée en minute, Definition de la pluie, Arrosage même si il pleut, Flagx3
int Tabl_Vannes[QteVannes];
// -------------------------------------------------------
// Numero des colonnes d'heures MARCHE/arrêt
// -------------------------------------------------------
#define DHTTYPE DHT11
DHT dht(DHT_PIN, DHTTYPE); // Crée un "objet" capteur DHT
RTC_DS1307 rtc; // Crée un "objet" horloge RTC
// -------------------------------------------------------
// Déclaration des variables globales
// -------------------------------------------------------
DateTime dateTimeNow; // stock les résultats du RTC
float humidityNow; // stock le résultat d'humidité du capteur DHT11
void setup() {
// -------------------------------------------------------
// Définition du 5V et de la masse du RTC
// -------------------------------------------------------
pinMode(RTC_5V_PIN, OUTPUT);
pinMode(RTC_GND_PIN, OUTPUT);
digitalWrite(RTC_5V_PIN, HIGH);
digitalWrite(RTC_GND_PIN, LOW);
// Initialise la librairie wire
#ifdef AVR
Wire.begin();
#else
// Shield I2C pins connect to alt I2C bus on Arduino Due
Wire1.begin();
#endif
rtc.begin(); // Initialize the RTC object
dht.begin(); // Initialize the DHT object
Serial.begin(9600); // Initialize the Serial object
// Définir les numéros de broche de la vanne
//dans le tableau
Tabl_Vannes[0] = E_Vanne_1_PIN;
Tabl_Vannes[1] = E_Vanne_2_PIN;
Tabl_Vannes[2] = E_Vanne_3_PIN;
//
// et les définir toutes en sorties
for (int N_Vanne = 0; N_Vanne < QteVannes; N_Vanne++) {
pinMode(Tabl_Vannes[N_Vanne], OUTPUT); //en sortie
}
/*for (int N_Vanne = 0; N_Vanne < QteVannes; N_Vanne++) {
digitalWrite(Tabl_Vannes[N_Vanne], HIGH);//HIGH TEST AU DEMARAGE POSITION ON
}*/
for (int N_Vanne = 0; N_Vanne < QteVannes; N_Vanne++) {
digitalWrite(Tabl_Vannes[N_Vanne], LOW);//LOW TEST AU DEMARAGE POSITION OFF
}
pinMode(Pompe_PIN, OUTPUT);
digitalWrite(Pompe_PIN, LOW);
// Parametre par default
for (int N_Vanne = 0; N_Vanne < QteVannes; N_Vanne++) {
switch (N_Vanne) {
case (0): // Vanne 1
Cfg_Vanne[N_Vanne][0] = 700; // 1 ère heure d'arrosage
Cfg_Vanne[N_Vanne][1] = 710; // 2 ème heure d'arrosage
Cfg_Vanne[N_Vanne][2] = 720; // 3 ème heure d'arrosage
Cfg_Vanne[N_Vanne][3] = 1; // Durée d'arrosage en minutes
Cfg_Vanne[N_Vanne][4] = 90; // Indice d'humidité pour définir si il 'pleut'
Cfg_Vanne[N_Vanne][5] = 0; // A 1 l'arrosage ce fait malgrée la pluie (ex plantes interieur)
Cfg_Vanne[N_Vanne][6] = 0; // Drapeau du Prog Horaire 1
Cfg_Vanne[N_Vanne][7] = 0; // Drapeau du Prog Horaire 2
Cfg_Vanne[N_Vanne][8] = 0; // Drapeau du Prog Horaire 3
Cfg_Vanne[N_Vanne][9] = (0,2,4,6); // N° des jours d'arrossage
break;
case (1): // Vanne 2
Cfg_Vanne[N_Vanne][0] = 800;
Cfg_Vanne[N_Vanne][1] = 810;
Cfg_Vanne[N_Vanne][2] = 820;
Cfg_Vanne[N_Vanne][3] = 1;
Cfg_Vanne[N_Vanne][4] = 90;
Cfg_Vanne[N_Vanne][5] = 0;
Cfg_Vanne[N_Vanne][6] = 0; //Prog Horaire 1
Cfg_Vanne[N_Vanne][7] = 0; //Prog Horaire 2
Cfg_Vanne[N_Vanne][8] = 0; //Prog Horaire 3
Cfg_Vanne[N_Vanne][9] = 1; //Jour d'arrossage
break;
case (2): // Vanne 3
Cfg_Vanne[N_Vanne][0] = 900;
Cfg_Vanne[N_Vanne][1] = 910;
Cfg_Vanne[N_Vanne][2] = 920;
Cfg_Vanne[N_Vanne][3] = 3;
Cfg_Vanne[N_Vanne][4] = 90;
Cfg_Vanne[N_Vanne][5] = 0;
Cfg_Vanne[N_Vanne][6] = 0; //Prog Horaire 1
Cfg_Vanne[N_Vanne][7] = 0; //Prog Horaire 2
Cfg_Vanne[N_Vanne][8] = 0; //Prog Horaire 3
Cfg_Vanne[N_Vanne][9] = 5,7; //Jour d'arrossage
break;
}
}
}
//------------------------------------------------------------------------------------------
void loop() {
// Rappeler brièvement l'utilisateur les commandes possibles
Serial.println("Tapez 'L' pour afficher les heures d'arrosage");
Serial.println("M pour voir la programmation");
Serial.println("P pour programmer les heures et les conditions d'arrosage");
Serial.println("Mode de programmation");
Serial.println("P0A06:45B10:30C20:00D5E68F1");
delay(100);
// Récupère (et affiche) la date, l'heure, température et humidité
ExtractionHrsTempHumidite();
// Vérifier la demande de l'utilisateur
Interaction_Utilisateur();
// Vérifiez s'il est temps d'activer ou de désactiver une vanne On/Off
checkTimeControlNvannes();
// Pas besoin de le faire trop souvent
delay(2000);
}
/*
*Obtenez et affichez la date, l'heure,
* humidité et température
*/
void ExtractionHrsTempHumidite() {
// Obtenez et affichez l'heure actuelle
dateTimeNow = rtc.now();
if (!rtc.isrunning()) {
Serial.println("RTC ne fonctionne pas!");
/* utilise ceci pour régler le RTC sur la date et l'heure
une fois le code compilé et téléverser
remettre la LIGNE ci dessous en commentaire */
////rtc.adjust(DateTime(__DATE__, __TIME__));
rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
return; // si le RTC ne fonctionne pas, ne continuez pas
}
Serial.print(daysArray[dateTimeNow.dayOfTheWeek()]); // Affiche Dimanche pour indice 0.
Serial.print(" ");
Serial.print(dateTimeNow.day(), DEC);
Serial.print('/');
Serial.print(dateTimeNow.month(), DEC);
Serial.print('/');
Serial.print(dateTimeNow.year(), DEC);
Serial.print(" - ");
Serial.print(dateTimeNow.hour(), DEC);
Serial.print(':');
Serial.print(dateTimeNow.minute(), DEC);
Serial.print(':');
Serial.println(dateTimeNow.second(), DEC);
Serial.print("Numéro du jour: ");
Serial.print(dateTimeNow.dayOfTheWeek()); // Retourne O et non pas 1 pour dimanche !
Serial.println();
// Obtenez et affichez la température et l'humidité actuelles
humidityNow = dht.readHumidity();
//Lire la température en Celsius
float t = dht.readTemperature();
// Lire la température en Fahrenheit
float f = dht.readTemperature(true);
// Vérifiez si les lectures ont échoué et quittez tôt (pour réessayer).
if (isnan(humidityNow) || isnan(t) || isnan(f)) {
Serial.println("Impossible de lire partir du capteur DHT!");
return; // si le DHT ne fonctionne pas, ne continuez pas;
}
Serial.print("Humidité ");
Serial.print(humidityNow);
Serial.print("% ");
Serial.print("Température ");
Serial.print(t);
Serial.print(" C° ");
//Serial.print(f);
//Serial.print(" F° ");
Serial.println();
} //fin de ExtractionHrsTempHumidite()
void ControleDeLaPompe(){
// Verifie si au moins une des 3 vannes est en service
int Pin1=0;
int Pin2=0;
int Pin3=0;
int Etat_Vannes=0;
int x = 0;
if (digitalRead(Tabl_Vannes[0]) != HIGH && digitalRead(Tabl_Vannes[1]) != HIGH && digitalRead(Tabl_Vannes[2])!= HIGH){
Pin1 = digitalRead(Tabl_Vannes[0]);
Pin2 = digitalRead(Tabl_Vannes[1]);
Pin3 = digitalRead(Tabl_Vannes[2]);
if (Pin1 != HIGH && Pin2 != HIGH && Pin3!= HIGH){
digitalWrite(Pompe_PIN,LOW); //arret de la pompe
}
}
}
/*
* Vérifiez l'interaction de l'utilisateur, qui sera sous la forme de
* quelque chose tapé sur le moniteur en série
* S'il y a quelque chose, assurez-vous que c'est correct, et effectuez la
* demande d'action
*/
void Interaction_Utilisateur() {
// Vérifier l'interaction de l'utilisateur
while (Serial.available() > 0) {
/* Le premier caractère nous dit quoi s'attendre
pour le reste de la ligne */
char temp = Serial.read();
/* Si le premier caractère est 'L' alors
affiche les paramètres actuels
et sort de la boucle while ()*/
if (temp == 'L' || temp =='l') {
ProgTimeDefaut();
//printSettings();
Serial.flush();
break;
} // fin des paramètres actuels d'affichage
// Si le premier caractère est 'P' alors le reste sera un paramètre
else if (temp == 'P' || temp =='p') {
Attente_Cfg_Vanne(); //Config
}
// Si le premier caractère est 'M' alors le reste sera un paramètre
else if (temp == 'M' || temp =='m') {
//printSettings();
ProgTimeDefaut(); //affiche la Config
}
// Si le premier caractère est 'R' alors le reste sera un paramètre
else if (temp == 'R') {
dateTimeNow = rtc.now();
Serial.println("RESET du RTC");
/* utilise ceci pour régler le RTC sur la date et l'heure */
rtc.adjust(DateTime(__DATE__, __TIME__));
} else {
printMenu();
Serial.flush();
break;
}
} // fin du traitement de l'interaction de l'utilisateur
}
/*
* Lire une chaîne du formulaire "2N13: 45" et le séparer
* dans le numéro de la vanne, la lettre indiquant ON ou OFF,
* et l'heure
*/
void Attente_Cfg_Vanne() {
// decodage de la chaine de caractere de la liaison série
// Le premier nombre entier devrait être le numéro de la pompe
int N_VanneNumber = Serial.parseInt();
// le prochain caractère devrait être A
char HeureA = Serial.read();
// l'heure devrait venir
int Heure1 = Serial.parseInt();
// le prochain caractère devrait être ':'
if (Serial.read() != ':') {
Serial.println("non trouver (:) "); // Verification
Serial.flush();
return;
}
// prochaine devrait venir les minutes
int Minutes1 = Serial.parseInt();
//--------------------------------------
// le prochain caractère devrait être B
char HeureB = Serial.read();
// l'heure devrait venir
int Heure2 = Serial.parseInt();
// le prochain caractère devrait être ':'
if (Serial.read() != ':') {
Serial.println("non trouver (:) "); // Verification
Serial.flush();
return;
}
// prochaine devrait venir les minutes
int Minutes2 = Serial.parseInt();
//--------------------------------------
// le prochain caractère devrait être C
char HeureC = Serial.read();
// l'heure devrait venir
int Heure3 = Serial.parseInt();
// le prochain caractère devrait être ':'
if (Serial.read() != ':') {
Serial.println("non trouver (:) "); // Verification
Serial.flush();
return;
}
// prochaine devrait venir les minutes
int Minutes3 = Serial.parseInt();
//--------------------------------------
// le prochain caractère devrait être D
char DRain = Serial.read();
// durée d'arrosage pour chaque plage horaire
int DureeRain = Serial.parseInt();
//--------------------------------------
// le prochain caractère devrait être E
char TxHumidite = Serial.read();
// Définition du taux humidité pour definir si il pleut
int TauxHumidite = Serial.parseInt();
//--------------------------------------
// le prochain caractère devrait être F
char ONRain = Serial.read();
// definir si il faut arrosé en si il pleut
int YesNoRain = Serial.parseInt();
//--------------------------------------
/* enfin attendre une nouvelle ligne qui est la fin de
la phrase:
*/
if (Serial.read() == '\n') { // Verification
Serial.println(
"Assurez-vous de validez votre demande <-' ");
Serial.flush();
return;
}
/* Convertir l'heure et la minute désirées
* au nombre de minutes écoulées depuis minuit
* Maintenant que nous avons toutes les informations dans le tableau
* dans la ligne et la colonne correctes
*/
if (HeureA == 'A') {
Cfg_Vanne[N_VanneNumber][0] = (Heure1 * 60 + Minutes1);
Cfg_Vanne[N_VanneNumber][1] = (Heure2 * 60 + Minutes2);
Cfg_Vanne[N_VanneNumber][2] = (Heure3 * 60 + Minutes3);
Cfg_Vanne[N_VanneNumber][3] = DureeRain;
Cfg_Vanne[N_VanneNumber][4] = TauxHumidite;
Cfg_Vanne[N_VanneNumber][5] = YesNoRain;
} else { // l'utilisateur n'a pas utilisé A,B ou C
Serial.print("Vous devez utiliser des majuscules A, B ou C ");
Serial.println("pour indiquer l'heure 1ère, 2ème ou 3ème Programmation d'arrosage");
Serial.flush();
return;
}
// maintenant imprimer l'ensemble du tableau afin que l'utilisateur puisse voir ce qu'il a définit
printSettings();
} // fin de Attente_Cfg_Vanne()
void printSettings() {
/* Affiche les paramètres de MARCHE et d'Arrêt actuels, en convertissant
nombre de minutes écoulées depuis minuit jusqu' l'heure en heures et minutes
*/
for (int N_Vanne = 0; N_Vanne < QteVannes; N_Vanne++) {
Serial.println();
Serial.print("Pompe (");
Serial.print(N_Vanne + 1);
Serial.print(") l'arrosage commence ");
// division entière par 60 donne les heures
// puisque la division entière supprime tout reste
Serial.print((Cfg_Vanne[N_Vanne][0]) / 60);
Serial.print(":");
// les minutes sont le reste après avoir divisé par 60.
// récupère le reste avec l'opérateur modulo (%)
Serial.print((Cfg_Vanne[N_Vanne][0]) % (60));
Serial.print(" et s'arretera : ");
int HeureStop = (Cfg_Vanne[N_Vanne][0] + Cfg_Vanne[N_Vanne][3]);
Serial.print(HeureStop / 60);
Serial.print(":");
Serial.print((HeureStop) % (60));
Serial.println();
}
// END printSettings
}
void ProgTimeDefaut() {
//faire un select case pas de if
Serial.println("Programmation par defaut des horaires d'arrosage");
Serial.println("------------------------------------------------");
for (int N_Vanne = 0; N_Vanne < QteVannes; N_Vanne++) {
for (int TabProg = 0; TabProg < 6; TabProg++) {
Serial.println();
Serial.print("Vanne (");
Serial.print(N_Vanne + 1);
Serial.print(", ");
Serial.print(TabProg);
switch (TabProg)
{
case 0:
Serial.print(") ");
Serial.print(TabProg + 1);
Serial.print(" ère heure = ");
Serial.print((Cfg_Vanne[N_Vanne][TabProg]) / 60); //Heures
Serial.print(":");
Serial.print((Cfg_Vanne[N_Vanne][TabProg]) % (60)); // minutes
Serial.println();
break;
case 1:
Serial.print(") ");
Serial.print(TabProg + 1);
Serial.print(" ème heure = ");
Serial.print((Cfg_Vanne[N_Vanne][TabProg]) / 60); //Heures
Serial.print(":");
Serial.print((Cfg_Vanne[N_Vanne][TabProg]) % (60)); // minutes
Serial.println();
break;
case 2:
Serial.print(") ");
Serial.print(TabProg + 1);
Serial.print(" ème heure = ");
Serial.print((Cfg_Vanne[N_Vanne][TabProg]) / 60); //Heures
Serial.print(":");
Serial.print((Cfg_Vanne[N_Vanne][TabProg]) % (60)); // minutes
Serial.println();
break;
case 3:
Serial.print(") durée d'arrosage = ");
Serial.print(Cfg_Vanne[N_Vanne][TabProg]);
Serial.println();
break;
case 4:
Serial.print(") Taux d'humidité = ");
Serial.print(Cfg_Vanne[N_Vanne][TabProg]);
Serial.println();
break;
case 5:
Serial.print(") MODE PLUIE = ");
if (Cfg_Vanne[N_Vanne][TabProg] != 0) {
Serial.print(" AVEC ");
Serial.println();
} else {
Serial.print(" SANS ");
Serial.println();
}
break;
}
}
}
Serial.println("-----------------------------------------");
}
void checkTimeControlNvannes() {
/* Déterminez combien de minutes se sont écoulées
depuis minuit. le plus grand nombre sera 2359 qui est
23 * 60 + 59 = 1439 ce qui est inférieur au
maximum qui peut être stocké dans un entier de sorte qu'un
int est assez grand
*/
int NowMinutesDepuisMinuit =
(dateTimeNow.hour() * 60) + dateTimeNow.minute(); // Détermine l'heure qu'il est pour comparaison avec la Configuration de l'arrosage
for (int N_Vanne = 0; N_Vanne < QteVannes; N_Vanne++) {
for (int P_Vanne = 0; P_Vanne < QteHeuresProg; P_Vanne++) {
if ((Cfg_Vanne[N_Vanne][P_Vanne]) != 0 ) {
if ((NowMinutesDepuisMinuit >= Cfg_Vanne[N_Vanne][P_Vanne]) && (NowMinutesDepuisMinuit < (Cfg_Vanne[N_Vanne][P_Vanne] + Cfg_Vanne[N_Vanne][3]))) {
// Je verifie si il pleut
if (humidityNow > Cfg_Vanne[N_Vanne][4]){ // si oui = il pleut
if (Cfg_Vanne[N_Vanne][5] == 1) { //si oui = Arrosage forcé
if (Cfg_Vanne[N_Vanne][P_Vanne + 6] != 1) {
Serial.println();Serial.print("Vanne n° ");Serial.print(N_Vanne + 1);Serial.print(" Ouverte - Prog Horaire :");Serial.print(P_Vanne + 1);Serial.println();
digitalWrite(Tabl_Vannes[N_Vanne], HIGH); // Vanne ouverte
Cfg_Vanne[N_Vanne][P_Vanne + 6] = 1;
digitalWrite(Pompe_PIN, HIGH); // POMPE MARCHE
ControleDeLaPompe(); // Vérifie si au moins une des 3 vannes est en service
}
} else {
if (humidityNow > Cfg_Vanne[N_Vanne][4]){ // si oui = il pleut
Serial.println();
Serial.print("L5750 - La pluie est la");
}
Cfg_Vanne[N_Vanne][(P_Vanne + 6)] = 0 ;
switch((P_Vanne + 6)){
case 6:
if (Cfg_Vanne[N_Vanne][7] == 0 && Cfg_Vanne[N_Vanne][8] == 0){
digitalWrite(Tabl_Vannes[N_Vanne],LOW); //ARRET
Serial.println();Serial.print("Vanne n° ");Serial.print(N_Vanne + 1);Serial.print(" Fermé - Prog Horaire :");Serial.print(P_Vanne + 1);Serial.println();
}
break;
case 7:
if (Cfg_Vanne[N_Vanne][6] == 0 && Cfg_Vanne[N_Vanne][8] == 0){
digitalWrite(Tabl_Vannes[N_Vanne],LOW); //ARRET
Serial.println();Serial.print("Vanne n° ");Serial.print(N_Vanne + 1);Serial.print(" Fermé - Prog Horaire :");Serial.print(P_Vanne + 1);Serial.println();
}
break;
case 8:
if (Cfg_Vanne[N_Vanne][6] == 0 && Cfg_Vanne[N_Vanne][7] == 0){
digitalWrite(Tabl_Vannes[N_Vanne],LOW); //ARRET
Serial.println();Serial.print("Vanne n° ");Serial.print(N_Vanne + 1);Serial.print(" Fermé - Prog Horaire :");Serial.print(P_Vanne + 1);Serial.println();
}
break;
}
Cfg_Vanne[N_Vanne][P_Vanne + 6] = 0 ;
ControleDeLaPompe(); // Vérifie si au moins une des 3 vannes est en service avant d'arreter la pompe
} // FIN DE Il pleut, je n'arrose pas
} else { // Il ne pleut pas, c'est l'heure d'arroser
if (Cfg_Vanne[N_Vanne][P_Vanne + 6] != 1 ){
Serial.println();
Serial.print (" MARCHE Vanne n°");Serial.print(Cfg_Vanne[N_Vanne][P_Vanne]);
Serial.println();Serial.print("Vanne n° ");Serial.print(N_Vanne + 1);Serial.print(" Ouverte - Prog Horaire :");Serial.print(P_Vanne + 1);Serial.println();
digitalWrite(Tabl_Vannes[N_Vanne], HIGH); //OUVERTURE
digitalWrite(Pompe_PIN, HIGH); //MARCHE
Cfg_Vanne[N_Vanne][P_Vanne + 6 ] = 1;
Serial.println();
ControleDeLaPompe();
}
}
} else { //Ce n'est pas l'heure d'arrosé
if (humidityNow > Cfg_Vanne[N_Vanne][4]){ // si oui = il pleut
}
Cfg_Vanne[N_Vanne][(P_Vanne + 6)] = 0 ;
switch((P_Vanne + 6)){
case 6:
if (Cfg_Vanne[N_Vanne][7] == 0 && Cfg_Vanne[N_Vanne][8] == 0){
digitalWrite(Tabl_Vannes[N_Vanne],LOW); //ARRET
Serial.println();Serial.print("Vanne n° ");Serial.print(N_Vanne + 1);Serial.print(" Fermé - Prog Horaire :");Serial.print(P_Vanne + 1);Serial.println();
}
break;
case 7:
if (Cfg_Vanne[N_Vanne][6] == 0 && Cfg_Vanne[N_Vanne][8] == 0){
digitalWrite(Tabl_Vannes[N_Vanne],LOW); //ARRET
Serial.println();Serial.print("Vanne n° ");Serial.print(N_Vanne + 1);Serial.print(" Fermé - Prog Horaire :");Serial.print(P_Vanne + 1);Serial.println();
}
break;
case 8:
if (Cfg_Vanne[N_Vanne][6] == 0 && Cfg_Vanne[N_Vanne][7] == 0){
digitalWrite(Tabl_Vannes[N_Vanne],LOW); //ARRET
Serial.println();Serial.print("Vanne n° ");Serial.print(N_Vanne + 1);Serial.print(" Fermé - Prog Horaire :");Serial.print(P_Vanne + 1);Serial.println();
}
break;
}
Cfg_Vanne[N_Vanne][P_Vanne + 6] = 0 ;
ControleDeLaPompe(); // Vérifie si au moins une des 3 vannes est en service avant d'arreter la pompe
}
}
} // fin de la boucle des programme Horaire de chaque vanne
} // Fin du controle de chaque vanne
} // Fin checkTimeControlNvannes
void printMenu() {
Serial.println(
"Veuillez entrer L pour afficher les paramètres actuels \n");
//Serial.println("Ex:Veuillez entrer P2A13:45-10 ou P2B13:45-10 pour régler l'arrosage de la pompe 2 13:45 et 10s d'arrosage");
}
Merci pour ton aide
Les lignes d'initialisation des jours d'arrosage ne sont pas bons :
Cfg_Vanne[N_Vanne][9] = (0,2,4,6);
et
Cfg_Vanne[N_Vanne][9] = 5,7;
ne font pas ce que tu imagines. Lorsque tu affiches le contenu avec
Serial.println(Cfg_Vanne[0][9]);
Serial.println(Cfg_Vanne[2][9]);
tu obtiens :
6
5
Cette ligne :
rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
sert à régler la RTC avec l'heure de compilation du code. Donc, le faire à répétition n'est pas utile, car cela règlera la RTC à la même heure continuellement !
Il faut le faire la première fois que tu compiles et ensuite, pour les autres compilations, tu peux la commenter.
Pour le reste, je n'ai pas le courage de tout lire à cette heure...
Merci, je corrigerai ça demain !
Cela dépend de ce que tu veux faire.
Tu veux arroser un jour de la semaine précis (lundi, mardi ...) ou tout les X jours.
Personnellement j'ai supposé que tu voulais la deuxième, car souvent les plantes non pas toutes le même besoin.
Si j'ai bien compris tu aurais voulu avoir une liste de jour ou tu dois activer ta vanne ?
Avec 0 pour lundi, 1 pour mardi ?
Comme l'indique @lesept cela ne marche pas aussi simplement que ce que tu voudrais faire.
Et comme il l'indique il faudrait que tu nous donne tous ton code.
Si tu veux garder le principe que tu as imaginé, le mieux est de définir un tableau de 7 éléments pour la cellule 9 comme le l'indique @lesept .
ce qui donnerais
typedef struct arrosageProp {
int premier;
int deuxieme;
int dureMn;
byte humidite;
bool force;
byte drapeau1;
byte drapeau2;
byte drapeau3;
bool jour[7];
}arrosageProp;
arrosageProp arrosage = {700, 710, 720, 1, 90, 0, 0, 0, {true, false, true, false, true, false, true}};
si tu veux économiser de la place, mais pas sûre que cela soit nécessaire, tu peux utiliser uniquement un type byte(byte jours) et faire un masque de bits.
J'ai oublié de préciser : elle doit être dans le setup, pas dans la loop.
Merci terwal et merci à tous ceux qui on pris de leur temps pour m'aidé, Mon prog n'est pas écris dans les règle de l'art et j'en suis conscient, il fonctionne comme je le souhaitai, ceux qui voudrons bien m'aider à réécrire mon code dans les règles avec les bonnes indentations, je suis preneur, cela m'aidera, à moi mais aussi à d'autre à assimilés le codage en c/c++ pour ARDUINO.
/*
Systeme d'arrosage sketch
*/
/*
Voir le schema de principe pour le système d'arrosage automatique de jardinière
09/04/2014 - Base Écrit par Michael Shiloh extrait du livre (Démarrez avec ARDUINO 3è édition)
02/07/2024 - Ré écrit par Carlos Moreira Da Silva
1) Lors de l'affichage des heures de MARCHE ,
sont convertir en heures et minutes : 12:37 ce lis => (12*60)+37 = 757 mn
2) Possibilité de configuré le seuil d'humidité pour chaque vanne
3) Mettre les broches numériques en sortie
4) fonction printSettings () a remplacer par la suite sur ecran LCD
5) Ajouté une sd card pour la programmation de l'arrosage.
*/
#include <Wire.h> // Wire library, used by RTC library
#include <RTClib.h> // RTC library
#include <DHT.h> // DHT temperature/humidity sensor library
//#include <SD.h> // Carte SD
//#include <SPI.h>
// -------------------------------------------------------
// Analog pin usage
// -------------------------------------------------------
//int BalplusPin = A0;
//int BalMoinsPin = A3;
//const int RTC_5V_PIN = A4; // A3;
//const int RTC_GND_PIN = A5; // A2;
// -------------------------------------------------------
// Digital pin usage
// -------------------------------------------------------
const int DHT_PIN = 2; // Capteur temperature/humidité relative
const int E_Vanne_1_PIN = 4; //8
const int E_Vanne_2_PIN = 5; //7
const int E_Vanne_3_PIN = 6; //4
const int Pompe_PIN = 7; //6?8
const int chipSelect = 10;
const int QteVannes = 3; // Nombre total de Vannes
const int QteHeuresProg = 3; // Quantité de cycles d'arrosage par vanne
const char *daysArray[] = { "Dimanche", "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi" };
int tempDelay = 1000;
// -------------------------------------------------------
// Tableau des heures MARCHE de chaque Vanne
// Stock les heures en minutes depuis 00:00
// Pour faciliter les calculs
// -------------------------------------------------------
int Cfg_Vanne[QteVannes][16]; // Cfg_Vanne[QteVannes][Nombre de parametre] = converti en minute : Hrs*60+mn
// 1ère heure,2ème heure,3ème heure, durée en minute, Definition de la pluie, Arrosage même si il pleut, Flagx3
int Tabl_Vannes[QteVannes];
// -------------------------------------------------------
// Numero des colonnes d'heures MARCHE/arrêt
// -------------------------------------------------------
#define DHTTYPE DHT11
DHT dht(DHT_PIN, DHTTYPE); // Crée un "objet" capteur DHT
RTC_DS1307 rtc; // Crée un "objet" horloge RTC
// -------------------------------------------------------
// Déclaration des variables globales
// -------------------------------------------------------
DateTime dateTimeNow; // stock les résultats du RTC
float humidityNow; // stock le résultat d'humidité du capteur DHT11
void setup() {
// -------------------------------------------------------
// Définition du 5V et de la masse du RTC
// -------------------------------------------------------
/*pinMode(RTC_5V_PIN, OUTPUT); // a retablir avec d'autres shield
pinMode(RTC_GND_PIN, OUTPUT);
digitalWrite(RTC_5V_PIN, HIGH);
digitalWrite(RTC_GND_PIN, LOW);
*/
// Initialise la librairie wire
#ifdef AVR
Wire.begin();
#else
// Shield I2C pins connect to alt I2C bus on Arduino Due
Wire1.begin();
#endif
rtc.begin(); // Initialize the RTC object
dht.begin(); // Initialize the DHT object
Serial.begin(9600); // Initialize the Serial object
rtc.adjust(DateTime(__DATE__, __TIME__));
// Définir les numéros de broche de la vanne
//dans le tableau
Tabl_Vannes[0] = E_Vanne_1_PIN;
Tabl_Vannes[1] = E_Vanne_2_PIN;
Tabl_Vannes[2] = E_Vanne_3_PIN;
//
// et les définir toutes en sorties
for (int N_Vanne = 0; N_Vanne < QteVannes; N_Vanne++) {
pinMode(Tabl_Vannes[N_Vanne], OUTPUT); //en sortie
}
/*for (int N_Vanne = 0; N_Vanne < QteVannes; N_Vanne++) {
digitalWrite(Tabl_Vannes[N_Vanne], HIGH);//HIGH TEST AU DEMARAGE POSITION ON
}*/
for (int N_Vanne = 0; N_Vanne < QteVannes; N_Vanne++) {
digitalWrite(Tabl_Vannes[N_Vanne], LOW); //LOW TEST AU DEMARAGE POSITION OFF
}
pinMode(Pompe_PIN, OUTPUT);
digitalWrite(Pompe_PIN, LOW);
// Parametre par default
for (int N_Vanne = 0; N_Vanne < QteVannes; N_Vanne++) {
switch (N_Vanne) {
case (0): // Vanne 1
Cfg_Vanne[N_Vanne][0] = 700; // 1 ère heure d'arrosage
Cfg_Vanne[N_Vanne][1] = 710; // 2 ème heure d'arrosage
Cfg_Vanne[N_Vanne][2] = 720; // 3 ème heure d'arrosage
Cfg_Vanne[N_Vanne][3] = 1; // Durée d'arrosage en minutes
Cfg_Vanne[N_Vanne][4] = 90; // Indice d'humidité pour définir si il 'pleut'
Cfg_Vanne[N_Vanne][5] = 0; // A 1 l'arrosage ce fait malgrée la pluie (ex plantes interieur)
Cfg_Vanne[N_Vanne][6] = 0; // Drapeau du Prog Horaire 1
Cfg_Vanne[N_Vanne][7] = 0; // Drapeau du Prog Horaire 2
Cfg_Vanne[N_Vanne][8] = 0; // Drapeau du Prog Horaire 3
Cfg_Vanne[N_Vanne][9] = 0; // arrossage le dimanche
Cfg_Vanne[N_Vanne][10] = 0; // arrossage le lundi
Cfg_Vanne[N_Vanne][11] = 1; // arrossage le mardi
Cfg_Vanne[N_Vanne][12] = 0; // arrossage le mercredi
Cfg_Vanne[N_Vanne][13] = 0; // arrossage le jeudi
Cfg_Vanne[N_Vanne][14] = 0; // arrossage le vendredi
Cfg_Vanne[N_Vanne][15] = 1; // arrossage le samedi
break;
case (1): // Vanne 2
Cfg_Vanne[N_Vanne][0] = 800;
Cfg_Vanne[N_Vanne][1] = 55;
Cfg_Vanne[N_Vanne][2] = 820;
Cfg_Vanne[N_Vanne][3] = 1;
Cfg_Vanne[N_Vanne][4] = 90;
Cfg_Vanne[N_Vanne][5] = 0;
Cfg_Vanne[N_Vanne][6] = 0; //Prog Horaire 1
Cfg_Vanne[N_Vanne][7] = 0; //Prog Horaire 2
Cfg_Vanne[N_Vanne][8] = 0; //Prog Horaire 3
Cfg_Vanne[N_Vanne][9] = 0; // arrossage le dimanche
Cfg_Vanne[N_Vanne][10] = 0; // arrossage le lundi
Cfg_Vanne[N_Vanne][11] = 1; // arrossage le mardi
Cfg_Vanne[N_Vanne][12] = 0; // arrossage le mercredi
Cfg_Vanne[N_Vanne][13] = 0; // arrossage le jeudi
Cfg_Vanne[N_Vanne][14] = 0; // arrossage le vendredi
Cfg_Vanne[N_Vanne][15] = 1; // arrossage le samedi
break;
case (2): // Vanne 3
Cfg_Vanne[N_Vanne][0] = 900;
Cfg_Vanne[N_Vanne][1] = 910;
Cfg_Vanne[N_Vanne][2] = 920;
Cfg_Vanne[N_Vanne][3] = 3;
Cfg_Vanne[N_Vanne][4] = 90;
Cfg_Vanne[N_Vanne][5] = 0;
Cfg_Vanne[N_Vanne][6] = 0; //Prog Horaire 1
Cfg_Vanne[N_Vanne][7] = 0; //Prog Horaire 2
Cfg_Vanne[N_Vanne][8] = 0; //Prog Horaire 3
Cfg_Vanne[N_Vanne][9] = 0; // arrossage le dimanche
Cfg_Vanne[N_Vanne][10] = 0; // arrossage le lundi
Cfg_Vanne[N_Vanne][11] = 1; // arrossage le mardi
Cfg_Vanne[N_Vanne][12] = 0; // arrossage le mercredi
Cfg_Vanne[N_Vanne][13] = 0; // arrossage le jeudi
Cfg_Vanne[N_Vanne][14] = 0; // arrossage le vendredi
Cfg_Vanne[N_Vanne][15] = 1; // arrossage le samedi
break;
}
}
}
//------------------------------------------------------------------------------------------
void loop() {
// Rappeler brièvement l'utilisateur les commandes possibles
Serial.println("Tapez 'L' pour afficher les heures d'arrosage");
Serial.println("M pour voir la programmation");
Serial.println("P pour programmer les heures et les conditions d'arrosage");
Serial.println("Mode de programmation");
Serial.println("P0A06:45B10:30C20:00D5E68F1");
//delay(100);
// Récupère (et affiche) la date, l'heure, température et humidité
ExtractionHrsTempHumidite();
delay(tempDelay);
// Vérifier la demande de l'utilisateur
Interaction_Utilisateur();
// Vérifiez s'il est temps d'activer ou de désactiver une vanne On/Off
checkTimeControlNvannes();
// Pas besoin de le faire trop souvent
//delay(2000);
}
/*
*Obtenez et affichez la date, l'heure,
* humidité et température
*/
void ExtractionHrsTempHumidite() {
// Obtenez et affichez l'heure actuelle
dateTimeNow = rtc.now();
if (!rtc.isrunning()) {
Serial.println("RTC ne fonctionne pas!");
/* utilise ceci pour régler le RTC sur la date et l'heure
une fois le code compilé et téléverser
remettre la LIGNE ci dessous en commentaire */
////rtc.adjust(DateTime(__DATE__, __TIME__));
//// rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
return; // si le RTC ne fonctionne pas, ne continuez pas
}
Serial.print(daysArray[dateTimeNow.dayOfTheWeek()]); // Affiche Dimanche pour indice 0.
Serial.print(" ");
Serial.print(dateTimeNow.day(), DEC);
Serial.print('/');
Serial.print(dateTimeNow.month(), DEC);
Serial.print('/');
Serial.print(dateTimeNow.year(), DEC);
Serial.print(" - ");
Serial.print(dateTimeNow.hour(), DEC);
Serial.print(':');
Serial.print(dateTimeNow.minute(), DEC);
Serial.print(':');
Serial.println(dateTimeNow.second(), DEC);
Serial.print("Numéro du jour: ");
Serial.print(dateTimeNow.dayOfTheWeek()); // Retourne O et non pas 1 pour dimanche !
Serial.println();
// Obtenez et affichez la température et l'humidité actuelles
humidityNow = dht.readHumidity();
//Lire la température en Celsius
float t = dht.readTemperature();
// Lire la température en Fahrenheit
float f = dht.readTemperature(true);
// Vérifiez si les lectures ont échoué et quittez tôt (pour réessayer).
if (isnan(humidityNow) || isnan(t) || isnan(f)) {
Serial.println("Impossible de lire partir du capteur DHT!");
return; // si le DHT ne fonctionne pas, ne continuez pas;
}
Serial.print("Humidité ");
Serial.print(humidityNow);
Serial.print("% ");
Serial.print("Température ");
Serial.print(t);
Serial.print(" C° ");
//Serial.print(f);
//Serial.print(" F° ");
Serial.println();
//delay(1000);
} //fin de ExtractionHrsTempHumidite()
void ControleDeLaPompe() {
// Verifie si au moins une des 3 vannes est en service
int Pin1 = 0;
int Pin2 = 0;
int Pin3 = 0;
int Etat_Vannes = 0;
int x = 0;
if (digitalRead(Tabl_Vannes[0]) != HIGH && digitalRead(Tabl_Vannes[1]) != HIGH && digitalRead(Tabl_Vannes[2]) != HIGH) {
Pin1 = digitalRead(Tabl_Vannes[0]);
Pin2 = digitalRead(Tabl_Vannes[1]);
Pin3 = digitalRead(Tabl_Vannes[2]);
if (Pin1 != HIGH && Pin2 != HIGH && Pin3 != HIGH) {
digitalWrite(Pompe_PIN, LOW); //arret de la pompe
}
}
}
/*
* Vérifiez l'interaction de l'utilisateur, qui sera sous la forme de
* quelque chose tapé sur le moniteur en série
* S'il y a quelque chose, assurez-vous que c'est correct, et effectuez la
* demande d'action
*/
void Interaction_Utilisateur() {
// Vérifier l'interaction de l'utilisateur
while (Serial.available() > 0) {
/* Le premier caractère nous dit quoi s'attendre
pour le reste de la ligne */
char temp = Serial.read();
/* Si le premier caractère est 'L' alors
affiche les paramètres actuels
et sort de la boucle while ()*/
if (temp == 'L' || temp == 'l') {
ProgTimeDefaut();
//printSettings();
Serial.flush();
break;
} // fin des paramètres actuels d'affichage
// Si le premier caractère est 'P' alors le reste sera un paramètre
else if (temp == 'P' || temp == 'p') {
Attente_Cfg_Vanne(); //Config
}
// Si le premier caractère est 'M' alors le reste sera un paramètre
else if (temp == 'M' || temp == 'm') {
//printSettings();
ProgTimeDefaut(); //affiche la Config
}
// Si le premier caractère est 'R' alors le reste sera un paramètre
else if (temp == 'R' || temp == 'r') {
int Delais1 = Serial.parseInt();
/*Serial.println();
Serial.print("= = = = = = = = ");
Serial.println();
Serial.print("tempDelay");Serial.print(Delais1);
Serial.println();
Serial.print("= = = = = = = = ");
Serial.println();*/
tempDelay = Delais1;
/* utilise ceci pour régler le RTC sur la date et l'heure */
//rtc.adjust(DateTime(__DATE__, __TIME__));
} else {
printMenu();
Serial.flush();
break;
}
} // fin du traitement de l'interaction de l'utilisateur
}
/*
* Lire une chaîne du formulaire "2N13: 45" et le séparer
* dans le numéro de la vanne, la lettre indiquant ON ou OFF,
* et l'heure
*/
void Attente_Cfg_Vanne() {
// decodage de la chaine de caractere de la liaison série
// Le premier nombre entier devrait être le numéro de la pompe
int N_VanneNumber = Serial.parseInt();
// le prochain caractère devrait être A
char HeureA = Serial.read();
// l'heure devrait venir
int Heure1 = Serial.parseInt();
// le prochain caractère devrait être ':'
if (Serial.read() != ':') {
Serial.println("non trouver (:) "); // Verification
Serial.flush();
return;
}
// prochaine devrait venir les minutes
int Minutes1 = Serial.parseInt();
//--------------------------------------
// le prochain caractère devrait être B
char HeureB = Serial.read();
// l'heure devrait venir
int Heure2 = Serial.parseInt();
// le prochain caractère devrait être ':'
if (Serial.read() != ':') {
Serial.println("non trouver (:) "); // Verification
Serial.flush();
return;
}
// prochaine devrait venir les minutes
int Minutes2 = Serial.parseInt();
//--------------------------------------
// le prochain caractère devrait être C
char HeureC = Serial.read();
// l'heure devrait venir
int Heure3 = Serial.parseInt();
// le prochain caractère devrait être ':'
if (Serial.read() != ':') {
Serial.println("non trouver (:) "); // Verification
Serial.flush();
return;
}
// prochaine devrait venir les minutes
int Minutes3 = Serial.parseInt();
//--------------------------------------
// le prochain caractère devrait être D
char DRain = Serial.read();
// durée d'arrosage pour chaque plage horaire
int DureeRain = Serial.parseInt();
//--------------------------------------
// le prochain caractère devrait être E
char TxHumidite = Serial.read();
// Définition du taux humidité pour definir si il pleut
int TauxHumidite = Serial.parseInt();
//--------------------------------------
// le prochain caractère devrait être F
char ONRain = Serial.read();
// definir si il faut arrosé en si il pleut
int YesNoRain = Serial.parseInt();
//--------------------------------------
/* enfin attendre une nouvelle ligne qui est la fin de
la phrase:
*/
if (Serial.read() == '\n') { // Verification
Serial.println(
"Assurez-vous de validez votre demande <-' ");
Serial.flush();
return;
}
/* Convertir l'heure et la minute désirées
* au nombre de minutes écoulées depuis minuit
* Maintenant que nous avons toutes les informations dans le tableau
* dans la ligne et la colonne correctes
*/
if (HeureA == 'A') {
Cfg_Vanne[N_VanneNumber][0] = (Heure1 * 60 + Minutes1);
Cfg_Vanne[N_VanneNumber][1] = (Heure2 * 60 + Minutes2);
Cfg_Vanne[N_VanneNumber][2] = (Heure3 * 60 + Minutes3);
Cfg_Vanne[N_VanneNumber][3] = DureeRain;
Cfg_Vanne[N_VanneNumber][4] = TauxHumidite;
Cfg_Vanne[N_VanneNumber][5] = YesNoRain;
} else { // l'utilisateur n'a pas utilisé A,B ou C
Serial.print("Vous devez utiliser des majuscules A, B ou C ");
Serial.println("pour indiquer l'heure 1ère, 2ème ou 3ème Programmation d'arrosage");
Serial.flush();
return;
}
// maintenant imprimer l'ensemble du tableau afin que l'utilisateur puisse voir ce qu'il a définit
printSettings();
} // fin de Attente_Cfg_Vanne()
void printSettings() {
/* Affiche les paramètres de MARCHE et d'Arrêt actuels, en convertissant
nombre de minutes écoulées depuis minuit jusqu' l'heure en heures et minutes
*/
for (int N_Vanne = 0; N_Vanne < QteVannes; N_Vanne++) {
Serial.println();
Serial.print("Pompe (");
Serial.print(N_Vanne + 1);
Serial.print(") l'arrosage commence ");
// division entière par 60 donne les heures
// puisque la division entière supprime tout reste
Serial.print((Cfg_Vanne[N_Vanne][0]) / 60);
Serial.print(":");
// les minutes sont le reste après avoir divisé par 60.
// récupère le reste avec l'opérateur modulo (%)
Serial.print((Cfg_Vanne[N_Vanne][0]) % (60));
Serial.print(" et s'arretera : ");
int HeureStop = (Cfg_Vanne[N_Vanne][0] + Cfg_Vanne[N_Vanne][3]);
Serial.print(HeureStop / 60);
Serial.print(":");
Serial.print((HeureStop) % (60));
Serial.println();
}
// END printSettings
}
void ProgTimeDefaut() {
//faire un select case pas de if
Serial.println("Programmation par defaut des horaires d'arrosage");
Serial.println("------------------------------------------------");
for (int N_Vanne = 0; N_Vanne < QteVannes; N_Vanne++) {
for (int TabProg = 0; TabProg < 6; TabProg++) {
Serial.println();
Serial.print("Vanne (");
Serial.print(N_Vanne + 1);
Serial.print(", ");
Serial.print(TabProg);
switch (TabProg) {
case 0:
Serial.print(") ");
Serial.print(TabProg + 1);
Serial.print(" ère heure = ");
Serial.print((Cfg_Vanne[N_Vanne][TabProg]) / 60); //Heures
Serial.print(":");
Serial.print((Cfg_Vanne[N_Vanne][TabProg]) % (60)); // minutes
Serial.println();
break;
case 1:
Serial.print(") ");
Serial.print(TabProg + 1);
Serial.print(" ème heure = ");
Serial.print((Cfg_Vanne[N_Vanne][TabProg]) / 60); //Heures
Serial.print(":");
Serial.print((Cfg_Vanne[N_Vanne][TabProg]) % (60)); // minutes
Serial.println();
break;
case 2:
Serial.print(") ");
Serial.print(TabProg + 1);
Serial.print(" ème heure = ");
Serial.print((Cfg_Vanne[N_Vanne][TabProg]) / 60); //Heures
Serial.print(":");
Serial.print((Cfg_Vanne[N_Vanne][TabProg]) % (60)); // minutes
Serial.println();
break;
case 3:
Serial.print(") durée d'arrosage = ");
Serial.print(Cfg_Vanne[N_Vanne][TabProg]);
Serial.println();
break;
case 4:
Serial.print(") Taux d'humidité = ");
Serial.print(Cfg_Vanne[N_Vanne][TabProg]);
Serial.println();
break;
case 5:
Serial.print(") MODE PLUIE = ");
if (Cfg_Vanne[N_Vanne][TabProg] != 0) {
Serial.print(" AVEC ");
Serial.println();
} else {
Serial.print(" SANS ");
Serial.println();
}
break;
}
}
}
Serial.println("-----------------------------------------");
}
void checkTimeControlNvannes() {
/* Déterminez combien de minutes se sont écoulées
depuis minuit. le plus grand nombre sera 2359 qui est
23 * 60 + 59 = 1439 ce qui est inférieur au
maximum qui peut être stocké dans un entier de sorte qu'un
int est assez grand
*/
int NowMinutesDepuisMinuit =
(dateTimeNow.hour() * 60) + dateTimeNow.minute(); // Détermine l'heure qu'il est pour comparaison avec la Configuration de l'arrosage
for (int N_Vanne = 0; N_Vanne < QteVannes; N_Vanne++) {
for (int P_Vanne = 0; P_Vanne < QteHeuresProg; P_Vanne++) {
Serial.print(dateTimeNow.dayOfTheWeek());
for (int X_Jours = 9; X_Jours < 16; X_Jours++) {
if ((Cfg_Vanne[N_Vanne][X_Jours]) != 0) {
if ((X_Jours - 9) == dateTimeNow.dayOfTheWeek()){
if ((Cfg_Vanne[N_Vanne][P_Vanne]) != 0) {
if ((NowMinutesDepuisMinuit >= Cfg_Vanne[N_Vanne][P_Vanne]) && (NowMinutesDepuisMinuit < (Cfg_Vanne[N_Vanne][P_Vanne] + Cfg_Vanne[N_Vanne][3]))) {
// Je verifie si il pleut
if (humidityNow > Cfg_Vanne[N_Vanne][4]) { // si oui = il pleut
if (Cfg_Vanne[N_Vanne][5] == 1) { //si oui = Arrosage forcé
if (Cfg_Vanne[N_Vanne][P_Vanne + 6] != 1) {
Serial.println();
Serial.print("Vanne n° ");
Serial.print(N_Vanne + 1);
Serial.print(" Ouverte - Prog Horaire :");
Serial.print(P_Vanne + 1);
Serial.println();
Serial.print("==============");
Serial.println();
digitalWrite(Tabl_Vannes[N_Vanne], HIGH); // Vanne ouverte
Cfg_Vanne[N_Vanne][P_Vanne + 6] = 1;
digitalWrite(Pompe_PIN, HIGH); // POMPE MARCHE
ControleDeLaPompe(); // Vérifie si au moins une des 3 vannes est en service
}
} else {
if (humidityNow > Cfg_Vanne[N_Vanne][4]) { // si oui = il pleut
Serial.println();
Serial.print("L5750 - La pluie est la");
}
Cfg_Vanne[N_Vanne][(P_Vanne + 6)] = 0;
switch ((P_Vanne + 6)) {
case 6:
if (Cfg_Vanne[N_Vanne][7] == 0 && Cfg_Vanne[N_Vanne][8] == 0) {
digitalWrite(Tabl_Vannes[N_Vanne], LOW); //ARRET
Serial.println();
Serial.print("Vanne n° ");
Serial.print(N_Vanne + 1);
Serial.print(" Fermé - Prog Horaire :");
Serial.print(P_Vanne + 1);
Serial.println();
}
break;
case 7:
if (Cfg_Vanne[N_Vanne][6] == 0 && Cfg_Vanne[N_Vanne][8] == 0) {
digitalWrite(Tabl_Vannes[N_Vanne], LOW); //ARRET
Serial.println();
Serial.print("Vanne n° ");
Serial.print(N_Vanne + 1);
Serial.print(" Fermé - Prog Horaire :");
Serial.print(P_Vanne + 1);
Serial.println();
Serial.print("==============");
Serial.println();
}
break;
case 8:
if (Cfg_Vanne[N_Vanne][6] == 0 && Cfg_Vanne[N_Vanne][7] == 0) {
digitalWrite(Tabl_Vannes[N_Vanne], LOW); //ARRET
Serial.println();
Serial.print("Vanne n° ");
Serial.print(N_Vanne + 1);
Serial.print(" Fermé - Prog Horaire :");
Serial.print(P_Vanne + 1);
Serial.println();
Serial.print("==============");
Serial.println();
}
break;
}
Cfg_Vanne[N_Vanne][P_Vanne + 6] = 0;
ControleDeLaPompe(); // Vérifie si au moins une des 3 vannes est en service avant d'arreter la pompe
} // FIN DE Il pleut, je n'arrose pas
} else { // Il ne pleut pas, c'est l'heure d'arroser
if (Cfg_Vanne[N_Vanne][P_Vanne + 6] != 1) {
Serial.println();
Serial.print(" MARCHE Vanne n°");
Serial.print(Cfg_Vanne[N_Vanne][P_Vanne]);
Serial.println();
Serial.print("Vanne n° ");
Serial.print(N_Vanne + 1);
Serial.print(" Ouverte - Prog Horaire :");
Serial.print(P_Vanne + 1);
Serial.println();
Serial.print("==============");
Serial.println();
digitalWrite(Tabl_Vannes[N_Vanne], HIGH); //OUVERTURE
digitalWrite(Pompe_PIN, HIGH); //MARCHE
Cfg_Vanne[N_Vanne][P_Vanne + 6] = 1;
Serial.println();
ControleDeLaPompe();
}
}
} else { //Ce n'est pas l'heure d'arrosé
if (humidityNow > Cfg_Vanne[N_Vanne][4]) { // si oui = il pleut
}
Cfg_Vanne[N_Vanne][(P_Vanne + 6)] = 0;
switch ((P_Vanne + 6)) {
case 6:
if (Cfg_Vanne[N_Vanne][7] == 0 && Cfg_Vanne[N_Vanne][8] == 0) {
digitalWrite(Tabl_Vannes[N_Vanne], LOW); //ARRET
Serial.println();
Serial.print("Vanne n° ");
Serial.print(N_Vanne + 1);
Serial.print(" Fermé - Prog Horaire :");
Serial.print(P_Vanne + 1);
Serial.println();
Serial.print("==============");
Serial.println();
}
break;
case 7:
if (Cfg_Vanne[N_Vanne][6] == 0 && Cfg_Vanne[N_Vanne][8] == 0) {
digitalWrite(Tabl_Vannes[N_Vanne], LOW); //ARRET
Serial.println();
Serial.print("Vanne n° ");
Serial.print(N_Vanne + 1);
Serial.print(" Fermé - Prog Horaire :");
Serial.print(P_Vanne + 1);
Serial.println();
Serial.print("==============");
Serial.println();
}
break;
case 8:
if (Cfg_Vanne[N_Vanne][6] == 0 && Cfg_Vanne[N_Vanne][7] == 0) {
digitalWrite(Tabl_Vannes[N_Vanne], LOW); //ARRET
Serial.println();
Serial.print("Vanne n° ");
Serial.print(N_Vanne + 1);
Serial.print(" Fermé - Prog Horaire :");
Serial.print(P_Vanne + 1);
Serial.println();
Serial.print("==============");
Serial.println();
}
break;
}
Cfg_Vanne[N_Vanne][P_Vanne + 6] = 0;
ControleDeLaPompe(); // Vérifie si au moins une des 3 vannes est en service avant d'arreter la pompe
}
} // fin de verif diff de 0
} // fin de comparaison du jour
} // fin de la verif des jours
} // fin de x_jours
} /// fin de la boucle des programme Horaire de chaque vanne
} // Fin du controle de chaque vanne
} // Fin checkTimeControlNvannes
void printMenu() {
Serial.println(
"Veuillez entrer L pour afficher les paramètres actuels \n");
//Serial.println("Ex:Veuillez entrer P2A13:45-10 ou P2B13:45-10 pour régler l'arrosage de la pompe 2 13:45 et 10s d'arrosage");
}
Bonne lecture.
si on ne sais pas on peut toujours chercher !
malgré ça, si la solution ne viens pas on peut toujours demander !
Oui surement, mais c'est en forgeant que l'on devient forgeron 
Après pour moi, il n'y a qu'une seul règle qui prévaut sur toutes les autres, cette régles est que ton programme fonctionne sans bug
Je n'ai pas noté de mauvaise indentations, l'appuis sur crtl-T dans l'IDE d'Arduino, me semble ne rien changer, donc de ce coté c'est ok
Pour moi, une bonne règle secondaire est que le programme soit lisible, cela aide à ne pas faire de bug et facilite leur correction.
Donc je te proposerais bien deux choses:
- La première serait d'utiliser la structure que propose @lesept avec un bool jours[7] à la place de int jours[7], sauf si tu veux dans le future pouvoir être plus fin que la journée(demi-journée ou tranche horaire).
- La deuxième serait d'utiliser des variables ou des macros à la place de tes indices.
const byte Dimanche = 9;
const byte Lundi = 10;
const byte Mardi = 11;
const byte Mercredi = 12;
const byte Jeudi = 13;
const byte Vendredi = 14;
const byte Samedi = 15;
...
case (0): // Vanne 1
Cfg_Vanne[N_Vanne][0] = 700; // 1 ère heure d'arrosage
Cfg_Vanne[N_Vanne][1] = 710; // 2 ème heure d'arrosage
Cfg_Vanne[N_Vanne][2] = 720; // 3 ème heure d'arrosage
Cfg_Vanne[N_Vanne][3] = 1; // Durée d'arrosage en minutes
Cfg_Vanne[N_Vanne][4] = 90; // Indice d'humidité pour définir si il 'pleut'
Cfg_Vanne[N_Vanne][5] = 0; // A 1 l'arrosage ce fait malgrée la pluie (ex plantes interieur)
Cfg_Vanne[N_Vanne][6] = 0; // Drapeau du Prog Horaire 1
Cfg_Vanne[N_Vanne][7] = 0; // Drapeau du Prog Horaire 2
Cfg_Vanne[N_Vanne][8] = 0; // Drapeau du Prog Horaire 3
Cfg_Vanne[N_Vanne][Dimanche] = 0; // arrossage le dimanche
Cfg_Vanne[N_Vanne][Lundi] = 0; // arrossage le lundi
Cfg_Vanne[N_Vanne][Mardi] = 1; // arrossage le mardi
Cfg_Vanne[N_Vanne][Mercredi] = 0; // arrossage le mercredi
Cfg_Vanne[N_Vanne][Jeudi] = 0; // arrossage le jeudi
Cfg_Vanne[N_Vanne][Vendredi] = 0; // arrossage le vendredi
Cfg_Vanne[N_Vanne][Samedi] = 1; // arrossage le samedi
break;
Là j'ai repris tes indices, mais il serait intéressant de plutôt commencer à 0, pour que tu puisse utiliser la même constante avec le tableau daysArray
Bien sûre tu pourrais faire de même avec tous tes indices si tu ne veux pas passer à une structure.
Merci de ce retour, je trouve ton approche intéressante 
<< Là j'ai repris tes indices, mais il serait intéressant de plutôt commencer à 0, pour que tu puisse utiliser la même constante avec le tableau daysArray >>
je suis en train de lire un bouquin sur le C pour apprendre a maitrisé les struc, les pointeur et les tableaux. Parce que je suis un peu perplexe, comment je vais utilisé ma boucle for
for (int X_Jours = 9; X_Jours < 16; X_Jours++) {
if ((Cfg_Vanne[N_Vanne][X_Jours]) != 0) {
if ((X_Jours - 9) == dateTimeNow.dayOfTheWeek()){
en utilisant ce type de tableau ci-dessous ! 
Cfg_Vanne[N_Vanne][Dimanche] = 0; // arrossage le dimanche
Cfg_Vanne[N_Vanne][Lundi] = 0; // arrossage le lundi
Cfg_Vanne[N_Vanne][Mardi] = 1; // arrossage le mardi
Cfg_Vanne[N_Vanne][Mercredi] = 0; // arrossage le mercredi
Cfg_Vanne[N_Vanne][Jeudi] = 0; // arrossage le jeudi
Cfg_Vanne[N_Vanne][Vendredi] = 0; // arrossage le vendredi
Cfg_Vanne[N_Vanne][Samedi] = 1; // arrossage le samedi
Les deux choses n'ont pas de rapport entre elles?
je suppose que ta boucle commence au dimanche et fini au samedi ?
donc je ferrais une simple boucle utilisant les deux constantes correspondantes comme borne?
Si dimanche vaut 9 et que dans ta boucle tu utilise 9, il suffit de remplacer l'un par l'autre?
pour l'autre borne en faite tu veux t'arrêter avant 16(<), donc 15, coup de bol samedi vaut 15.
cela donne :
for (int X_Jours = Dimanche; X_Jours <= Samedi; X_Jours++) {
}
Si tu as des questions sur tes lectures en cours, n'hésite pas, car le passage en structure, va te permettre de passer à un code plus proche de la réflexion humain et rendre ton code beaucoup plus lisible, ce qui te ferra gagner du temps au débugage et si tu dois l'améliorer plus tard.
Si vous voulez gagner de la mémoire parce que vous êtes vraiment à l'étroit, vous pourriez utiliser les structures avec champs de bits.
On peut utiliser les bits d'un octet pour représenter les jours de la semaines ➜ un 0 veut dire que la vanne n'est pas activée ce jour là, un 1 qu'il faudra l'activer.
par exemple
enum Etat {OFF = 0, ON = 1};
struct __attribute__((packed)) JoursSemaine {
Etat dimanche : 1;
Etat lundi : 1;
Etat mardi : 1;
Etat mercredi : 1;
Etat jeudi : 1;
Etat vendredi : 1;
Etat samedi : 1;
Etat inutilise : 1; // Un bit inutilisé pour remplir le uint8_t
};
La structure est déclarée avec l'attribut packed pour éviter tout ajout de padding et garantir que les membres utilisent le minimum de bits requis
et dans le code si on a une variable JoursSemaine semaine;on peut affecter les jours comme cela
semaine.dimanche = OFF;
semaine.lundi = ON;
semaine.mardi = OFF;
semaine.mercredi = ON;
semaine.jeudi = OFF;
semaine.vendredi = OFF;
semaine.samedi = OFF;
Pour l'horaire on peut faire aussi une structure en champs de bits (5 bits pour les heures de 0 à 23, 6 bits pour les minutes de 0 à 59 et 1 bit pour savoir si cet horaire est activé)
struct __attribute__((packed)) ProgrammeHoraire {
unsigned int heure : 5; // 0 à 23, donc besoin de 5 bits (2^5 = 32)
unsigned int minute : 6; // 0 à 59, donc besoin de 6 bits (2^6 = 64)
Etat active : 1; // 0 ou 1, donc besoin de 1 bit
};
et enfin on peut créer une structure pour une vanne qui va contenir des éléments de ces structures
// Définir la taille du tableau
const size_t nombreHoraires = 3;
struct __attribute__((packed)) Vanne {
ProgrammeHoraire horaires[nombreHoraires]; // Tableau de ProgrammeHoraire
JoursSemaine jours;
uint8_t numeroBroche;
uint8_t humidite; // 0 à 100
uint32_t duree;
};
➜ la structure qui représente une vanne contient seulement 13 octets à comparer avec la structure d'origine
struct ConfigVanne{
int heure1;
int heure2;
int heure3;
int duree;
int humidite;
bool forcer;
bool progH1;
bool progH2;
bool progH3;
int jours[7];
};
qui en contenait 52
Ensuite — en utilisant la possibilité d'avoir des fonctions dédies à chaque structure, on pourrait rajouter des aides à la déclaration ou impression. Voici ce que cela pourrait donner (dans un code que vous pouvez tester)
enum Etat : uint8_t { OFF = 0, ON = 1 };
struct __attribute__((packed)) JoursSemaine {
Etat dimanche : 1;
Etat lundi : 1;
Etat mardi : 1;
Etat mercredi : 1;
Etat jeudi : 1;
Etat vendredi : 1;
Etat samedi : 1;
Etat inutilise : 1; // Un bit inutilisé pour remplir le uint8_t
// Constructeur pour faciliter l'initialisation
JoursSemaine(Etat dim = OFF, Etat lun = OFF, Etat mar = OFF, Etat mer = OFF,
Etat jeu = OFF, Etat ven = OFF, Etat sam = OFF)
: dimanche(dim), lundi(lun), mardi(mar), mercredi(mer), jeudi(jeu),
vendredi(ven), samedi(sam), inutilise(OFF) {}
// Fonction pour imprimer les jours et leurs états
void print() const {
Serial.print(etat(dimanche));
Serial.print(etat(lundi));
Serial.print(etat(mardi));
Serial.print(etat(mercredi));
Serial.print(etat(jeudi));
Serial.print(etat(vendredi));
Serial.println(etat(samedi));
}
private:
const char* etat(Etat etat) const {
return (etat == ON) ? "ON " : "OFF ";
}
};
struct __attribute__((packed)) ProgrammeHoraire {
unsigned int heure : 5; // 0 à 23, donc besoin de 5 bits (2^5 = 32)
unsigned int minute : 6; // 0 à 59, donc besoin de 6 bits (2^6 = 64)
Etat active : 1; // 0 ou 1, donc besoin de 1 bit
// Constructeur pour faciliter l'initialisation
ProgrammeHoraire(unsigned int h = 0, unsigned int m = 0, Etat b = OFF)
: heure(h), minute(m), active(b) {}
void print() const {
if (heure < 10) Serial.write('0');
Serial.print(heure);
Serial.print(':');
if (minute < 10) Serial.write('0');
Serial.print(minute);
Serial.write('\t');
Serial.println(active == ON ? "ON" : "OFF");
}
};
// Définir la taille du tableau
const size_t nombreHoraires = 3;
struct __attribute__((packed)) Vanne {
ProgrammeHoraire horaires[nombreHoraires]; // Tableau de ProgrammeHoraire
JoursSemaine jours;
uint8_t numeroBroche;
uint8_t humidite; // 0 à 100
uint32_t duree;
// Constructeur pour faciliter l'initialisation
Vanne(ProgrammeHoraire h[], JoursSemaine j, uint8_t broche, uint8_t hum, uint32_t d)
: jours(j), numeroBroche(broche), humidite(hum), duree(d) {
memcpy(horaires, h, sizeof(ProgrammeHoraire) * nombreHoraires);
}
// Fonction pour imprimer les informations de la Vanne
void print() const {
Serial.print(F("Vanne sur Broche: ")); Serial.println(numeroBroche);
for (int i = 0; i < nombreHoraires; i++) {
Serial.print(F("Programme Horaire "));
Serial.print(i + 1);
Serial.print(F(": "));
horaires[i].print();
}
Serial.println(F("DIM LUN MAR MER JEU VEN SAM"));
jours.print();
Serial.print(F("Humidité: "));
Serial.print(humidite);
Serial.println(F("%"));
Serial.print(F("Durée: "));
Serial.print(duree);
Serial.println(F(" millisecondes"));
}
};
// Initialiser un tableau de nombreHoraires ProgrammeHoraire
ProgrammeHoraire horaires[] = {
ProgrammeHoraire(8, 30, ON),
ProgrammeHoraire(12, 0, OFF),
ProgrammeHoraire(18, 45, ON)
};
// on peut vérifier qu'il y en a bien nombreHoraires
static_assert(sizeof(horaires) / sizeof(horaires[0]) == nombreHoraires, "Le nombre d'entrées dans le tableau horaires ne correspond pas à nombreHoraires");
// Initialiser un objet Vanne
Vanne vanne(
horaires,
JoursSemaine(ON, OFF, ON, OFF, ON, OFF, ON),
13, // numéro de broche
55, // humidité
120000 // durée en millisecondes
);
void setup() {
// Initialiser la communication série
Serial.begin(115200);
vanne.print(); // Afficher les informations de la Vanne
}
void loop() {}
ça vous affichera dans la console série
Vanne sur Broche: 13
Programme Horaire 1: 08:30 ON
Programme Horaire 2: 12:00 OFF
Programme Horaire 3: 18:45 ON
DIM LUN MAR MER JEU VEN SAM
ON OFF ON OFF ON OFF ON
Humidité: 55%
Durée: 120000 millisecondes
1 Like
Merci J-M-L Jackson,
Je vais faire une copie de vos exemple qui me donnerons des bouton à la tête le temps que je décortique et comprenne votre code (bien commenté par ailleurs). j'aime cette approche, étant novice en C/C++ et arduino il va me falloir un peut de temps pour tout réécrire.
Re merci de ton aide. 