> >

guide de fabrication d'un portier automatique pour poulailler Fabrication d'une porte auto pour poulailler


Fabriquer porte poulailler automatique DIY

Dans cet article découvrez l'évolution de mon projet de porte automatique pour poulailler qui lorsqu'il sera finalisé pourra être utilisé comme un tutoriel afin de vous guider dans la réalisation de votre propre portier automatique de poulailler afin de sécuriser vos poules dans le poulailler.

Sommaire :

Le projet : Porte automatique de poulailler
Etape 1 : Motorisation à commande manuelle de la porte de poulailler
Etape 2 : Automatisation du portier pour poulailler
Etape 3 : Sécurisation de la porte du poulailler
Activités pratiques (BAC PRO MELEC)


guide de fabrication d'un portier automatique pour poulailler Le projet : Porte automatique de poulailler

Ayant subi à deux reprises les attaques nocturne d'un prédateur, je me suis lancé dans le projet de fabriquer une porte de poulailler motorisée afin de pouvoir l'automatiser. Cette automatisation permettant de sécuriser les poules et m'éviter de devoir sortir le matin ou le soir pour ouvrir ou fermer la porte du poulailler.
Le poulailler utilisé dispose d'une porte frontale qui s'ouvre et se ferme horizontalement.
poulailler pets imperial avec nichoir et perchoir
Poulailler pour 4 à 6 poules

Projet initial | Porte coulissante :

Au début, j'avais opté pour garder le principe de la porte horizontale coulissante afin de ne pas trop toucher au poulailler.
Portier automatique poulailler horizontal et coulissant En réutilisant le mécanisme d'une imprimante à jet d'encre HP et plus précisement le chariot et son moteur à courant continu, il était possible d'ouvrir et de fermer la porte du poulailler. Mais certaines contraintes mécaniques m'ont vite orienter vers une autre façon de faire.
Chariot imprimante jet d'encre et moteur à courant continu

Projet modifié | Pont-levis :

Pour faciliter la mise en œuvre de ce portier de poulailler automatique, je me suis orienté vers un porte de type pont-levis, il m'a donc été nécessaire d'enlever le cadre de l'ancien mécanisme et j'ai réutilisé l'ancienne porte que j'ai fixé au poulailler avec deux charnières.
Fabrication d'une porte pont-levis pour poulailler avec charnière et corde
Porte pont-levis pour poulailler

Afin d'automatiser l'ouverture et la fermeture de cette porte je l'ai relié à une corde qui sera enroulée par un moteur pas à pas.
Corde à enrouler pour ouvrir et fermer la porte du poulailler
Corde du mécanisme pont-levis
Mécanisme enrouleur pour déplacer la porte automatique du poulailler
Mécanisme de la porte pont-levis du poulailler

Le moteur pas à pas utilisé est de type unipolaire avec 5 fils pour l'alimentation des 4 bobines et le commun (GND). Les avantages d'utiliser un moteur pas à pas est de connaître facilement sa position (en comptant le nombre de pas), la vitesse de rotation n'est pas élevée et il est possible de bloquer un peu l'arbre moteur en alimentant une seule Bobine 4u moteur (utile pour la sécurisation de la porte).
Par contre l'inconvénient de ce type de moteur et que l'alimentation et la commande sont plus complexes. L'alimentation se fait avec 4 conducteurs pour le moteur pas à pas bipolaire) et 5 ou 6 conducteurs pour le moteur pas à pas unipolaire.
Différents types de moteur pas à pas unipolaire ou bipolaire
Exemples de moteurs pas à pas

Pour résoudre certains problèmes liés à votre projet, vous pouvez opter pour l'utilisation d'équipements à renvois d'angle vous permettant de changer l'axe de rotation de votre moteur afin de transférer la puissance entre deux arbres placés perpendiculairement.





guide de fabrication d'un portier automatique pour poulailler Etape 1 : Motorisation à commande manuelle de la porte de poulailler

