Porte automatique de poulailler qui fonctionne sans un code farfelu

Bonjour à toutes et tous

Ayant fouillé sur le forum d’Arduino , acheté et fais de multiples essais qui ne marchent PAS !!! suivant des explications et des plans parues sur ce site .
mon matériel .
arduino nano
1 ldr
1 R de 10 k ohms
deux led verte et rouge
deux résistances de 220 ohms
1 module L298
1 motoréducteur 12 volts
deux boutons poussoir pour la montée et descente manuel de la porte

Je ne sais pas programmer ce type compilation
je cherche un programme qui fonctionne correctement sans faille , dont la consommation est réduite car je n'ai pas le courant dans le poulailler .
merci d'avance de votre compréhension , et de votre dévouement
cordialement Philippe

si vous ne voulez pas programmer ni apprendre le plus simple:

il y a en a plein d'autres, à tous les prix...

Déjà bonjour et

Merci de votre réponse rapide , instructive et surtout de votre aide !!!.
Effectivement cette réponse commercial , n’insiste pas à continuer dans le système ARDUINO .
Le gain de temps et d'euros ne font plus que rage .
Je pensais que ce site pédagogique était là pour nous aider , je me suis trompé !!comme dans la programmation que j'ai essayé de compiler mainte fois .
Donc ce site est réservé à une certaine élite de l'art duino .
Cordialement Philippe

Bonjour,
Ce site de bénévoles a toujours aidé les personnes qui essaient d'apprendre la programmation.
Nous ne pouvons pas apprendre à votre place et encore moins faire le programme à votre place.
Il existe dans la section "Réalisations et Projets finis" des exemples de portes pour poulailler qui, il me semble, sont fonctionnelles.
Il faudrait expliquer avec plus de détails les problèmes que vous rencontrez.

Je réagissais à votre texte où vous disez ne pas savoir coder ce genre de solution et que vous cherchiez un code tout fait.

ma réponse était factuelle, comme vous le dites c'est un site à but pédagogique... si vous ne souhaitez pas développer votre solution et cherchez un truc tout fait avec un certain niveau d'assurance qualité, le plus simple et sans doute le moins cher c'est d'acheter une solution du commerce. Même si je sais coder, j'achète moi même souvent des solutions toutes faites car au final c'est mieux fini, mieux intégré, il y a une garantie etc.. Ce n'est pas un jugement de valeur.

si vous souhaitez apprendre et coder votre solution, on vous aidera mais sur la base de votre code...

Lorsqu'on lance une recherche sur le forum avec les mots "porte de poulailler", on a plus de 50 résultats.
https://forum.arduino.cc/search?q=porte%20de%20poulailler
Sur la quantité je serais étonné qu'il n'y en ait pas un qui soit fonctionnel.

Si tu donnais le montage que tu as réalisé, le code que tu as utilisé et les problèmes que tu rencontres on pourrait peut-être t'aider.

Bonsoir à toutes et tous

j'ai trouvé ce schéma qui fonctionne ouf merci à vous tous , mais je souhaiterais rajouter des éléments supplémentaires un délai de 15 minute sur la LDR afin que les nuages ne perturbent pas la sonde photovoltaïque jour de pleine lune et un programmation journalier/horaire avec ouverture/fermeture .
Avec s'il vous plait les instructions de modification .
Peut on mettre un potentiomètre à la place de la résistance de 10 k ohms ?

Merci d'avance de votre collaboration à tous
bonne soirée
Cordialement Philippe

vous ne voulez pas essayer un minimum de proposer votre code pour le délai ?

(en pratique s'il fait moche 16 minutes, la porte va se fermer... une LDR n'est pas le bon moyen pour déterminer le coucher du soleil. les projects fonctionnels utilisent généralement une RTC)

Bonsoir a tous et toutes
Merci de vos réponses
Peut on associer un programme avec la LDR et des heures de fermeture et d'ouverture avec le module RTC DS 1307 .Suivant le temps que par sécurité la porte se ferme ou s'ouvre à des heures programmées .

Merci de votre réponse
Bonne soirée
cordialement Philippe

