Go Down

Topic: est ce possible d ecrire un timer de ce type (Read 165 times) previous topic - next topic

vtec35

bonjour tout le monde, dans mes programmes, je met des securités conçernant mes actions


exemple, un etat statique d'une sortie au "repos", n est pas un probleme, par contre un etat actif plus long que la normal , n'est pas normal



actuellement je fais des choses de ce type:

Code: [Select]

  if (digitalRead(SORTIE_BUZZER_POWER) == LOW)                                      //si le buzzer n'est pas activé
  {
    timerbuzzer = millis() + tempsbuzzer;                                           //on réarme en permanence la tempo de buzzer
  }
  if ((digitalRead(SORTIE_BUZZER_POWER) == HIGH) && (millis() > timerbuzzer) )      //si le buzzer est activé et la tempo dépassée
  {
    digitalWrite (SORTIE_BUZZER_POWER, LOW) ;                                       //on arrette le buzzer
  }




c'est un exemple pris au hasard, mon probleme c est que je dois ecrire autant de timer qu il n y a de sortie.... donc ça peut aller a une dizaine, a la fin j'ai un peu les yeux qui se croise



donc a la question est : est il possible de limiter le nombre de timer et de variable associé, en disant un truc du genre


en fait je pars du principe que a partir du moment ou je donne un ordre à un verin pneumatique par exemple

tu sors, si au bout de x seconde, il n active pas sa butée, = alarme
si je lui dit tu rentre, si au bout de x seconde, sa position de repos n'est pas activé = alarme

je sais pas si je suis tres clair, mais voila ce que peux donner une page de timer