Principe de fonctionnement :

Lors de cette étape, je vais expérimenter l'ouverture et la fermeture de la porte en comptant le nombre de pas ou de tours du moteur pas à pas. Un bouton poussoir servira à la fermeture la porte et le second servira pour l'ouverture de la porte.
Même si cette solution n'est pas viable dans le temps, c'est du provisoire pour réaliser les essais. En effet, il pourrait arriver que quelque choses vienne empêcher le déplacement de la porte et le fait d'arrêter le moteur à un certain nombre de pas n'assure pas de la fermeture ou de l'ouverture réelle de la porte de poulailler.
Cette partie devra être améliorée lors de la prochaine étape.

L'étape 1 en vidéo :


Les essais sont concluants, le principe de base est fonctionnel mais doit être amélioré. Il est nécessaire de connaître la position haute (position fermée) de la porte du poulailler afin d'être sûr que la porte est bien fermée. Il est donc nécessaire d'ajouter un capteur fin de course haut sur la porte afin d'en détecter la fermeture.
D'autre part afin d'automatiser la porte de poulailler, il faut ajouter un capteur de luminosité permettant de détecter le jour et la nuit afin de rendre autonome le fonctionnement de la porte du poulailler.

Le matériel nécessaire :

Afin de commander la rotation du moteur pas à pas dans les deux sens pour ouvrir et fermer la porte du poulailler je vais utiliser un clone d'arduino. Pour réaliser cette commande simple j'ai besoin du matériel suivant :
Matériel nécessaire pour motoriser la porte du poulailler
Matériel nécessaire à l'étape 1
• Carte officielle ou clone Arduino en version Uno ou une Arduino Mega.
• Contrôleur Moteur avec circuit intégré L293D.
• Deux boutons poussoirs
• Des conducteurs pour plaque d'essai ou fils de prototypage.
• Une platine d'expérimentation ou breadboard.
• Des bornes automatiques Wago.
• Une alimentation convertisseur 12V DC et son adaptateur femelle (5,5 / 2,1mm) à visser.
• Un moteur pas à pas unipolaire avec un arbre assez long pour y enrouler une corde.


Les branchements électriques :

Pour cette première étape voici le schéma électrique permettant de réaliser les branchements de l'ensemble du matériel.
Schéma de raccordements électriques du moteur pas à pas et arduino
Schéma électrique
Voici à quoi ressemble les raccordements en fils volants en utilisant une plaque d'essais et des bornes automatiques Wago :
Raccordements électriques en fils volants
Raccordements en fils volants

Pour simplifier les raccordement du moteur, surtout si vous utilisez un moteur pas à pas unipolaire comme dans mon cas, vous pouvez opter pour l'utilisation d'un Shield Moteur venant s'imbriquer sur l'arduino. Vous réduirez ainsi les connectiques entre l'arduino et le circuit intégré L293D ou L298P pour le cas d'un Motor Shield.
tutoriel motor shield L298P deek-robot

Moteur Shield L298P avec moteur à courant continu ou moteur pas à pas


Le programme Arduino :

Vous trouverez ci-dessous le programme arduino permettant l'ouverture et la fermeture de la porte avec deux commandes par boutons poussoir. La commande du moteur pas à pas se fait en Full Step, c'est-à-dire que deux bobines sont alimentées en même temps ce qui permet d'augmenter le couple du moteur mais augmenter également la consommation. En effet, on double l'intensité du courant car deux bobines du moteur sont alimentées simultanément.
int MotorPin1= 8; // Déclaration broche commande Bobine 1 moteur
int MotorPin2= 9; // Déclaration broche commande Bobine 2 moteur
int MotorPin3= 10; // Déclaration broche commande Bobine 3 moteur
int MotorPin4= 11; // Déclaration broche commande Bobine 4 moteur
int Tour=0; // Déclaration variable pour gérer le nombre de tours du moteur
int delayTime=10; // Vitesse d'ouverture et fermeture de la porte
int commande_haut=4; // Bouton haut
int commande_bas=5; // Bouton bas
boolean etat_bp_h=false,etat_bp_b=false; // Déclaration des variables bas et haut
boolean mem_h=false,mem_b=false; // Déclaration des mémoires haut et bas

