Porte automatique pour poulailler version 5-B (Vérin électrique ou Moteur DC 12v)

Description :

Version 4 : Avec moteur PAP

3 modes disponibles et entièrement configurables grâce aux boutons et de l’affichage LCD.

Mode LDR : porte sera pilotée par le capteur de luminosité (LDR) avec option hysteresis.

Mode Manuel : porte sera pilotée par 2 boutons manuellement.

Mode Programmateur : programmer une heure ouverture / fermeture.

Options système :

-Réglage de l’heure directement avec les boutons.

-Mise en veille programmable de l’écran.

Tous les paramètres seront sauvegardés automatiquement sur la RAM en cas de coupure de courant.

 

    Prérequis :

Matériel :

  • 1 x Carte Arduino Uno
  • 2 x Fin de course
  • 1 x LDR photorésistance
  • 1 x Résistance 10 KΩ
  • 3 x Boutons
  • 1 x Ecran LCD 20×4
  • 1 x Module I2C
  • 1 x Vérin électrique ou Moteur DC
  • 1 x L298N
  • 1 x DS1302 Module RTC
  • 1 x Alimentation 12v
  • Fils de connexion
  • 1 x Breadboard

Version IDE :

Bibliothèque :

 

 

Vidéo de démonstration :

 

Schéma de câblage moteur DC :

 

Schéma de câblage vérin électrique :

 

Code :

//DS1302 //////////////////////////////////////////
#include <DS1302.h>
DS1302 rtc(7, 6, 5);
Time t;
DS1302_RAM ramBuffer;

//L298N ///////////////////////////////////////////

// le numéro de la broche ou est branché la sortie IN1 du L298N
int IN1 = 10;
// le numéro de la broche ou est branché la sortie IN2 du L298N
int IN2 = 11;

//LCD I2C /////////////////////////////////////////
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 20, 4);

//Gestion des entrées /////////////////////////////
int Bthaut = A1; //Pin du Bouton fleche haut
int Btbas = A2; //Pin du Bouton fleche bas
int Btselect = A3; //Pin du Bouton select
const int LDR = A0; //Pin du LDR
const int fdchaut = 3; //Pin du fin de course haut
const int fdcbas = 4; //Pin du fin de course bas

//Gestion des timers //////////////////////////////
unsigned long timerarduino;
unsigned long previousTime = 0;
unsigned long previousTimer1 = 0;
unsigned long Timer1;
unsigned long Timer1ON = 500; // Tps clignotement pendant saisie
unsigned long Timer1OFF = 500; // Tps clignotement pendant saisie
bool Timer1Etat;
unsigned long previousTimer2 = 0;
unsigned long Timer2;
unsigned long Timer2ON = 60000; // Utiliser pour decompte pour hysterisis
unsigned long previousTimer3 = 0;
unsigned long Timer3;
unsigned long Timer3ON = 1000; // Utiliser pour decompte pour hysterisis
unsigned long previousTimer4 = 0;
unsigned long Timer4;
unsigned long Timer4ON; // Utiliser pour la mise en veille
unsigned long previousTimer5 = 0;
unsigned long Timer5;
unsigned long Timer5ON = 2000; // Utiliser pour la saisie rapide
unsigned long previousTimer6 = 0;
unsigned long Timer6;
unsigned long Timer6ON = 500; // Utiliser pour la saisie rapide
int TpsAvouverture;
int TpsAvfermeture;
unsigned long TpsAvouverturesec;
unsigned long TpsAvfermeturesec;

//Variable Menu ///////////////////////////////////
int Accueil = 1; // Ecran Accueil
int Menu; // Menu Principal
int MenuMdm; // Menu Mode de Marche
int MenuPara; // Menu parametres
int MenuParaProg; // Menu parametres programmateur
int ParaProgHouv; // Menu parametrage Progr Heure ouverture
int ParaProgHferm; // Menu parametrage Progr Heure fermeture
int MenuParaLDR; // Menu parametres LDR
int ParaLDRouv; // Menu parametrage LDR ouverture
int ParaLDRferm; // Menu parametrage LDR fermeture
int ParaLDRhysteresis; // Menu parametrage LDR Hysteresis
int MenuSyst; // Menu systeme
int MenuSystVeille; // Menu systeme veille
int SystVeilleetat; // Menu systeme veille etat
int SystVeilleTpsactiv;// Menu systeme veille tps activation
int SystReglheure; // Menu systeme Reglage Heure


//Variables programme/////////////////////////////
boolean RefreshAffHeure;
boolean RefreshAffEtatTrappeManu;
int Thour;
int Tmin;
int Tsec;
boolean EtatBtselect;
boolean EtatBthaut ;
boolean EtatBtbas;
boolean Etattrappe = 0;
boolean Saisierapide;
boolean Pause; //Permet de mettre en pause certain affichage temps que moteur activer
int Modedemarche = 1; //Defini mode de marche (1 = Progr, 2 = LDR, 3 = Manu)
long V_MinOuv = 23; //Stock valeur Minute pour Progr Minute ouverture
long V_HeureOuv = 11; //Stock valeur Heure pour Progr Heure ouverture
long V_MinFerm = 23; //Stock valeur Minute pour Progr Minute fermeture
long V_HeureFerm = 23; //Stock valeur Heure pour Progr Heure fermeture
int V_LDRouv = 800; //Stock valeur LDR pour ouverture
int V_LDRferm = 700; //Stock valeur LDR pour fermeture
int V_Hysteresis = 20; //Stock valeur LDR pour Hysterisis
int V_Tsystheure; //Stock la valeur dans systeme Reglage heure avant SAV
int V_Tsystminute; //Stock la valeur dans systeme Reglage minute avant SAV
int V_Tsystseconde; //Stock la valeur dans systeme Reglage seconde avant SAV
int Veille = 0; // Ecran mise en veille
boolean Etatveille = 0;//Stock etat de la veille (actif ou inactif)
int V_TpsAvveille = 5; //Stock la valeur tps avant mise en veille en sec

byte customChar1[] = {B00000, B00000, B00001, B00001, B00001, B10110, B11000, B10000};
byte customChar2[] = {B00000, B11000, B00100, B10100, B00110, B01000, B00100, B00100};
byte customChar3[] = {B01000, B00111, B00001, B00011, B00000, B00000, B00000, B00000};
byte customChar4[] = {B01000, B10000, B10000, B11000, B00000, B00000, B00000, B00000};

void setup()
{
Serial.begin(9600);
//DS1302 //////////////////////////////////////////
rtc.halt(false);
// Réglez l'horloge en mode exécution et désactivez la protection en écriture
rtc.writeProtect(true);
rtc.setDOW(FRIDAY); // Set Day-of-Week to FRIDAY
rtc.setTime(19, 03, 0); // Set the time to 12:00:00 (24hr format)
rtc.setDate(22, 8, 2021); // Set the date to August 6th, 2010
//LCD I2C /////////////////////////////////////////
lcd.init(); lcd.backlight();
lcd.createChar(1, customChar1); lcd.createChar(2, customChar2);
lcd.createChar(3, customChar3); lcd.createChar(4, customChar4);
//Declaration des entrées /////////////////////////
pinMode(Bthaut, INPUT_PULLUP);
pinMode(Btbas, INPUT_PULLUP);
pinMode(Btselect, INPUT_PULLUP);
pinMode(fdchaut, INPUT_PULLUP);
pinMode(fdcbas, INPUT_PULLUP);
//L298N ///////////////////////////////////////////
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);
//Lecture et Récupération des valeurs de réglages dans RAM DS1302
ramBuffer = rtc.readBuffer();
Serial.println("Lecture de la RAM : ");
for (int i = 0; i < 31; i++)
{
Serial.print(" "); Serial.print(ramBuffer.cell[i]); Serial.print(" ");
}
Serial.println(" ");
LoadSav();
//Intro ///////////////////////////////////////////
Intro();
}

