Poulailler mobile sur rails

Partagez ici vos systèmes Arduino, Raspberry, ou autres, qui vous facilitent certaines tâches à la ferme
Avatar de l’utilisateur
PGueret
Messages : 42
Inscription : 18 mai 2021, 14:44

Poulailler mobile sur rails

Message par PGueret »

Bonjour,

Voici un projet (tué ''dans l’œuf'') concernant un groupe de payan·nes qui souhaitait faire un poulailler mobile sur rails.

Cahier des charges :
  • Poulailler de 50 poules pondeuses
  • Déplacement sur des parcelles restreintes pour minimiser l'impact du pâturage prolongée
  • Déplacement autonome et solaire
  • fermeture/ouverture Autonome en fonction de la luminosité
Pourquoi sur rails ? Pour diminuer considérablement la puissance de la motorisation mise en jeu et pouvoir ainsi utiliser l'énergie solaire pour mouvoir le poulailler.
Le rail permet également un déplacement précis et prévisible (idéal pour laisser l’accès à des parcelles bien définies).
Les gros inconvénients étant le coût du rail (compensé en partie par la plus faible motorisation), la gestion de l’enherbement du rail (débroussailleuse), et la planéité du terrain.

Voici donc les quelques pistes de R&D, dont une maquette fabriquée dans le cadre des initiations Arduino proposées par l'Atelier Paysan :
Poulailler sur rail
Poulailler sur rail
20221121_165152.jpg (223.54 Kio) Consulté 1372 fois
Syst. Arduino embarqué
Syst. Arduino embarqué
20221121_165200.jpg (417.16 Kio) Consulté 1372 fois
détail porte poulailler sur rail
détail porte poulailler sur rail
20221121_165209.jpg (223.71 Kio) Consulté 1372 fois
Détail entrainement Poulailler sur rail
Détail entrainement Poulailler sur rail
20221121_165218.jpg (248.41 Kio) Consulté 1372 fois

Aisni que le code Arduino pour celleux que ça intéresse :

Code : Tout sélectionner

* Poulailler : Automatisme de fermeture/ouverture en fonction de la luminosité et d'un pont en h BTS7960
    avec systeme de comparaison temps nuit-jour / 15min pour etre eviter ouv/ferm intempestives
  cablage du pont ibt_2
  IBT-2 pin 1 (RPWM) to Arduino pin 5(PWM)
  IBT-2 pin 2 (LPWM) to Arduino pin 6(PWM)
  IBT-2 pins 3 (R_EN), 4 (L_EN), 7 (VCC) to Arduino 5V pin
  IBT-2 pin 8 (GND) to Arduino GND
  IBT-2 pins 5 (R_IS) and 6 (L_IS) not connected
*/
int PhotoRLue;
int Seuil = 650;       //seuil de basculement jour/nuit
int PhotoR = A0;       // entrée analogique de la photorésistance
int RPWM2 = 9;         // moteur de déplacement sens 1
int LPWM2 = 10;        // moteur de déplacement sens 2
int Captfinsens1 = 2;  //capteur de fin de sens 1
int Captfinsens2 = 4;  //capteur de fin de sens 2
int Captmilieu = 3;    //capteur de detection arrêt milieu
int FinCHaut = 13;     // entrée du fin de course HAUT. Une broche sur la masse l'autre sur l'arduino
int FinCBas = 12;      // entrée du fin de course BAS. Une broche sur la masse l'autre sur l'arduino
int RPWM = 5;          // Arduino PWM output pin 5; connect to IBT-2 pin 5 (RPWM)
int LPWM = 6;          // Arduino PWM output pin 6; connect to IBT-2 pin 6 (LPWM)
int ledmot = 8;        //led de danger = fonctionnment moteur
int BUZZ = 11;         //BUZZ de déplacement
int etatbuzz = 0;
int a;
unsigned long previousMillis = 0;  //temps précédent secu fermeture
long previousMillis1 = 0;          // variable pour mémoriser le temps écoulé depuis le dernier changement dubuzzer
unsigned long interval = 2000;     // temps pendant lesquelle on s'assure qu'il fait bien nuit (ici 15min)
long interval1 = 800;              //intervalle de clignotement du buzzer (en millisecondes)