void setup() {
Serial.begin(9600); // Ouverture du port série et debit de communication fixé à 9600 bauds
pinMode(commande_haut, INPUT_PULLUP); // Inverse de la lecture sur entrée BP haut
pinMode(commande_bas, INPUT_PULLUP); // Inverse de la lecture sur entrée BP bas
pinMode(MotorPin1, OUTPUT); // Pin 8 de l'arduino en sortie digitale
pinMode(MotorPin2, OUTPUT); // Pin 9 de l'arduino en sortie digitale
pinMode(MotorPin3, OUTPUT); // Pin 10 de l'arduino en sortie digitale
pinMode(MotorPin4, OUTPUT); // Pin 11 de l'arduino en sortie digitale
}

void loop() {
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

if(etat_bp_h!=mem_h)// Changement d'état du bouton poussoir haut (front montant ou descendant)
{
if(etat_bp_h && !etat_bp_b) // Appui sur BP haut mais pas sur le bas
{
Fermer_porte(); // Lancer la fonction fermeture de la porte du poulailler
}
}
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) // Appui sur BP bas mais pas sur le haut
{
Ouvrir_porte(); // Lancer la fonction ouverture de la porte du poulailler
}
}
mem_b=etat_bp_b; // Mémorisation du nouvel état du bouton bas
}
// Séquence d'alimentation normale des bobines du moteur en Full Step
void Fermer_porte(){
// Il faut 306 * 4 = 1224 pas pour fermer la porte
for (Tour = 0; Tour < 306; Tour++){
digitalWrite(MotorPin1,HIGH); // Alimentation A de la Bobine 1 du moteur pas à pas
digitalWrite(MotorPin2,HIGH); // Alimentation B de la Bobine 2 du moteur pas à pas
digitalWrite(MotorPin3,LOW); // Bobine 3 du moteur pas à pas au repos
digitalWrite(MotorPin4,LOW); // Bobine 4 du moteur pas à pas au repos
delay(delayTime);
digitalWrite(MotorPin1,LOW); // Bobine 1 du moteur pas à pas au repos
digitalWrite(MotorPin2,HIGH); // Alimentation B de la Bobine 2 du moteur pas à pas
digitalWrite(MotorPin3,HIGH); // Alimentation C de la Bobine 3 du moteur pas à pas
digitalWrite(MotorPin4,LOW); // Bobine 4 du moteur pas à pas au repos
delay(delayTime);
digitalWrite(MotorPin1,LOW); // Bobine 1 du moteur pas à pas au repos
digitalWrite(MotorPin2,LOW); // Bobine 2 du moteur pas à pas au repos
digitalWrite(MotorPin3,HIGH); // Alimentation C de la Bobine 3 du moteur pas à pas
digitalWrite(MotorPin4,HIGH); // Alimentation D de la Bobine 4 du moteur pas à pas
delay(delayTime);

digitalWrite(MotorPin1,HIGH); // Alimentation A de la Bobine 1 du moteur pas à pas
digitalWrite(MotorPin2,LOW); // Bobine 2 du moteur pas à pas au repos
digitalWrite(MotorPin3,LOW); // Bobine 3 du moteur pas à pas au repos
digitalWrite(MotorPin4,HIGH); // Alimentation D de la Bobine 4 du moteur pas à pas
delay(delayTime);
Serial.println("Fermer porte"); // Affichage sur le moniteur série
}
Serial.println("Porte Fermée"); // Affichage sur le moniteur série
Arret();
}
// Séquence d'alimentation inverse des bobines du moteur en Full Step
void Ouvrir_porte(){
for (Tour = 0; Tour < 306; Tour++){
// Il faut 306 * 4 = 1224 pas pour ouvrir la porte
digitalWrite(MotorPin1,LOW); // Bobine 1 du moteur pas à pas au repos
digitalWrite(MotorPin2,LOW); // Bobine 2 du moteur pas à pas au repos
digitalWrite(MotorPin3,HIGH); // Alimentation C de la Bobine 3 du moteur pas à pas
digitalWrite(MotorPin4,HIGH); // Alimentation D de la Bobine 4 du moteur pas à pas
delay(delayTime);

digitalWrite(MotorPin1,LOW); // Bobine 1 du moteur pas à pas au repos
digitalWrite(MotorPin2,HIGH); // Alimentation B de la Bobine 2 du moteur pas à pas
digitalWrite(MotorPin3,HIGH); // Alimentation C de la Bobine 3 du moteur pas à pas
digitalWrite(MotorPin4,LOW); // Bobine 4 du moteur pas à pas au repos
delay(delayTime);

digitalWrite(MotorPin1,HIGH); // Alimentation A de la Bobine 1 du moteur pas à pas
digitalWrite(MotorPin2,HIGH); // Alimentation B de la Bobine 2 du moteur pas à pas
digitalWrite(MotorPin3,LOW); // Bobine 3 du moteur pas à pas au repos
digitalWrite(MotorPin4,LOW); // Bobine 4 du moteur pas à pas au repos
delay(delayTime);

digitalWrite(MotorPin1,HIGH); // Alimentation A de la Bobine 1 du moteur pas à pas
digitalWrite(MotorPin2,LOW); // Bobine 2 du moteur pas à pas au repos
digitalWrite(MotorPin3,LOW); // Bobine 3 du moteur pas à pas au repos
digitalWrite(MotorPin4,HIGH); // Alimentation D de la Bobine 4 du moteur pas à pas
delay(delayTime);
Serial.println("Ouvrir porte"); /// Affichage sur le moniteur série du texte
}
Serial.println("Porte Ouverte"); // Affichage sur le moniteur série
Arret();
}

