supprimer fin de course bas par une tempo

Bonjour,

Je suis en train de faire une porte de poulailler automatique sauf que j'aimerais supprimer le fin de course bas par une temporisation
Le programme que j'ai actuellement fonctionne avec 2 fins de course haut et bas quand l'un ou l'autre est actionné lors de la fermeture ou l'ouverture de la porte celui ci arrête le moteur.
Je souhaiterais enlever le fin de course bas et arrêté le moteur lorsque j'ouvre la porte avec une temporisation.
Arduino Uno avec moteur dc et carte l293d

int commande_haut = 4; // Déclaration broche Bouton fermeture
int commande_bas = 5; // Déclaration broche Bouton ouverture
int fin_de_course_haut = 6; // Capteur fin de course haut
int fin_de_course_bas = 7; /// Capteur fin de course bas
int MotorPin1 = 8;  // Déclaration broche IN1 L293D
int MotorPin2 = 9;  // Déclaration broche IN2 L293D
int MotorPin3 = 10; // Déclaration broche IN3 L293D
int MotorPin4 = 11; // Déclaration broche IN4 L293D

int LuminositePin = A0; // Déclaration broche LDR
int Luminosite = 0; // Variable de la luminosité

int Tour = 0;
int delayTime = 10; // Temps entre chaque pas 10ms
int Seuil_Jour = 250; // Variable de luminosité seuil pour le jour
int Seuil_Nuit = 50; // Variable de luminosité seuil pour la nuit
int Tempo_luminosite = 10000; // Temporisation luminosité 10 secondes = 10000ms

boolean porte_fermee = false; //Déclaration variable porte fermée
boolean porte_ouverte = false; //Déclaration variable porte ouverte
boolean fdch = false; // Déclaration variable Fin de Course Haut
boolean fdcb = false; // Déclaration variable Fin de Course Bas
boolean etat_bp_h = false, etat_bp_b = false; // Déclaration des variables bas et haut
boolean mem_h = false, mem_b = false, mem_fdch = false,  mem_fdcb = false; // Déclaration des mémoires
boolean mem_mouvement = false; // Déclaration de la mémoire mouvement
boolean mem_lumiere = false; // Déclaration de la mémoire lumière
boolean mem_init = false; // Déclaration de la mémoire initialisation
boolean Detecte_lumiere = false; // Déclaration variable détection lumière
boolean Jour = true; // Déclaration variable Jour = 1 | Nuit = 0
boolean Initialisation = false; // Déclaration variable initialisation

// État d'activation de la tempo
boolean tempoActive = false;

// Temps à l'activation de la tempo
unsigned long tempoDepart = 0;

void setup() {
  Serial.begin(9600); // Ouverture du port série et debit de communication fixé à 9600 bauds
  pinMode(commande_haut, INPUT_PULLUP); // Déclaration entrée pull-up sur entrée BP haut
  pinMode(commande_bas, INPUT_PULLUP); // Déclaration entrée pull-up sur entrée BP bas
  pinMode(fin_de_course_haut, INPUT_PULLUP); // Déclaration entrée pull-up sur entrée Fin de course haut
  pinMode(fin_de_course_bas, INPUT_PULLUP); // Déclaration entrée pull-up sur entrée Fin de course bas
  pinMode(MotorPin1, OUTPUT); // Déclaration de la sortie A- Moteur
  pinMode(MotorPin2, OUTPUT); // Déclaration de la sortie A+ Moteur
  pinMode(MotorPin3, OUTPUT); // Déclaration de la sortie B- Moteur
  pinMode(MotorPin4, OUTPUT); // Déclaration de la sortie B+ Moteur

  Lance_initialisation();
}


void Lance_initialisation() {
  Fermer_porte_Initialisation();
}


