Projet porte de poule automatique

Bonjour, j'essaie de faire ma porte de poule automatique pour mes poules.

j'ai une carte arduino Mega 2560R3, une photorésistance, une L293D, un Moteur DC et deux capteurs (Haut et bas représenté par des BP).

je voudrais que ma porte s'ouvre quand la luminosité est bonne (valeur superieure à 500) jusqu’à ce que le haut la porte touche le capteur BP Haut (le moteur s'arrete).

puis a la tomber de la nuit le moteur se met en route en sens inverse (la photoresistance a une valeur inferieure a 500), la porte descend et le moteur s'arrete quand la porte touche le capteur bas. et ainsi de suite.

Or cela ne fonctionne pas et je ne comprend pas pourquoi ?

Merci pour votre aide

Franck

/************************************************/
/*                Déclarations                  */
/************************************************/
const char AN_PHOTORESISTANCE = 1;
char PWM_ENABLE = 3;
char DO_MOTOR_1 = 2;
char DO_MOTOR_2 = 4;
int etatBP_Bas;
int etatBP_Haut;
int valeurPotentiometre = 0;
int vitesseDuMoteur = 0;
int offset = 1;
const int FDC_Bas = 6;
int FDC_Haut = 5;

/************************************************/
/*                Déclarations                  */
/************************************************/
void setup()
{
    pinMode(DO_MOTOR_1,OUTPUT);
    pinMode(DO_MOTOR_2,OUTPUT);
    pinMode(PWM_ENABLE,OUTPUT);
    pinMode (FDC_Bas,INPUT_PULLUP);
    pinMode (FDC_Haut,INPUT_PULLUP); 
    digitalWrite(DO_MOTOR_1, LOW);
    digitalWrite(DO_MOTOR_2, LOW);
    analogWrite(PWM_ENABLE, 0);
    analogWrite(AN_PHOTORESISTANCE, 1);
    Serial.begin(9600);
  
}
/************************************************/
/*                Boucle Infinie                */
/************************************************/
void loop() {

 etatBP_Bas = digitalRead(FDC_Bas);
 etatBP_Haut = digitalRead(FDC_Haut);
 
  int valeurSurA1 = analogRead(AN_PHOTORESISTANCE);
  int Luminosite = 1023 - valeurSurA1;
 
 Luminosite = Luminosite - offset;
   vitesseDuMoteur = 200;

//*  fermeture porte
  if(Luminosite<500)

 {
 
/*rotation horaire*/

digitalWrite(DO_MOTOR_1,LOW);
digitalWrite(DO_MOTOR_2,HIGH);
Serial.print("+");
while ((etatBP_Bas) != LOW){
digitalWrite(DO_MOTOR_2,LOW);
digitalWrite (DO_MOTOR_1,LOW); //pas necessaire (normalement)
}
 }

 
if(Luminosite>500)

{
/*rotation anti horaire*/
digitalWrite(DO_MOTOR_2,LOW);
digitalWrite(DO_MOTOR_1,HIGH);

Serial.print("-");
while ((etatBP_Bas) !=LOW){
  digitalWrite (DO_MOTOR_1,LOW);
  digitalWrite (DO_MOTOR_2,LOW);
}
}

analogWrite(PWM_ENABLE,vitesseDuMoteur);

Serial.println(vitesseDuMoteur); 
Serial.println(Luminosite);
Serial.println(etatBP_Bas) ;
Serial.println(etatBP_Haut) ;
delay(200);
  
}

Dans le setup(), cela ne te choque pas un peu?

analogWrite(AN_PHOTORESISTANCE, 1);

Tu es sûr pour cette partie:

while ((etatBP_Bas) !=LOW){
  digitalWrite (DO_MOTOR_1,LOW);
  digitalWrite (DO_MOTOR_2,LOW);
}

Les 2 sorties LOW ça ne couperait pas le moteur

En mettant un seuil à 500 sur les 2 tests tu ne penses pas que tu vas décapiter les poules?

if(Luminosite<500){
....
}
if(Luminosite>500){
....
}

La porte s'ouvre, une variation minime de la luminosité se produit, la porte se referme aussitôt.
Il faut mettre de l'hystérésis pour éviter ce problème.

Bonjour,
Je débute en arduino,
Pourquoi le setup devrait-il me choqué ?

Pour ce qui es de savoir si j'en suis sûre, non pas du tout !!!

En gros je voudrais que mon moteur s'arrête quand il rencontre le capteur bas.

En ce qui concerne la valeur de 500, ceci et un exemple et elle sera réglé via le offset en fonction l'emplacement de la photo résistance.

Bien cordialement
Franck

Pourquoi le setup devrait-il me choqué ?

Parce que analogWrite ecrit dans la photoresistance ... En fait, comme vous la lisez par la suite, ce n'est pas bien grave....

Maintenant que se passerait-il si votre montage fonctionne, et que vous êtes très voisin du seuil (disons 500)
Mettons qu'une seconde, vous ayez seuil+1, l'autre seconde seuil-1 : votre porte va s'agiter frénétiquement et ça va user le moteur en vain, bouffer de l'énergie, voire décapiter une poule (ou la faire glousser comme une oie). là c'est beaucoup plus gênant.