// Fonction arrêt du moteur
void Arret(){
digitalWrite(MotorPin1,LOW); // Bobine 1 du moteur pas à pas au repos
digitalWrite(MotorPin2,LOW); // Bobine 2 du moteur pas à pas au repos
digitalWrite(MotorPin3,LOW); // Bobine 3 du moteur pas à pas au repos
digitalWrite(MotorPin4,LOW); // Bobine 4 du moteur pas à pas au repos
}

La séquence correspondante au sens normal de rotation du moteur pas à pas est la suivante :
Séquence Full Step commande moteur pas à pas unipolaire
Chronogramme de la séquence full step | Moteur pas à pas unipolaire



guide de fabrication d'un portier automatique pour poulailler Etape 2 : Automatisation du portier pour poulailler et sécurisation

fabriquer un portier automatique pour poulailler
Portier automatique poulailler

Principe de fonctionnement :

Lors de cette étape je vais utiliser des capteurs fin de course permettant de détecter les positions ouverte et fermée de la porte du poulailler. Si vous ne voulez pas utiliser de capteurs, il faut maintenir dans le programme la fonction comptage des tours du moteur pas à pas.


L'étape 2 en vidéo :



Liste du matériel nécessaire :

Pour réaliser cette étape d'automatisation, il est nécessaire d'ajouter le matériel suivant :
• Une photorésistance (voir mesure de la lumière).
• Une résistance de 10 kOhms (voir pont diviseur de tension).
• Deux mini fin de course à galet.


Pour les essais provisoires j'ai utilisé un bouton poussoir afin de simuler le fin de course haut. Pour la finalisation, j'ai installé un mini fin de course à galet comme ceux sur l'image ci-contre.