void loop() {
  Luminosite = analogRead(LuminositePin);
  if (Initialisation) {
Serial.println(Luminosite); // Affichage sur le moniteur série du texte
    if (Luminosite >= Seuil_Jour)
    {
      Detecte_lumiere = true;
    }
    if (Luminosite <= Seuil_Nuit)
    {
      Detecte_lumiere = false;
     }
    if (Detecte_lumiere != mem_lumiere) {
      tempoActive = true;
      tempoDepart = millis();
      Serial.println("La lumière lance tempo"); // Affichage sur le moniteur série du texte
    }
    if (Detecte_lumiere && tempoActive && ((millis() - tempoDepart) >= Tempo_luminosite))
    {
      Jour = true;
      Serial.println("Il fait jour"); // Affichage sur le moniteur série du texte
      tempoActive = false;
      if (!fdcb  && !porte_ouverte) {
        Ouvrir_porte();
      }
    }
    mem_lumiere = Detecte_lumiere;

    if (!Detecte_lumiere && tempoActive && (millis() - tempoDepart) >= Tempo_luminosite)
    {
      Jour = false;
      Serial.println("Il fait nuit"); // Affichage sur le moniteur série du texte
      tempoActive = false;
      if (!fdch  && !porte_fermee){
      Fermer_porte();
    }}
    mem_lumiere = Detecte_lumiere;
  }

  etat_bp_h = !digitalRead(commande_haut); // Inverse de la lecture sur entrée BP haut
  etat_bp_b = !digitalRead(commande_bas); // Inverse de la lecture sur entrée BP bas
  fdch = !digitalRead(fin_de_course_haut); // Inverse de la lecture sur entrée Fin de course haut
  fdcb = !digitalRead(fin_de_course_bas); // Inverse de la lecture sur entrée Fin de course bas

  if (fdch != mem_fdch) // Changement d'état du fin de course haut (front montant ou descendant)
  {
    if (fdch) 
    {
      Serial.println("Porte fermée !"); // Affichage sur le moniteur série du texte
    }
    if (!fdch)
    {
      Serial.println("Porte non fermée"); // Affichage sur le moniteur série du texte
    }
  }
  if (fdcb != mem_fdcb) // Changement d'état du fin de course bas (front montant ou descendant)
  {
    if (fdcb) 
    {
      Serial.println("Porte ouverte !"); // Affichage sur le moniteur série du texte
    }
    if (!fdcb)
    {
      Serial.println("Porte non ouverte"); // Affichage sur le moniteur série du texte
    }
  }
  mem_fdcb = fdcb; // Mémorisation du nouvel état du fin de course bas

  if (etat_bp_h != mem_h) // Changement d'état du bouton poussoir haut (front montant ou descendant)
  {
    Serial.println("Appui BP Haut"); // Affichage sur le moniteur série du texte
    if (etat_bp_h && !etat_bp_b && !fdch && !porte_fermee) // Appui sur BP haut mais pas sur le bas
    {
      Fermer_porte(); // Lancer la fonction sens normal
    }
  }
  mem_h = etat_bp_h; // Mémorisation du nouvel état du bouton haut
  if (etat_bp_b != mem_b) // Changement d'état du bouton poussoir bas (front montant ou descendant)
  {
    if (etat_bp_b && !etat_bp_h && !fdcb && !porte_ouverte) // Appui sur BP bas mais pas sur le haut
    {
        Ouvrir_porte();
    }
  }
  mem_b = etat_bp_b; // Mémorisation du nouvel état du bouton bas
}


void Fermer_porte_Initialisation() {
      delay(5000);
  while (!fdch) {
      digitalWrite(MotorPin1, HIGH);
      digitalWrite(MotorPin2, LOW);
      digitalWrite(MotorPin3, HIGH);
      digitalWrite(MotorPin4, LOW);
      Serial.println("Fermer porte"); // Affichage sur le moniteur série du texte
      fdch = !digitalRead(fin_de_course_haut);
      etat_bp_b = !digitalRead(commande_bas); // Inverse de la lecture sur entrée BP bas
      if (fdch)
      {
        Serial.println("Porte en haut"); // Affichage sur le moniteur série du texte
        Arret();
        porte_fermee = true;
        porte_ouverte = false;
        Initialisation = true;
        break;
      }
  }
}

void Fermer_porte() {
  while (!fdch) {
      digitalWrite(MotorPin1, HIGH);
      digitalWrite(MotorPin2, LOW);
      digitalWrite(MotorPin3, HIGH);
      digitalWrite(MotorPin4, LOW);
      Serial.println("Fermer porte"); // Affichage sur le moniteur série du texte

      fdch = !digitalRead(fin_de_course_haut);
      etat_bp_b = !digitalRead(commande_bas); // Inverse de la lecture sur entrée BP bas
      if (fdch || etat_bp_b)
      {
        porte_fermee = true;
        porte_ouverte = false;
        Serial.println("Porte en haut"); // Affichage sur le moniteur série du texte
        Arret();
        break;
      }
  }
}

void Ouvrir_porte() {
  while (!fdcb) {
    digitalWrite(MotorPin1, LOW);
    digitalWrite(MotorPin2, HIGH);
    digitalWrite(MotorPin3, LOW);
    digitalWrite(MotorPin4, HIGH);
    Serial.println("Ouvrir porte"); // Affichage sur le moniteur série du texte
   
   fdcb = !digitalRead(fin_de_course_bas);
   etat_bp_h = !digitalRead(commande_haut); // Inverse de la lecture sur entrée BP haut
      if (fdcb || etat_bp_h)
      {
        porte_fermee = false;
        porte_ouverte = true;
        Serial.println("Porte en bas"); // Affichage sur le moniteur série du texte
        Arret();
        break;
      }
  }
}