fdufnews a raison d'indiquer qu'il faut une programmation un peu plus compliquée, pour éviter un comportement erratique au crépuscule, à l'aube ou près d'un gros nuage....
La façon la plus simple de le faire est de ne rien faire si l'on est dans la plage (500 - Seuil, 500 + seuil) et de remplacer les tests
if (luminosité < 500) par if (luminosite < (500 - Seuil))
et
if (luminosite > 500) par if (luminosite > (500 + Seuil))
Seuil étant, comme 500, à définir....

Et que font les poules qui ne seront pas rentrées à temps...?

lesept:
Et que font les poules qui ne seront pas rentrées à temps...?

Elles se démmerdébrouillent :grin:

Peut être faudrait il rajouter un compteur de poules, ou peser le nichoir....
Mais c'est plus compliqué (et que se passe-t-il s'il y a des poussins?)

Une autre solution serait de fermer le nichoir une heure après le coucher du soleil, s'il y a une horloge temps reel, et de l'ouvrir une heure avant son lever. Ca permettrait de s'affranchir des feuilles, autres fients qui vont occulter une LDF, et de gros nuages d'orage.
A noter qu'avr-libc avr-libc: <time.h>: Time offre (mais pas dans la portion qui est livée avec arduino des fonctions gérant la position su solei (sun_rise et sun_set, pour l'aube et le crépuscule); il y a 2 ans, je les avais comparées avec un calendrier, sans être choqué (ça manque cruellement sur un PC/RPi) ....

Tu fais tourner le moteur dans un sens (enfin c'est ce que dit le commentaire)

/*rotation anti horaire*/
digitalWrite(DO_MOTOR_2,LOW);
digitalWrite(DO_MOTOR_1,HIGH);

ou dans l'autre

/*rotation horaire*/

digitalWrite(DO_MOTOR_1,LOW);
digitalWrite(DO_MOTOR_2,HIGH);

et dans la fraction de seconde qui suit tu fais

while ((etatBP_Bas) !=LOW){
  digitalWrite (DO_MOTOR_1,LOW);
  digitalWrite (DO_MOTOR_2,LOW);
}

Les 2 entrées à LOW doivent mettre le moteur à l'arrêt.

à la limite je comprendrais

while ((etatBP_Bas) !=LOW);  // <- noter le point virgule ici
  digitalWrite (DO_MOTOR_1,LOW);
  digitalWrite (DO_MOTOR_2,LOW);

qui attendrait que la porte atteigne la butée puis arrête le moteur.
Encore que cette solution est dangereuse car il n'y a pas de sécurité, si la porte se bloque.

Bonjour à tous,
Déjà merci pour vos commentaires,

Si cela est plus simple on peux refaire le code depuis le début en ajoutant les composants pour assurer une sécurité.
Cela ne me dérange pas et me permettrait d'avancer dans mon projet.

Franck

Je suis dans le même projet que toi.
C'est mon premier projet en arduino.

Je fait comme toi, sauf que je pense utilisé un calendrier avec les éphémérides pour l'ouverture et fermeture de la porte, en complément de la photoresistance.

Et je veux créer un tutoriel simple pour tout le gens qui cherche à créer la même chose.

Je vais suivre ton travail avec beaucoup d'attention !

Salut ,

moi je vois encore un probleme , lors de l' utilisation de ce script + automatisme .

Que se passe t ' il si une poule se trouve dessous la porte pendant qu ' elle se ferme ?

cette histoire est comparable a un portail coulissant .

soit on utilise une photocellule , soit un palpeur par securité et eviter de blesser quoi que ce soit non ?

fdufnews:
Il faut mettre de l'hystérésis pour éviter ce problème.

+1

Tu ne parles pas de la mécanique. Comment est actionnée la porte (coulissante, battante) :

  • vis sans fin
  • fil
  • etc.

Suggestions :
https://forum.arduino.cc/index.php?topic=265520.0
https://forum.arduino.cc/index.php?topic=379566.0

Salut,

AU niveau de la mecanique, la porte coulissante vers le haut a l'aide :

relier a une tige qui fait enroulé la ficelle j'usqu'au capteur Haut ou deroulé j'usqu'au capteur Bas

à mon avis la luminosité n'est pas un capteur adéquat pour piloter la porte. Jours gris, nuages, saleté sur le capteur... trop d'incertitude sur la source d'information.

une RTC de qualité correcte (DS3231) avec un code qui prend en compte les heures d'hiver et d'été et lever / coucher de soleil me semble plus approprié.

Le reste du fonctionnement est vraiment une simple machine à état (cf mon tuto éventuellement)

Les états seraient enum : byte {PORTE_FERMEE, PORTE_EN_OUVERTURE, PORTE_EN_FERMETURE, PORTE_FERMEE, PORTE_BLOQUEE} etatPorte;

les évènements seraient leverDuSoleil, coucherDuSoleil, capteurFinDeCourseBas, capteurFinDeCourseHaut, surConsommationCourant (si la porte se bloque en cours de route).

C'est comme cela que j'approcherais la programmation