Bonjour , suite a modifications du code d ' un serveur web a based ' arduino mega2560 et shield ethernet 5500 , j ' essaie d' ameliorer les choses et de corriger les nombreux bugs que comporte mon code .
Une bonne partie du code n ' a pas été ecrit par moi-meme , et il y a surement beaucoup de chose a revoir .
bref , le probleme principal reside dans le fait de passer les bons arguments aux bonnes fonctions , je voudrais faire en sorte a la fin du code de pouvoir gerer un mode entierment automatique desactivable via un bouton sur la page du serveur ( deja operationnel ) et un systeme manuel avec un timer que gere asynctask deja fonctionnel aussi , en utilisant si possible des fonctions avec des pointeurs , ou bien alors supprimer entierement les pointeurs .
le mode automatique , sur lequel je bute actuellement , se verra lancer les taches via asynctask aussi , si pas plus contaignant que ca . ?
sauf que je n' arrive pas a repartir sur les pointeurs en recuperant le pin du relais du retour de asynctask ![]()
NOTE : dans le code il y a aussi une structure qui gere les volets electriques et une autre structure pour les relais " annexes " ce qui empeche de passer a asynctask l ' indice de tableau d' une structure qui peut elle aussi utiliser cette bibliotheque ...
voici ce que j' utilise pour le moment :
////* Arrosage *////
bool resetZoneArroseeOK;
uint8_t saison = 0;
enum t_saison : uint8_t {PRINTEMPS, ETE, AUTOMNE, HIVER};
enum t_commandeArrosage : uint8_t {MARCHE, ARRET, MARCHE_TOUT, ARRET_TOUT, TIMERR_A, AUTOMA, NULL_A};
enum t_etat : uint8_t {ACTIF, INACTIF, TIMER, AUTO};
struct t_arrosage { // "Arbres", "Bordures", "Fruitiers", "Haies", "Jardin", "Potager
uint8_t zone; //1 index
const char* nom; //2
uint8_t pinRelais; //3
t_etat etat; //4
uint32_t timerArrosage; //5
uint32_t finArrosage; //6 utile ?
// mode auto :
uint32_t joursIntervalle; //7
bool zoneArrosee; //8
uint32_t debutArrosage; //9
uint32_t dureeJusquaFinArrosage; //10
uint32_t timerProchainArrosage; //11
};
#define tempsDArrosage(coeffSaison) ((uint32_t) (TIMER_A * (coeffSaison)))
t_arrosage lesArrosages[] = {
//zone nom pin etat DuréeArrosage coeff // ZA
{0, "Arbres", 38, INACTIF, tempsDArrosage(1), 0, 0, false, 0, 0, TIMER_A},
{1, "Bordures", 39, INACTIF, tempsDArrosage(1), 0, 0, false, 0, 0, TIMER_A},
{2, "Fruitiers", 40, INACTIF, tempsDArrosage(1), 0, 0, false, 0, 0, TIMER_A},
{3, "Haies", 41, INACTIF, tempsDArrosage(1), 0, 0, false, 0, 0, TIMER_A},
{4, "Jardin", 42, INACTIF, tempsDArrosage(1), 0, 0, false, 0, 0, TIMER_A},
{5, "Potager", 43, INACTIF, tempsDArrosage(1), 0, 0, false, 0, 0, TIMER_A}
};
const uint8_t NOMBREDARROSAGE = sizeof(lesArrosages) / sizeof(t_arrosage) , HEURE_RESET_A = 24, HEURE_DEBUT_A = 0;
bool arrosageAutoON = false;
//// Fonctions d ' arrosage : ////
void initialiserUnArrosage(t_arrosage* unArrosage) {
pinMode(unArrosage->pinRelais, OUTPUT);
digitalWrite(unArrosage->pinRelais, RELAIS_INACTIF); // à l'arret
if (DEBUG) {
Serial.print (F("* initialiserUnArrosage => PIN : "));
Serial.println (unArrosage->pinRelais);
}
}
//// mode manuel ////
void activerTimerArrosage (uint8_t i) {
// si une tache existe deja , on la remplace par la nouvelle , donc , 1ere chose , on supprime la tache si elle existe deja .
desactiverTimerArrosage(lesArrosages[i].pinRelais);
if (!gestionnaireDeTache.findAsyncCommand(lesArrosages[i].pinRelais)) {
gestionnaireDeTache.registerAsyncCommand(lesArrosages[i].pinRelais, lesArrosages[i].timerArrosage, desactiverArrosage);// normal le reinit ici : oui fonction de callback ( c ' est elle qui reinitialisera le relais a la fin du timer )
if (DEBUG) {
Serial.print (F("* activerTimerArrosage => tache "));
Serial.print (lesArrosages[i].pinRelais);
Serial.print (F(" enregistrée pour dans "));
Serial.println (lesArrosages[i].timerArrosage);
}
}
}
// pour supprimer le timer lors de l' arret manuel d ' un arrosage si celui-ci a été activé
void desactiverTimerArrosage (uint8_t pin) {
if (gestionnaireDeTache.findAsyncCommand(pin)) {
gestionnaireDeTache.unregisterAsyncCommand(pin);
if (DEBUG) {
Serial.print (F("* desactiverTimerArrosage => tache : "));
Serial.print (pin);
Serial.println (F(" supprimee"));
}
}
}
// on recoit le pin du timer asynctask ...
// cette fonction sert uniquement a desactiver le bon relais et mettre a jour l' etat .
// elle est appelée uniquement par le callback du gestionnaire de tache , voir fichier timers_rtc.ino
void desactiverArrosage(t_commandID pin) {
for (uint8_t i = 0; i < NOMBREDARROSAGE; i++) {
if (lesArrosages[i].pinRelais == pin) {
lesArrosages[i].etat = INACTIF;
digitalWrite(lesArrosages[i].pinRelais, RELAIS_INACTIF);
lesArrosages[i].finArrosage = millis();
if (DEBUG) {
Serial.print (F("* desactiverArrosage => indice = "));
Serial.print (i);
Serial.print (F(", relais = "));
Serial.println (lesArrosages[i].pinRelais);
}
}
}
}
void activerUnArrosageEtUnTimer(t_arrosage* unArrosage) {
digitalWrite(unArrosage->pinRelais, RELAIS_ACTIF);
unArrosage->etat = ACTIF;
activerTimerArrosage (unArrosage->zone);
unArrosage->debutArrosage = millis(); // voir comment faire pour afficher le temps d' arrosage effectue pour chaque zone active.
unArrosage->finArrosage = 0;
if (DEBUG) {
Serial.print (F("* activerUnArrosageEtUnTimer => "));
Serial.print (F("unArrosage->zone : "));
Serial.print (unArrosage->zone);
Serial.print (F(", unArrosage->pinRelais : "));
Serial.println (unArrosage->pinRelais);
}
}
void desactiverUnArrosageEtUnTimer(t_arrosage* unArrosage) {
if (DEBUG) {
Serial.print (F("* desactiverUnArrosageEtUnTimer => "));
Serial.print (F("unArrosage->zone : "));
Serial.print (unArrosage->zone);
Serial.print (F(", unArrosage->pinRelais : "));
Serial.println (unArrosage->pinRelais);
}
digitalWrite(unArrosage->pinRelais, RELAIS_INACTIF);
unArrosage->etat = INACTIF;
desactiverTimerArrosage (unArrosage->pinRelais);
//unArrosage->debutArrosage = millis(); // voir comment faire pour afficher le temps d' arrosage effectue pour chaque zone active.
unArrosage->finArrosage = millis();
}
void inverserUnArrosageEtUnTimer(t_arrosage* unArrosage) {
if (unArrosage->etat != ACTIF) activerUnArrosageEtUnTimer (unArrosage);
else if (unArrosage->etat != INACTIF) desactiverUnArrosageEtUnTimer (unArrosage);
}
void activerUnArrosage(t_arrosage* unArrosage) {
digitalWrite(unArrosage->pinRelais, RELAIS_ACTIF);
unArrosage->debutArrosage = millis(); // voir comment faire pour afficher le temps d' arrosage effectue pour chaque zone active.
unArrosage->finArrosage = 0;
unArrosage->etat = ACTIF;
if (DEBUG) {
Serial.print (F("* activerUnArrosage : "));
Serial.println (unArrosage->pinRelais);
}
}
void desactiverUnArrosage(t_arrosage* unArrosage) {
unArrosage->finArrosage = millis();
digitalWrite(unArrosage->pinRelais, RELAIS_INACTIF);
unArrosage->etat = INACTIF;
if (DEBUG) {
Serial.print (F("* desactiveArrosage : "));
Serial.println (unArrosage->pinRelais);
}
}
void gererUnArrosage(t_arrosage* unArrosage) {
switch (unArrosage->etat) { // ACTIF, INACTIF, TIMER, AUTO
case INACTIF : // MARCHE, ARRET, NULL_A, MARCHE_TOUT, ARRET_TOUT
if ((commandeWeb.active) && (commandeWeb.arrosage == unArrosage)) {
if (commandeWeb.actionCMD_A == MARCHE) {
if (DEBUG) {
Serial.print (F("* gererUnArrosage => case inactif => unArrosage-> zone : "));
Serial.print (unArrosage->zone);
Serial.print (F(", unArrosage->pinRelais : "));
Serial.println (unArrosage->pinRelais);
}
//activeArrosage(unArrosage);
//activerArrosageEtUnTimer (unArrosage);
activerUnArrosageEtUnTimer (unArrosage);
commandeWeb.active = false;
}
}
break;
case ACTIF :
if ((commandeWeb.active) && (commandeWeb.arrosage == unArrosage)) {
if (commandeWeb.actionCMD_A == ARRET) {
if (DEBUG) {
Serial.print (F("* gererUnArrosage => case actif => unArrosage-> zone : "));
Serial.print (unArrosage->zone);
Serial.print (F(", unArrosage->pinRelais : "));
Serial.println (unArrosage->pinRelais);
}
desactiverUnArrosageEtUnTimer(unArrosage);
commandeWeb.active = false;
}
}
break;
case TIMER :
if ((commandeWeb.active) && (commandeWeb.arrosage == unArrosage)) {
if (commandeWeb.actionCMD_A == TIMERR_A) {
inverserUnArrosageEtUnTimer(unArrosage);
commandeWeb.active = false;
}
}
break;
case AUTO :
if ((commandeWeb.active) && (commandeWeb.arrosage == unArrosage)) {
if (commandeWeb.actionCMD_A == AUTOMA) {
inverserUnArrosageEtUnTimer(unArrosage);
commandeWeb.active = false;
}
} break;
default:
if (DEBUG) Serial.println (F("* gererUnArrosage => probleme = case non reconnu !"));
break;
} // fin switch
}
void gererLesArrosages() {
if (commandeWeb.active && commandeWeb.arrosage == NULL && commandeWeb.volet == NULL && commandeWeb.actionCMD_V == NULL_V) {
if(commandeWeb.actionCMD_A == MARCHE_TOUT) for (uint8_t a = 0; a < NOMBREDARROSAGE; a++) activerUnArrosage(&(lesArrosages[a]));
else if(commandeWeb.actionCMD_A == ARRET_TOUT) for (uint8_t a = 0; a < NOMBREDARROSAGE; a++) desactiverUnArrosage(&(lesArrosages[a]));
else if(commandeWeb.actionCMD_A == AUTOMA) for (uint8_t a = 0; a < NOMBREDARROSAGE; a++) initialArrosageAuto(&(lesArrosages[a]));
commandeWeb.active=false;
}
else {
for (uint8_t a = 0; a < NOMBREDARROSAGE; a++) gererUnArrosage(&(lesArrosages[a]));
}
}
/* mode manuel */
/***************************************************************************************************************/
/* mode auto */
/* TODO :
variable active / desactive le mode arrosage auto : arrosageAutoON
calculer la durée de l' arrosage en fonction de la saison : dureeJusquaFinArrosage
determiner l ' heure a laquelle arroser en fonction de la saison.
determiner les jours des differentes zones a arroser en fonction de la saison.
a l' heure determinée , enclencher l' arrosage automatiquement : Action
arreter l' arrosage a la fin de la durée determinée : Action
marquer la zone comme etant arrosée : zoneArrosee
prevoir un timer pour enclencher le prochain arrosage apres la fin du 1er en fonction de la saison : timerProchainArrosage
si arrosage auto on , on fait les calculs et on verifie que ca se passe bien
remplissage des données adequates de la structure
void initialArrosageAuto () { // objectif lancer les taches auto a intervalles reguliers
static uint8_t initArrosageOK = NOMBREDARROSAGE;
if (arrosageAutoON && initArrosageOK) {
for (uint8_t i=0; i < NOMBREDARROSAGE; i++) {
initArrosageOK--; // gestion de l' initialisation des taches de façon a n' effectuer qu ' une seule fois .
// lancement des nouvelles taches auto
// si on desire se fier au relais utilisé , il faut d' abord recuperer celui-ci : lesArrosages[i].pinRelais
uint8_t ID100=lesArrosages[i].pinRelais + 100;
gestionnaireDeTache.registerAsyncCommand(ID100, 3000, marcheArrosageAuto); // initialisation autonome : ID 100 a 105
// on active une nouvelle tache ayant pour id le numero de pin + 100 / un temps de 3 secondes / et la fonction automatique d ' arrosage pour callback .
// NOTE : on n ' active pas les relais ici , il s' agist juste de lancer la tache apres l' intervalle defini .
if (DEBUG) {
Serial.print (F("* initialArrosageAuto => zone "));
Serial.print (i);
Serial.print (F(" effectue sur zone : "));
Serial.print (lesArrosages[i].zone);
Serial.print (F(" ID100 : "));
Serial.print (ID100);
Serial.print (F(" sur pin correspondant : "));
Serial.println (lesArrosages[i].pinRelais);
}
}
}
}
*/
void initialArrosageAuto (t_arrosage* unArrosage) { // objectif lancer les taches auto a intervalles reguliers
if (arrosageAutoON) {
// si on desire se fier au relais utilisé , il faut d' abord recuperer celui-ci : lesArrosages[i].pinRelais
uint8_t ID100=unArrosage->pinRelais + 100;
gestionnaireDeTache.registerAsyncCommand(ID100, 3000, marcheArrosageAuto); // initialisation autonome : ID 100 a 105
// on active une nouvelle tache ayant pour id le numero de pin + 100 / un temps de 3 secondes / et la fonction automatique d ' arrosage pour callback .
// NOTE : on n ' active pas les relais ici , il s' agist juste de lancer la tache apres l' intervalle defini .
if (DEBUG) {
Serial.print (F("* initialArrosageAuto => effectue sur zone : "));
Serial.print (unArrosage->zone);
Serial.print (F(" ID100 : "));
Serial.print (ID100);
Serial.print (F(" sur pin correspondant : "));
Serial.println (unArrosage->pinRelais);
}
//}
}
}
void marcheArrosageAuto (t_commandID ID100) { // ID100 est le numero de pin +100 , pas un index du tableau
uint8_t index = ID100-100;
lesArrosages[index].zoneArrosee = false;
//if (saison != HIVER && !lesArrosages[index].zoneArrosee) {
//if (!lesArrosages[index].zoneArrosee) { // la condition peut si zone arrosée vaut vrai , bloquer la creation de la tache d' arrosage
lesArrosages[index].etat = ACTIF; // gestion etat du relais
if (!TEST) digitalWrite (lesArrosages[index].pinRelais , RELAIS_ACTIF); // gestion du relais
gestionnaireDeTache.registerAsyncCommand(ID100, lesArrosages[index].dureeJusquaFinArrosage, resetTimerArrosageAuto);
// on utilise ID100 pour les taches automatiques / la durée de l' arrosage desirée / la fonction qui arretera le relais ( et l' arrosage donc ).
if (DEBUG) {
Serial.print (F("* marcheArrosageAuto => tache arrosageAuto id100 : "));
Serial.print (ID100);
Serial.print (F(" lance pendant "));
Serial.print (lesArrosages[index].dureeJusquaFinArrosage/1000);
Serial.print (F(" secondes , sur le pin : "));
Serial.println (lesArrosages[index].pinRelais);
}
//}
// ce que l ' on fait tout le temps : relancer la prochaine tache
gestionnaireDeTache.registerAsyncCommand(ID100, lesArrosages[index].joursIntervalle, marcheArrosageAuto); // tourne en boucle , enregistre le prochain arrosage differe
if (DEBUG) {
Serial.print (F("* marcheArrosageAuto => tache arrosageAuto id100 : "));
Serial.print (ID100);
Serial.print (F(" lance pendant "));
Serial.print (lesArrosages[index].dureeJusquaFinArrosage/1000);
Serial.print (F(" secondes , sur le pin : "));
Serial.println (lesArrosages[index].pinRelais);
}
}
void resetTimerArrosageAuto (t_commandID ID100) { // permet de stopper le mode d ' arrosage automatique
// ID100 est le numero de pin +100 , pas un index du tableau
uint8_t index = ID100-100;
if (lesArrosages[index].etat == ACTIF) {
resetZoneArroseeOK = true; // marque les zones a reinitialiser
lesArrosages[index].zoneArrosee = true; // marque la zone comme arrosee
digitalWrite(lesArrosages[index].pinRelais, RELAIS_INACTIF); // relais off
lesArrosages[index].etat = INACTIF; // gestion etat
if (DEBUG) {
Serial.print (F("* resetTimerArrosageAuto => zoneArrosee "));
Serial.print (index);
Serial.print (F(" = "));
Serial.println (lesArrosages[index].zoneArrosee);
}
}
}
void resetZoneArrosee () { // on reinitialise les zones arrosées pour le lendemain
if (resetZoneArroseeOK && (RTC.heure() >= HEURE_RESET_A)) {
resetZoneArroseeOK = false;
for (uint8_t a = 0; a < NOMBREDARROSAGE; a++) if (lesArrosages[a].zoneArrosee) lesArrosages[a].zoneArrosee = false;
if (DEBUG) Serial.println (F("resetZoneArrosee => zones reinitialisees !"));
}
}
//// Fonctions de calculs : ////
void setSaison(t_commandID identifier) { // Gere le mode HORSGEL_ON *///////
if ((RTC.mois() == 3 && RTC.jour() >= 20) || RTC.mois() == 4 || RTC.mois() == 5 || (RTC.mois() == 6 && RTC.jour() < 20)) saison = PRINTEMPS;
else if ((RTC.mois() == 6 && RTC.jour() >= 20) || RTC.mois() == 7 || RTC.mois() == 8 || (RTC.mois() == 9 && RTC.jour() < 22)) saison = ETE;
else if ((RTC.mois() == 9 && RTC.jour() >= 22) || RTC.mois() == 10 || RTC.mois() == 11 || (RTC.mois() == 12 && RTC.jour() < 21)) saison = AUTOMNE;
else if ((RTC.mois() == 12 && RTC.jour() >= 21) || RTC.mois() == 1 || RTC.mois() == 2 || (RTC.mois() == 3 && RTC.jour() < 20)) saison = HIVER;
gestionnaireDeTache.registerAsyncCommand(identifier, 12 * TIMER_A, setSaison); // verifie 24 H apres si la saison n' a pas changé , ID 98
if (DEBUG) {
Serial.print (F("* setSaison => saison = "));
Serial.println (saison);
}
}
unsigned long calculIntervalleJoursArrosage (uint8_t index) { // l ' objectif est d ' espacer a intervalle de jours reguliers les arrosages des differentes zones en fonctions des saisons et de la zone a arroser
unsigned long nbJours = 0;
uint8_t saison =1;
switch (saison) {
case PRINTEMPS :
if (strcmp(lesArrosages[index].nom, "Arbres") == 0 || strcmp(lesArrosages[index].nom, "Fruitiers") == 0) {
nbJours = 7; // utile pour lancer le prochain arrosage via asynctask.
lesArrosages[index].joursIntervalle = 7;
}
else if (strcmp(lesArrosages[index].nom, "Haies") == 0 || strcmp(lesArrosages[index].nom, "Jardin") == 0) {
nbJours = 5 ;
lesArrosages[index].joursIntervalle = 5;
}
else if (strcmp(lesArrosages[index].nom, "Bordures") == 0 || strcmp(lesArrosages[index].nom, "Potager") == 0) {
nbJours = 2;
lesArrosages[index].joursIntervalle = 2;
}
break;
case ETE :
if (strcmp(lesArrosages[index].nom, "Arbres") == 0 || strcmp(lesArrosages[index].nom, "Fruitiers") == 0) {
nbJours = 4;
lesArrosages[index].joursIntervalle = 4;
}
else if (strcmp(lesArrosages[index].nom, "Haies") == 0 || strcmp(lesArrosages[index].nom, "Jardin") == 0) {
nbJours = 3;
lesArrosages[index].joursIntervalle = 3;
}
else if (strcmp(lesArrosages[index].nom, "Bordures") == 0 || strcmp(lesArrosages[index].nom, "Potager") == 0) {
nbJours = 1;
lesArrosages[index].joursIntervalle = 1;
}
break;
case AUTOMNE :
if (strcmp(lesArrosages[index].nom, "Arbres") == 0 || strcmp(lesArrosages[index].nom, "Fruitiers") == 0) {
nbJours = 7; // utile pour lancer le prochain arrosage via asynctask.
lesArrosages[index].joursIntervalle = 7;
}
else if (strcmp(lesArrosages[index].nom, "Haies") == 0 || strcmp(lesArrosages[index].nom, "Jardin") == 0) {
nbJours = 5 ;
lesArrosages[index].joursIntervalle = 5;
}
else if (strcmp(lesArrosages[index].nom, "Bordures") == 0 || strcmp(lesArrosages[index].nom, "Potager") == 0) {
nbJours = 2;
lesArrosages[index].joursIntervalle = 2;
}
break;
case HIVER : // voir avec temperature exterieure , sinon desactive
nbJours = 21;
lesArrosages[index].joursIntervalle = 21;
break;
default:
if (DEBUG) Serial.println(F("* => calculIntervalleJoursArrosage : ERREUR !!!"));
break;
} // fin du switch
if (DEBUG) {
Serial.print(F("* => calculIntervalleJoursArrosage => joursIntervalle = "));
Serial.println(lesArrosages[index].joursIntervalle);
}
nbJours = nbJours*24*60*60*1000; // Conversion en millisecondes
//lesArrosages[index].intervalle = nbJours;
return nbJours;
}
unsigned long calculTempsArrosage (uint8_t pinRelais) { // a mettre en place en fonction des zones et des saisons
pinRelais = pinRelais;
return TIMER_A; // un simple timer pour le moment
}
/* mode auto */
//// FIN des Fonctions d ' arrosage : ////