Porte de poulailler auto fini [demande d'avis]

Les portes de poulailler auto ont un succès fou ! J'ai commencé la mienne il y'a un an (elle n'a jamais fonctionné plus de 3 jours faute problème technique) , et j'arrive à la troisième version où j'ai décidé de tout changer niveau système de fermeture.

La porte fonctionne bien pour l'instant, j'aimerai avoir un retour sur ma programmation ou sur le système d'ouverture/fermeture, peut être que vous arriverez à voir des erreurs ou incohérences que je pourrais corriger, ou tout simplement des conseils, je suis preneur :slight_smile:

(j'ai pas réussi à mettre une vidéo)
image
image
image
image

toutes les pièces blanches sont imprimés en 3D.

Les composants sont dans le boitier : L298n, convertisseur >12v , Arduino Uno, photorésistance avec résistance 10K, plaque avec pin pour agrandir les pins Gnd et +5v.

Puis 2 capteur fin de course en dehors du boitier. Un moteur 12v puissant (10kg.cm-1) il a du couple !

Dans le programme initial j'ai mis un buzzer, mais pas sur de le garder


float timedoor = 0;
unsigned long Emin = 0;
unsigned long buttonX = 0;


void setup() {

  pinMode(12, OUTPUT); // Sound

  pinMode(A0, INPUT);  // Capteur de luminosité
  pinMode(4, OUTPUT); //moteur Gnd ou 5v
  pinMode(3, OUTPUT); //moteur Gnd ou 5v
  pinMode(5, OUTPUT); digitalWrite(5, LOW); //EnableB

  pinMode(6, INPUT_PULLUP);//Capteur porrte fermé

  pinMode(9, INPUT_PULLUP);//Capteur porrte fermé

  pinMode(7, OUTPUT); digitalWrite(7, HIGH); // LED VERTE
  pinMode(8, OUTPUT); digitalWrite(8, LOW); // LED ROUGE

  pinMode(10, INPUT_PULLUP);//Bouton haut

  pinMode(11, INPUT_PULLUP);//Bouton bas

  digitalWrite(4, LOW); //eteindre le moteur
  digitalWrite(3, LOW); //eteindre le moteur

  Serial.begin(9600);
  Serial.println("- INITIALISATION V.3 -");
  Serial.println("- FINISH 25/08/2024 -");
  Serial.println("- LAST LOADING 21h20 -");
  Serial.println(analogRead(A0));
  if (analogRead(A0) <= 100 ) {
    if (digitalRead(6) == HIGH) {
      fermer();
    }
  } else {
    if (digitalRead(9) == HIGH) {
      ouvrir();
    }
  }


}


void loop() {
  if (digitalRead(10) == HIGH && digitalRead(9) == HIGH) { //bouton haut préssé
    digitalWrite(8, HIGH); // LED ROUGE
    buttonX = 0;
    while (digitalRead(10) == HIGH && buttonX < 300) { //3secondes max
      delay(100);
      buttonX = buttonX + 10;
    }

    if (buttonX >= 300) { //bug appuie trop long
      tone(12, 110, 1000);
      delay(1000);
      digitalWrite(8, LOW);
      delay(3000);

    } else { //bon appuie

      tone(12, 880, 1000);
      delay(1000);
      digitalWrite(8, LOW);
      ouvrir();
    }

  }



  if (digitalRead(11) == HIGH && digitalRead(6) == HIGH ) { //bouton bas préssé
    digitalWrite(8, HIGH); // LED ROUGE
    buttonX = 0;
    while (digitalRead(11) == HIGH && buttonX < 300) { //3secondes max
      delay(100);
      buttonX = buttonX + 10;
      Serial.println(buttonX);
    }
    if (buttonX >= 300) { //bug appui trop long
      Serial.println("appui trop long");
      tone(12, 110, 1000);
      delay(1000);
      digitalWrite(8, LOW);
      delay(3000);

    } else { //bon appuie
      Serial.println("bon appui");
      tone(12, 880, 1000);
      digitalWrite(8, LOW);

      fermer();
    }
  }


  if (analogRead(A0) >= 350 && digitalRead(9) == HIGH) { //jour et capteur porte ouverte pas préssé
    Serial.println("Signal - DAY");
    Serial.println(analogRead(A0));
    delay(3000);
    ouvrir();
  }

  if (analogRead(A0) <= 100 && digitalRead(6) == HIGH) { //nuit et capteur porte fermé pas encore préssé {
    Serial.println("Signal - NIGHT");
    delay(3000);
    fermer();
  }
Serial.println(analogRead(A0));
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////FERMER
void fermer() {
  Serial.println("DOOR CLOSING");
  digitalWrite(4, LOW);
  digitalWrite(3, HIGH);
  digitalWrite(5, HIGH); //EnableB
  timedoor = 0;
  while (digitalRead(6) == HIGH && timedoor < 10) { //le capteur n'est pas préssé
    Serial.println(timedoor);
    timedoor = timedoor + 0.1;
    Serial.println(analogRead(A0));
    delay(100);
  }
  //le capteur a été préssé

  digitalWrite(5, LOW); //EnableB
  digitalWrite(4, LOW);
  digitalWrite(3, LOW);

  Serial.println("DOOR CLOSED");
  delay(1000);
  tone(12, 220, 1000);
  delay(1000);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////OUVRIR
void ouvrir() {
  Serial.println("DOOR OPENING");
  digitalWrite(4, HIGH);
  digitalWrite(3, LOW);
  digitalWrite(5, HIGH); //EnableB
  timedoor = 0;
  while (digitalRead(9) == HIGH and timedoor < 10) {
    Serial.println(timedoor);
    timedoor = timedoor + 0.1;
    Serial.println(analogRead(A0));
    delay(100);
  }

  digitalWrite(5, LOW); //EnableB
  digitalWrite(4, LOW);
  digitalWrite(3, LOW);

  Serial.println("DOOR OPENED");
  delay(1000);
  tone(12, 220, 1000);
  delay(1000);
}

J'espère que je pourrais paufiner ma porte de poulailler et m'assurer qu'elle aura aucun souci une fois installé chez les grands parents (j'ai du la récup, la "réparer" et la renvoyer de nombreuses fois snif)

Bonne journée

Tu n’as pas tué de poule avec ça ? Il y a une détection de blocage ?

Bonjour,

Les pièces imprimés en 3D sont dans quelle matière ?
Le raccord entre le bras du moteur et la glissière sur la porte fonctionne comment ?

Salut.
De ce que j'ai pu constater chez moi, les poules ont tendance a se coucher plus tard en hiver.
J'ai donc ajouté un délai de 30 minutes après le coucher du soleil pour la fermeture.

Bravo pour l'idée du levier avec glissière. Ça doit être assez peu consommateur en énergie .

non pas encore je dois l'envoyer chez les grands parents et on verra après :rofl:

Pas de détection de blocage, j'ai préféré donner plus de temps aux poules pour rentrer, et après la porte se ferme, normalement y'a pas de raison qu'une sorte sa tête

la porte se ferme en 5secondes

Plus sérieusement, sans détection de blocage, c'est plus pour le moteur que j'aurais des inquiétudes.

PLA, pas le top pour le projet c'est vrai, mais pas moyen d'imprimer en ABS... je vais passer une couche de vernis en bombe sur toute la porte et la planche en bois, j'espère que ça va faire le taff :slight_smile:

Le raccord est basé sur une "boule" j'ai laissé un jeu de 5mm entre la boule et la porte une fois dans la glissière (j'enverrais des vrais photo dans l'heure)


edit :

merci pour l'info ça va être utile :slight_smile: j'ai baissé la detection à 100 pour être sur qu'il fasse bien nuit et que les poules soient rentrés, mais ça suffira pas ? si c'est pas assez je vais rajouter un délai ( avec la fontion delay ? ou milis je maitrise pas celle là)

j'ai pompé l'idée du volet electrique chez ma grand mère x)

c'est vrai, mais je vois pas trop comment faire... Pour l'instant la porte se met en pause 3s si elle a pas reussi à se fermer/ouvrir en 7s... et après elle retente. Des idées ?

Je vois deux méthodes possibles :

  • Un contact (ou barrière IR) sur la tranche de la porte qui envoie un signal à l'arduino
  • La mesure du courant du moteur : un moteur bloqué a une intensité électrique qui augmente assez fortement (d'où le risque de cramage)

Il y en a peut-être d'autres...

le capteur fin de course arrête la porte une fois activé, mais rajouter la mesure du courant ça peut être top ! Comment on mesure une intensité en arduino ?

La façon la plus simple (à voir si c'est suffisant, il faudrait les caractéristiques du moteur : courant nominal et courant axe bloqué) est de rajouter une résistance de shunt (à dimensionner en fonction des caractéristiques précédentes) en série avec le moteur. La tension (ça arduino sait mesurer) entre ses bornes est proportionnelle à l'intensité du courant (la fameuse loi d'Ohm)

Tu as de quoi mesurer ces deux intensités ?

ha bien vu avec la loi d'ohm, je peux faire un pont diviseur de tension et lire avec arduino.

Non il ne faut pas lire la tension du moteur mais son intensité, d'où le shunt.

Je lis la tension d'une résistance dans un pont diviseur de tension non, et avec la loi d'ohm je peux effectivement calculer l'intensité n'est ce pas ?

Ce n'est pas celui qu'il faut utiliser, mais le L293D (avec diodes de roue libre), à moins d'avoir mis toi même des diodes de roue libre :
image

Pas besoin de pont diviseur, regarde R8 sur ce schéma :

Bonjour,

Ton moteur ne va pas consommer un "fort" ampérage.

La résistance shunt pour mesurer un courant est mise en série avec le moteur.
Et pour ne pas dissiper inutilement de la puissance en chaleur (pertes) = Rshunt x I², on prend une Rshunt faible voir inférieure à 1 Ohm.

Je prend un exemple bidon.

Tu as 1 moteur 12V 2A soit 24W.
Tu met en série Rshunt 1 Ohm
Si tu consomme toujours 2A, la Rshunt absorbe 2V et 2W.

Résultat ton moteur tourne moins vite et tu perd 2W.

Donc si tu veut perdre peu, tu prend Rshunt faible, par exemple 0,2 Ohms.

Mais inconvénient, pour calculer le courant, tu lis une tension faible aux bornes d'une Résistance faible, U=RI.

A cette tension faible s'ajoute immanquablement le bruit qui parasite ta mesure, et comme l'a si bien expliqué ailleurs un imminent électronicien du forum, s'ajoute les piétres qualités du convertisseur analogique/numérique.

Bref, à petit shunt, petites pertes, c'est cool.
Mais grosses difficultés de mesure du courant et c'est moins cool.

A voir.

Sinon il existe d'autres piste, les modules capteur de courants pour Arduino par exemple, à voir sur Google.

Oups, erreur de frappe, autant pour moi... j'utilise un l298n

Merci pour l'explication, j'ai vu ce système en science de l'ingénieur avec une diode de roue libre et tout, mais j'avais pas saisi. Donc pour ma porte il est inutile de mesurer l'intensité de la sorte à cause de la précision ?

Et puis une protection moteur vaut vraiment le coup ? certains ont eu déjà un souci de ce côté ? Si vraiment c'est nécéssaire je prendrais un module déjà fait

Non, pas inutile, mais un peu hasardeux de cette façon.