Temporisation d'un relais pour un anémomètre
Répondre à la discussion
Page 1 sur 2 1 DernièreDernière
Affichage des résultats 1 à 30 sur 39

Temporisation d'un relais pour un anémomètre



  1. #1
    gthum62

    Temporisation d'un relais pour un anémomètre


    ------

    Bjr à tous,
    j'explique mon projet:
    j'ai une serre dont je veux gérer la T° et Humidity. De ce côté là, j'y suis arrivé avec un DHT22 et un Arduino Uno en prenant des codes par ci par là sur le net, hé oui je n'y connait rein ,mais j'ai appris pas mal.
    j'ai donc un anémomètre, et je voudrais que lorsque le vent dépasse "x" KM/h ma serre ce referme. Alors ,j'ai bien un code pour l'anémometre et je commande un relais pour fermer, je voudrais temporiser le relais pour une heure. En effet , dans mon code (que je n'ai pas écrit ,c'est du coller),l'anemo déclenche bien à une certaine vitesse, déclenche le relais, mais à chaque passage de l'ILS.mon but c'est que lorsqu'il déclenche le relais je voudrais qu'il reste fermé pendant une heure.,j'ai essayer pas mal de choses ,mais je ne trouve pas de code pour faire des essais, c'est pour cela que je fait appel à une âme charitable.
    En fait ,je bricole çà pendant l'hiver,ma passion c'est le jardinage. Ma serre s'arose automatiquement et s'ouvre selon une certaine T°, et là je voudrais qu'elle se ferme par grand vent. Honnêtement ,c'est pour m'amuser,mais là çà fait déjà 1 semaine que je me bat avec les codes.
    Par contre ,j'ai essayer de voir avec mBlock, sur le coup je me suis dis que c'est impeccable, mais voilà ,je n'y arrive pas non plus,qu'elqu'un peut-il me dire ou trouver toutes les explication détaillées pour pouvoir bien comprendre le fonctionnement.

    En attendant je vous dis un grand merci d'avance.
    je joins mon code ,enfin mon bidouillage

    Code:
    #include <LiquidCrystal.h>
    #define INTER 2
    int anemo = 2;  
    int relaisPin = 3;
      
    LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
    // initialisation, on définit les ports pour RS, E et D4 à D7
    
    unsigned long timeRun;
    unsigned long timeLast;
    float periode;
    const int RELAY = 3;
    /***************Variables pour la  vitesse du vent*****************************/
                           //declare un var anemo qui = 2
    float v_vent = 0.00;                     //var qui contiendra la vitesse du vent
    float rayonBras = 0.01;                  //rayon du bras 9cm => 0.09m
    int anemoTickCompteur = 0;               //variable pour le comptage du nombre de "TICKS" du capteur ILS de l'anemo
    float FEtalonage = 3.1;
    
    unsigned long previousMillis = 0;
    const unsigned long TimePause = 30 * 60000;
    const unsigned long TimeMarche = 5 * 60000 ;
    
    enum {ARRET, MARCHE} etat;
    
    void setup()
    {
     
      lcd.setCursor(0, 0);               //place le c  lcd.begin(16, 2);                  // definit l'écran sur caractères (16) et de lignes (2)
      delay(100);                        //pause
      lcd.setCursor(1, 0);               //place le cursor
      lcd.print("initialisation");       // affiche le message
      delay(500);                        //pause
      lcd.clear();                       //efface l'écran
      delay(250);                        //pause
      lcd.print("vent: ");               //affiche texte
      lcd.setCursor(6, 0);               //place le cursor
      lcd.print(v_vent);                 //affiche la valeur de la vitesse du vent égale à 0.00 au départ
      lcd.setCursor(11, 0);              //place le cursor
      lcd.print("km/h");                 //affiche le texte
       // On initialise les entrées/sorties
       
    Serial.begin(9600);
     
    
      /*********************************************************************
          Mise en place des broches avec les fonctions d'interruption
      *********************************************************************/
      pinMode(anemo, INPUT); // On écrit l'état du relais//definit la pin anemo(2) comme une entrée  
      
      
    
      attachInterrupt(digitalPinToInterrupt(anemo), AnemoTicks, RISING);       //dès que la broche anemo(2) changera d'etat (RISING = état BAS vers HAUT (front montant)) on appelle le SP AnemoTicks
    }
    
    
    
    void loop()
    {
      timeRun = millis();  //affecte le temps depuis lequel le programme tourne à la var timeRu
    
    }
    
    
    void AnemoTicks ()
    {
      anemoTickCompteur++;
    
      if (anemoTickCompteur >= 4)
      {
        periode = (timeRun - timeLast) / 1000.0;             //???calcul la période et on divise par 1000.0 pour obtenir le résultat en seconde
        v_vent = rayonBras * 2 * 3.14 * (4 / periode) * FEtalonage; //calcul de la vitesse du vent avec la formule vitesse du vent = rayonBras*2pi*fréquence  (frequence=nb_tour/s) => résultat en m/s  2 Ticks = 1 tour/ 4 Ticks = 2 tours
        v_vent = v_vent * 3.6;                               //met le resultat en km/h
        timeLast = timeRun;                                  // ???
        anemoTickCompteur = 0;  //remise à 0 du compteur anemoTickCompteur
        Afficher();                                          //appelle le SP Afficher
    
      }
    }
    
    void Afficher()
    {
      lcd.setCursor(6, 0);               //place le cursor
      lcd.print(v_vent);                 //affiche la valeur de la vitesse du vent
      lcd.setCursor(7, 1);               //place le cursor
      //affiche la valeur de la quantité de pluie
      {
        pinMode( 3, OUTPUT);
      }
     if ((v_vent = v_vent * 3.6)>100)
      {
        
       digitalWrite(RELAY, LOW);
        delay(60000);
    
      } else {
        // sinon on l'éteint
        digitalWrite(RELAY, HIGH);
      }
    }

    -----
    Fichiers attachés Fichiers attachés
    Dernière modification par Jack ; 01/02/2021 à 12h04. Motif: Ajout code

  2. #2
    Jack
    Modérateur

    Re : Temporisation d'un relais pour un anémomètre

    Merci de fournir le code entre balises code la prochaine fois (voir les règles participatives). Aucun intérêt à le joindre dans un fichier Word.

  3. #3
    gthum62

    Re : Temporisation d'un relais pour un anémomètre

    bjr voici le code,j'éspère que c'est comme çà que l'on fait,je ne vois pas autrement.Et MERCI


    Code:
    #include <LiquidCrystal.h>
    int relaisPin = 3;
    int anemo = 2;     
    LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
    // initialisation, on définit les ports pour RS, E et D4 à D7
    
    unsigned long timeRun;
    unsigned long timeLast;
    float periode;
    const int RELAY = 3;
    /***************Variables pour la  vitesse du vent*****************************/
                           //declare un var anemo qui = 2
    float v_vent = 0.00;                     //var qui contiendra la vitesse du vent
    float rayonBras = 0.01;                  //rayon du bras 9cm => 0.09m
    int anemoTickCompteur = 0;               //variable pour le comptage du nombre de "TICKS" du capteur ILS de l'anemo
    float FEtalonage = 3.1;
    
    unsigned long previousMillis = 0;
    const unsigned long TimePause = 30 * 60000;
    const unsigned long TimeMarche = 5 * 60000 ;
    
    enum {ARRET, MARCHE} etat;
    
    void setup()
    {
     
      lcd.setCursor(0, 0);               //place le c  lcd.begin(16, 2);                  // definit l'écran sur caractères (16) et de lignes (2)
      delay(100);                        //pause
      lcd.setCursor(1, 0);               //place le cursor
      lcd.print("initialisation");       // affiche le message
      delay(500);                        //pause
      lcd.clear();                       //efface l'écran
      delay(250);                        //pause
      lcd.print("vent: ");               //affiche texte
      lcd.setCursor(6, 0);               //place le cursor
      lcd.print(v_vent);                 //affiche la valeur de la vitesse du vent égale à 0.00 au départ
      lcd.setCursor(11, 0);              //place le cursor
      lcd.print("km/h");                 //affiche le texte
       // On initialise les entrées/sorties
       
     pinMode(relaisPin, OUTPUT);
      digitalWrite (relaisPin, HIGH);  // démarre en marche
      etat = MARCHE;
      /*********************************************************************
          Mise en place des broches avec les fonctions d'interruption
      *********************************************************************/
      pinMode(anemo, INPUT); // On écrit l'état du relais//definit la pin anemo(2) comme une entrée  
      
      
    
      attachInterrupt(digitalPinToInterrupt(anemo), AnemoTicks, RISING);       //dès que la broche anemo(2) changera d'etat (RISING = état BAS vers HAUT (front montant)) on appelle le SP AnemoTicks
    }
    
    
    
    void loop()
    {
      timeRun = millis();  //affecte le temps depuis lequel le programme tourne à la var timeRu
    
    }
    
    
    void AnemoTicks ()
    {
      anemoTickCompteur++;
    
      if (anemoTickCompteur >= 4)
      {
        periode = (timeRun - timeLast) / 1000.0;             //???calcul la période et on divise par 1000.0 pour obtenir le résultat en seconde
        v_vent = rayonBras * 2 * 3.14 * (4 / periode) * FEtalonage; //calcul de la vitesse du vent avec la formule vitesse du vent = rayonBras*2pi*fréquence  (frequence=nb_tour/s) => résultat en m/s  2 Ticks = 1 tour/ 4 Ticks = 2 tours
        v_vent = v_vent * 3.6;                               //met le resultat en km/h
        timeLast = timeRun;                                  // ???
        anemoTickCompteur = 0;  //remise à 0 du compteur anemoTickCompteur
        Afficher();                                          //appelle le SP Afficher
    
      }
    }
    
    void Afficher()
    {
      lcd.setCursor(6, 0);               //place le cursor
      lcd.print(v_vent);                 //affiche la valeur de la vitesse du vent
      lcd.setCursor(7, 1);               //place le cursor
     
      {
        pinMode( 3, OUTPUT);
      }
     if ((v_vent = v_vent * 3.6)>100)// condition Km/h selon affichage sur l'écran
      {
       digitalWrite(RELAY, LOW);
        delay(30000);
    
      } else {
        // sinon on l'éteint
        digitalWrite(RELAY, HIGH);
        delay(20000);
      }


    C'est au niveau du relais je voudrais faire une temporisation "x temps".Comme vous pouvez le remarquer c'est du coller avec des modifications que j'ai apporté, mais sans plus, je ne suis même pas novice c'est du bidouillage ,mais j'arrive à comprendre certaines choses Après..............
    Mais en attendant merci ,et si çà peut intéresser certains, ce sera encore mieux.
    Dernière modification par JPL ; 01/02/2021 à 19h12. Motif: ajout de la balise Code (#) pour garder l’indentation

  4. #4
    invite7a0a8d2e

    Re : Temporisation d'un relais pour un anémomètre

    Je n'ai jamais programmé sur de l'Arduino, mais je vois que votre programme est plutôt bien réalisé et voici ce que je peux vous en dire.
    Vous avez déjà déclaré une interruption aynt l'ID anemo (qui vaut 2) qui permet de "faire quelque-chose" en boucle en appelant la procédure AnemoTicks().
    Vous appelez Afficher() à la fin d'AnemoTicks() et c'est au niveau de cette procédure que nous allons implémenter votre nouveau traitement.

    Tout est donc déjà prêt pour l'opération que vous comptez faire, à savoir (je reformule pour être sûr que c'est bien ce que vous voulez faire) : Lorsque la commande de fermeture de la serre a été initiée par la vitesse du vent supérieur à un seuil, on attend un certain temps (2 heures) pour à nouveau commander la réouverture de la serre.

    Donc, on va employer une variable qui va nous servir d'indicateur d'état de la serre, soit etat_serre, qui sera mise à 0 au début du programme et qui passera à 1 lorsque la commande de fermeture aura été demandée.
    On saura de cette manière qu'il ne faut plus chercher à fermer la serre selon la vitesse du vent, et qu'à la place il faut calculer le temps passé depuis la demande de fermeture et lancer l'ouverture de la serre si le délai est dépassé (soit 2 heures).
    On a donc besoin d'une autre variable indicatrice, qui stocke le moment de la fermeture, soit fermeture_serre_tic , qu'on initialise au moment de la fermeture.

    Code:
    #include <LiquidCrystal.h>
    int etat_serre =0;                                  // Indicateur d'état de la serre (0 = Ouvert/ 1=fermée)
    unsigned long fermeture_serre_tic = 0;              // tic de fermeture de la serre (le tic c'est "le temps")
    unsigned long duree_fermeture_serre = 180 * 60000;  // Durée max de fermeture de la serre en millisecondes (2 heures)
    
    int relaisPin = 3;
    int anemo = 2;     
    LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
    // initialisation, on définit les ports pour RS, E et D4 à D7
    
    unsigned long timeRun;
    unsigned long timeLast;
    float periode;
    const int RELAY = 3;
    /***************Variables pour la  vitesse du vent*****************************/
                           //declare un var anemo qui = 2
    float v_vent = 0.00;                     //var qui contiendra la vitesse du vent
    float rayonBras = 0.01;                  //rayon du bras 9cm => 0.09m
    int anemoTickCompteur = 0;               //variable pour le comptage du nombre de "TICKS" du capteur ILS de l'anemo
    float FEtalonage = 3.1;
    
    unsigned long previousMillis = 0;
    const unsigned long TimePause = 30 * 60000;
    const unsigned long TimeMarche = 5 * 60000 ;
    
    enum {ARRET, MARCHE} etat;
    
    void setup()
    {
     
      lcd.setCursor(0, 0);               //place le c  lcd.begin(16, 2);                  // definit l'écran sur caractères (16) et de lignes (2)
      delay(100);                        //pause
      lcd.setCursor(1, 0);               //place le cursor
      lcd.print("initialisation");       // affiche le message
      delay(500);                        //pause
      lcd.clear();                       //efface l'écran
      delay(250);                        //pause
      lcd.print("vent: ");               //affiche texte
      lcd.setCursor(6, 0);               //place le cursor
      lcd.print(v_vent);                 //affiche la valeur de la vitesse du vent égale à 0.00 au départ
      lcd.setCursor(11, 0);              //place le cursor
      lcd.print("km/h");                 //affiche le texte
       // On initialise les entrées/sorties
       
     pinMode(relaisPin, OUTPUT);
      digitalWrite (relaisPin, HIGH);  // démarre en marche
      etat = MARCHE;
      /*********************************************************************
          Mise en place des broches avec les fonctions d'interruption
      *********************************************************************/
      pinMode(anemo, INPUT); // On écrit l'état du relais//definit la pin anemo(2) comme une entrée  
      
      
    
      attachInterrupt(digitalPinToInterrupt(anemo), AnemoTicks, RISING);       //dès que la broche anemo(2) changera d'etat (RISING = état BAS vers HAUT (front montant)) on appelle le SP AnemoTicks
    }
    
    
    
    void loop()
    {
      timeRun = millis();  //affecte le temps depuis lequel le programme tourne à la var timeRu
    
    }
    
    
    void AnemoTicks ()
    {
      anemoTickCompteur++;
    
      if (anemoTickCompteur >= 4)
      {
        periode = (timeRun - timeLast) / 1000.0;             //???calcul la période et on divise par 1000.0 pour obtenir le résultat en seconde
        v_vent = rayonBras * 2 * 3.14 * (4 / periode) * FEtalonage; //calcul de la vitesse du vent avec la formule vitesse du vent = rayonBras*2pi*fréquence  (frequence=nb_tour/s) => résultat en m/s  2 Ticks = 1 tour/ 4 Ticks = 2 tours
        v_vent = v_vent * 3.6;                               //met le resultat en km/h
        timeLast = timeRun;                                  // ???
        anemoTickCompteur = 0;  //remise à 0 du compteur anemoTickCompteur
        Afficher();                                          //appelle le SP Afficher
    
        
      }
    }
    
    void Afficher()
    {
      lcd.setCursor(6, 0);               //place le cursor
      lcd.print(v_vent);                 //affiche la valeur de la vitesse du vent
      lcd.setCursor(7, 1);               //place le cursor
     
      {
        pinMode( 3, OUTPUT);
      }
    
    
    if (etat_serre = 0)
     { // Si la serre n'a pas encore été fermée
     if ((v_vent = v_vent * 3.6)>100)// condition Km/h selon affichage sur l'écran
      { // On ferme la serre
       digitalWrite(RELAY, LOW);
       delay(30000);
        // On notifie la fermeture
        etat_serre = 1;
        // On mémorise le Tic de fermeture
        fermeture_serre_tic = timerun; 
    
      } else 
       { // On ouvre la serre
        // sinon on l'éteint
        digitalWrite(RELAY, HIGH);
        delay(20000);
        // On notifie l'ouverture
        etat_serre = 0;
      }
    }
    else
    { // Ici on traite le cas où la serre a été fermée (etat_serre=1)
      // Tester ici si la fermeture de la serre est plus ancienne que 2 heures
      if ((timerun - fermeture_serre_tic) > duree_fermeture_serre )
      { // Le délai est dépassé, réouvrir la serre
        digitalWrite(RELAY, HIGH);
        delay(20000);
        // On notifie l'ouverture
        fermeture_serre = 0;
      }
    }
    Je vous laisse vérifier, en espérant ne pas avoir oublié une coquille.

  5. A voir en vidéo sur Futura
  6. #5
    gthum62

    Re : Temporisation d'un relais pour un anémomètre

    Merci beaucoup BrainMan,
    c'est exactement ce que je veux, mais je ne peux l'essayer car il y a une erreur quand je le téléverse,.
    "timerun" was not declared in this scope ; et le ligne if ((timerun - fermeture_serre_tic) > duree_fermeture_serre ) est en surbrillance.
    En attendant merci pour tout encore sincèrement.

  7. #6
    Jack
    Modérateur

    Re : Temporisation d'un relais pour un anémomètre

    C'est timeRun, pas timerun

  8. #7
    invite7a0a8d2e

    Re : Temporisation d'un relais pour un anémomètre

    Citation Envoyé par gthum62 Voir le message
    Merci beaucoup BrainMan,
    c'est exactement ce que je veux, mais je ne peux l'essayer car il y a une erreur quand je le téléverse,.
    "timerun" was not declared in this scope ; et le ligne if ((timerun - fermeture_serre_tic) > duree_fermeture_serre ) est en surbrillance.
    Ah oui je vois, c'est du C, il faut faire attention "à la casse" (c'est le cas de le dire ), je pense qu'il faut écrire timeRun et non pas timerun (une coquille donc)

  9. #8
    invite7a0a8d2e

    Re : Temporisation d'un relais pour un anémomètre

    Citation Envoyé par Jack Voir le message
    C'est timeRun, pas timerun
    Voilà c'est ça, on est d'accord.

  10. #9
    invite7a0a8d2e

    Re : Temporisation d'un relais pour un anémomètre

    Sinon, à part ça (dans le programme d'origine), je me demandais s'il était nécessaire de lancer, relancer etc, l'ouverture de la serre à chaque test de vitesse de vent.

    Code:
     if ((v_vent = v_vent * 3.6)>100)// condition Km/h selon affichage sur l'écran
      { // On ferme la serre
       digitalWrite(RELAY, LOW);
       delay(30000);
        // On notifie la fermeture
        etat_serre = 1;
        // On mémorise le Tic de fermeture
        fermeture_serre_tic = timerun; 
    
      } else 
       { // On ouvre la serre
        // sinon on l'éteint
        digitalWrite(RELAY, HIGH);
        delay(20000);
        // On notifie l'ouverture
        etat_serre = 0;
      }
    D'autant qu'il y a un delay(20000) qui bloque (si je ne m'abuse) la poursuite du programme (pendant 20 secondes probablement).

    Je ne sais pas si ça peut jouer sur la consommation électrique de tenter d'ouvrir la serre en boucle (c'est pour ça que je le note).
    Pour éviter ça on peut remplacer ce code par :

    Code:
     if ((v_vent = v_vent * 3.6)>100)// condition Km/h selon affichage sur l'écran
      { // On ferme la serre
       digitalWrite(RELAY, LOW);
       delay(30000);
        // On notifie la fermeture
        etat_serre = 1;
        // On mémorise le Tic de fermeture
        fermeture_serre_tic = timerun; 
    
      } else 
       { // On ouvre la serre
        if (etat_serre =1)
          { // sinon on l'éteint
            digitalWrite(RELAY, HIGH);
            delay(20000);
            // On notifie l'ouverture
            etat_serre = 0;
          }
      }

  11. #10
    gthum62

    Re : Temporisation d'un relais pour un anémomètre

    Bjr BrainMan,
    C'est très sympa de réfléchir au problème. En fait le procédeé c'est çà en grosses lignes:

    La serre est fermée quand la T° <35 ,là si le vent souffle très fort (45 km/h)pas de problème, puisqu'elle est fermée. Par contre ,le but ,c'est que si la T° est >35 donc la serre s'ouvre,mais si jamais un vent violent se met à souffler (>45km/h),donc elle se ferme, Jai mis 2 H de fermeture au cas ou si ça se calme et que le T° est encore >35,donc elle peut se rouvrir, mais si au bout de deux heure le vent souffle encore très fort, et bien elle se refermera aussitôt, d'ailleurs elle n'aura pas le temps de se rouvrir complètement,je pense. Après je peux moduler le temp de fermeture; on peut le mettre plus que deux ,8h par exemple ,et on verra demain quand ce sera calmé, çà c'est pas trop un souci; je modifierai.
    Le but c'est la temporisation ,c'est a dire que dés la première impulsion du contact ILS de l'anemo,selon la condition "if ((v_vent = v_vent * 3.6)>100)// condition Km/h selon affichage sur l'écran",cela enclenche le relais et maintient la fermeture pour 2 h ou(çà je règlerai) .
    J'ai testé les code donné(ET ENCORE MERCI POUR TOUT)mai malheureusement le relais s'active mais ne reste pas bloqué pour 2 h.Dans le premier code le relais ne s'active pas du tout et dans les deux autres ,il s'active mais ne reste pas bloqué pour 2 h.
    je vais checher encore

  12. #11
    invite7a0a8d2e

    Re : Temporisation d'un relais pour un anémomètre

    Citation Envoyé par gthum62 Voir le message
    J'ai testé les code donné(ET ENCORE MERCI POUR TOUT)mai malheureusement le relais s'active mais ne reste pas bloqué pour 2 h.Dans le premier code le relais ne s'active pas du tout et dans les deux autres ,il s'active mais ne reste pas bloqué pour 2 h.
    D'accord.
    Donc gardez plutôt le premier code que je vous ai envoyé.
    Le problème vient peut-être du fait que l'état réel de la serre ne correspond pas à l'indicateur etat_serre.
    Un truc simple pour s'en assurer c'est d'ouvrir la serre au lancement du programme, dans le setup, en mettant ce bout de code

    Code:
        // On ouvre la serre
        digitalWrite(RELAY, HIGH);
        delay(20000);
        // On notifie l'ouverture
        etat_serre = 0;
    Juste après le code (qui y est déjà), c'est pour indiquer où vous devez coller ce code
    Code:
      pinMode(anemo, INPUT); // On écrit l'état du relais//definit la pin anemo(2) comme une entrée
    (Il faut le placer avant la déclaration de l'interriuption pour éviter que AnemoTicks() ne soit appelé avant le code qui ouvre la serre

  13. #12
    gthum62

    Re : Temporisation d'un relais pour un anémomètre

    Bjr BrainMan,
    C'est très sympa de réfléchir au problème. En fait le procédeé c'est çà en grosses lignes:

    La serre est fermée quand la T° <35 ,là si le vent souffle très fort (45 km/h)pas de problème, puisqu'elle est fermée. Par contre ,le but ,c'est que si la T° est >35 donc la serre s'ouvre,mais si jamais un vent violent se met à souffler (>45km/h),donc elle se ferme, Jai mis 2 H de fermeture au cas ou si ça se calme et que le T° est encore >35,donc elle peut se rouvrir, mais si au bout de deux heure le vent souffle encore très fort, et bien elle se refermera aussitôt, d'ailleurs elle n'aura pas le temps de se rouvrir complètement,je pense. Après je peux moduler le temp de fermeture; on peut le mettre plus que deux ,8h par exemple ,et on verra demain quand ce sera calmé, çà c'est pas trop un souci; je modifierai.
    Le but c'est la temporisation ,c'est a dire que dés la première impulsion du contact ILS de l'anemo,selon la condition "if ((v_vent = v_vent * 3.6)>100)// condition Km/h selon affichage sur l'écran",cela enclenche le relais et maintient la fermeture pour 2 h ou(çà je règlerai) .
    J'ai testé les code donné(ET ENCORE MERCI POUR TOUT)mai malheureusement le relais s'active mais ne reste pas bloqué pour 2 h.Dans le premier code le relais ne s'active pas du tout et dans les deux autres ,il s'active mais ne reste pas bloqué pour 2 h.
    je vais checher encore

  14. #13
    gthum62

    Re : Temporisation d'un relais pour un anémomètre

    He bien ,
    non çà ne marche pas, j'ai essaye avec le premier (déjà le relais n'était pas actionné)ici c'est pareil: rien, j'ai par contre pris le dernier code, alors là le relais est actionné, en mettant la modif juste après le code,çà n'y fait rien ,pire çà indique l'écran "vent 0 km/h en faisant aller l'anemo rien ne se passe.
    Après je comprend vos modifs.J'ai essayer un peu de tout mais rien.Tant que l'écran indique le seuil le relais s'actione ,mais des en dessous il s'arrete

    Ce que je voudrais ,c'est que quand le seuil ( if ((v_vent = v_vent * 3.6)>100)// condition Km/h selon affichage sur l'écran ) >45 km/h) par exemple est atteins même qu'une fois (c'est à dire première impulsion çà déclenche le relais pour une tempo de 2 h par exemple, de toute façon tant le seuil est indiqué sur l'ecran est >45,la serre reste fermé.
    Ce serait comme si je temporise un éclairage d'escalier ,dés que j'appuis sur le bouton la lumière s'allume ,et je peux appuyer des centaine de fois, la lumière toujours allumée et des que la tempo est fini la lampe s'etteind.
    Ici c'est dés que >45 km/h serre fermée et quand l'ecran affichera un seuil <45 la tempo démarre.

  15. #14
    invite7a0a8d2e

    Re : Temporisation d'un relais pour un anémomètre

    Bizarre tout ça.
    Question bête : Vous êtes sûr d'avoir employé le code que j'ai posté, tel quel, sans l'avoir modifié, même pas le délai de 2 heures ?
    Sinon, pour y voir plus clair (on commence à parler de "versions" comme ça en l'air), ce qui serait bien ce serait de reposter la version de base (celle qui vous parait être la meilleur, à vous de voir) sur laquelle nous allons pouvoir plancher à nouveau.

  16. #15
    gthum62

    Re : Temporisation d'un relais pour un anémomètre

    le premier code,n'active pas du tout le relais meme .si je met

    (// On ouvre la serre
    digitalWrite(RELAY, HIGH);
    delay(20000);
    // On notifie l'ouverture
    etat_serre = 0

    après (pinMode(anemo, INPUT); // O)c'est pire meme pas indication sur écran vent 0. Par contre quand je met la dernière recommandation comme celle-ci,dessous, le relais s'active mais s'éteint tout de suite, j'ai remarqué et c'est normale ;c'est parce pendant un bref moment(puisque je lance l'anemo à la main don vent>),écran afficher, le relais s'active,mais comme je l'ai dis tout à l'heure ,c'est que dés la première impulsion ,il se bloque pour 2 heure. Après j'éspèreque je suis bien exprimé, c'est un défaut chez moi surtout à l'écrit.

    Code:
    #include <LiquidCrystal.h>
    int etat_serre =0;                                  // Indicateur d'état de la serre (0 = Ouvert/ 1=fermée)
    unsigned long fermeture_serre_tic = 0;              // tic de fermeture de la serre (le tic c'est "le temps")
    unsigned long duree_fermeture_serre = 180 * 60000;  // Durée max de fermeture de la serre en millisecondes (2 heures)
    
    int relaisPin = 3;
    int anemo = 2;     
    LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
    // initialisation, on définit les ports pour RS, E et D4 à D7
    
    unsigned long timeRun;
    unsigned long timeLast;
    float periode;
    const int RELAY = 3;
    /***************Variables pour la  vitesse du vent*****************************/
                           //declare un var anemo qui = 2
    float v_vent = 0.00;                     //var qui contiendra la vitesse du vent
    float rayonBras = 0.01;                  //rayon du bras 9cm => 0.09m
    int anemoTickCompteur = 0;               //variable pour le comptage du nombre de "TICKS" du capteur ILS de l'anemo
    float FEtalonage = 3.1;
    
    unsigned long previousMillis = 0;
    const unsigned long TimePause = 30 * 60000;
    const unsigned long TimeMarche = 5 * 60000 ;
    
    enum {ARRET, MARCHE} etat;
    
    void setup()
    {
     
      lcd.setCursor(0, 0);               //place le c  lcd.begin(16, 2);                  // definit l'écran sur caractères (16) et de lignes (2)
      delay(100);                        //pause
      lcd.setCursor(1, 0);               //place le cursor
      lcd.print("initialisation");       // affiche le message
      delay(500);                        //pause
      lcd.clear();                       //efface l'écran
      delay(250);                        //pause
      lcd.print("vent: ");               //affiche texte
      lcd.setCursor(6, 0);               //place le cursor
      lcd.print(v_vent);                 //affiche la valeur de la vitesse du vent égale à 0.00 au départ
      lcd.setCursor(11, 0);              //place le cursor
      lcd.print("km/h");                 //affiche le texte
       // On initialise les entrées/sorties
       
     pinMode(relaisPin, OUTPUT);
      digitalWrite (relaisPin, HIGH);  // démarre en marche
      etat = MARCHE;
      /*********************************************************************
          Mise en place des broches avec les fonctions d'interruption
      *********************************************************************/
      pinMode(anemo, INPUT); // On écrit l'état du relais//definit la pin anemo(2) comme une entrée  
      
      
    
      attachInterrupt(digitalPinToInterrupt(anemo), AnemoTicks, RISING);       //dès que la broche anemo(2) changera d'etat (RISING = état BAS vers HAUT (front montant)) on appelle le SP AnemoTicks
    }
    
    
    
    void loop()
    {
      timeRun = millis();  //affecte le temps depuis lequel le programme tourne à la var timeRu
    
    }
    
    
    void AnemoTicks ()
    {
      anemoTickCompteur++;
    
      if (anemoTickCompteur >= 4)
      {
        periode = (timeRun - timeLast) / 1000.0;             //???calcul la période et on divise par 1000.0 pour obtenir le résultat en seconde
        v_vent = rayonBras * 2 * 3.14 * (4 / periode) * FEtalonage; //calcul de la vitesse du vent avec la formule vitesse du vent = rayonBras*2pi*fréquence  (frequence=nb_tour/s) => résultat en m/s  2 Ticks = 1 tour/ 4 Ticks = 2 tours
        v_vent = v_vent * 3.6;                               //met le resultat en km/h
        timeLast = timeRun;                                  // ???
        anemoTickCompteur = 0;  //remise à 0 du compteur anemoTickCompteur
        Afficher();                                          //appelle le SP Afficher
    
        
      }
    }
    
    void Afficher()
    {
      lcd.setCursor(6, 0);               //place le cursor
      lcd.print(v_vent);                 //affiche la valeur de la vitesse du vent
      lcd.setCursor(7, 1);               //place le cursor
     
      {
        pinMode( 3, OUTPUT);
      }
    
     if ((v_vent = v_vent * 3.6)>100)// condition Km/h selon affichage sur l'écran
      { // On ferme la serre
       digitalWrite(RELAY, LOW);
       delay(30000);
        // On notifie la fermeture
        etat_serre = 1;
        // On mémorise le Tic de fermeture
        fermeture_serre_tic = timeRun; 
    
      } else 
       { // On ouvre la serre
        if (etat_serre =1)
          { // sinon on l'éteint
            digitalWrite(RELAY, HIGH);
            delay(20000);
            // On notifie l'ouverture
            etat_serre = 0;
          }
      }
    }
    Dernière modification par JPL ; 03/02/2021 à 23h59.

  17. #16
    invite7a0a8d2e

    Re : Temporisation d'un relais pour un anémomètre

    Un truc qui m'avait échappé et qui pourrait peut-être expliquer le non déclenchement en rapport avec la vitesse du vent :

    (1)
    Code:
    if ((v_vent = v_vent * 3.6)>100)
    Vous avez simplement recopié
    Code:
    v_vent = v_vent * 3.6;
    Or ce code indique que la variable v_vent prend la valeur v_vent * 3.6
    Donc il faut corriger le code (1) par :

    Code:
    if (v_vent > 100)
    Après, je me suis dit que les appels de type DigitalWrite(RELAY, LOW), qui selon vous conditionnent un relai nécessitent peut-être d'être rafraichis, mais ça dépend si c'est du relai qui reste en position ou pas, bref.
    Sinon, je me posais aussi la question de la nécessité de temporiser après écriture sur le relai, avec des valeurs aussi longues, genre 20 secondes (pourquoi ?)
    Si ce n'est pas un relai mais que ça fait avancer un moteur pas à pas, l'ouverture et la fermeture doit être lente.

  18. #17
    gthum62

    Re : Temporisation d'un relais pour un anémomètre

    Bjr BrainMan,
    J'ai mis if (v_vent > 100),çà ne va pas ;çà va mieux avec if ((v_vent = v_vent * 3.6)>100) cette valeur pour l'intant sur l'anemo me fait déclencher le relais à 35 km/h sur l'ecran,or si il reste afficher toujours 35 km/h mini ou plus le relais fonctionne, cé que je désir c'est que dés qu'il a atteind un fois les 35 km/h le relais reste contacter pendant 2 h, mais attention c'est la valeur écrite sur l'ecran qui fait déclencher le relais.
    Pour l'intant s'il tourne à 35km/h ou plus le relais est actionné, si c'est inscrit moins à l'ecran il s'arete.

  19. #18
    invite7a0a8d2e

    Re : Temporisation d'un relais pour un anémomètre

    Je suis en train de regarder plus en profondeur ce qui ne va pas.
    Il semblerait déjà que delay() ne peut fonctionner au sein d'une ISR (Sous-programme de type interruption).
    De la même manière, les variables qui doivent être communes à loop() et à l'ISR, comme c'est le cas avec timeRun, doivent être déclarées volatile, et de plus si cette variable fait plus d'1 Byte (ici c'est unsigned long donc > 1 Byte) il faut demander à ce que cette valeur soit stoquée dans la RAM, pour garantir son emploi (sinon on peut avoir des choses bizarres).
    Je regarde si on peut arranger ça.

    Un peu de lecture :
    Citation Envoyé par Arduino
    Inside the attached function, delay() won’t work and the value returned by millis() will not increment.
    Serial data received while in the function may be lost.

    You should declare as volatile any variables that you modify within the attached function. See the section on ISRs below for more information.
    https://www.arduino.cc/reference/en/...tachinterrupt/
    https://www.arduino.cc/reference/en/...iers/volatile/

  20. #19
    invite7a0a8d2e

    Re : Temporisation d'un relais pour un anémomètre

    J'ai fait quelques corrections et mis des commentaires, à tester.

    Code:
    #include <LiquidCrystal.h>
    int etat_serre =0;                                                     // Indicateur d'état de la serre (0 = Ouvert/ 1=fermée)
    unsigned long fermeture_serre_tic = 0;                       // tic de fermeture de la serre (le tic c'est "le temps")
    unsigned long duree_fermeture_serre = 120 * 60000;  // Durée max de fermeture de la serre en millisecondes (2 heures)
    
    int relaisPin = 3;
    int anemo = 2;     
    LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
    // initialisation, on définit les ports pour RS, E et D4 à D7
    
    // Temps en millisecondes depuis lequel le programme tourne 
    // Est déclaré volative pour permettre de transmettre cette valeur de manière fiable
    // vers une SP de type ISR (SP de type Interruption)
    volatile unsigned long timeRun;   
    
    unsigned long timeLast;
    float periode;
    const int RELAY = 3;
    
    /***************Variables pour la  vitesse du vent*****************************/
                           //declare un var anemo qui = 2
    float v_vent = 0.00;                     //var qui contiendra la vitesse du vent
    float rayonBras = 0.01;                  //rayon du bras 9cm => 0.09m
    int anemoTickCompteur = 0;               //variable pour le comptage du nombre de "TICKS" du capteur ILS de l'anemo
    float FEtalonage = 3.1;
    
    unsigned long previousMillis = 0;
    const unsigned long TimePause = 30 * 60000;
    const unsigned long TimeMarche = 5 * 60000 ;
    
    enum {ARRET, MARCHE} etat;
    
    void setup()
    {
      lcd.setCursor(0, 0);               // Place le c  lcd.begin(16, 2);                  // definit l'écran sur caractères (16) et de lignes (2)
      delay(100);                        // Pause
      lcd.setCursor(1, 0);               // Place le cursor
      lcd.print("initialisation");       // Affiche le message
      delay(500);                        // Pause
      lcd.clear();                       // Efface l'écran
      delay(250);                        // Pause
      lcd.print("vent: ");               // Affiche texte
      lcd.setCursor(6, 0);               // Place le cursor
      lcd.print(v_vent);                 // Affiche la valeur de la vitesse du vent égale à 0.00 au départ
      lcd.setCursor(11, 0);              // Place le cursor
      lcd.print("km/h");                 // Affiche le texte
      
      // On initialise les entrées/sorties
       
      etat = MARCHE;
      /*********************************************************************
          Mise en place des broches avec les fonctions d'interruption
      *********************************************************************/
      pinMode(anemo, INPUT); // On écrit l'état du relais, definit la pin anemo(2) comme une entrée  
     
      // Dès que la broche anemo(2) changera d'etat (RISING = état BAS vers HAUT (front montant)) on appelle le SP AnemoTicks
      attachInterrupt(digitalPinToInterrupt(anemo), AnemoTicks, RISING);      
    
      // On initialise timeLast
      timeLast = millis(); 
    }
    
    
    /*****************************************************/
    /** Boucle lancée automatiquement après Setup()     **/
    /*****************************************************/ 
    void loop()
    {
      // Interdit les interruptions, le temps que la variable timeRun soit chargée
      // pour éviter que AnemoTicks() soit lancé en plein chargement de la variable
      noInterrupts();
    
      // Affecte le temps depuis lequel le programme tourne à la variable timeRun
      timeRun = millis();  
      
      // Autorise à nouveau les interruptions
      Interrupts();
    }
    
    
    /***********************************************************/
    /** Sous-programme (ISR) appelé par interruption anemo    **/
    /** (Note : delay() ne peut pas fonctionner à ce niveau)  **/
    /** Une seule interruption sur 4 est prise en compte      **/
    /***********************************************************/
    void AnemoTicks()
    {
      anemoTickCompteur++;
    
      if (anemoTickCompteur >= 4)
      {
        // Remise à 0 du compteur anemoTickCompteur
        anemoTickCompteur = 0;                                     
    
        // Calcul la période et on divise par 1000.0 pour obtenir le résultat en seconde
        periode = (timeRun - timeLast) / 1000.0;                    
        
        // On initialise timeLast pour préparer le prochaine calcul de la période
        timeLast = timeRun;
     
        // calcul de la vitesse du vent avec la formule 
        // vitesse du vent = rayonBras * 2pi * fréquence  (frequence=nb_tour/s) 
        // => résultat en m/s  2 Ticks = 1 tour/ 4 Ticks = 2 tours
        v_vent = rayonBras * 2 * 3.14 * (4 / periode) * FEtalonage; 
        
        // Met le resultat en km/h
        v_vent = v_vent * 3.6;                                      
    
        // Appelle le SP d'affichage des informations surle panel LCD
        Afficher();                                                 
        
        // Appelle le SP de Gestion de la Serre
        GereSerre();                                                
      }
    }
    
    /***********************************************/
    /** Affichage des informations sur le PANEL   **/
    /***********************************************/
    void Afficher()
    {
      lcd.setCursor(6, 0);               // Place le cursor
      lcd.print(v_vent);                 // Affiche la valeur de la vitesse du vent
    
      lcd.setCursor(7, 1);               // Place le cursor
     
      pinMode( 3, OUTPUT);               // Prépare l'activation du relai relié au PIN 3
    }
    
    /***************************************************/
    /**  Gestion de la Serre (commande l'ouverture et **/
    /**  la fermeture)                                **/
    /***************************************************/
    void GereSerre()
    {
     if (v_vent > 27.77)  // condition Km/h selon affichage sur l'écran (100/3.6)
       { 
         // On ferme la serre
         digitalWrite(RELAY, LOW);
         
         // On notifie la fermeture
         etat_serre = 1;
         
         // On mémorise le Tic de fermeture
         fermeture_serre_tic = timeRun; 
       } 
     else 
       { 
        if (etat_serre = 1) 
          { // La serre a été fermée suite à un vent trop fort
            if ((timeRun - fermeture_serre_tic) > duree_fermeture_serre )
              {
               // On reouvre la serre préalablement fermée à cause du vent
               digitalWrite(RELAY, HIGH);
    
               // On notifie l'ouverture
               etat_serre = 0;
              }
            else
              {
               // On ferme la serre (ou on termine de la fermer)
               digitalWrite(RELAY, LOW);
              } 
          }
        else
          { 
            // On ouvre la serre
            digitalWrite(RELAY, HIGH);
          }
       }
    }
    J'espère n'avoir pas fait d'erreur de syntaxe (je travaille sur notepad)

  21. #20
    gthum62

    Re : Temporisation d'un relais pour un anémomètre

    Merci pour ton travail, mais là je me sens très gêné, je suis désolé mais çà ne fonctionne pas:au premier contact de l'ILS de l'anemo donc 0.2 km/h le relais s'enclenche et ne s'arrete plus du tout j'avais réglé le temps de fermeture 1 * 60000,je precise qu'il y a que 2 contacts sur l'anemo.
    Désolé

  22. #21
    invite7a0a8d2e

    Re : Temporisation d'un relais pour un anémomètre

    Citation Envoyé par gthum62 Voir le message
    au premier contact de l'ILS de l'anemo donc 0.2 km/h le relais s'enclenche et ne s'arrete plus du tout
    Oui c'est normal qu'il s'enclenche.
    AnemoTicks ne sera jamais appelé si l'anémomètre n'envoie pas de signal.
    Sinon s'il envoi un signal (donc au premier coup de vent), AnemoTicks() sera appelé.
    Ce qui permet, entre autre d'afficher la vitesse du vent à l'écran.

    Ensuite, puisque AnemoTicks() est appelé, que la vitesse du vent est inférieur à la valeur seuil de fermeture et que etat_serre est égal à 0, alors le code suivant est appelé en boucle :

    Code:
      // On ouvre la serre
      digitalWrite(RELAY, HIGH);
    Qui ouvre, ou qui ouvre, la serre ( ).
    Bref, qui fait quelque-chose en tout cas qui aboutit à ce que la serre termine ouverte, et ça pour sûr, puisqu'on appelle ce code en boucle.

    Pour que le programme bifurque vers une fermeture de la serre, il faut que le vent ait dépassé au moins 1 fois 27.77 affiché sur le panneau d'affichage (J'ai repris très exactement votre calcul)

    j'avais réglé le temps de fermeture 1 * 60000,je précise qu'il y a que 2 contacts sur l'anemo.
    Je ne comprend pas où vous avez réglé un temps de fermeture, ni pourquoi vous précisez qu'il y a 2 contacts sur l'anémo.

    Bon, je vois que ça avance, on va y arriver.

  23. #22
    gthum62

    Re : Temporisation d'un relais pour un anémomètre

    Bjr,
    j'avais mis " 1 * 60000,j ) pour pas faire 2 h à attendre, et après dire qu'il y avais 2 contacts sur l'anemo,c'était pour donner un peu plus d'information.
    Quand vous dites " que Oui c'est normal qu'il s'enclenche AnemoTicks ne sera jamais appelé si l'anémomètre n'envoie pas de signal."
    Mais pour ma part normalement le relais devrait s'actionner quand à l'ecran vitesse dépassée (27.7 km/h) et cela pendant 2h.Mais là le problème c'est que à peine qu'il a tourné il déclenche mais ne s'arrete plus du tout.
    le but, c'est que dés que vitesse atteint (27.7 comme avait écrit mais aussi affichage écran) le relais s'enclanche pour une duré(2h en, l'ocurence) et ensuite tout redevient normal.
    En tout ca ,je vous remercie pour votre dévouement et votre patience , mais si çà vous prend trop de temps, faut arrêter là, je verrai autrement,ne vous sentez pas obligé, parce que sincèrement çà me gêne,je ne voudrais pas abuser.

  24. #23
    invite7a0a8d2e

    Re : Temporisation d'un relais pour un anémomètre

    Citation Envoyé par gthum62 Voir le message
    Bjr,
    j'avais mis " 1 * 60000,j ) pour pas faire 2 h à attendre,
    D'accord, et effectivement j'ai mis 3h puis 2h, et c'est 1h, il suffit de corriger la ligne :
    Code:
    unsigned long duree_fermeture_serre = 120 * 60000;  // Durée max de fermeture de la serre en millisecondes (2 heures)
    par

    Code:
    unsigned long duree_fermeture_serre = 60 * 60000;  // Durée max de fermeture de la serre en millisecondes (1 heure)
    Donc pas 1*60000 mais 60*60000, c'est pour ça je me demandais d'où sortait le 1*60000
    60000 millisecondes ça fait 60 secondes = 1minute
    1 heure = 60 minutes = 60 * 60000 millisecondes

    Citation Envoyé par gthum62
    Quand vous dites " que Oui c'est normal qu'il s'enclenche AnemoTicks ne sera jamais appelé si l'anémomètre n'envoie pas de signal."
    Je reprends.
    Comme le programme est fait, le sous-programme AnemoTicks(), si vous ne branchiez pas l'anémomètre, ne serait jamais appelé.
    C'est l'anémomètre qui, lorsqu'il tourne, et lorsque la partie contact de sa roue codeuse atteint le senseur, envoi un signal vers un pin du boitier arduino.
    Ce signal déclenche, au niveau programme cette fois, une demande d'interruption.
    Cette interruption, si elle prise en compte (ça dépend du mot clé interrupt et noninterrupt) arrête le traitement là où il en était, et lance l'appel du sous-programme AnemoTicks().
    Ensuite, à la fin du sous-programme AnemoTicks(), il revient là où il en était (donc quelque-part dans la boucle loop()) et continue.

    Citation Envoyé par gthum62
    Mais pour ma part normalement le relais devrait s'actionner quand à l'ecran vitesse dépassée (27.7 km/h)
    Comme pour l'actionnement des relais de la serre, il n'y a pas d'affichage de la vitesse du vent si l'anémomètre ne tourne pas.
    Il ne va pas par exemple afficher "Vent : 0.0 km/h" , à part au tout début, au moment du lancement du programme (puisqu'on demande dans le setup de le faire).

    Donc pour en avoir le coeur net, voilà ce qui doit se passer : Normalement, comme le programme est actuellement conçu, et s'il n'y a pas de vent (oui, s'il n'y a pas de vent, il ne se passe RIEN, c'est le gros problème du programme tel qu'il a été conçu à la base).
    Affichage du message Vent : 0 km/h.
    Et c'est tout.

    Si vous faites alors légèrement tourner l'anémo, AnemoTicks() est appelé, la vitesse du vent est calculée (elle sera fausse, très sous-évaluée lors de ce premier calcul, mais à la limite ce n'est pas problème), puis cette vitesse est affichée "Vent : 0.1 km/h" par exemple.
    Dans la foulée, le sous-programme GereSerre() est appelé, et comme la vitesse est très inférieure à la vitesse limite qui force la fermeture de la serre, la commande d'ouverture de la serre est envoyée.

    Code:
            // On ouvre la serre
            digitalWrite(RELAY, HIGH);
    Et là, je vous avoue que je suis pas sûr de savoir précisément ce que fait cette commande, et on ne peut pas le déduire avec les informations précédentes.
    Donc, "ça ouvre" la serre, certes, mais :

    1) Est-ce que le fait d'avoir lancé cette commande fait que le relai de la serre reste en position (ici HIGH) et donc que le moteur de la serre continue d'ouvrir la serre jusqu'à la butée... s'il y a une butée (et ça prend combien de temps ????).

    2) Ou alors, le relai reçoit le message, envoi une impulsion au moteur de la serre (qui serait un pas à pas) et ça s'arrete là.

    Pour le moment, je continue de penser que c'est le fonctionnement 1) qui est le bon.

    Ce qui fait qu'à partir du moment où on a lancé la commande digitalWrite(RELAY, HIGH), (ou LOW, même problème), s'il n'y a pas de butée qui éteint le relai, il n'a aucune raison que le moteur ne s'arrête (je ne sais pas comment c'est fait, j'imagine qu'il doit y avoir un truc pour éviter de tout casser, bref).

    Citation Envoyé par gthum62
    Mais là le problème c'est que à peine qu'il a tourné il déclenche mais ne s'arrete plus du tout.
    Oui, c'est normal, si vous avez lançé l'anémo à la main au départ, que rien ne le fait plus bouger après, et que vous attendez, il ne se passera RIEN.
    Le calcul de la vitesse ne se fera pas.
    L'affichage restera à la vitesse initialement affichée (alors qu'on devrai avoir une vitesse égale à 0...).
    Et aucun changement ne sera conditionné dans l'état des relais de la serre.
    Si la serre est en cours d'ouverture, elle continuera à s'ouvrir.

    Voilà déjà pour être sûr qu'on a bien compris ce qui se passe, ce qui permet ensuite d'avancer.
    Je vous laisse me confirmer que c'est bien comme ça que ça se passe.
    Faites des tests pour valider/invalider des hypothèses, c'est comme ça qu'on fait des diagnostiques lorsque certains point échappent au simple raisonnement (méthode scientifique en somme).

    Citation Envoyé par gthum62
    En tout ca ,je vous remercie pour votre dévouement et votre patience , mais si çà vous prend trop de temps, faut arrêter là, je verrai autrement,ne vous sentez pas obligé, parce que sincèrement çà me gêne,je ne voudrais pas abuser.
    Non, ne vous en faites pas.
    J'aime bien programmer et résoudre des énigmes.

    Pour la suite, je pense que pour résoudre votre problématique, il va peut-être falloir revoir légèrement la structure du programme, j'y réfléchi.
    (On a par exemple des problèmes qui peuvent survenir suite à l'emploi de interrupt et noninterrupt, alors que c'était pourtant nécessaire au bon fonctionnent du programme... donc une voie sans issue)
    Il vaut mieux que le sous-programme d'interruption soit le plus court possible.
    L'affichage sur le panel peut tout à fait se faire dans la boucle loop, ainsi que le conditionnement des différents traitements.
    je me demande d'ailleurs si une solution plus solide ne serait pas par exemple de monter une autre interruption déclenchée par un timer, qui permettrait par exemple d'allouer une tranche de temps de calcul et de lancer le calcul de la vitesse du vent de temps en temps seulement, par exemple toutes les 15 secondes et pendant 5 secondes (inutile de faire du temps réel ici).
    Et le conditionnement de la serre ainsi que l'affichage se ferait dans la boucle loop();
    Comme ça on ne serait pas dépendant de la rotation de l'anémomètre pour ouvrir ou fermer la serre comme c'est le cas actuellement.

  25. #24
    invite7a0a8d2e

    Re : Temporisation d'un relais pour un anémomètre

    Voilà, ça donne quelque-chose comme ça :
    Code:
    #include <LiquidCrystal.h>
    int etat_serre =0;                                  // Indicateur d'état de la serre (0 = Ouvert/ 1=fermée)
    
    unsigned long fermeture_serre_tic = 0;              // tic de fermeture de la serre (le tic c'est "le temps")
    unsigned long duree_fermeture_serre = 120 * 60000;  // Durée max de fermeture de la serre en millisecondes (2 heures)
    
    // On démarre par le cycle Serre (donc on initialise avec la valeur Anemo... pour switcher tout de suite vers le cycle Serre)
    int cycle = 0;                          // Indicateur de Cycle, 0=Cycle gestion Anemo, 1=Cycle gestion Serre
    
    usigned long TicProchainCycle = 0;      // "Temps" précalculé à atteindre pour changer de Cycle 
    unsigned long DureeCycleSerre = 30000;  // Durée du Cycle Serre      30 Secondes
    unsigned long DureeCycleAnemo = 15000;  // Durée du Cycle Anemomètre 15 Secondes
    
    int relaisPin = 3;
    int anemo = 2;     
    
    // initialisation, on définit les ports pour RS, E et D4 à D7
    LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
    
    
    // Temps en millisecondes depuis lequel le programme tourne 
    // Est déclaré volative pour permettre de transmettre cette valeur de manière fiable
    // vers une SP de type ISR (SP de type Interruption)
    volatile unsigned long timeRun;   
    
    // Employé pour calculer l'interval de temps entre deux appels à la routine AnemoTicks()
    volatile unsigned long timeLast;
    
    float periode;
    const int RELAY = 3;
    
    /***************Variables pour la  vitesse du vent*****************************/
    float v_vent = 0.00;                     //var qui contiendra la vitesse du vent
    float rayonBras = 0.01;                  //rayon du bras 9cm => 0.09m
    int anemoTickCompteur = 0;               //variable pour le comptage du nombre de "TICKS" du capteur ILS de l'anemo
    float FEtalonage = 3.1;
    
    unsigned long previousMillis = 0;
    const unsigned long TimePause = 30 * 60000;
    const unsigned long TimeMarche = 5 * 60000 ;
    
    enum {ARRET, MARCHE} etat;
    
    /*************************************************************************/
    /*  Lancé automatiquement, avant loop(),au démarrage du programme        */
    /*************************************************************************/
    void setup()
    {
      // Definit l'écran sur caractères (16) et de lignes (2)
      lcd.begin(16, 2);  
    
      lcd.setCursor(0, 0);               // Place le curseur  
      delay(100);                        // Pause
      lcd.setCursor(1, 0);               // Place le curseur
      lcd.print("initialisation");       // Affiche le message
      delay(500);                        // Pause
    
      lcd.clear();                       // Efface l'écran
    
      delay(250);                        // Pause
      lcd.print("vent: ");               // Affiche le texte
      lcd.setCursor(6, 0);               // Place le curseur
      lcd.print(v_vent);                 // Affiche la valeur de la vitesse du vent égale à 0.00 au départ
      lcd.setCursor(11, 0);              // Place le curseur
      lcd.print("km/h");                 // Affiche le texte
      
      // Initialisation des entrées/sorties
      etat = MARCHE;
     
    /***************************************************************/
    /* Mise en place des broches avec les fonctions d'interruption */
    /***************************************************************/
      pinMode(anemo, INPUT);             // On écrit l'état du relais, definit la pin anemo(2) comme une entrée  
     
      pinMode(relaisPin, OUTPUT);        // Prépare l'activation du relai relié au PIN 3
    
      // On commence par interdire les interruptions
      noInterrupts();
    
      // Dès que la broche anemo(2) changera d'etat (RISING = état BAS vers HAUT (front montant))
      // on appelle le SP AnemoTicks
      attachInterrupt(digitalPinToInterrupt(anemo), AnemoTicks, RISING);    
    }
    
    /*****************************************************/
    /** Boucle lancée automatiquement après Setup()     **/
    /*****************************************************/ 
    void loop()
    {
      timeRun = millis();
     
      if (timeRun > TicProchainCycle)
        {// Le tic (temps actuel en millisecondes) a dépassé le tic indiquant qu'il faut changer de cycle
    
          // Préparation de la valeur à dépasser pour lancer un prochain cycle de lecture Anemo ou Gestion Serre
          if (Cycle = 0)
            { // On est actuellement dans le cycle Anemo
    
             // On interdit les interruptions
             noInterrupts();
    
             TicProchainCycle = timeRun + DureeCycleSerre;
            
             // On indique qu'on est maintenant dans le cycle Gestion Serre
             Cycle = 1;   
            }
          else
            {// On est actuellement dans le cycle Gestion Serre
             TicProchainCycle = timeRun + DureeCycleAnemo;
    
             // On indique qu'on est maintenant dans le cycle Lecture Anemo
             Cycle = 0;  
    
             // Charge timeLast avec la valeur timeRun, pour indiquer qu'il faut éviter de calculer la vitesse
             // du vent la premiere fois que le cycle anemo démarre
             timeLast = timeRun;
    
             // On autorise les interruptions  
             Interrupts();
            }
        }
    
     
      if (cycle = 0) 
        {// On est dans le cycle Anemo, ne rien faire
        }
       else
        {// On est dans le cycle interdisant les interruption
         // Appelle le SP de Gestion de la Serre
         GereSerre();  
        }
    
       // Appelle à tous les coups le SP d'affichage des informations sur le panel LCD
       Afficher();
    }
    
    
    /***********************************************************/
    /** Sous-programme (ISR) appelé par interruption anemo    **/
    /** (Note : delay() ne peut pas fonctionner à ce niveau)  **/
    /** Une seule interruption sur 4 est prise en compte      **/
    /***********************************************************/
    void AnemoTicks()
    {
      anemoTickCompteur++;
    
      if (anemoTickCompteur >= 4)
      {
        // Remise à 0 du compteur anemoTickCompteur
        anemoTickCompteur = 0;                                     
    
        if (timeLast = timeRun)
          { // Ne pas Calculer la valeur du vent ce tour ci (la valeur actuelle du vent est conservée)
          }
        else
          { 
           // Calcul la période et on divise par 1000.0 pour obtenir le résultat en seconde
           periode = (timeRun - timeLast) / 1000.0;                    
        
           // On initialise timeLast pour préparer le prochaine calcul de la période
           timeLast = timeRun;
     
           // calcul de la vitesse du vent avec la formule 
           // vitesse du vent = rayonBras * 2pi * fréquence  (frequence=nb_tour/s) 
           // => résultat en m/s  2 Ticks = 1 tour/ 4 Ticks = 2 tours
           v_vent = rayonBras * 2 * 3.14 * (4 / periode) * FEtalonage; 
        
           // Met le resultat en km/h
           v_vent = v_vent * 3.6;
          }                                      
      }
    }
    
    /***********************************************/
    /** Affichage des informations sur le PANEL   **/
    /***********************************************/
    void Afficher()
    {
      lcd.setCursor(6, 0);               // Place le curseur
      lcd.print(v_vent);                 // Affiche la valeur de la vitesse du vent
      lcd.setCursor(7, 1);               // Place le curseur ??? Pourquoi faire....
    }
    
    /***************************************************/
    /**  Gestion de la Serre (commande l'ouverture et **/
    /**  la fermeture)                                **/
    /***************************************************/
    void GereSerre()
    {
      if (v_vent > 27.77)  // condition Km/h selon affichage sur l'écran (100/3.6)
        { 
         // On ferme la serre
         digitalWrite(RELAY, LOW);
         
         // On notifie la fermeture
         etat_serre = 1;
         
         // On mémorise le Tic de fermeture
         fermeture_serre_tic = timeRun; 
        } 
      else 
        { 
         if (etat_serre = 1) 
           {// La serre a été fermée suite à un vent trop fort
            if ((timeRun - fermeture_serre_tic) > duree_fermeture_serre )
              {
               // On reouvre la serre préalablement fermée à cause du vent
               digitalWrite(RELAY, HIGH);
    
               // On notifie l'ouverture
               etat_serre = 0;
              }
            else
              {
               // On ferme la serre (ou on termine de la fermer)
               digitalWrite(RELAY, LOW);
              } 
           }
         else
           { 
            // On ouvre la serre
            digitalWrite(RELAY, HIGH);
           }
       }
    }
    Fait à main levée, donc peut-être quelques erreurs de syntaxe.
    A tester.

  26. #25
    gthum62

    Re : Temporisation d'un relais pour un anémomètre

    Merci alors je'ai testé il y a en effet quelques erreur de syntaxe,le programme téléversé donne ceci
    l'ecran affiche initialisation,(comme d'habitude)tout de suite après, il affiche vent: 0.00 km/h et le relais s'active ,quand je tourne l'anémo pas de vitesse du vent qui s'affiche.
    j'ai réglé pour faire l'essai ""unsigned long duree_fermeture_serre = 1 * 60000; // Durée max de fermeture de la serre en millisecondes (2 heures)" donc 1 mn et là au bout d'une mn le relais se désactive(là c'est oh).
    Il ya juste que la vitesse du vent ne s'affiche pas et que si j'ai bien compris donc çà ne peut pas déclencher le relai quant le seuil dépassé.
    Encore merci

  27. #26
    invite7a0a8d2e

    Re : Temporisation d'un relais pour un anémomètre

    Citation Envoyé par gthum62 Voir le message
    Merci alors je'ai testé il y a en effet quelques erreur de syntaxe,le programme téléversé donne ceci
    l'ecran affiche initialisation,(comme d'habitude)tout de suite après, il affiche vent: 0.00 km/h et le relais s'active ,quand je tourne l'anémo pas de vitesse du vent qui s'affiche.
    Il faut tourner l'anémo lorsque la prise en compte de l'anémomètre est activée (il y a maintenant un cycle qui alterne anémo ou serre)
    Pour être sur que l'anémomètre ne renvoi pas la vitesse du vent, il faut essayer de le faire tourner pendant plus de 30 secondes.

    Sinon, il serait bien que vous remettiez le programme corrigé, s'il y a avait des erreurs de syntaxe, et que vous les avez corrigés, il vaudrait mieux qu'on soit sûr de parler de la même chose (si ça se trouve, la correction a provoqué un dysfonctionnement ou met en lumière un autre problème que je ne peux pas deviner d'ici)

  28. #27
    gthum62

    Re : Temporisation d'un relais pour un anémomètre

    Je me suis mal exprimer c'est des majuscule et des miniscules qu'il fallait changer mais c'est toujours pareil

  29. #28
    invite7a0a8d2e

    Re : Temporisation d'un relais pour un anémomètre

    Citation Envoyé par gthum62 Voir le message
    Je me suis mal exprimer c'est des majuscule et des miniscules qu'il fallait changer mais c'est toujours pareil
    Daccord.
    Vous avez essayé de faire tourner l'anémomètre pendant plus de 30 secondes pour vérifier si v_vent est affiché ou non (s'il vaut alors plus de 0 km/h) ?

  30. #29
    gthum62

    Re : Temporisation d'un relais pour un anémomètre

    oui toujours pareil ,indique pas la vitesse du vent affichage ''vent:0.00 km/h" le relais démarre tout de suite et s'arrete comme prévu (là il est bien temporisé.

  31. #30
    invite7a0a8d2e

    Re : Temporisation d'un relais pour un anémomètre

    Citation Envoyé par gthum62 Voir le message
    oui toujours pareil ,indique pas la vitesse du vent affichage ''vent:0.00 km/h" le relais démarre tout de suite et s'arrete comme prévu (là il est bien temporisé.
    Ça fait comme si AnemoTicks() n'était pas appelé...
    Il faudrait que vous le vérifiez.

Page 1 sur 2 1 DernièreDernière

Discussions similaires

  1. [Thermique] Problème de relais de temporisation pour PAC Sofath
    Par invite34fc0b27 dans le forum Dépannage
    Réponses: 117
    Dernier message: Aujourd'hui, 16h08
  2. Recherche pour relais commandé avec temporisation
    Par invitec4fc901c dans le forum Électronique
    Réponses: 12
    Dernier message: 15/02/2015, 13h22
  3. temporisation relais 24v
    Par invite760550e1 dans le forum Électronique
    Réponses: 5
    Dernier message: 10/11/2010, 14h21
  4. Relais avec temporisation
    Par invitee29491f1 dans le forum Électronique
    Réponses: 8
    Dernier message: 28/07/2007, 21h47
  5. Temporisation pour relais
    Par invite04cd3749 dans le forum Électronique
    Réponses: 22
    Dernier message: 01/04/2007, 01h40