👨‍💻 Si le capteur bas est appuyé (Fin De Course BAS = FDCB) ➡️ la porte est ouverte.
👨‍💻 Si le capteur haut est appuyé (Fin De Course Haut = FDCH) ➡️ la porte est fermée.
👨‍💻 Si aucun des capteurs n'est appuyé, la porte est bloquée entre deux positions ou elle est en mouvement (prévoir un cycle d'initialisation lors d'une remis sous tension).

Pour automatiser l'ouverture et la fermeture de la porte, il est nécessaire d'utiliser une commande non manuelle. Deux solutions sont possibles :
🕰️ Une horloge de type DS1307 qui fonctionne avec une pile rechargeable de type LIR2032H.

🌒☀️ Un capteur de luminosité de type photorésistance (photosensible LDR).
La solution horloge nécessite d'ajouter au programme une sorte de calendrier solaire pour connaître les heures du coucher de soleil et l'heure à laquelle se lève le soleil sur toute l'année.
Pour faciliter la programmation j'opte donc pour un capteur de luminosité qui donnera l'ordre d'ouverture ou de fermeture après avoir atteint l'un des deux seuils de luminosité et une temporisation permettra de pallier aux variations brutales de la luminosité (si éclairage externe).

👨‍💻 S'il fait nuit 🌒 (coucher du soleil) ➡️ Fermeture automatique poulailler.
👨‍💻 S'il fait jour ☀️ (lever du soleil) ➡️ Ouverture automatique poulailler.
Photorésistance photo sensible LDR
Capteur de luminosité (Photorésistance LDR)
La photorésistance (LDR : Light Dependent Resistor) est un composant dont la résistance varie en fonction de la luminosité ambiante.
Courbe de variation de la résistance en fonction de la lumière et de l'éclairement
Courbe de l'éclairement et variation de la résistance (photorésistance)

☀️ En plein jour la résistance vaut environ 10kΩ (10000Ω).
🌚 En pleine nuit la valeur de la résistance vaut aux alentours de 1MΩ (1 000 000Ω).

La variation de la résistance de la photorésistance va entraîner une variation de la tension (voir montage pont diviseur de tension).

Les branchements électriques :

Afin de détecter la luminosité et la position de la porte du poulailler en ayant toujours la commande manuelle par bouton poussoir, voici le schéma électrique de raccordement réalisé.
Schéma électrique détection luminosité LDR et capteur de position de la porte du poulailler
Schéma électrique de l'étape n°2 de la porte du poulailler

Les boutons poussoirs et les capteurs de position de la porte sont câblés entre les entrées digitales et le GND du montage, utilisez les contacts NO Normalement Ouvert afin d'être conforme au programme. Il sera nécessaire de les déclarer ces entrées en Input Pullup (input_pullup) dans le programme de l'Arduino.
Pour obtenir une bonne sensibilité avec le capteur de luminosité (LDR), il faut réaliser un montage pont diviseur de tension avec une résistance de 10kΩ.
Pont diviseur de tension avec photorésistance LDR
Pont diviseur de tension avec photorésistance LDR
La valeur mesurée par la borne analogique A0 de l'arduino correspond au calcul ci-contre :
Formule du Pont diviseur de tension
VA0 = 5V x R1 / (R1 + RLDR)
Formule du Pont diviseur de tension


Le programme arduino :