void loop()
{
int valeurLDR = analogRead(LDR);
timerarduino = millis();
//Ecran Accueil ///////////////////////////////////
switch (Accueil) {
case 0:
break;
case 1:
lcd.clear(); Accueil++;
break;
case 2:
lcd.setCursor(0, 1); lcd.print("Mode :");
lcd.setCursor(0, 2); lcd.print("Trappe :");
Accueil++;
break;
case 3:
if (Modedemarche == 1) {
Accueil = 4 ; RefreshAffHeure = 0;
}
else if (Modedemarche == 2) {
Accueil = 5; RefreshAffHeure = 0;
}
else if (Modedemarche == 3) {
Accueil = 6; RefreshAffHeure = 0;
}
break;
case 4:
lcd.setCursor(7, 1); lcd.print("Programmateur");
lcd.setCursor(0, 3); lcd.print("Ouv ");
if (V_HeureOuv < 10) {
lcd.setCursor(4, 3); lcd.print("0");
lcd.setCursor(5, 3); lcd.print(V_HeureOuv);
}
else {
lcd.setCursor(4, 3); lcd.print(V_HeureOuv);
}
lcd.setCursor(6, 3); lcd.print(":");
if (V_MinOuv < 10) {
lcd.setCursor(7, 3); lcd.print("0");
lcd.setCursor(8, 3); lcd.print(V_MinOuv);
}
else {
lcd.setCursor(7, 3);
lcd.print(V_MinOuv);
}
lcd.setCursor(11, 3); lcd.print("Fer");
if (V_HeureFerm < 10) {
lcd.setCursor(15, 3); lcd.print("0");
lcd.setCursor(16, 3); lcd.print(V_HeureFerm);
}
else {
lcd.setCursor(15, 3);
lcd.print(V_HeureFerm);
}
lcd.setCursor(17, 3); lcd.print(":");
if (V_MinFerm < 10) {
lcd.setCursor(18, 3); lcd.print("0");
lcd.setCursor(19, 3); lcd.print(V_MinFerm);
}
else {
lcd.setCursor(18, 3); lcd.print(V_MinFerm);
}
Accueil = 7;
break;
case 5:
lcd.setCursor(7, 1); lcd.print("LDR");
lcd.setCursor(0, 3); lcd.print("Ouv.: ");
lcd.setCursor(6, 3); lcd.print(V_LDRouv);
lcd.setCursor(11, 3); lcd.print("Fer.: ");
lcd.setCursor(17, 3); lcd.print(V_LDRferm);
Accueil = 7;
break;
case 6:
lcd.setCursor(7, 1); lcd.print("Manuel");
Accueil = 7;
break;
case 7:
if (Modedemarche == 2) {
if (Pause == 0) {
AffValeurLDR(valeurLDR); AffEtatTrappeLDR();
}
GestionTrappeLDR(); GestionTrappeAuto(); EcrVeille();
}
if (Modedemarche == 1) {
if (Pause == 0) {
GestionTrappeProg(); AffEtatTrappeProg();
}
GestionTrappeAuto(); EcrVeille();
}
if (Modedemarche == 3) {
GestionTrappeManu(); AffEtatTrappeManu(); EcrVeille();
}
AffHeure();
break;
default:
break;
}

//Menu principal///////////////////////////////////
switch (Menu) {
case 0:
break;
case 1:
lcd.clear(); Menu++;
break;
case 2:
lcd.setCursor(0, 0); lcd.print("------- Menu -------");
lcd.setCursor(0, 1); lcd.print("Mode de marche");
lcd.setCursor(0, 2); lcd.print("Parametres");
lcd.setCursor(0, 3); lcd.print("Systeme");
Menu++;
break;
case 3:
lcd.setCursor(19, 3); lcd.print(" ");
lcd.setCursor(19, 1); lcd.print("<");
lcd.setCursor(19, 2); lcd.print(" ");
break;
case 4:
lcd.setCursor(19, 1); lcd.print(" ");
lcd.setCursor(19, 2); lcd.print("<");
lcd.setCursor(19, 3); lcd.print(" ");
break;
case 5:
lcd.setCursor(19, 2); lcd.print(" ");
lcd.setCursor(19, 3); lcd.print("<");
lcd.setCursor(19, 1);
lcd.print (" ");
break;
case 6:
lcd.clear(); Menu = 8;
break;
case 7:
lcd.setCursor(0, 0); lcd.print("------- Menu -------");
lcd.setCursor(0, 1); lcd.print("Mode de marche");
lcd.setCursor(0, 2); lcd.print("Parametres");
lcd.setCursor(0, 3); lcd.print("Systeme");
Menu = 5;
break;
case 8:
lcd.clear(); Menu++;
break;
case 9:
lcd.setCursor(0, 0); lcd.print("------- Menu -------");
lcd.setCursor(0, 1); lcd.print("Retour");
Menu = 11;
break;
case 10:
Menu = 7;
break;
case 11:
lcd.setCursor(19, 3); lcd.print(" ");
lcd.setCursor(19, 1); lcd.print("<");
lcd.setCursor(19, 2); lcd.print(" ");
break;
default:
break;
}

//Menu mode de marche//////////////////////////////
switch (MenuMdm) {
case 0:
break;
case 1:
lcd.clear(); MenuMdm++;
break;
case 2:
lcd.setCursor(0, 0); lcd.print("-- Mode de marche --");
lcd.setCursor(0, 1); lcd.print("Programmateur");
lcd.setCursor(0, 2); lcd.print("LDR");
lcd.setCursor(0, 3); lcd.print("Manuel");
MenuMdm++;
break;
case 3:
lcd.setCursor(19, 3); lcd.print(" ");
lcd.setCursor(19, 1); lcd.print("<");
lcd.setCursor(19, 2); lcd.print(" ");
break;
case 4:
lcd.setCursor(19, 1); lcd.print(" ");
lcd.setCursor(19, 2); lcd.print("<");
lcd.setCursor(19, 3); lcd.print(" ");
break;
case 5:
lcd.setCursor(19, 2); lcd.print(" ");
lcd.setCursor(19, 3); lcd.print("<");
lcd.setCursor(19, 1); lcd.print(" ");
break;
case 6:
lcd.clear();
MenuMdm = 8;
break;
case 7:
lcd.setCursor(0, 0); lcd.print("-- Mode de marche --");
lcd.setCursor(0, 1); lcd.print("Programmateur");
lcd.setCursor(0, 2); lcd.print("LDR");
lcd.setCursor(0, 3); lcd.print("Manuel");
MenuMdm = 5;
break;
case 8:
lcd.clear();
MenuMdm++;
break;
case 9:
lcd.setCursor(0, 0); lcd.print("-- Mode de marche --");
lcd.setCursor(0, 1); lcd.print("Retour");
MenuMdm = 11;
break;
case 10:
MenuMdm = 7;
break;
case 11:
lcd.setCursor(19, 3); lcd.print(" ");
lcd.setCursor(19, 1); lcd.print("<");
lcd.setCursor(19, 2); lcd.print(" ");
break;
default:
break;
}

//Menu parametres /////////////////////////////////
switch (MenuPara) {
case 0:
break;
case 1:
lcd.clear(); MenuPara++;
break;
case 2:
lcd.setCursor(0, 0); lcd.print("---- Parametres ----");
lcd.setCursor(0, 1); lcd.print("Programmateur");
lcd.setCursor(0, 2); lcd.print("LDR");
lcd.setCursor(0, 3); lcd.print("Retour");
MenuPara++;
break;
case 3:
lcd.setCursor(19, 3); lcd.print(" ");
lcd.setCursor(19, 1); lcd.print("<");
lcd.setCursor(19, 2); lcd.print(" ");
break;
case 4:
lcd.setCursor(19, 1); lcd.print(" ");
lcd.setCursor(19, 2); lcd.print("<");
lcd.setCursor(19, 3); lcd.print(" ");
break;
case 5:
lcd.setCursor(19, 2); lcd.print(" ");
lcd.setCursor(19, 3); lcd.print("<");
lcd.setCursor(19, 1); lcd.print(" ");
break;
default:
break;
}

//Menu Parametres programmateur////////////////////
switch (MenuParaProg) {
case 0:
break;
case 1:
lcd.clear(); MenuParaProg++;
break;
case 2:
lcd.setCursor(0, 0); lcd.print("-- Programmateur ---");
lcd.setCursor(0, 1); lcd.print("Heure ouverture");
lcd.setCursor(0, 2); lcd.print("Heure fermeture");
lcd.setCursor(0, 3); lcd.print("Retour");
MenuParaProg++;
break;
case 3:
lcd.setCursor(19, 3); lcd.print(" ");
lcd.setCursor(19, 1); lcd.print("<");
lcd.setCursor(19, 2); lcd.print(" ");
break;
case 4:
lcd.setCursor(19, 1); lcd.print(" ");
lcd.setCursor(19, 2); lcd.print("<");
lcd.setCursor(19, 3); lcd.print(" ");
break;
case 5:
lcd.setCursor(19, 2); lcd.print(" ");
lcd.setCursor(19, 3); lcd.print("<");
lcd.setCursor(19, 1); lcd.print(" ");
break;
default:
break;
}

//Menu parametrage Progr Heure ouverture///////////
switch (ParaProgHouv) {
case 0:
break;
case 1:
lcd.clear(); ParaProgHouv++;
break;
case 2:
lcd.setCursor(0, 0); lcd.print("- Heure ouverture --");
lcd.setCursor(9, 2); lcd.print(":");
if (V_MinOuv < 10) {
lcd.setCursor(10, 2); lcd.print("0");
lcd.setCursor(11, 2); lcd.print(V_MinOuv);
}
else {
lcd.setCursor(10, 2); lcd.print(V_MinOuv);
}
ParaProgHouv++;
break;
case 3:
if (Timer1Etat) {
Timer1 = Timer1OFF;
}
else {
Timer1 = Timer1ON;
}
if ((timerarduino - previousTimer1) > Timer1) {
previousTimer1 = timerarduino;
Timer1Etat = !Timer1Etat;
if (Timer1Etat) {
if (V_HeureOuv < 10) {
lcd.setCursor(7, 2); lcd.print("0");
lcd.setCursor(8, 2); lcd.print(V_HeureOuv);
}
else {
lcd.setCursor(7, 2); lcd.print(V_HeureOuv);
}
}
else {
lcd.setCursor(7, 2); lcd.print(" ");
}
}
break;
case 4:
if (V_HeureOuv < 10) {
lcd.setCursor(7, 2); lcd.print("0");
lcd.setCursor(8, 2); lcd.print(V_HeureOuv);
}
else {
lcd.setCursor(7, 2); lcd.print(V_HeureOuv);
}
previousTimer1 = timerarduino;
ParaProgHouv++;
break;
case 5:
if (Timer1Etat) {
Timer1 = Timer1OFF;
} else {
Timer1 = Timer1ON;
}
if ((timerarduino - previousTimer1) > Timer1) {
previousTimer1 = timerarduino;
Timer1Etat = !Timer1Etat;
if (Timer1Etat) {
if (V_MinOuv < 10) {
lcd.setCursor(10, 2); lcd.print("0");
lcd.setCursor(11, 2); lcd.print(V_MinOuv);
}
else {
lcd.setCursor(10, 2); lcd.print(V_MinOuv);
}
}
else {
lcd.setCursor(10, 2); lcd.print(" ");
}
}
break;
default:
break;
}

//Menu parametrage Progr Heure fermeture///////////
switch (ParaProgHferm) {
case 0:
break;
case 1:
lcd.clear(); ParaProgHferm++;
break;
case 2:
lcd.setCursor(0, 0); lcd.print("- Heure fermeture --");
lcd.setCursor(9, 2); lcd.print(":");
if (V_MinFerm < 10) {
lcd.setCursor(10, 2); lcd.print("0");
lcd.setCursor(11, 2); lcd.print(V_MinFerm);
}
else {
lcd.setCursor(10, 2); lcd.print(V_MinFerm);
}
ParaProgHferm++;
break;
case 3:
if (Timer1Etat) {
Timer1 = Timer1OFF;
}
else {
Timer1 = Timer1ON;
}
if ((timerarduino - previousTimer1) > Timer1) {
previousTimer1 = timerarduino;
Timer1Etat = !Timer1Etat;
if (Timer1Etat) {
if (V_HeureFerm < 10) {
lcd.setCursor(7, 2); lcd.print("0");
lcd.setCursor(8, 2); lcd.print(V_HeureFerm);
}
else {
lcd.setCursor(7, 2); lcd.print(V_HeureFerm);
}
}
else {
lcd.setCursor(7, 2); lcd.print(" ");
}
}
break;
case 4:
if (V_HeureFerm < 10) {
lcd.setCursor(7, 2); lcd.print("0");
lcd.setCursor(8, 2); lcd.print(V_HeureFerm);
}
else {
lcd.setCursor(7, 2); lcd.print(V_HeureFerm);
}
ParaProgHferm++;
break;
case 5:
if (Timer1Etat) {
Timer1 = Timer1OFF;
}
else {
Timer1 = Timer1ON;
}
if ((timerarduino - previousTimer1) > Timer1) {
previousTimer1 = timerarduino;
Timer1Etat = !Timer1Etat;
if (Timer1Etat) {
if (V_MinFerm < 10) {
lcd.setCursor(10, 2); lcd.print("0");
lcd.setCursor(11, 2); lcd.print(V_MinFerm);
}
else {
lcd.setCursor(10, 2); lcd.print(V_MinFerm);
}
}
else {
lcd.setCursor(10, 2); lcd.print(" ");
}
}
break;
case 6:
break;
default:
break;
}

//Menu parametres LDR /////////////////////////////
switch (MenuParaLDR) {
case 0:
break;
case 1:
lcd.clear(); MenuParaLDR++;
break;
case 2:
lcd.setCursor(0, 0); lcd.print("------- LDR --------");
lcd.setCursor(0, 1); lcd.print("Valeur ouverture");
lcd.setCursor(0, 2); lcd.print("Valeur fermeture");
lcd.setCursor(0, 3); lcd.print("Hysteresis");
MenuParaLDR++;
break;
case 3:
lcd.setCursor(19, 3); lcd.print(" ");
lcd.setCursor(19, 1); lcd.print("<");
lcd.setCursor(19, 2); lcd.print(" ");
break;
case 4:
lcd.setCursor(19, 1); lcd.print(" ");
lcd.setCursor(19, 2); lcd.print("<");
lcd.setCursor(19, 3); lcd.print(" ");
break;
case 5:
lcd.setCursor(19, 2); lcd.print(" ");
lcd.setCursor(19, 3); lcd.print("<");
lcd.setCursor(19, 1); lcd.print(" ");
break;
case 6:
lcd.clear();
MenuParaLDR = 8;
break;
case 7:
lcd.setCursor(0, 0); lcd.print("------- LDR --------");
lcd.setCursor(0, 1); lcd.print("Valeur ouverture");
lcd.setCursor(0, 2); lcd.print("Valeur fermeture");
lcd.setCursor(0, 3); lcd.print("Hysteresis");
MenuParaLDR = 5;
break;
case 8:
lcd.clear();
MenuParaLDR++;
break;
case 9:
lcd.setCursor(0, 0); lcd.print("------- LDR --------");
lcd.setCursor(0, 1); lcd.print("Retour");
MenuParaLDR = 11;
break;
case 10:
MenuParaLDR = 7;
break;
case 11:
lcd.setCursor(19, 3); lcd.print(" ");
lcd.setCursor(19, 1); lcd.print("<");
lcd.setCursor(19, 2); lcd.print(" ");
break;
default:
break;
}

//Menu parametrage LDR ouverture///////////////////
switch (ParaLDRouv) {
case 0:
break;
case 1:
lcd.clear(); ParaLDRouv++;
break;
case 2:
lcd.setCursor(0, 0); lcd.print("-- LDR ouverture ---");
ParaLDRouv++;
break;
case 3:
if (Timer1Etat) {
Timer1 = Timer1OFF;
}
else {
Timer1 = Timer1ON;
}
if ((timerarduino - previousTimer1) > Timer1) {
previousTimer1 = timerarduino;
Timer1Etat = !Timer1Etat;
if (Timer1Etat || Saisierapide) {
if (V_LDRouv < 100 && V_LDRouv > 9) {
lcd.setCursor(8, 2); lcd.print(" ");
lcd.setCursor(9, 2); lcd.print(V_LDRouv);
}
else if (V_LDRouv < 10) {
lcd.setCursor(8, 2); lcd.print(" ");
lcd.setCursor(10, 2); lcd.print(V_LDRouv);
}
else {
lcd.setCursor(8, 2); lcd.print(V_LDRouv);
}
}
else {
lcd.setCursor(8, 2); lcd.print(" ");
}
}
break;
default:
break;
}

//Menu parametrage LDR fermeture //////////////////
switch (ParaLDRferm) {
case 0:
break;
case 1:
lcd.clear(); ParaLDRferm++;
break;
case 2:
lcd.setCursor(0, 0); lcd.print("-- LDR fermeture ---");
ParaLDRferm++;
break;
case 3:
if (Timer1Etat) {
Timer1 = Timer1OFF;
}
else {
Timer1 = Timer1ON;
}
if ((timerarduino - previousTimer1) > Timer1) {
previousTimer1 = timerarduino; Timer1Etat = !Timer1Etat;
if (Timer1Etat || Saisierapide) {
if (V_LDRferm < 100 && V_LDRferm > 9) {
lcd.setCursor(8, 2); lcd.print(" ");
lcd.setCursor(9, 2); lcd.print(V_LDRferm);
}
else if (V_LDRferm < 10) {
lcd.setCursor(8, 2); lcd.print(" ");
lcd.setCursor(10, 2); lcd.print(V_LDRferm);
}
else {
lcd.setCursor(8, 2); lcd.print(V_LDRferm);
}
}
else {
lcd.setCursor(8, 2); lcd.print(" ");
}
}
break;
default:
break;
}

//Menu parametrage LDR Hysteresis /////////////////
switch (ParaLDRhysteresis) {
case 0:
break;
case 1:
lcd.clear(); ParaLDRhysteresis++;
break;
case 2:
lcd.setCursor(0, 0); lcd.print ("-- LDR hysteresis --");
lcd.setCursor(11, 2); lcd.print ("min");
ParaLDRhysteresis++;
break;
case 3:
if (Timer1Etat) {
Timer1 = Timer1OFF;
} else {
Timer1 = Timer1ON;
}
if ((timerarduino - previousTimer1) > Timer1) {
previousTimer1 = timerarduino;
Timer1Etat = !Timer1Etat;
if (Timer1Etat || Saisierapide) {
if (V_Hysteresis < 100 && V_Hysteresis > 9) {
lcd.setCursor(7, 2); lcd.print(" ");
lcd.setCursor(8, 2); lcd.print(V_Hysteresis);
}
else if (V_Hysteresis < 10) {
lcd.setCursor(7, 2); lcd.print(" ");
lcd.setCursor(9, 2); lcd.print(V_Hysteresis);
}
else {
lcd.setCursor(7, 2); lcd.print(V_Hysteresis);
}
}
else {
lcd.setCursor(7, 2); lcd.print(" ");
}
}
break;
default:
break;
}

//Menu Systeme ////////////////////////////////////
switch (MenuSyst) {
case 0:
break;
case 1:
lcd.clear(); MenuSyst++;
break;
case 2:
lcd.setCursor(0, 0); lcd.print("----- Systeme ------");
lcd.setCursor(0, 1); lcd.print("Reglage heure");
lcd.setCursor(0, 2); lcd.print("Gest. Veille");
lcd.setCursor(0, 3); lcd.print("Retour");
MenuSyst++;
break;
case 3:
lcd.setCursor(19, 3); lcd.print(" ");
lcd.setCursor(19, 1); lcd.print("<");
lcd.setCursor(19, 2); lcd.print (" ");
break;
case 4:
lcd.setCursor(19, 1); lcd.print(" ");
lcd.setCursor(19, 2); lcd.print("<");
lcd.setCursor(19, 3); lcd.print(" ");
break;
case 5:
lcd.setCursor(19, 2); lcd.print(" ");
lcd.setCursor(19, 3); lcd.print("<");
lcd.setCursor(19, 1); lcd.print(" ");
break;
default:
break;
}

//Menu systeme Reglage Heure //////////////////////
switch (SystReglheure) {
case 0:
break;
case 1:
lcd.clear();
V_Tsystheure = t.hour; V_Tsystminute = t.min; V_Tsystseconde = t.sec;
SystReglheure++;
break;
case 2:
lcd.setCursor(0, 0); lcd.print("-- Heure systeme ---");
lcd.setCursor(8, 2); lcd.print(":");
if (V_Tsystminute < 10) {
lcd.setCursor(9, 2); lcd.print("0");
lcd.setCursor(10, 2); lcd.print(V_Tsystminute);
}
else {
lcd.setCursor(9, 2); lcd.print(V_Tsystminute);
}
lcd.setCursor(11, 2); lcd.print(":");
if (V_Tsystseconde < 10) {
lcd.setCursor(12, 2); lcd.print("0");
lcd.setCursor(13, 2); lcd.print(V_Tsystseconde);
}
else {
lcd.setCursor(12, 2); lcd.print(V_Tsystseconde);
}
SystReglheure++;
break;
case 3:
if (Timer1Etat) {
Timer1 = Timer1OFF;
} else {
Timer1 = Timer1ON;
}
if ((timerarduino - previousTimer1) > Timer1) {
previousTimer1 = timerarduino;
Timer1Etat = !Timer1Etat;
if (Timer1Etat) {
if (V_Tsystheure < 10) {
lcd.setCursor(6, 2); lcd.print("0");
lcd.setCursor(7, 2); lcd.print(V_Tsystheure);
}
else {
lcd.setCursor(6, 2); lcd.print(V_Tsystheure);
}
}
else {
lcd.setCursor(6, 2); lcd.print(" ");
}
}
break;
case 4:
if (V_Tsystheure < 10) {
lcd.setCursor(6, 2); lcd.print("0");
lcd.setCursor(7, 2); lcd.print(V_Tsystheure);
}
else {
lcd.setCursor(6, 2); lcd.print(V_Tsystheure);
}
SystReglheure++;
break;
case 5:
if (Timer1Etat) {
Timer1 = Timer1OFF;
} else {
Timer1 = Timer1ON;
}
if ((timerarduino - previousTimer1) > Timer1) {
previousTimer1 = timerarduino;
Timer1Etat = !Timer1Etat;
if (Timer1Etat) {
if (V_Tsystminute < 10) {
lcd.setCursor(9, 2); lcd.print("0");
lcd.setCursor(10, 2); lcd.print(V_Tsystminute);
}
else {
lcd.setCursor(9, 2); lcd.print(V_Tsystminute);
}
}
else {
lcd.setCursor(9, 2); lcd.print(" ");
}
}
break;
case 6:
if (V_Tsystminute < 10) {
lcd.setCursor(9, 2); lcd.print("0");
lcd.setCursor(10, 2); lcd.print(V_Tsystminute);
}
else {
lcd.setCursor(9, 2); lcd.print(V_Tsystminute);
}
SystReglheure++;
break;
case 7:
if (Timer1Etat) {
Timer1 = Timer1OFF;
} else {
Timer1 = Timer1ON;
}
if ((timerarduino - previousTimer1) > Timer1) {
previousTimer1 = timerarduino;
Timer1Etat = !Timer1Etat;
if (Timer1Etat) {
if (V_Tsystseconde < 10) {
lcd.setCursor(12, 2); lcd.print("0");
lcd.setCursor(13, 2); lcd.print(V_Tsystseconde);
}
else {
lcd.setCursor(12, 2); lcd.print(V_Tsystseconde);
}
}
else {
lcd.setCursor(12, 2); lcd.print(" ");
}
}
break;
default:
break;
}

//Menu systeme veille /////////////////////////////
switch (MenuSystVeille) {
case 0:
break;
case 1:
lcd.clear(); MenuSystVeille++;
break;
case 2:
lcd.setCursor(0, 0); lcd.print("----- Veille ------");
lcd.setCursor(0, 1); lcd.print("Etat");
lcd.setCursor(0, 2); lcd.print("Tps av. activation");
lcd.setCursor(0, 3); lcd.print("Retour");
MenuSystVeille++;
break;
case 3:
lcd.setCursor(19, 3); lcd.print(" ");
lcd.setCursor(19, 1); lcd.print("<");
lcd.setCursor(19, 2); lcd.print(" ");
break;
case 4:
lcd.setCursor(19, 1); lcd.print(" ");
lcd.setCursor(19, 2); lcd.print("<");
lcd.setCursor(19, 3); lcd.print(" ");
break;
case 5:
lcd.setCursor(19, 2); lcd.print(" ");
lcd.setCursor(19, 3); lcd.print("<");
lcd.setCursor(19, 1); lcd.print(" ");
break;
default:
break;
}

//Menu systeme veille etat //////////////////
switch (SystVeilleetat) {
case 0:
break;
case 1:
lcd.clear(); SystVeilleetat++;
break;
case 2:
lcd.setCursor(0, 0); lcd.print("--- Veille Etat ----");
SystVeilleetat++;
break;
case 3:
if (Timer1Etat) {
Timer1 = Timer1OFF;
}
else {
Timer1 = Timer1ON;
}
if ((timerarduino - previousTimer1) > Timer1) {
previousTimer1 = timerarduino; Timer1Etat = !Timer1Etat;
if (Timer1Etat) {
if (Etatveille) {
lcd.setCursor(6, 2); lcd.print(" Actif ");
}
else {
lcd.setCursor(6, 2); lcd.print("Inactif");
}
}
else {
lcd.setCursor(6, 2); lcd.print(" ");
}
}
break;
default:
break;
}
//Menu systeme veille Tps av. activation //////////
switch (SystVeilleTpsactiv) {
case 0:
break;
case 1:
lcd.clear(); SystVeilleTpsactiv++;
break;
case 2:
lcd.setCursor(0, 0); lcd.print(" Tps av. Act Veille ");
lcd.setCursor(11, 2); lcd.print("sec");
SystVeilleTpsactiv++;
break;
case 3:
if (Timer1Etat) {
Timer1 = Timer1OFF;
} else {
Timer1 = Timer1ON;
}
if ((timerarduino - previousTimer1) > Timer1) {
previousTimer1 = timerarduino;
Timer1Etat = !Timer1Etat;
if (Timer1Etat || Saisierapide) {
if (V_TpsAvveille < 100 && V_TpsAvveille > 9) {
lcd.setCursor(7, 2); lcd.print(" ");
lcd.setCursor(8, 2); lcd.print(V_TpsAvveille);
}
else if (V_TpsAvveille < 10) {
lcd.setCursor(7, 2); lcd.print(" ");
lcd.setCursor(9, 2); lcd.print(V_TpsAvveille);
}
else {
lcd.setCursor(7, 2); lcd.print(V_TpsAvveille);
}
}
else {
lcd.setCursor(7, 2); lcd.print (" ");
}
}
break;
default:
break;
}
///////////////////////////////////////////////////

//Gestion des boutons /////////////////////////////
if (digitalRead(Bthaut) == LOW && EtatBthaut == 0) {
EtatBthaut = 1; NavBthaut();
}
if (digitalRead(Btbas) == LOW && EtatBtbas == 0) {
EtatBtbas = 1; NavBtbas();
}
if (digitalRead(Btselect) == LOW && EtatBtselect == 0) {
EtatBtselect = 1; navmenuboutonselect();
}
if (digitalRead(Bthaut) == LOW && EtatBthaut == 1) {
if ((timerarduino - previousTimer5) > Timer5ON) {
NavBthautrapide(); Saisierapide = 1;
}
}
if (digitalRead(Btbas) == LOW && EtatBtbas == 1) {
if ((timerarduino - previousTimer5) > Timer5ON) {
NavBtbasrapide(); Saisierapide = 1;
}
}
if (digitalRead(Bthaut) == HIGH && digitalRead(Btbas) == HIGH) {
previousTimer5 = timerarduino; Saisierapide = 0;
}
if (digitalRead(Bthaut) == HIGH) {
EtatBthaut = 0;
}
if (digitalRead(Btbas) == HIGH) {
EtatBtbas = 0;
}
if (digitalRead(Btselect) == HIGH) {
EtatBtselect = 0;
}
}

