Pointeur ou pas pointeur

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 :worried:

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 : ////

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.