Pour la gestion automatique de la porte du poulailler, le programme doit intégrer les mesures de luminosité renvoyé par la photorésistance sur l'entrée analogique A0.
Un cycle d'initialisation est également intégré afin de connaître la position de la porte du poulailler lors d'une remise sous tension de la carte Arduino.
La position fermée sera connue grace au fin de course placé en haut de la porte pont levis qui sera appuyé dès que la porte sera fermée.


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 = 350;	// Variable de luminosité seuil pour le jour
int Seuil_Nuit = 200;	// 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, HIGH);
      digitalWrite(MotorPin3, LOW);
      digitalWrite(MotorPin4, LOW);
      delay(delayTime);

      digitalWrite(MotorPin1, LOW);
      digitalWrite(MotorPin2, HIGH);
      digitalWrite(MotorPin3, HIGH);
      digitalWrite(MotorPin4, LOW);
      delay(delayTime);

      digitalWrite(MotorPin1, LOW);
      digitalWrite(MotorPin2, LOW);
      digitalWrite(MotorPin3, HIGH);
      digitalWrite(MotorPin4, HIGH);
      delay(delayTime);

      digitalWrite(MotorPin1, HIGH);
      digitalWrite(MotorPin2, LOW);
      digitalWrite(MotorPin3, LOW);
      digitalWrite(MotorPin4, HIGH);
      delay(delayTime);
      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, HIGH);
      digitalWrite(MotorPin3, LOW);
      digitalWrite(MotorPin4, LOW);
      delay(delayTime);

      digitalWrite(MotorPin1, LOW);
      digitalWrite(MotorPin2, HIGH);
      digitalWrite(MotorPin3, HIGH);
      digitalWrite(MotorPin4, LOW);
       delay(delayTime);

      digitalWrite(MotorPin1, LOW);
      digitalWrite(MotorPin2, LOW);
      digitalWrite(MotorPin3, HIGH);
      digitalWrite(MotorPin4, HIGH);
      delay(delayTime);

      digitalWrite(MotorPin1, HIGH);
      digitalWrite(MotorPin2, LOW);
      digitalWrite(MotorPin3, LOW);
      digitalWrite(MotorPin4, HIGH);
      delay(delayTime);
      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, LOW);
    digitalWrite(MotorPin3, HIGH);
    digitalWrite(MotorPin4, HIGH);
    delay(delayTime);

    digitalWrite(MotorPin1, LOW);
    digitalWrite(MotorPin2, HIGH);
    digitalWrite(MotorPin3, HIGH);
    digitalWrite(MotorPin4, LOW);
    delay(delayTime);

    digitalWrite(MotorPin1, HIGH);
    digitalWrite(MotorPin2, HIGH);
    digitalWrite(MotorPin3, LOW);
    digitalWrite(MotorPin4, LOW);
    delay(delayTime);

    digitalWrite(MotorPin1, HIGH);
    digitalWrite(MotorPin2, LOW);
    digitalWrite(MotorPin3, LOW);
    digitalWrite(MotorPin4, HIGH);
    delay(delayTime);
    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;
}



guide de fabrication d'un portier automatique pour poulailler Etape 3 : Sécurisation de la porte du poulailler

Pour sécuriser les alentours du poulailler la nuit, je souhaite détecter la présence d'un animal à l'extérieur du poulailler et l'effrayer. Deux solutions sont possibles pour éloigner le renard le son ou la lumière. J'ai opté pour l'utilisation de la lumière avec un ruban de LED. Mais il serait possible de placer une radio qui serait mise en marche par l'arduino.

Sécuriser porte automatique pour poulailler
Sécurité pour porte de poulailler automatique


Liste du matériel nécessaire :

Pour réaliser la sécurisation de la porte du poulailler, il est nécessaire d'ajouter le matériel suivant :
• Un capteur de mouvement PIR | SR-602.
• Un relais 1 voie.
• Un ruban de LED 12V étanche.

Le détecteur de mouvement choisit est peu encombrant et détecte la présence d'un chat jusqu'à 2 mètres.

Détection mouvement capteur PIR
Détection d'un mouvement et allumage ruban LED


Les raccordements électriques :

Afin de détecter la présence d'un animal la nuit à proximité du poulailler le capteur PIR (Infrarouge) doit être positionné en hauteur au niveau du poulailler. Le relais permettra de commander le bandeau de LED en 12V continu.
Schéma électrique sécurisation de la porte du poulailler
Schéma électrique de l'étape n°2 de la porte du poulailler