//Gestion de la Trappe par Programmateur //////////
void GestionTrappeProg() {
unsigned long ouverturesec = (V_MinOuv * 60) + (V_HeureOuv * 3600);
unsigned long fermeturesec = (V_MinFerm * 60) + (V_HeureFerm * 3600);
t = rtc.getTime();
long hour = t.hour; long min = t.min; long sec = t.sec;
unsigned long heuresec = (min * 60) + (hour * 3600) + sec;
if (ouverturesec < fermeturesec && Modedemarche == 1) {
if (heuresec > ouverturesec && heuresec < fermeturesec) {
Etattrappe = 1;
}
else {
Etattrappe = 0;
}
}
if (ouverturesec > fermeturesec && Modedemarche == 1) {
if ((heuresec > ouverturesec && heuresec > fermeturesec) || (heuresec < ouverturesec && heuresec < fermeturesec)) {
Etattrappe = 1;
}
if (heuresec > fermeturesec && heuresec < ouverturesec) {
Etattrappe = 0;
}
}
}

//Gestion de la Trappe par le LDR /////////////////
void GestionTrappeLDR() {
int valeurLDR = analogRead(LDR);
if (valeurLDR > V_LDRouv && Etattrappe == 0 && Modedemarche == 2) {
if (TpsAvouverture == 0 && TpsAvouverturesec == 0) {
TpsAvouverture = V_Hysteresis; previousTimer2 = timerarduino;
TpsAvouverturesec = V_Hysteresis * 60; previousTimer3 = timerarduino;
}
else {
if ((timerarduino - previousTimer2) > Timer2ON) {
previousTimer2 = timerarduino; TpsAvouverture--;
}
if ((timerarduino - previousTimer3) > Timer3ON) {
previousTimer3 = timerarduino; TpsAvouverturesec--;
}
}
if (TpsAvouverturesec == 0) {
lcd.setCursor(9, 2); lcd.print(" ");
Etattrappe = 1;
}
}
else {
TpsAvouverture = 0; TpsAvouverturesec = 0;
}
if (valeurLDR < V_LDRferm && Etattrappe == 1 && Modedemarche == 2) {
if (TpsAvfermeture == 0 && TpsAvfermeturesec == 0) {
TpsAvfermeture = V_Hysteresis; previousTimer2 = timerarduino;
TpsAvfermeturesec = V_Hysteresis * 60; previousTimer3 = timerarduino;
}
else {
if ((timerarduino - previousTimer2) > Timer2ON) {
previousTimer2 = timerarduino; TpsAvfermeture--;
}
if ((timerarduino - previousTimer3) > Timer3ON) {
previousTimer3 = timerarduino; TpsAvfermeturesec--;
}
}
if (TpsAvfermeturesec == 0 ) {
lcd.setCursor(9, 2); lcd.print(" ");
Etattrappe = 0;
}
}
else {
TpsAvfermeture = 0; TpsAvfermeturesec = 0;
}
}