void Arret() {
  digitalWrite(MotorPin1, LOW);
  digitalWrite(MotorPin2, LOW);
  digitalWrite(MotorPin3, LOW);
  digitalWrite(MotorPin4, LOW);
  tempoActive = 0;
}

Regardez les projets finis il y a des tonnes d’exemples.

Vu le peu de "répétabilité" des moteurs dans la durée (je suppose que vous attendiez que ça fonctionne plusieurs mois/années) et du glissement de la porte vous allez sans doute au devant de déceptions - soit la porte ne sera pas complètement fermée, soit ça va forcer si vous avez un système rigide (ou votre corde sera trop détendue ou s’enroulera dans l’autre sens en rouvrant la porte)

Sinon pour votre question ça se fait avec millis() en notant le temps de départ et en attendant qu’un certain temps se soit écoulé. (Cf blink without delay)

C’est typiquement une définition de programme qui se prête bien à la programmation par machine à états (cf mon tuto éventuellement)

Effectivement je vais garder mon fin de course bas, car le moteur aura des variations de puissance et cela ne sera pas juste a tout les coups.
J'aimerais mettre un fin de course NC, alors que le programme actuel et fait pour un FDC NO, et je ne vois pas comment faire dans le programme ?!

J'aimerais savoir aussi si il est possible de rajouter un mode veille sur l'arduino Uno pour que cela consomme le moins possible ?!

Merci.

Le code n’est pas très « propre » - c’est quelque chose copié sur internet je suppose ?

Regardez le blog perso de @hbachetti (chrerchez RitonDuino) de mémoire il a partagé toutes ses recherches sur la gestion de sa porte de poulailler y compris la consommation électrique et usage de panneau solaire.

Pour passer d’un NO à un NC il suffit d’inverser vos tests sur HIGH ou LOW concernant ce fin de course (donc inverser vos while (!fdcb) ou ce que vous mettez dans fdcb)

Merci je suis aller voir c'est très voir trop complet pour moi.

je regarde maintenant comment rajouter la variable de temps qu'il met sur son site. Car je souhaiterais arreter le moteur au bout d'un certain temps en cas de divers pb.

#define MOTOR_MAX_ONTIME 15000

mais je ne sais pas ou la mettre dan mon code.

pour infos je me suis basé sur ce tutos

https://electrotoile.eu/fabrication-diy-porte-poulailler-automatique-arduino.php

djgary:
Merci je suis aller voir c'est très voir trop complet pour moi.

prenez que ce qui vous intéresse...

djgary:
je regarde maintenant comment rajouter la variable de temps qu'il met sur son site. Car je souhaiterais arreter le moteur au bout d'un certain temps en cas de divers pb.
#define MOTOR_MAX_ONTIME 15000
mais je ne sais pas ou la mettre dan mon code.

il faut enregistrer le moment de départ du moteur dans une variable globale et lorsque le moteur bouge comparer le temps courant (millis) avec la valeur enregistrée et voir si la différence dépasse votre temps max.

Je commence a pigé un peu plus, mais c'est toujours le fouara dans ma tete

Dans void setup il faut que je rajoute

// on initialise le temps
    temps = millis();

dans void loop
je dois rajouter la notion de temps
on avance

J-M-L:
Vu le peu de "répétabilité" des moteurs dans la durée (je suppose que vous attendiez que ça fonctionne plusieurs mois/années) et du glissement de la porte vous allez sans doute au devant de déceptions - soit la porte ne sera pas complètement fermée, soit ça va forcer si vous avez un système rigide (ou votre corde sera trop détendue ou s’enroulera dans l’autre sens en rouvrant la porte)

J-M-L n'a pas tort. Avec une ficelle et une porte pont levis c'est difficile de se passer de FDC.
Mais pour certaines raisons (humidité, salissures), je conseillerais un FDC du type ampoule REED + aimant.

Sur mon projet j'ai expérimenté deux possibilités :

Servomoteur avec FDC mais c'est une porte à guillotine donc on peut placer les deux FDC en haut :


Sur ce dessin les contacts de fin de course sont en jaune.

Solution motoréducteur + courroie
Là j'utilise une mesure du courant moteur (résistance sur la broche GND du L293) et une temporisation au cas où la mesure ne fonctionne pas.
Impossible avec une porte à pont levis + ficelle.

djgary:
J'aimerais savoir aussi si il est possible de rajouter un mode veille sur l'arduino Uno pour que cela consomme le moins possible ?!

Dans quel but ?
Si c'est dans l'optique d'une alimentation par batterie la UNO est un mauvais choix.

En faite j'ai suivie le tuto du lien que j'ai mis plus haut, voila pourquoi j'ai pris un Arduino UNO.
Maintenant j’espère qu'un petit panneaux et un batterie 12v de 7A suffira.
J'ai découvert ton tuto que hier qui et d’ailleurs vraiment bien et complet, juste un peu plus complexe que celui que j'ai suivie. Car j'ai un peu de mal avec tes schémas électrique et la programmation en plusieurs partie.