//variable pour stocker la valeur lue après conversion
//int PhotoRLue;

enum { jour,
       nuit } JouN;  //pour ouv et ferm de la porte
enum { Pmonte,
       Pfermee,
       Pdescend,
       Pouverte,
       Pstop } etatporte;  //pour ouv et ferm de la porte
enum { sens1,
       sens2 } etatsens;  // pour déplacement du poulailler
enum { Finsens1,
       Finsens2,
       Milieu,
       initialisationsens1,
       Attendcycle,
       Cycle,
       Vasens1,
       Vasens2 } Position;
unsigned long currentMillis1;  // pour déplacement du poulailler
/////////////////////////////////////////SETUP/////////////////////////////////////////////
void setup() {  /////////déplacement /////////////
  pinMode(RPWM2, OUTPUT);
  pinMode(LPWM2, OUTPUT);
  pinMode(Finsens1, INPUT_PULLUP);
  pinMode(Finsens2, INPUT_PULLUP);
  pinMode(Captmilieu, INPUT_PULLUP);
  pinMode(FinCBas, INPUT_PULLUP);
  pinMode(BUZZ, OUTPUT);
  tone(BUZZ, 0);
  /////////ouverture de porte ////////
  pinMode(RPWM, OUTPUT);
  pinMode(LPWM, OUTPUT);
  pinMode(ledmot, OUTPUT);
  pinMode(BUZZ, OUTPUT);
  // démarrage la liaison série entre entrée analogique et ordi
  Serial.begin(9600);
  previousMillis = millis();
  //Déclaration des contacts fin de course en entrée avec utilisation de la fonction PULLUP interne
  pinMode(FinCHaut, INPUT_PULLUP);  //Les Pull Up sont des résistances internes à l'arduino.
  pinMode(FinCBas, INPUT_PULLUP);   //Donc de base lorsque le boutton n'est pas appuyé on lit un état haut (5V = niveau logique 1 ou HIGH)
  digitalWrite(ledmot, LOW);
  JouN = jour;  // on considère que l'on installe le module dans la journée...
  etatporte = Pstop;
  Position = initialisationsens1;
  a = 0;
}
/////////////////////////////////////////////////////////////////debut loop/////////////////////////////////////////////////////////////////
void loop() {
  currentMillis1 = millis();  // stocke la valeur courante de la fonction millis()
  /////////////////////gestion du déplacement///////////////////////////
  switch (Position) {
    case initialisationsens1:
      etatsens = sens1;
      Stop();
      Position = Attendcycle;
      break;
    case Finsens1:
      Stop();
      etatsens = sens2;
      Position = Attendcycle;
      break;
    case Finsens2:
      Stop();
      etatsens = sens1;
      Position = Attendcycle;
      break;
    case Milieu:
      Stop();
      Position = Attendcycle;
      break;
    case Vasens1:
      Marchesens1();
      if (digitalRead(Captfinsens1) == LOW) {
        Position = Finsens1;
      }
      //if (digitalRead(Captmilieu) == LOW) {
      //  Position = Milieu;
      // }
      break;
    case Vasens2:
      Marchesens2();
      if (digitalRead(Captfinsens2) == LOW) {
        Position = Finsens2;
      }
      if (digitalRead(Captmilieu) == LOW) {
        Position = Milieu;
      }
      break;

    case Attendcycle:
      if (digitalRead(FinCBas) != LOW && digitalRead(FinCHaut) == LOW && etatporte == Pstop) {
        Position = Cycle;
      }
      break;
    case Cycle:
      if (digitalRead(FinCBas) == LOW && digitalRead(FinCHaut) != LOW) {
        if (etatsens == sens1) {
          Position = Vasens1;
        }
        if (etatsens == sens2) {
          Position = Vasens2;
        }
      }
      break;
  }
  /////////////////////gestion de l'ouverture de la porte////////////////
  switch (etatporte) {
    case Pstop:
      arret();
      digitalWrite(ledmot, LOW);
      if (analogRead(PhotoR) < Seuil && JouN == nuit) {
        if (digitalRead(FinCBas) != LOW) {
          etatporte = Pdescend;
        } else {
          etatporte = Pstop;
          previousMillis = millis();
        }
      }
      if (analogRead(PhotoR) > Seuil && JouN == jour) {
        if (digitalRead(FinCHaut) != LOW) {
          etatporte = Pmonte;
        } else {
          etatporte = Pstop;
          previousMillis = millis();
        }
      }
      break;
    case Pouverte:
      arret();
      etatporte = Pstop;
      previousMillis = millis();
      break;
    case Pfermee:
      arret();
      etatporte = Pstop;
      previousMillis = millis();
      break;

    case Pmonte:
      if (Position == Attendcycle) {
        montee();
        if (digitalRead(FinCHaut) == LOW) {
          etatporte = Pouverte;
        }
      }
      previousMillis = millis();
      break;

    case Pdescend:
      descente();
      if (digitalRead(FinCBas) == LOW) {
        arret();
        delay(5);  //sécu pour etre sur que la porte est bien arrêtée
        digitalWrite(ledmot, LOW);
        etatporte = Pfermee;

      } else {
        etatporte = Pdescend;
      }
      previousMillis = millis();
      break;
  }
  ////////////////////////////////////////////////////SECU///////////////////////////////////////
  if (digitalRead(FinCHaut) == LOW && digitalRead(FinCBas) == LOW) {  //capteur haut ET capteur bas en même temps, alors :
    arret();
    tone(BUZZ, 200);
    etatporte = Pstop;
  }

  if (analogRead(PhotoR) < Seuil && JouN == jour) {
    if (millis() - previousMillis >= interval) {
      previousMillis = millis();
      JouN = nuit;  // jour ou nuit ?
    }
  }
  if (analogRead(PhotoR) >= Seuil && JouN == nuit) {
    if (millis() - previousMillis >= interval) {
      previousMillis = millis();
      JouN = jour;  // jour ou nuit ?
    }
  }
  delay(10);
}
/////////////////////////////////////////////////////////////////fin loop/////////////////////////////////////////////////////////////////
void Stop() {
  a = 0;
  analogWrite(RPWM2, 0);
  analogWrite(LPWM2, 0);
  tone(BUZZ, 0);
}
void Marchesens1() {
  while (a < 255) {  // phase d'accélération.
    analogWrite(RPWM2, a);
    analogWrite(LPWM2, 0);
    tone(BUZZ, 200);
    a = a + 1;
    delay(10);
  }
  ///////////buzzer gestion sens 1///////////////////////////////////////////
  if (currentMillis1 - previousMillis1 > interval1) {  // mémorise la valeur de la fonction millis()
    previousMillis1 = currentMillis1;

    // inverse la variable d'état du buzzer
    if (etatbuzz == 0) {
      etatbuzz = 200;
    } else {
      etatbuzz = 0;
    }
    analogWrite(BUZZ, etatbuzz);
  }
  //////////////////////////////////////////////////////////////////////////
}
void Marchesens2() {
  while (a < 255) {  // phase d'accélération.
    analogWrite(RPWM2, 0);
    analogWrite(LPWM2, a);
    tone(BUZZ, 200);
    a = a + 1;
    delay(10);
  }
  ///////////buzzer gestion sens 2///////////////////////////////////////////
  if (currentMillis1 - previousMillis1 > interval1) {

    // mémorise la valeur de la fonction millis()
    previousMillis1 = currentMillis1;

    // inverse la variable d''état du buzzer
    if (etatbuzz == 0)
      etatbuzz = 200;
    else
      etatbuzz = 0;

    tone(BUZZ, etatbuzz);
  }
  //////////////////////////////////////////////////////////////////////////
}
void arret() {
  analogWrite(RPWM, 0);
  analogWrite(LPWM, 0);
  digitalWrite(ledmot, LOW);
}
void montee() {
  analogWrite(RPWM, 0);
  analogWrite(LPWM, 80);
  digitalWrite(ledmot, HIGH);
}
void descente() {
  analogWrite(RPWM, 80);
  analogWrite(LPWM, 0);
  digitalWrite(ledmot, HIGH);
}
N’hésitez pas à réagir en commentaires, possibilité de vous donner plus d'infos sur les pistes de réflexions.
Bonne journée à tous·tes
Pierre :arrow: Animateur Formateur sur l'Antenne Grand Ouest de l'Atelier Paysan.

Répondre

Revenir à « Électronique libre appliquée à la ferme »