//Affichage Etat Trappe en Mode Manu /////
void AffEtatTrappeManu() {
if (digitalRead(Bthaut) == LOW && RefreshAffEtatTrappeManu == 0) {
lcd.setCursor(9, 2); lcd.print(" ");
RefreshAffEtatTrappeManu = 1;
}
if (digitalRead(Btbas) == LOW && RefreshAffEtatTrappeManu == 0) {
lcd.setCursor(9, 2); lcd.print(" ");
RefreshAffEtatTrappeManu = 1;
}
if (digitalRead(Bthaut) == HIGH && digitalRead(Btbas) == HIGH) {
RefreshAffEtatTrappeManu = 0;
}
if (digitalRead(fdchaut) == LOW && digitalRead(Btbas) == HIGH) {
lcd.setCursor(9, 2); lcd.print("Ouverte");
}
if (digitalRead(fdcbas) == LOW && digitalRead(Bthaut) == HIGH) {
lcd.setCursor(9, 2); lcd.print("Fermer ");
}
}

//Affichage Etat Trappe en Mode Programmateur /////
void AffEtatTrappeProg() {
if (Etattrappe == 1 && digitalRead(fdchaut) == LOW) {
lcd.setCursor(9, 2); lcd.print("Ouverte");
}
if (Etattrappe == 0 && digitalRead(fdcbas) == LOW) {
lcd.setCursor(9, 2); lcd.print("Fermer ");
}
}