on peut (mais je ne vois alors pas trop l'intérêt de la LDR). Il vaut mieux prendre un DS3231 qui est plus précise, la DS1307 va dériver dans le temps

Eclipse ? :grinning:

Surtout les éclipses de soleil, c'est super dangereux pour les yeux des poules, mieux vaut qu'elles soient renfermées. :rofl: :joy: :rofl:

A+

bonjour à tous et a toute

Suivant vos conseils il vaut mieux un système horaire avec la précision du DS3231.
Alors je cherche une compilation qui :
pourrait varier selon le calendrier exemple : augmenter , ou diminuer le temps d'ouverture par rapport au calendrier à partir de janvier .
est t'il possible !!.
Ou associer les deux fonctions horaire et lumière en même temps
Qui ne consomme pas trop aussi car pas de 220v dans le poulailler
Merci de votre réponse
Cordialement Philippe

Si vous cherchez sur le forum vous verrez un post avec des formules pour le lever et coucher de soleil en fonction de la date et vos coordonnées latitude et longitude (cherchez éphémérides)

Bonjour à toutes et à tous

merci de votre aide

J'ai trouvé deux compilations sur le forum
mais comment actionner le L298 pour faire tourner le moteur de la porte par rapport à l'heure d'ouverture et de fermeture suivant la levée du jour et la tombée de la nuit ?

#include <SPI.h>
#include <Wire.h>
#include "RTClib.h"

RTC_DS3231 rtc;

String nfm = ""; // jours avant la prochaine pleine lune

void setup() {
  Serial.begin(115200);
  
  rtc.begin();
  if (! rtc.begin()) {
  Serial.println("Couldn't find RTC");
  while (1);
  }
  
  // pour changer la date de la RTC
  // exemple pour Le 22 janvier 2020 à 6h du matin :
  // rtc.adjust(DateTime(2020, 1, 22, 6, 0, 0));

  rtc.adjust(DateTime(F(__DATE__), F(__TIME__))); // la RTC prends l'heur et la date de l'ordinateur
  Wire.begin();
}

void loop() {

  affichagelune();
  delay(1000);
}

void affichagelune(void) {

  DateTime now = rtc.now();
  int Year = (now.year());
  Serial.print(now.day(), DEC);
  Serial.print(" / ");
  Serial.print(now.month(), DEC);
  Serial.print(" / ");
  Serial.print(Year, DEC);
  Serial.print(" :  ");

  int mp = lune_phase();

  switch (mp) {
    case 0:
      Serial.println("  Pleine Lune ");
      break;
    case 1:
      Serial.println("  Gibbeuse Décroissante");
      break;
    case 2:
      Serial.println("  Dernier Quartier ");
      break;
    case 3:
      Serial.println("  Dernier Croissant ");
      break;
    case 4:
      Serial.println("  Nouvelle Lune ");
      break;
    case 5:
      Serial.println("  Premier Croissant ");
      break;
    case 6:
      Serial.println("  Premier Quartier");
      break;
    case 7:
      Serial.println("  Gibbeuse Croissante");
      break;
  }

}

int lune_phase() {
  // calcule l'âge de la phase de lune (0 à 7)
  // il y a huit étapes, 0 est la pleine lune et 4 est une nouvelle lune
  DateTime now = rtc.now();
  double jd = 0; //Date julienne
  double ed = 0; //jours écoulés depuis le début de la pleine lune
  int b = 0;
  jd = datejulienne(now.year(), now.month(), now.day());
  jd = int(jd - 2244116.75); // reférence au 1 janvier 1972
  jd /= 29.53; // diviser par le cycle lunaire
  b = jd;
  jd -= b; // laisse la partie fractionnaire de jd
  ed = jd * 29.53; // jours écoulés ce mois-ci
  nfm = String((int(29.53 - ed))); // jours avant la prochaine pleine lune
  b = jd * 8 + 0.5;
  b = b & 7;
  return b;

}
double datejulienne(int y, int m, int d) {
  //convertir une date en date julienne}
  int mm, yy;
  double k1, k2, k3;
  double j;

  yy = y - int((12 - m) / 10);
  mm = m + 9;
  if (mm >= 12) {
    mm = mm - 12;
  }
  k1 = 365.25 * (yy + 4172);
  k2 = int((30.6001 * mm) + 0.5);
  k3 = int((((yy / 100) + 4) * 0.75) - 38);
  j = k1 + k2 + d + 59;
  j = j - k3; //j est la date julienne à 12h TU (temps universel)

  return j;
}


*Il y a celui ci aussi*


void setup()
{
  Serial.begin(115200);
  delay(500);

  demo(0);

  demoUnix(1608316975UL); // le 18/12/2020 à 18:42:55 UTC (heure hiver)
  demoUnix(1600454575UL); // le 18/09/2020 à 18:42:55 UTC (heure été)
}

void loop()
{
}

//timestamp contient le nombre de secondes écoulées depuis le 01/01/2000 00:00:00 UTC
void demo(uint32_t timestamp)
{
  Serial.print("\ntimestamp=");
  Serial.println(timestamp);

  uint8_t annee, mois, jour, heure, minute, seconde;
  decomposer(timestamp, &annee, &mois, &jour, &heure, &minute, &seconde);

  afficher(annee, mois, jour, heure, minute, seconde);
  Serial.println(" UTC");

  if (heureEte(annee, mois, jour, heure))
  {
    timestamp += 7200;
  }
  else
  {
    timestamp += 3600;
  }
  decomposer(timestamp, &annee, &mois, &jour, &heure, &minute, &seconde);

  afficher(annee, mois, jour, heure, minute, seconde);
  Serial.println(" local");
}

//un timestamp unix contient le nombre de secondes écoulées depuis le 01/01/1970 00:00:00 UTC
void demoUnix(uint32_t timestampUnix)
{
  const uint32_t SECONDES_ENTRE_1970_ET_2000 = 946684800UL;
  demo(timestampUnix - SECONDES_ENTRE_1970_ET_2000);
}

//calcul du nombre de jours d'un mois
uint8_t nbJoursMois(uint8_t annee, uint8_t mois)
{
  return (mois==4 || mois==6 || mois==9 || mois==11) ? 30 : (mois==2 ? ((annee&3) ? 28 : 29) : 31);
}

//décomposition d'un timestamp en année/mois/jour/heure/minute/seconde
void decomposer(uint32_t timestamp, uint8_t *annee, uint8_t *mois, uint8_t *jour, uint8_t *heure, uint8_t *minute, uint8_t *seconde)
{
  //Partie facile
  *seconde = timestamp % 60;
  timestamp /= 60;
  *minute = timestamp % 60;
  timestamp /= 60;
  *heure = timestamp % 24;

  //Partie amusante
  uint16_t jours = timestamp / 24;

  const uint16_t JOURS_PAR_ANNEE = 365;
  const uint16_t JOURS_PAR_4_ANNEES = 1 + 4 * JOURS_PAR_ANNEE;
  const uint16_t QUANTIEME_29_FEVRIER_2000 = 31 + 29;

  uint8_t nb_29_fevrier_echus = (jours + (JOURS_PAR_4_ANNEES - QUANTIEME_29_FEVRIER_2000)) / JOURS_PAR_4_ANNEES;
  *annee = (jours - nb_29_fevrier_echus) / JOURS_PAR_ANNEE;

  jours -= ((uint16_t) *annee) * JOURS_PAR_ANNEE + ((*annee + 3) >> 2) - 1;

  *mois = 1;
  uint8_t duree_mois = nbJoursMois(*annee, *mois);
  while (jours > duree_mois)
  {
    jours -= duree_mois;
    *mois = *mois + 1;
    duree_mois = nbJoursMois(*annee, *mois);
  }

  *jour = jours;
}

//détermination de l'heure été ou hiver
bool heureEte(uint8_t anneeUTC, uint8_t moisUTC, uint8_t jourUTC, uint8_t heureUTC)
{
  //En France métropolitaine :
  //Passage de l'heure d'hiver à l'heure d'été le dernier dimanche de mars à 1h00 UTC (à 2h00 locales il est 3h00)
  //Passage de l'heure d'été à l'heure d'hiver le dernier dimanche d'octobre à 1h00 UTC (à 3h00 locales il est 2h00)

  const uint8_t MARS = 3;
  const uint8_t OCTOBRE = 10;

  if (moisUTC == MARS)
  {
    uint8_t dernierDimancheMars = 31 - ((5 + anneeUTC + (anneeUTC >> 2)) % 7); //Pas évidente à trouver celle-là
    return jourUTC > dernierDimancheMars || (jourUTC == dernierDimancheMars && heureUTC != 0);
  }

  if (moisUTC == OCTOBRE)
  {
    uint8_t dernierDimancheOctobre = 31 - ((2 + anneeUTC + (anneeUTC >> 2)) % 7);
    return jourUTC < dernierDimancheOctobre || (jourUTC == dernierDimancheOctobre && heureUTC == 0);
  }

  return MARS < moisUTC && moisUTC < OCTOBRE;
}

//Calcul du jour de la semaine : 0 Dimanche, 1 Lundi, etc.
uint8_t calculerJoursem(uint8_t annee, uint8_t mois, uint8_t jour)
{
  //Formule maison, économe en calculs fin d'épargner les petits processeurs 8 bits
  uint8_t somme = annee + (annee >> 2) + jour;
  switch (mois)
  {
  case  2 :
  case  3 :
  case 11 : somme++;    break;
  case  6 : somme += 2; break;
  case  9 :
  case 12 : somme += 3; break;
  case  4 :
  case  7 : somme += 4; break;
  case  1 :
  case 10 : somme += 5; break;
  case  5 : somme += 6;
  }
  if (mois > 2 || (annee & 3)) somme++;
  return somme % 7;
}

void afficher(uint8_t annee, uint8_t mois, uint8_t jour, uint8_t heure, uint8_t minute, uint8_t seconde)
{
  uint8_t joursem = calculerJoursem(annee, mois, jour);

  switch (joursem)
  {
    case 0 : Serial.print("dim "); break;
    case 1 : Serial.print("lun "); break;
    case 2 : Serial.print("mar "); break;
    case 3 : Serial.print("mer "); break;
    case 4 : Serial.print("jeu "); break;
    case 5 : Serial.print("ven "); break;
    case 6 : Serial.print("sam "); break;
  }  

  Serial.print("20");
  Serial2print(annee);
  Serial.print('/');
  Serial2print(mois);
  Serial.print('/');
  Serial2print(jour);
  Serial.print(' ');
  Serial2print(heure);
  Serial.print(':');
  Serial2print(minute);
  Serial.print(':');
  Serial2print(seconde);
}

void Serial2print(uint8_t nombre)
{
  if (nombre < 10) Serial.print('0');
  Serial.print(nombre);
}




Ce na va pas être facile je le conçois , 
mais si ça marche youpi 
Cordialement Philippe

HS
Petite tentative de correction d'une idée reçue et répandue : les éclipses de soleil ne sont absolument pas dangereuses pour les yeux !
Ce qui est (très) dangereux, c'est de regarder le soleil en face. Tout bêtement.
En général, personne ne fait ça (ça fait mal). Sauf pendant une éclipse, parce que là, il y a quelque chose à voir.

Bonjour à toutes et tous

Bon à part les éclipses que l'on n'a pas tous les jours .
A ce jour je n'ai toujours pas trouvé une compilation arduino éphéméride qui actionne un moteur à courant continu .
j'ai trouvé des compilations partiellement inachevées .
Je ne suis pas un cador de programmation mais j’essaie de comprendre .

Merci de votre aide

Cordialement Philippe

Salut.
Ce que tu cherches s'appelle l’arlésienne.
En général, en matière de logiciel, on établit un cahier des charges, et on essaie de se former aux technologies nécessaires à la mise en oeuvre de ce cahier des charges.
Je peux bien t'indiquer un projet qui correspond à ce que tu désires :

Tout est là. Je te laisse explorer. Il y a de longues heures de lecture.
Mais n'attends pas de moi que je t'explique en long, en large, et en travers, le fonctionnement de ce truc qui me semble largement hors de ta portée.

Juste pour que l'on se comprenne bien, ce n'est pas compilation mais code
"je n'ai toujours pas trouvé un code arduino éphéméride qui actionne un moteur à courant continu ."
La compilation c'est l'action de convertir un code source en code interprétable par la machine.

Il y a une librairie qui permet de calculer les heures de lever et de coucher du soleil
https://forum.arduino.cc/t/calcul-ephemeride-precis-lever-et-coucher-de-soleil/266532/45

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.