Le programme arduino (Complet) :

Pour sécuriser les alentours du poulailler, lorsqu'il fait nuit dès qu'un mouvement à l'extérieur est détecté cela va entraîner un cycle de clignotement du ruban LED afin d'effrayer le prédateur.


int Mouvement_PIR = 3; // Déclaration broche capteur de mouvement PIR
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 LED_Pin = 12; // Déclaration broche commande ruban LED

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 = 350;	// Variable de luminosité seuil pour le jour
int Seuil_Nuit = 200;	// 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 active_PIR = false; // Déclaration de la variable activation capteur PIR
boolean etat_mouvement = false; // Déclaration variable détection mouvement
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;
boolean tempoActive_Securite = false;

// Temps à l'activation de la tempo
unsigned long tempoDepart = 0;
unsigned long tempoSecu = 0;
int Tempo_mouvement = 10000; // Temporisation mouvement 10 secondes = 100000ms


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(Mouvement_PIR, INPUT_PULLUP); // Déclaration entrée pull-up sur entrée Détecteur de mouvement PIR
  pinMode(LED_Pin, OUTPUT);	// Déclaration de la sortie LED
  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
    }
  }
  mem_fdch = fdch; // Mémorisation du nouvel état du fin de course haut
  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
    }
  }
  
  
  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
    {
      if (!fdcb) {
        Ouvrir_porte();
      }
    }
  }
  mem_b = etat_bp_b; // Mémorisation du nouvel état du bouton bas
  boolean lecture_PIR=false;
  unsigned long Tempo_PIR = 0; // Temporisation anti parasite
  unsigned long intervalle = 100; // Temporisation anti parasite  

  lecture_PIR = digitalRead(Mouvement_PIR); // Lecture de l'état du capteur PIR
  if (lecture_PIR != mem_mouvement && active_PIR && !Jour) // Changement d'état du capteur PIR (front montant ou descendant)
  {
 Tempo_PIR = millis();
  }
if ((millis() - Tempo_PIR) > intervalle)
  {
  etat_mouvement = lecture_PIR;
  }
  if (etat_mouvement && active_PIR && !Jour)
  {
  tempoActive_Securite = etat_mouvement;
  tempoSecu = millis();
  Securite_poulailler();
  }
  mem_mouvement = lecture_PIR; // Mémorisation du nouvel état du capteur PIR
}

void Securite_poulailler() {
     while((millis() - tempoSecu) <= Tempo_mouvement)
    {
      if(!fdch)
      {
      digitalWrite(MotorPin1, HIGH);
      digitalWrite(MotorPin2, HIGH);
      digitalWrite(MotorPin3, LOW);
      digitalWrite(MotorPin4, LOW);
      }
      digitalWrite(LED_Pin, HIGH);
      delay(random(50,200));
      fdch = !digitalRead(fin_de_course_haut);
      if(!fdch)
      {
      digitalWrite(MotorPin1, LOW);
      digitalWrite(MotorPin2, HIGH);
      digitalWrite(MotorPin3, HIGH);
      digitalWrite(MotorPin4, LOW);
      }
      digitalWrite(LED_Pin, LOW);
      delay(random(50,400));
      fdch = !digitalRead(fin_de_course_haut); 
      if(!fdch)
      {
      digitalWrite(MotorPin1, LOW);
      digitalWrite(MotorPin2, LOW);
      digitalWrite(MotorPin3, HIGH);
      digitalWrite(MotorPin4, HIGH);
      }
      digitalWrite(LED_Pin, HIGH);
      delay(random(50,500));
      fdch = !digitalRead(fin_de_course_haut);
      if(!fdch)
      {
      digitalWrite(MotorPin1, HIGH);
      digitalWrite(MotorPin2, LOW);
      digitalWrite(MotorPin3, LOW);
      digitalWrite(MotorPin4, HIGH);
      }
      digitalWrite(LED_Pin, LOW);
      delay(random(50,100)); 
      fdch = !digitalRead(fin_de_course_haut);
    }
      digitalWrite(MotorPin1, LOW);
      digitalWrite(MotorPin2, LOW);
      digitalWrite(MotorPin3, LOW);
      digitalWrite(MotorPin4, LOW);
      digitalWrite(LED_Pin, LOW);
}