//Affichage Etat Trappe en Mode LDR ///////////////
void AffEtatTrappeLDR() {
if (TpsAvfermeturesec == 0 && TpsAvouverturesec == 0 && TpsAvouverture == 0 && Etattrappe == 1 && TpsAvfermeture == 0 && digitalRead(fdchaut) == LOW) {
lcd.setCursor(9, 2); lcd.print("Ouverte ");
}
if (TpsAvfermeturesec == 0 && TpsAvouverturesec == 0 && TpsAvfermeture == 0 && Etattrappe == 0 && TpsAvouverture == 0 && digitalRead(fdcbas) == LOW) {
lcd.setCursor(9, 2); lcd.print("Fermer ");
}
if (TpsAvouverture > 1) {
if (TpsAvouverture < 100 && TpsAvouverture > 9) {
lcd.setCursor(9, 2); lcd.print(" ");
lcd.setCursor(10, 2); lcd.print(TpsAvouverture);
}
else if (TpsAvouverture < 10) {
lcd.setCursor(9, 2); lcd.print(" ");
lcd.setCursor(11, 2); lcd.print(TpsAvouverture);
}
else {
lcd.setCursor(9, 2); lcd.print(TpsAvouverture);
}
lcd.setCursor(12, 2); lcd.print("m AvOuv.");
}
if (TpsAvouverturesec < 60 && TpsAvouverturesec != 0) {
if (TpsAvouverturesec < 100 && TpsAvouverturesec > 9) {
lcd.setCursor(9, 2); lcd.print(" ");
lcd.setCursor(10, 2); lcd.print(TpsAvouverturesec);
}
else if (TpsAvouverture < 10) {
lcd.setCursor(9, 2); lcd.print(" ");
lcd.setCursor(11, 2); lcd.print(TpsAvouverturesec);
}
else {
lcd.setCursor(9, 2); lcd.print(TpsAvouverturesec);
}
lcd.setCursor(12, 2); lcd.print("s AvOuv.");
}
if (TpsAvfermeture > 1) {
lcd.setCursor(0, 2); lcd.print("Trappe : ");
if (TpsAvfermeture < 100 && TpsAvfermeture > 9) {
lcd.setCursor(9, 2); lcd.print(" ");
lcd.setCursor(10, 2); lcd.print(TpsAvfermeture);
}
else if (TpsAvfermeture < 10 && TpsAvfermeture > 0) {
lcd.setCursor(9, 2); lcd.print(" ");
lcd.setCursor(11, 2); lcd.print(TpsAvfermeture);
}
else if (TpsAvfermeture < 1) {
lcd.setCursor(9, 2); lcd.print(" ");
}
else {
lcd.setCursor(9, 2); lcd.print(TpsAvfermeture);
}
lcd.setCursor(12, 2); lcd.print("m AvFer.");
}
if (TpsAvfermeturesec < 60 && TpsAvfermeturesec != 0) {
if (TpsAvfermeturesec < 100 && TpsAvfermeturesec > 9) {
lcd.setCursor(9, 2); lcd.print(" ");
lcd.setCursor(10, 2); lcd.print(TpsAvfermeturesec);
}
else if (TpsAvfermeture < 10) {
lcd.setCursor(9, 2); lcd.print(" ");
lcd.setCursor(11, 2); lcd.print(TpsAvfermeturesec);
}
else {
lcd.setCursor(9, 2); lcd.print(TpsAvfermeturesec);
}
lcd.setCursor(12, 2); lcd.print("s AvOuv.");
}
}

//Affichage Valeur LDR ////////////////////////////
int AffValeurLDR (int valeurLDR) {
if (valeurLDR < 1000 && valeurLDR > 99) {
lcd.setCursor(16, 0); lcd.print(" ");
lcd.setCursor(17, 0); lcd.print(valeurLDR);
}
else if (valeurLDR < 100 && valeurLDR > 9) {
lcd.setCursor(16, 0); lcd.print(" ");
lcd.setCursor(18, 0); lcd.print(valeurLDR);
}
else if (valeurLDR < 10) {
lcd.setCursor(16, 0); lcd.print(" ");
lcd.setCursor(19, 0); lcd.print(valeurLDR);
}
else {
lcd.setCursor(16, 0); lcd.print(valeurLDR);
}
}

//Affichage de l'heure ////////////////////////////
void AffHeure() {
t = rtc.getTime();
if (RefreshAffHeure == 0) {
Thour = t.hour; Tmin = t.min; Tsec = t.sec;
lcd.setCursor(2, 0); lcd.print(":");
lcd.setCursor(5, 0); lcd.print(":");
}

if (Thour != t.hour || RefreshAffHeure == 0 ) {
Thour = t.hour;
if (t.hour < 10) {
lcd.setCursor(0, 0); lcd.print("0");
lcd.setCursor(1, 0); lcd.print(t.hour);
}
else {
lcd.setCursor(0, 0); lcd.print(t.hour);
}
}
if (Tmin != t.min || RefreshAffHeure == 0 ) {
Tmin = t.min;
if (t.min < 10) {
lcd.setCursor(3, 0); lcd.print("0");
lcd.setCursor(4, 0); lcd.print(t.min);
}
else {
lcd.setCursor(3, 0); lcd.print(t.min);
}
}
if (Tsec != t.sec || RefreshAffHeure == 0 ) {
Tsec = t.sec;
if (t.sec < 10) {
lcd.setCursor(6, 0); lcd.print("0");
lcd.setCursor(7, 0); lcd.print(t.sec);
}
else {
lcd.setCursor(6, 0); lcd.print(t.sec);
}
RefreshAffHeure = 1;
}
}

//Gestion de la Trappe en Mode Manu ///////////////
void GestionTrappeManu() {
if (Modedemarche == 3 && Accueil == 7 && EtatBthaut == 1 && digitalRead(fdchaut) == HIGH) {
Pause = 1; digitalWrite(IN1, 1); digitalWrite(IN2, 0);
}
else if (Modedemarche == 3 && Accueil == 7 && EtatBtbas == 1 && digitalRead(fdcbas) == HIGH) {
Pause = 1; digitalWrite(IN1, 0); digitalWrite(IN2, 1);
}
else {
Moteurrepos ();
Pause = 0;
}
if (digitalRead(fdchaut) == LOW) {
Etattrappe = 1;
}
if (digitalRead(fdcbas) == LOW) {
Etattrappe = 0;
}
}

//Gestion de la Trappe en Mode Auto ///////////////
void GestionTrappeAuto() {
if ((Modedemarche == 1 || Modedemarche == 2) && Etattrappe == 1 && digitalRead(fdchaut) == HIGH) {
Pause = 1; digitalWrite(IN1, 1); digitalWrite(IN2, 0);
}
else if ((Modedemarche == 1 || Modedemarche == 2) && Etattrappe == 0 && digitalRead(fdcbas) == HIGH) {
Pause = 1; digitalWrite(IN1, 0); digitalWrite(IN2, 1);
}
else {
Moteurrepos ();
Pause = 0;
}
}

//Mise au repos moteur PAP ////////////////////////
void Moteurrepos () {
digitalWrite(IN1, 0);
digitalWrite(IN2, 0);
}

//Sauvegarde Heures sur DS1302 ////////////////////
void SavHeure () {
rtc.writeProtect(false);
rtc.setTime(V_Tsystheure, V_Tsystminute, V_Tsystseconde);
delay(50);
rtc.writeProtect(true);
}

//Sauvegarde sur RAM DS1302 ///////////////////////
void Sav () {
rtc.writeProtect(false);
byte v_1LDRouverture = lowByte(V_LDRouv); byte v_2LDRouverture = highByte(V_LDRouv);
byte v_1LDRfermeture = lowByte(V_LDRferm); byte v_2LDRfermeture = highByte(V_LDRferm);
byte v_1LDRhysteresis = lowByte(V_Hysteresis); byte v_2LDRhysteresis = highByte(V_Hysteresis);
byte v_1V_TpsAvveille = lowByte(V_TpsAvveille); byte v_2V_TpsAvveille = highByte(V_TpsAvveille);
ramBuffer.cell[0] = 99; ramBuffer.cell[1] = Modedemarche;
ramBuffer.cell[2] = V_HeureOuv; ramBuffer.cell[3] = V_MinOuv;
ramBuffer.cell[4] = V_HeureFerm; ramBuffer.cell[5] = V_MinFerm;
ramBuffer.cell[6] = v_1LDRouverture; ramBuffer.cell[7] = v_2LDRouverture;
ramBuffer.cell[8] = v_1LDRfermeture; ramBuffer.cell[9] = v_2LDRfermeture;
ramBuffer.cell[10] = v_1LDRhysteresis; ramBuffer.cell[11] = v_2LDRhysteresis;
ramBuffer.cell[12] = Etattrappe; ramBuffer.cell[13] = Etatveille;
ramBuffer.cell[14] = v_1V_TpsAvveille; ramBuffer.cell[15] = v_2V_TpsAvveille;

rtc.writeBuffer(ramBuffer);
ramBuffer = rtc.readBuffer();
rtc.writeProtect(true);
Serial.println("Sauvegarde sur RAM");
for (int i = 0; i < 31; i++)
{
Serial.print(" "); Serial.print(ramBuffer.cell[i]); Serial.print(" ");
}
Serial.println(" ");
}