Code: [Select]
void timer()
{
//*****************filtre passage poudre***********************/
if (digitalRead(detection_passage_poudre) == LOW){
  flag_passage_poudre_actif = true;
  //Serial.println("flag_passage_poudre_actif = true");
}
else{
 flag_passage_poudre_actif = false;
 //Serial.println("flag_passage_poudre_actif = false");
}

if (flag_passage_poudre_actif == true){
  timer_passage_poudre_inactif = millis()  + temps_passage_poudre_inactif;
}
if (flag_passage_poudre_actif == false && millis()>timer_passage_poudre_inactif ){
  flag_passage_poudre_inactif_valide = true;
  //Serial.println("flag_passage_poudre_inactif_valide = true");
}
else{
  flag_passage_poudre_inactif_valide = false;
  //Serial.println("flag_passage_poudre_inactif_valide = false");
}



  
//*****************filtre position haute ejection***********************/

  if (digitalRead(position_haute_ejection) == LOW && digitalRead(position_basse_ejection) == HIGH)
  {
    timer_position_haute_ejection = millis()+ temps_position_haute_ejection;
  }
  if (digitalRead(position_haute_ejection) == HIGH  && millis() > timer_position_haute_ejection && digitalRead(position_basse_ejection) == LOW)
  {
    position_haute_ejection_valide= 1;
    //Serial.println("position_haute_ejection_valide= 1");
  }
  else
  {
    position_haute_ejection_valide= 0;
    //Serial.println("position_haute_ejection_valide= 0");
  }

   //*****************filtre position basse ejection***********************/

  if (digitalRead(position_basse_ejection) == LOW && digitalRead(position_haute_ejection) == HIGH)
  {
    timer_position_basse_ejection = millis()+ temps_position_basse_ejection;
  }
  if (digitalRead(position_basse_ejection) == HIGH  && millis() > timer_position_basse_ejection && digitalRead(position_haute_ejection) == LOW)
  {
    position_basse_ejection_valide= 1;
    //Serial.println("position_basse_ejection_valide= 1");
  }
  else
  {
    position_basse_ejection_valide= 0;
    //Serial.println("position_basse_ejection_valide= 0");
  }

  //*****************timer sortie ejection***********************/

    if (digitalRead(sonde_sortie_ejection) == LOW)
  {
  flag_presence_sortie_ejection = true;
  //Serial.println("presence_sortie_ejection = true");
  timer_presence_sortie_ejection = millis() + temps_presence_sortie_ejection;
  }
  else
  {
  flag_presence_sortie_ejection = false;
  //Serial.println("presence_sortie_ejection = false");    
  }
  if (flag_presence_sortie_ejection == false)
  {
  if (millis() > timer_presence_sortie_ejection)
  {
    presence_sortie_ejection_valide= false;  //valeur que l'on cherche precisement
    //Serial.println("presence_sortie_ejection = false");
  }
  else
  {
   flag_presence_sortie_ejection = true;
    //Serial.println("presence_sortie_ejection = true");
  }
  }


  
  //*****************timer pause table***********************/

  if (stepper1.isRunning() == true)
  {
    timer_arret_table = millis() + temps_arret_table;
    //Serial.println("mvt en cours");
  }
  if (stepper1.isRunning() == false)
  {
    if (millis() > timer_arret_table)
    {
      mvt_table = 1; // table peut demarrer le mouvement
      //Serial.println("peut demarrer le mouvement");
    }
    else
    {
      mvt_table = 0; // table en pause
      //Serial.println("table arreté");
    }
  }

  //*****************timer filtre palpeur***********************/
  if (digitalRead(sonde_entree_palpeur) == LOW) {
    flag_entree_palpeur = true;
    //Serial.println("flag_entree_palpeur = true");
  }
  else
  {
    flag_entree_palpeur = false;
    //Serial.println("flag_entree_palpeur = false");
  }

  if (flag_entree_palpeur == false) {
    timer_entree_palpeur_actif = millis() + temps_entree_palpeur;
  }
  if (flag_entree_palpeur == true && millis() > timer_entree_palpeur_actif) {
    flag_entree_palpeur_actif_valide = true;
  }
  else
  {
    flag_entree_palpeur_actif_valide = false;
  }
  if (flag_entree_palpeur == true) {
    timer_entree_palpeur_inactif = millis() + temps_entree_palpeur;
  }
  if (flag_entree_palpeur == false && millis() > timer_entree_palpeur_inactif) {
    flag_entree_palpeur_inactif_valide = true;
  }
  else
  {
    flag_entree_palpeur_inactif_valide = false;
  }


  //*****************timer filtre capteur magnetique position table***********************/

  if (digitalRead(capteur_position_magnetique_table) == LOW)
  {
    flag_capteur_position_table = true; // capteur magnetique actif
  }
  else
  {
    flag_capteur_position_table = false; // capteur magnetique inacactif
  }


  if (flag_capteur_position_table == false)
  {
    timer_capteur_position_table_actif = millis() + temps_capteur_position_table;
  }

  if (flag_capteur_position_table == true && millis() > timer_capteur_position_table_actif)
  {
    flag_capteur_position_table_actif_valide = true;
  }
  else
  {
    flag_capteur_position_table_actif_valide = false;
  }
  if (flag_capteur_position_table == true)
  {
    timer_capteur_position_table_inactif = millis() + temps_capteur_position_table;
  }

  if (flag_capteur_position_table == true && millis() > timer_capteur_position_table_inactif)
  {
    flag_capteur_position_table_inactif_valide = true;
  }
  else
  {
    flag_capteur_position_table_inactif_valide = false;
  }
  

 




ça en fait beaucoup, j'ai du limiter, et beaucoup on le meme temps de securité...

lesept

Si tous ces groupes de lignes sont les mêmes, tu peux en faire une fonction dont les paramètres seraient dans des tableaux, et appelée au sein d'une boucle for qui parcourt les tableaux
A force d'essayer on finit par réussir... Donc, plus ça rate, plus on a de chances que ça marche (proverbe Sharduinok).

vtec35

merde.... j'aime pas quand tu me parle comme ça.... ^^

lesept

A force d'essayer on finit par réussir... Donc, plus ça rate, plus on a de chances que ça marche (proverbe Sharduinok).

vtec35

Arf j ai déjà englober tellement de truc en baba la je sature niveau neurone

lesept

Je suis sur mon smartphone, pas facile de lire un code un peu complexe, je regarde demain sur un PC si j'ai un peu de temps
A force d'essayer on finit par réussir... Donc, plus ça rate, plus on a de chances que ça marche (proverbe Sharduinok).

Go Up