Oui bien sûr, je comprends, mais l'auteur utilise une alimentation secteur.

Une UNO consomme 11mA en mode veille (alimentée sous 12V). A cela il faut ajouter 10mA pour le L293.

Avec une batterie de 7AH l'autonomie sera de 333 heures (13 jours). C'est beaucoup mais en même temps une période de 13 jours sans soleil en hiver est possible.
Ensuite il y a le problème du choix du chargeur, car il est hors de question de brancher un panneau sur une batterie plomb directement.
Une batterie plomb se recharge à courant constant (1ère phase) puis à tension constante (2ème phase), tout comme une LITHIUM-ION d'ailleurs (sauf qu'elle n'aime pas la charge en floating).
De plus la charge à tension constante doit être régulée en fonction de la température, est c'est très précis.

alimentation-par-batterie-panneaux

un kit comme solaire (lien) gère le chargement automatiquement ?!

https://fr.aliexpress.com/item/4001267791597.html?spm=a2g0o.detail.1000014.31.5ab376b9HF7b7z&gps-id=pcDetailBottomMoreOtherSeller&scm=1007.13338.192130.0&scm_id=1007.13338.192130.0&scm-url=1007.13338.192130.0&pvid=2200699d-64cd-4421-9144-8b0ef37fdec8&_t=gps-id:pcDetailBottomMoreOtherSeller,scm-url:1007.13338.192130.0,pvid:2200699d-64cd-4421-9144-8b0ef37fdec8,tpp_buckets:668%230%23131923%230_668%23888%233325%238_3338%230%23192130%230_3338%233142%239890%238_668%232846%238116%23936_668%232717%237563%23590_668%231000022185%231000066058%230_668%233422%2315392%23106

https://fr.aliexpress.com/item/32287069409.html?spm=a2g0s.9042311.0.0.27426c375ZQrSJ

Ce chargeur 3A peut convenir pour une batterie plomb, il est compensé en température.
Pour une batterie 7AH il ne faudra pas dépasser un courant de C/10, donc 700mA.
Je ne sais pas si ce chargeur permet de régler le courant de charge (j'espère), mais il est facile de le limiter par le choix du panneau. Un panneau 18V est nécessaire.

djgary:
un kit comme solaire (lien) gère le chargement automatiquement ?!

https://fr.aliexpress.com/item/4001267791597.html?spm=a2g0o.detail.1000014.31.5ab376b9HF7b7z&gps-id=pcDetailBottomMoreOtherSeller&scm=1007.13338.192130.0&scm_id=1007.13338.192130.0&scm-url=1007.13338.192130.0&pvid=2200699d-64cd-4421-9144-8b0ef37fdec8&_t=gps-id:pcDetailBottomMoreOtherSeller,scm-url:1007.13338.192130.0,pvid:2200699d-64cd-4421-9144-8b0ef37fdec8,tpp_buckets:668%230%23131923%230_668%23888%233325%238_3338%230%23192130%230_3338%233142%239890%238_668%232846%238116%23936_668%232717%237563%23590_668%231000022185%231000066058%230_668%233422%2315392%23106

Non :

Courant de charge: 10-100A

Une batterie de 7AH ne supportera pas ce courant de 10A, en tous cas pas longtemps.

Tension de charge flottante: 13.7V (defaul, réglable)

La tension de charge floating ne doit pas être réglable manuellement, sauf si la température est constante. Elle doit être asservie en température, et de manière très précise.

https://ni-cd.net/wpnicd/index.php/la-charge-des-batteries-au-plomb/

Vous devez aussi trouver sur les sites constructeur une abaque résumant ces valeurs.
Soit pour résumer : 14.6V à -10°C 13.6V à +25°C et 13.2V à +40°C.

Donc 13.7V est une tension de floating convenable pour une température d'environ 23 à 24°C.

D'après ce même site, le courant de charge peut être au maxi de C/5, donc 1.4A pour une batterie de 7AH.

https://www.manomano.fr/p/panneau-solaire-polycristallin-10w-12v-4304888

Quand je parle de panneau 18V, en général il s'agit d'un panneau 12V, dont la tension nominale est en général de 18V.
Il faut plutôt interpréter par "panneau prévu pour une batterie 12V".

Exemple :
https://www.manomano.fr/p/panneau-solaire-polycristallin-10w-12v-4304888

Puissance maximale : 10 W.
Tension à puissance maximum : 18,1 V.
Courant à puissance maximum : 0,56 A.
Tension en circuit ouvert : 22,3 V.
Courant de court-circuit : 0,60 A.

Ne jamais acheter un panneau dont ces 5 caractéristiques ne sont pas précisées.