//Chargement de la RAM DS1302 /////////////////////
void LoadSav() {
if (ramBuffer.cell[0] == 99) {
Modedemarche = ramBuffer.cell[1]; V_HeureOuv = ramBuffer.cell[2];
V_MinOuv = ramBuffer.cell[3]; V_HeureFerm = ramBuffer.cell[4];
V_MinFerm = ramBuffer.cell[5];
byte V_1LDRouv = ramBuffer.cell[6]; byte V_2LDRouv = ramBuffer.cell[7];
byte V_1LDRferm = ramBuffer.cell[8]; byte V_2LDRferm = ramBuffer.cell[9];
byte V_1Hysteresis = ramBuffer.cell[10]; byte V_2Hysteresis = ramBuffer.cell[11];
Etattrappe = ramBuffer.cell[12]; Etatveille = ramBuffer.cell[13];
byte V_1V_TpsAvveille = ramBuffer.cell[14]; byte V_2V_TpsAvveille = ramBuffer.cell[15];
V_LDRouv = word(V_2LDRouv, V_1LDRouv); V_LDRferm = word(V_2LDRferm, V_1LDRferm);
V_Hysteresis = word(V_2Hysteresis, V_1Hysteresis);
V_TpsAvveille = word(V_2V_TpsAvveille, V_1V_TpsAvveille);
}
}

//Gestion Navigation Bouton Bas ///////////////////
void NavBtbas() {
if (Menu > 0) {
if (Menu > 10) {
Menu = 1;
} else {
Menu++;
}
}
if (MenuMdm > 0) {
if (MenuMdm > 10) {
MenuMdm = 1;
} else {
MenuMdm++;
}
}
if (MenuPara > 0) {
if (MenuPara > 4) {
MenuPara = 3;
} else {
MenuPara++;
}
}
if (MenuParaProg > 0) {
if (MenuParaProg > 4) {
MenuParaProg = 3;
} else {
MenuParaProg++;
}
}
if (MenuParaLDR > 0) {
if (MenuParaLDR > 10) {
MenuParaLDR = 1;
} else {
MenuParaLDR++;
}
}
if (MenuSyst > 0) {
if (MenuSyst > 4) {
MenuSyst = 2;
} else {
MenuSyst++;
}
}
if (MenuSystVeille > 0) {
if (MenuSystVeille > 4) {
MenuSystVeille = 2;
} else {
MenuSystVeille++;
}
}
if (SystVeilleetat == 3) {
Etatveille = !Etatveille;
}
if (SystVeilleTpsactiv == 3) {
if (V_TpsAvveille < 4) {
V_TpsAvveille = 180;
} else {
V_TpsAvveille--;
}
}
if (ParaProgHouv == 3) {
if (V_HeureOuv < 1) {
V_HeureOuv = 23;
} else {
V_HeureOuv--;
}
}
if (ParaProgHouv == 5) {
if (V_MinOuv < 1) {
V_MinOuv = 59;
} else {
V_MinOuv--;
}
}
if (ParaProgHferm == 3) {
if (V_HeureFerm < 1) {
V_HeureFerm = 23;
} else {
V_HeureFerm--;
}
}
if (ParaProgHferm == 5) {
if (V_MinFerm < 1) {
V_MinFerm = 59;
} else {
V_MinFerm--;
}
}
if (ParaLDRouv == 3) {
if (V_LDRouv < 1) {
V_LDRouv = 999;
} else {
V_LDRouv--;
}
}
if (ParaLDRferm == 3) {
if (V_LDRferm < 1) {
V_LDRferm = 999;
} else {
V_LDRferm--;
}
}
if (ParaLDRhysteresis == 3) {
if (V_Hysteresis < 1) {
V_Hysteresis = 999;
} else {
V_Hysteresis--;
}
}
if (SystReglheure == 3) {
if (V_Tsystheure < 1) {
V_Tsystheure = 23;
} else {
V_Tsystheure--;
}
}
if (SystReglheure == 5) {
if (V_Tsystminute < 1) {
V_Tsystminute = 59;
} else {
V_Tsystminute--;
}
}
if (SystReglheure == 7) {
if (V_Tsystseconde < 1) {
V_Tsystseconde = 59;
} else {
V_Tsystseconde--;
}
}
}

//Gestion Navigation Bouton HAUT ///////////////////
void NavBthaut() {
if (Menu > 0) {
if (Menu == 3) {
Menu = 8;
} else {
Menu--;
}
}
if (MenuMdm > 0) {
if (MenuMdm == 3) {
MenuMdm = 8;
} else {
MenuMdm--;
}
}
if (MenuPara > 0) {
if (MenuPara == 3) {
MenuPara = 5;
} else {
MenuPara--;
}
}
if (MenuParaProg > 0) {
if (MenuParaProg == 3) {
MenuParaProg = 5;
} else {
MenuParaProg--;
}
}
if (MenuParaLDR > 0) {
if (MenuParaLDR == 3) {
MenuParaLDR = 8;
} else {
MenuParaLDR--;
}
}
if (MenuSyst > 0) {
if (MenuSyst == 3) {
MenuSyst = 5;
} else {
MenuSyst--;
}
}
if (MenuSystVeille > 0) {
if (MenuSystVeille == 3) {
MenuSystVeille = 5;
} else {
MenuSystVeille--;
}
}
if (SystVeilleetat == 3) {
Etatveille = !Etatveille;
}
if (SystVeilleTpsactiv == 3) {
if (V_TpsAvveille > 179) {
V_TpsAvveille = 3;
} else {
V_TpsAvveille++;
}
}
if (ParaProgHouv == 3) {
if (V_HeureOuv > 22) {
V_HeureOuv = 0;
} else {
V_HeureOuv++;
}
}
if (ParaProgHouv == 5) {
if (V_MinOuv > 58) {
V_MinOuv = 0;
} else {
V_MinOuv++;
}
}
if (ParaProgHferm == 3) {
if (V_HeureFerm > 22) {
V_HeureFerm = 0;
} else {
V_HeureFerm++;
}
}
if (ParaProgHferm == 5) {
if (V_MinFerm > 58) {
V_MinFerm = 0;
} else {
V_MinFerm++;
}
}
if (ParaLDRouv == 3) {
if (V_LDRouv > 998) {
V_LDRouv = 0;
} else {
V_LDRouv++;
}
}
if (ParaLDRferm == 3) {
if (V_LDRferm > 998) {
V_LDRferm = 0;
} else {
V_LDRferm++;
}
}
if (ParaLDRhysteresis == 3) {
if (V_Hysteresis > 998) {
V_Hysteresis = 0;
} else {
V_Hysteresis++;
}
}
if (SystReglheure == 3) {
if (V_Tsystheure > 22) {
V_Tsystheure = 0;
} else {
V_Tsystheure++;
}
}
if (SystReglheure == 5) {
if (V_Tsystminute > 58) {
V_Tsystminute = 0;
} else {
V_Tsystminute++;
}
}
if (SystReglheure == 7) {
if (V_Tsystseconde > 58) {
V_Tsystseconde = 0;
} else {
V_Tsystseconde++;
}
}
}