void Fermer_porte_Initialisation() {
      delay(5000);
  while (!fdch) {
      digitalWrite(MotorPin1, HIGH);
      digitalWrite(MotorPin2, HIGH);
      digitalWrite(MotorPin3, LOW);
      digitalWrite(MotorPin4, LOW);
      delay(delayTime);

      digitalWrite(MotorPin1, LOW);
      digitalWrite(MotorPin2, HIGH);
      digitalWrite(MotorPin3, HIGH);
      digitalWrite(MotorPin4, LOW);
      delay(delayTime);

      digitalWrite(MotorPin1, LOW);
      digitalWrite(MotorPin2, LOW);
      digitalWrite(MotorPin3, HIGH);
      digitalWrite(MotorPin4, HIGH);
      delay(delayTime);

      digitalWrite(MotorPin1, HIGH);
      digitalWrite(MotorPin2, LOW);
      digitalWrite(MotorPin3, LOW);
      digitalWrite(MotorPin4, HIGH);
      delay(delayTime);
      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)
      {
        active_PIR=true;
        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, HIGH);
      digitalWrite(MotorPin3, LOW);
      digitalWrite(MotorPin4, LOW);
      delay(delayTime);

      digitalWrite(MotorPin1, LOW);
      digitalWrite(MotorPin2, HIGH);
      digitalWrite(MotorPin3, HIGH);
      digitalWrite(MotorPin4, LOW);
       delay(delayTime);

      digitalWrite(MotorPin1, LOW);
      digitalWrite(MotorPin2, LOW);
      digitalWrite(MotorPin3, HIGH);
      digitalWrite(MotorPin4, HIGH);
      delay(delayTime);

      digitalWrite(MotorPin1, HIGH);
      digitalWrite(MotorPin2, LOW);
      digitalWrite(MotorPin3, LOW);
      digitalWrite(MotorPin4, HIGH);
      delay(delayTime);
      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;
        active_PIR=true;
        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, LOW);
    digitalWrite(MotorPin3, HIGH);
    digitalWrite(MotorPin4, HIGH);
    delay(delayTime);

    digitalWrite(MotorPin1, LOW);
    digitalWrite(MotorPin2, HIGH);
    digitalWrite(MotorPin3, HIGH);
    digitalWrite(MotorPin4, LOW);
    delay(delayTime);

    digitalWrite(MotorPin1, HIGH);
    digitalWrite(MotorPin2, HIGH);
    digitalWrite(MotorPin3, LOW);
    digitalWrite(MotorPin4, LOW);
    delay(delayTime);

    digitalWrite(MotorPin1, HIGH);
    digitalWrite(MotorPin2, LOW);
    digitalWrite(MotorPin3, LOW);
    digitalWrite(MotorPin4, HIGH);
    delay(delayTime);
    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;
}



guide de fabrication d'un portier automatique pour poulailler Activités pratiques (BAC PRO MELEC)

Retrouvez ci-dessous les activités pratiques (travaux pratiques ou projet) en rapport avec la porte de poulailler automatique pour la formation en lycée professionnel BAC PRO MELEC.

Activité pratique de préparatio à la réalisation d'une porte automatique pour poulailler

TP MELEC U2 | Préparation de l'automatisation d'une porte de poulailler.


Si vous aimez les articles, n'hésitez pas à faire vos achats sur Amazon via ce lien, ils me permettront de recevoir une commission grâce au programme Partenaires Amazon EU.