//Gestion Navigation Bouton Select ////////////////
void navmenuboutonselect() {
if (Accueil > 0 && Veille == 0) {
Accueil = 0; Menu = 1;
}
if (Menu == 3) {
Menu = 0; MenuMdm = 1;
}
if (Menu == 4) {
Menu = 0; MenuPara = 1;
}
if (Menu == 5) {
MenuSyst = 1; Menu = 0;
}
if (Menu == 11) {
Accueil = 1; Menu = 0;
}
if (MenuMdm == 3) {
Modedemarche = MenuMdm - 2; MenuMdm = 0; Menu = 1; Sav();
}
if (MenuMdm == 4) {
Modedemarche = MenuMdm - 2; MenuMdm = 0; Menu = 1; Sav();
}
if (MenuMdm == 5) {
Modedemarche = MenuMdm - 2;
MenuMdm = 0; Menu = 1; Sav();
}
if (MenuMdm == 11) {
MenuMdm = 0; Menu = 1;
}
if (MenuPara == 5) {
MenuPara = 0; Menu = 1;
}
if (MenuPara == 3) {
MenuPara = 0; MenuParaProg = 1;
}
if (MenuPara == 4) {
MenuPara = 0; MenuParaLDR = 1;
}
if (MenuParaLDR == 11) {
MenuParaLDR = 0; MenuPara = 1;
}
if (MenuSyst == 3) {
MenuSyst = 0; SystReglheure = 1;
}
if (MenuSyst == 4) {
MenuSyst = 0; MenuSystVeille = 1;
}
if (MenuSyst == 5) {
MenuSyst = 0; Menu = 1;
}
if (MenuSystVeille == 3) {
MenuSystVeille = 0; SystVeilleetat = 1;
}
if (MenuSystVeille == 4) {
MenuSystVeille = 0; SystVeilleTpsactiv = 1;
}
if (MenuSystVeille == 5) {
MenuSystVeille = 0; MenuSyst = 1;
}
if (SystVeilleetat == 3) {
SystVeilleetat = 0; MenuSystVeille = 1; Sav();
}
if (SystVeilleTpsactiv == 3) {
SystVeilleTpsactiv = 0; MenuSystVeille = 1; Sav();
}
if (MenuParaProg == 3) {
MenuParaProg = 0; ParaProgHouv = 1;
}
if (MenuParaProg == 4) {
MenuParaProg = 0; ParaProgHferm = 1;
}
if (MenuParaProg == 5) {
MenuParaProg = 0; MenuPara = 1;
}
if (ParaProgHouv == 3) {
ParaProgHouv = 4;
}
if (ParaProgHouv == 5) {
MenuParaProg = 1; ParaProgHouv = 0; Sav();
}
if (ParaProgHferm == 3) {
ParaProgHferm = 4;
}
if (ParaProgHferm == 5) {
MenuParaProg = 1; ParaProgHferm = 0; Sav();
}
if (MenuParaLDR == 3) {
MenuParaLDR = 0; ParaLDRouv = 1;
}
if (MenuParaLDR == 4) {
MenuParaLDR = 0; ParaLDRferm = 1;
}
if (MenuParaLDR == 5) {
MenuParaLDR = 0; ParaLDRhysteresis = 1;
}
if (ParaLDRouv == 3) {
MenuParaLDR = 1; ParaLDRouv = 0; Sav();
}
if (ParaLDRferm == 3) {
MenuParaLDR = 1; ParaLDRferm = 0; Sav();
}
if (ParaLDRhysteresis == 3) {
MenuParaLDR = 1; ParaLDRhysteresis = 0; Sav();
}
if (SystReglheure == 3) {
SystReglheure = 4;
}
if (SystReglheure == 5) {
SystReglheure = 6;
}
if (SystReglheure == 7) {
SavHeure(); SystReglheure = 0; MenuSyst = 1;
}
}
//Gestion Navigation Bouton HAUT rapide ////////////
void NavBthautrapide() {
if ((timerarduino - previousTimer6) > Timer6ON) {
if (ParaLDRouv == 3) {
if (V_LDRouv > 988) {
V_LDRouv = 0;
} else {
V_LDRouv = V_LDRouv + 10;
}
}
if (ParaLDRferm == 3) {
if (V_LDRferm > 988) {
V_LDRferm = 0;
} else {
V_LDRferm = V_LDRferm + 10;
}
}
if (ParaLDRhysteresis == 3) {
if (V_Hysteresis > 988) {
V_Hysteresis = 0;
} else {
V_Hysteresis = V_Hysteresis + 10;
}
}
if (SystVeilleTpsactiv == 3) {
if (V_TpsAvveille > 169) {
V_TpsAvveille = 3;
} else {
V_TpsAvveille = V_TpsAvveille + 10;
}
}
previousTimer6 = timerarduino;
}
}
//Gestion Navigation Bouton BAS rapide ////////////
void NavBtbasrapide() {
if ((timerarduino - previousTimer6) > Timer6ON) {
if (ParaLDRouv == 3) {
if (V_LDRouv < 11) {
V_LDRouv = 999;
} else {
V_LDRouv = V_LDRouv - 10;
}
}
if (ParaLDRferm == 3) {
if (V_LDRferm < 11) {
V_LDRferm = 999;
} else {
V_LDRferm = V_LDRferm - 10;
}
}
if (ParaLDRhysteresis == 3) {
if (V_Hysteresis < 11) {
V_Hysteresis = 999;
} else {
V_Hysteresis = V_Hysteresis - 10;
}
}
if (SystVeilleTpsactiv == 3) {
if (V_TpsAvveille < 14) {
V_TpsAvveille = 180;
} else {
V_TpsAvveille = V_TpsAvveille - 10;
}
}
previousTimer6 = timerarduino;
}
}


void Intro() {
lcd.home();
lcd.setCursor(1, 0); lcd.write(1);
lcd.setCursor(2, 0); lcd.write(2);
lcd.setCursor(1, 1); lcd.write(3);
lcd.setCursor(2, 1); lcd.write(4);
lcd.setCursor(6, 0); lcd.print("DomoPoule");
lcd.setCursor(5, 1); lcd.print("Version.5-B");
lcd.setCursor(0, 3); lcd.print(" www.robdomo.com ");
delay(2000);
}

//Gestion Mise en veille Ecran/////////////////////
void EcrVeille() {
Timer4ON = V_TpsAvveille * 1000;
if (((timerarduino - previousTimer4) > Timer4ON) && Accueil == 7 && Etatveille == 1) {
lcd.noBacklight(); Veille = 1;
}
if (EtatBtselect == 1 || EtatBthaut == 1 || EtatBtbas == 1 || Accueil != 7) {
lcd.backlight(); previousTimer4 = timerarduino;
Veille = 0;
}
}

 


 

Cet article a 24 commentaires

  1. Lecoanet

    Bonjour
    J ai 69 ans , ayant quelques connaissances en électronique mis pas en programmation, je me suis mis à arduino . Voulant réaliser une porte poulailler,je suis tombé sur votre site qui est très bien et où l on apprend beaucoup même pour des novices comme moi.
    J ai donc voulu réaliser votre projet version 5-B que j ai réussi malgré quelques difficultés .A l heure actuelle le système marche très bien . Mais j aimerais vous soumettre un petit problème .
    On ne peut travailler qu en mode programme ou en mode LDR .
    Ce que j aurais souhaité c est que l on puisse ouvrir tous les matins en programment une heure et fermer le soir avec la LDR . Ceci afin d éviter d ouvrir trop tôt le matin en été (coq qui chante).
    Je pense que pour vous tout est réalisable .Dans l attente de vous lire je tiens encore à vous féliciter et à continuer à nous faire aimer ARDUINO

    Cordialement

    1. steven

      Bonjour,

      Merci pour le commentaire, ça fait plaisir et ça m’encourage à continuer.
      L’idée est pas mal, je la garde pour effectuer une version future.
      Il va falloir malheureusement être un peu patient, car j’ai décidé de mettre à jour mon site internet pour augmenter sa performance et cela me demande actuellement pas mal de temps.
      Mais je compte bien, très prochainement faire de nouvelles versions.

      Cordialement

  2. Henri

    Bonjour,
    J’ai recherché pendant quelques temps un programme pour gérer une porte de poulailler automatiquement, Je suis arrivé sur votre site qui m’a tout de suite intéressé étant donné les explications précises dans les vidéos.
    J’ai donc testé les premières versions pour comprendre le fonctionnement pour arriver à la version 5B.
    Je tiens à vous remercier pour votre travail très professionnel qui permet à des débutants comme moi d’évoluer et de passer de bons moments durant l’hiver (je suis retraité).
    Comme j’ai cherché à comprendre le fonctionnement du programme, j’ai trouvé 2 petites erreurs provenant certainement d’un « copier coller »:
    Ligne 1252 « s AvOuv. » à remplacer par « s AvFer. »
    Ligne 1351 « // mise au repos moteur PAP// » à remplacer par « // mise au repos moteur courant continu// »

    Cordialement

    1. steven

      Bonjour,
      Merci pour ce retour positif, ça fait plaisir et donne envie de continuer.
      Effectivement, j’ai fait un copier-coller entre les 2 versions, car le code est identique sauf pour les moteurs, je ferais la correction de ces petites erreurs merci.
      Cordialement,

  3. Turnoff

    Bonjour; je souhaitais faire ce dispositif, j’ai beaucoup piétiné seul sur place. Puis je suis tombé sur votre site WEB, le sourire m’est revenu. J’ai débuté progressivement…Les morceaux de la version 5 sont difficiles à appréhendés. J’ai beaucoup appris en refaisant les diagrammes de transitions entre les menus. Ensuite comme je ne trouvais pas exactement les mêmes composants, il a fallu accommoder puis broder.Donc module Horloge DS3221, Afficheur LCD20x4, actionneur linéaire nichois, alimentation par panneau solaire et accumulateur Li-on récupéré.( Avec le panneau solaire pas besoin de LDR). Toujours 3 modes, manuel, Time-Prog, et Solaire. Le mode solaire à été réaménagé , je n’ai pas bien compris le système d’hystérésis, pour m’en passer, le mode solaire reprend le mode Time-Prog, ou les temps sont ajustés aux heures de lever et de coucher du soleil observées. Je travail maintenant(mal) sur l’adjonction du WiFi et le contrôle par Internet/Android.
    je ne suis pas capable de faire un site comme le votre et si vous pensez que cela puisse être d’un quelconque intérêt je suis disposer à vous soumettre mon travail. Encore merci et bravo.

    1. steven

      Bonjour,
      Merci pour ce retour.
      Le mode hystérésis a pour but de supprimer les détections intempestives sur le capteur LDR.
      Avant si on mettez le doigt sur le capteur LDR la porte se fermer instantanément, maintenant, il faut laisser le doigt un certain temps avant que la porte se ferme.
      Je suis preneur de votre travail juste par curiosité.
      Votre panneau solaire et accumulateur arrivent à faire fonctionner le système en autonomie ?
      Cordialement,

  4. Turnoff

    Bonjour, merci de m’avoir répondu. Le dispositif est en service en Anjou, depuis fin Avril en mode « Solaire » (=LDR)Les poules l’ont de suite adopté. Donc 2mois c’est encore peu. L’autonomie est plus que suffisante en ces saisons, il faut attendre l’hiver pour savoir si mes estimations restent correctes. De jour, le « BMS » coupe la recharge assez rapidement et le système est alors en veille sur le pnx solaire; il était bien calé sur les éphémérides au solstice d’été.
    je ne sais pas comment vous transmettre un quelconque document autrement que d’écrire sur ce tchat? Vous avez mon e-mail, peut-être pourriez m’y donner un lien pour ce faire? Mais ce n’est pas important… Je vous donnerais des nouvelles cet hiver. Encore bravo et merci…

  5. Turnoff

    Après relecture de mon premier message, je m’aperçois qu’il est peu être maladroit. Je voulais juste dire que je vous suis très reconnaissant pour votre partage, et, s’il y a un quelconque intérêt, je souhaitais en retour partager, par dette envers vous et pas uniquement profiter. Impossible ici de poster une quelconque photo ou bien même la notice d’emploi qui résume bien.

  6. André

    Bonjour, je trouve votre projet très intéressant, c’est exactement ce que je recherchais, je suis novice en programmation . j’ai des messages d’erreur a la compilation que je ne comprend pas.
    j’ai inclus la bibliothèque Ds 1302
    – DS 1302 does not name a type , did you mean Ds 1302, j’ai donc mis le ‘s ‘en minuscule.
    -en suite j’ai un message ‘Time’ does not name a type , et la je suis bloqué, si vous avez un conseil a me donner je vous en remercie.
    Encore bravos pour tout ce travail.

    1. steven

      Bonjour,
      Le problème vient sûrement de la bibliothèque que vous avez installée.
      Cela ne doit pas être la bonne version.
      Cordialement,

  7. patcatcat

    Bonjour Steven,
    Belle réalisation et beau programme!
    J’ai réalisé aussi une porte de poulailler avec LDR, mais je n’en suis pas satisfait à 100% pour les raisons suivantes : les fortes variations de luminosités qu’il peut y avoir ( moyenne montagne sud de la France) malgré la temporisation, la difficulté de réglages des seuils et l’humeur des volatiles….
    J’ai observé le fonctionnement et le comportements des poules sur plusieurs mois et j’en ai déduit que l’idéal serait l’ouverture et la fermeture réglés sur les levers et couchers de soleil grâces au éphémérides. Avec un décalage d’au moins 30mn le soir (crépuscule astronomique)
    Avec les éphémérides ont est certain que la fermetures se fera lorsque toutes les poules seront rentrées, car c’est surtout la fermeture qui pose problème.
    Il y a des programmes (arduino) de calculs des éphémérides fait par Bricoleau (https://forum.arduino.cc/t/calcul-ephemeride-precis-lever-et-coucher-de-soleil/266532) ou ChPr (https://forum.arduino.cc/t/bibliotheque-pour-suivi-et-ephemerides-du-soleil/436157) mais je ne suis pas suffisamment costaud en programmation pour intégré et faire fonctionner entre elles ses fonctions (RTC, éphémérides etc.).
    Un plus serait l’installation d’une cellule de détection de présence de poule sous la porte pour éviter un écrasement (vécu) retardant le fermeture.
    Une version 6-A serait bienvenue!
    Cordialement
    patcatcat

    1. steven

      Merci pour votre retour
      Je vais étudier votre proposition et regarder toutes ces informations sur les éphémérides.
      Il y aura bien une version 6.
      Je recueille le maximum de proposition et j’essayerais de faire tout ça pour cette fin d’année.
      Cordialement,

  8. patcatcat

    Eh bien je vais suivre avec attention, et si je peux aider….
    La porte auto de mon poulailler
    L;’ouverture se fait avec un lève vitre de voiture (complet glissière et câbles) moteur courant continu 12V. et glissières chariot à bille à l’opposé (initialement glissière à billes de tiroir mais fonctionnement verticale perfectible).
    Monté /descente : Inversion par relai double pour arduino
    Contrôle de la vitesse : Contrôleur de vitesse du moteur 6V-90V ,15A à courant continu avec bouton rotatif
    Alimentation par capteur solaire, régulateur et batterie 12V plomb (voiture).
    Alimentation 5V : Conertisseur DC/DC 12V 5V 3A + sortie USB (non utilisé)

    Converti

  9. Barnard

    Bonjour,
    J’ai suivi vos conseils et suis parvenu à faire fonctionner votre script. Je rencontre cependant un problème : le montage fonctionne nickel en manuel, la porte s’arrête en montée ou en descente dès qu’elle rencontre un fin de course. En revanche en mode « programmateur » la porte passe son temps à remonter et redescendre dès qu’elle rencontre un fin de course (le moteur ne se coupe que lorsque l’on appuie en même temps sur les deux « fin de course » ) Auriez-vous une piste ? D’avance je vous remercie.

  10. Sohet

    Bonjour,
    étant possesseur d’un montage complet venu de Chine pour commander l’ouverture et fermeture de porte du poulailler, je n’en suis que deçu et très mécontent.
    Je viens de trouver votre site et toutes les merveilles de montage possible avec arduino.
    Je vais réaliser mon système en suivant vos instructions pour la version 5B.
    Mon souci est le suivant. Quand je vérifie le code sur mon arduino ide version 2 j’obtiens ce message:
    C:\Users\Administrateur\AppData\Local\Temp\.arduinoIDE-unsaved202295-2812-k5cv66.yp858\sketch_oct5e\sketch_oct5e.ino:2:10: fatal error: DS1302.h: No such file or directory
    #include
    ^~~~~~~~~~
    compilation terminated.

    exit status 1

    Compilation error: DS1302.h: No such file or directory.

    Quelle est la librairie DS1302 que vous utiliser pour compiler ce code et par la même occasion avez vous une dernière mise a jour du code pour ce montage.
    Merci et bonne journée

    1. steven

      Bonjour,
      Normalement, en téléchargement, il y a les liens des bibliothèques que j’ai utilisées.
      Cordialement,

  11. Antonin

    Bonjour,

    J’ai un problème au niveau de l’affichage de l’écran (20×4) avec le module I2C, car quand je téléverse le programme sur l’arduino (l’application n’affiche aucun message d’erreur) rien ne se passe au niveau de l’écran (même le rétro-éclairage ne s’éteint pas et ne se rallume pas). Pourtant j’ai vérifié mes branchements et j’ai téléchargé la librairie (LiquidCrystal I2C) qui est disponible sur votre site.
    J’utilise un Arduino Uno.
    J’avais déjà réalisé un première porte automatique pour les poules (qui fonctionne encore super bien aujourd’hui), je n’avais pas rencontré ce problème, et je voudrais en réaliser une deuxième, mais je suis confronté à ce problème.
    Au passage, je vous remercie d’avoir partagé votre programme, car il me convient parfaitement et fonctionne très bien !
    Avez-vous une solution ?

    Cordialement.

    1. steven

      Bonjour,
      Vous pouvez dans un premier temps essayer un programme simple qui affiche juste une phrase sur écran i2c pour commencer a éliminer des erreurs.
      Cordialement,

  12. JEAN MARIE

    Bonjour, voilà un tuto explicit, bravo. J’ai testé en tant que débutant et ça fonctionne très bien même sans poule ;-). Bon ma question n’a rien à voir avec les poules, en fait je voudrai adapter ce principe (manuel, programmation et avec LDR) mais pour un tracker solaire. Je me suis fabriquer un support pour mes panneaux (voir ma chaine), actuellement, ils fonctionnent en rotation et en élévation via des routines horaires commander par boitier Sonoff. J’aimerai bien modifier en plaçant une carte Arduino par panneau afin qu’ils puissent suivre le soleil. Il y a 1 vérin de 12v pour l’élévation et un moteur de 12v pour la rotation par panneau. J’ai fouiné un peu partout mais sans trop de résultats. Pouvez vous m’aider? En vous remerciant. Cordialement

    1. steven

      Bonjour merci du retour
      Contactez-moi en privé sur Facebook on va regarder ça.
      Cordialement,

  13. Manu

    Bonjour, merci pour ce partage et les explications très claires.
    J’ai d’abord monter la version avec le moteur pas-à-pas mais je n’avais pas assez de puissance pour monter ma trappe.
    Je viens de passer à la version vérin, qui fonctionne bien.
    j’ai juste un problème avec l’horloge : elle se remet à 00:00 lorsque le verin est actionné, quelque soit le mode (manuel, prog, LDR).
    J’y est mis une pile neuve mais le problème persiste. Une idée ?
    Merci d’avance

    1. steven

      Bonjour,

      Lors de l’actionnement du Relais de votre moteur, celui-ci doit créer un parasite qui remet effectivement votre horloge à O.
      J’ai déjà rencontré ce problème quand j’actionnais ma pompe de piscine avec un Relais, mais je n’ai malheureusement pas trouvé de solution bien fiable.
      La seule solution fiable que j’ai eue et de le remplacer l’horloge par une horloge DS3231 beaucoup moins sensible aux parasites.
      Si des fois vous trouver une solution, je suis preneur.
      Si vous rencontrez des problèmes pour modifier le programme contactez moi.

      Cordialement,

  14. Sébastien

    Bonjour, merci pour le partage de votre travail, notamment les différentes versions qui vont me permettre de faire un mix de tout ça et faire évoluer mon installation. J’ai d’abord automatisé ma porte de poulailler uniquement par une photorésistance et un relais LY2NJ 12V qui actionnaient un vérin électrique il y a quelques années mais je l’ai démontée suite à un accident (une poule a été écrasée par la porte sectionnelle) et pour éviter que ça arrive à un enfant.
    Je relance le système mais plus évolué car je voudrais piloter d’autres éléments au même endroit donc système type Arduino.
    En guise de protection je pensais mettre un capteur (capteur de présence ou module à ultrasons ou laser…) mais finalement je vais simplement faire un système mécanique de bas de porte avec ressorts qui contiendra l’interrupteur de fin de course, indiquant à la fois un animal ou objet bloquant la porte et sinon lorsque la porte arrivera au sol. Que pensez-vous de cette solution?
    Ce sera mes débuts en Arduino, j’espère faire évoluer le système pour pouvoir le contrôler à distance (en WiFi avec un ESP32) et ajouter de nouvelles fonctions.

    1. steven

      Bonjour merci du retour
      Effectivement attention de ne pas tuer les poules quand même ^^
      Pour détecter une poule, vous pouvez utiliser différents capteurs sur votre porte, il faut trouver le bon compromis.
      Dans la future version que je vais publier, j’ai ajouté un nouveau système de sécurité qui va détecter si la porte, mais trop longtemps à fermer, ça arrêtera le système.
      Si vous partez sur un système esp32 avec wifi vous pouvez même utiliser le tuto que j’ai fait avec openweather pour récupérer les infos de lever et coucher du soleil pour que votre porte s’ouvre automatiquement (plus besoin de LDR)
      Cordialement,

Laisser un commentaire