Porte automatique pour poulailler version 4 *

Description :

Version 4 :

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).

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

Mode Programmateur : programmer une heure ouverture / fermeture .

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 Moteur Nema PAP
  • 1 x L298N
  • 1 x DS1302 Module RTC
  • 1 x Alimentation 12v
  • Fils de connexion
  • 1 x Breadboard

Version IDE :

Bibliothèque :

 

 

Infos :

Pour le premier téléversement du programme dans votre Arduino il vous faudra modifier le paramètre rtc.writeProtect(true) par rtc.writeProtect(false), pour pouvoir écrire la date et l’heure dans la RAM du DS1302.

Et de renseigner le jour, la date et l’heure dans :

rtc.setDOW(FRIDAY); // Jour a FRIDAY

rtc.setTime(02, 22, 0); // Heure a 15:14:00 (format sur 24 heure)

rtc.setDate(24, 05, 2020); // Date au 28 juin 2020

Une fois le téléversement terminé n’oublier pas de re remplacer rtc.writeProtect(false) par rtc.writeProtect(true) et de re téléverser le programme.

 

Vidéo de démonstration :

 

Schéma de câblage :

 

Code :

int boutonhaut = A1; //broche du Bouton fleche haut
int boutonbas = A2; //broche du Bouton fleche bas
int boutonselect = A3; //broche du Bouton select
const int LDR = A0; // broche du LDR
const int fdchaut = 3; // broche du fin de course haut
const int fdcbas = 4; // broche du fin de course bas
int val_LDR_ouverture = 400; // valeur luminosité minimum pour ouverture
int val_LDR_fermeture = 100; // valeur luminosité minimum pour fermeture

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

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

#include <Stepper.h>
const int stepsPerRevolution = 200;
// Initialise le moteur sur les broches 8 à 11
Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11);

int menu = 1;
int modedemarche = 4;
int menumodemarche = 1;
int menuprogrammateur = 1;
int menuldr = 1;
long heureouverture = 23;
long minouverture = 59;
long heurefermeture = 0;
long minfermeture = 1;
boolean etatporte = 0;
int nbcyclerefresh = 10; //Nb de cycle progr. avant rafraichissement LCD
unsigned int refreshLDRms;
int refrechchgetat = 0;
byte tiretbas[8] = {B11111,B00000,B00000,B00000,B00000,B00000,B00000,};
byte egal[8] = {B00000,B00000,B11111,B00000,B11111,B00000,B00000,};

void setup() {
  Serial.begin(9600);

  myStepper.setSpeed(200); //Vitesse de rotation du moteur à 200
  
  pinMode(boutonhaut, INPUT_PULLUP);
  pinMode(boutonbas, INPUT_PULLUP);
  pinMode(boutonselect, INPUT_PULLUP);
  pinMode(fdchaut, INPUT_PULLUP);
  pinMode(fdcbas, INPUT_PULLUP);
  
  rtc.halt(false);
  
  //Active = false Desactive = true la protection en ecriture pour mettre à jour heure et la date
  rtc.writeProtect(true);
  rtc.setDOW(FRIDAY);        // Jour a FRIDAY
  rtc.setTime(02, 22, 0);    // Heure a 15:14:00 (format sur 24 heure)
  rtc.setDate(24, 05, 2020);   // Date  au 28 juin 2020 
  /////////////////////////////////////

  lcd.init();                     
  lcd.backlight();
  lcd.createChar(0, tiretbas);
  lcd.createChar(1, egal);
  
  //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(" ");
  if(ramBuffer.cell[0] == 99){
    modedemarche = ramBuffer.cell[1];
    heureouverture = ramBuffer.cell[2];
    minouverture = ramBuffer.cell[3];
    heurefermeture = ramBuffer.cell[4];
    minfermeture = ramBuffer.cell[5];
    byte v_1LDRouverture = ramBuffer.cell[6];
    byte v_2LDRouverture = ramBuffer.cell[7];
    byte v_1LDRfermeture = ramBuffer.cell[8];
    byte v_2LDRfermeture = ramBuffer.cell[9];
    val_LDR_ouverture = word(v_2LDRouverture, v_1LDRouverture); 
    val_LDR_fermeture = word(v_2LDRfermeture, v_1LDRfermeture);   
  } 
}

void loop() {
  int valeurLDR = analogRead(LDR);
  //Gestion du bouton select
  if (digitalRead(boutonselect) == LOW){ 
    //Entrer dans le Menu de Accueil
    if(menu == 1){
      menu = 2;  
    }
    //Menu / Entrer dans Mode de marche
    else if(menu == 2 && menumodemarche == 1 && menuprogrammateur == 1 && menuldr == 1){
      menu = 6;
      menumodemarche = modedemarche;
    }
    //Menu / Entrer dans Programmateur
    else if(menu == 3 && menumodemarche == 1 && menuprogrammateur == 1 && menuldr == 1){
      menu = 6;
      menuprogrammateur = 2;
    }
    //Menu / Entrer dans LDR
    else if(menu == 4 && menumodemarche == 1 && menuprogrammateur == 1 && menuldr == 1){
      menu = 6;
      menuldr = 2;
    }
    //Menu / Accueil
    else if(menu == 5 && menumodemarche == 1 && menuprogrammateur == 1 && menuldr == 1){
      menu = 1;
    }
    //Menu / Mode de marche / Selection du Mode de marche et retour
    else if(menu == 6 && menumodemarche != 1 && menuprogrammateur == 1 && menuldr == 1){
      modedemarche = menumodemarche;
      menumodemarche = 1;
      menu = 1;
      sauvegarde();
      if(modedemarche == 2){
        affichageautomatique(valeurLDR);
        refreshLDRms = nbcyclerefresh + 1;  
      }
    }
    //Menu / Programmateur / Conf.Programmateur / Selection heure ouverture
    else if(menu == 6 && menumodemarche == 1 && menuldr == 1 && menuprogrammateur == 2){
      menuprogrammateur = 5;
    }
    //Menu / Programmateur / Conf.Programmateur / Passer reglage heure ouverture au reglage min ouverture
    else if(menu == 6 && menumodemarche == 1 && menuldr == 1 && menuprogrammateur == 5){
      menuprogrammateur = 6;
    }
    //Menu / Programmateur / Conf.Programmateur / Passer reglage min ouverture à Conf.Programmateur
    else if(menu == 6 && menumodemarche == 1 && menuldr == 1 && menuprogrammateur == 6){
      menuprogrammateur = 2;
      sauvegarde();
    }
    //Menu / Programmateur / Conf.Programmateur / Selection heure fermeture
    else if(menu == 6 && menumodemarche == 1 && menuldr == 1 && menuprogrammateur == 3){
      menuprogrammateur = 7;
    }
    //Menu / Programmateur / Conf.Programmateur / Passer reglage heure fermeture au reglage min fermeture
    else if(menu == 6 && menumodemarche == 1 && menuldr == 1 && menuprogrammateur == 7){
      menuprogrammateur = 8;
    }
    //Menu / Programmateur / Conf.Programmateur / Passer reglage min fermeture à Conf.Programmateur
    else if(menu == 6 && menumodemarche == 1 && menuldr == 1 && menuprogrammateur == 8){
      menuprogrammateur = 3;
      sauvegarde();
    }
    //Menu / Programmateur / Conf.Programmateur / Passer Conf.Programmateur à Accueil
    else if(menu == 6 && menumodemarche == 1 && menuldr == 1 && menuprogrammateur == 4){
      menu = 1;
      menuprogrammateur = 1;
    }
    //Menu / Programmateur / Conf.LDR / Passer Conf.LDR à Accueil
    else if(menu == 6 && menumodemarche == 1 && menuldr == 4 && menuprogrammateur == 1){
      menu = 1;
      menuldr = 1;
    }
    //Menu / Programmateur / Conf.LDR / Reglage valeur LDR ouverture
    else if(menu == 6 && menumodemarche == 1 && menuldr == 2 && menuprogrammateur == 1){
      menuldr = 5;
    }
    //Menu / Programmateur / Conf.LDR / Reglage valeur LDR ouverture
    else if(menu == 6 && menumodemarche == 1 && menuldr == 3 && menuprogrammateur == 1){
      menuldr = 6;
    }
    //Menu / Programmateur / Conf.LDR / Reglage valeur LDR ouverture à Conf.LDR
    else if(menu == 6 && menumodemarche == 1 && menuldr == 5 && menuprogrammateur == 1){
      menuldr = 2;
      sauvegarde();
    }
    //Menu / Programmateur / Conf.LDR / Reglage valeur LDR fermeture à Conf.LDR
    else if(menu == 6 && menumodemarche == 1 && menuldr == 6 && menuprogrammateur == 1){
      menuldr = 3;
      sauvegarde();
    }
    while (digitalRead(boutonselect) == LOW){
    }
    lcd.clear();
  } 
  //Gestion du bouton bas
  if (digitalRead(boutonbas) == LOW){
    //Navigation dans Menu//
    if(menu != 6 && menu != 1){
      if(menu > 1 && menu < 5 && menumodemarche == 1 && menuprogrammateur == 1 && menuldr == 1){
        menu++;  
      }
      else{
        menu = 2;
      }
    }
    //Navigation dans  Mode de marche//
    if(menu == 6 && menumodemarche != 1 && menuprogrammateur == 1 && menuldr == 1){
      if(menu == 6 && menumodemarche > 1 && menumodemarche < 4){
        menumodemarche++;  
      }
      else{
        menumodemarche = 2;
      }
    }
    //Navigation dans Conf.Programmateur//
    if(menu == 6 && menumodemarche == 1 && menuprogrammateur != 1 && menuprogrammateur < 5 && menuldr == 1){
      if(menu == 6 && menuprogrammateur > 1 && menuprogrammateur < 4){
        menuprogrammateur++;  
      }
      else{
        menuprogrammateur = 2;
      }
    }
    //Navigation dans LDR//
    if(menu == 6 && menumodemarche == 1 && menuprogrammateur == 1 && menuldr != 1 && menuldr < 5){
      if(menu == 6 && menuldr > 1 && menuldr < 4){
        menuldr++;  
      }
      else{
        menuldr = 2;
      }
    }
    //Reglage LDR ouverture//
    if(menu == 6 && menumodemarche == 1 && menuprogrammateur == 1 && menuldr == 5){
      if(val_LDR_ouverture > 2){
        val_LDR_ouverture--;  
      }
    }
    //Reglage LDR fermeture//
    if(menu == 6 && menumodemarche == 1 && menuprogrammateur == 1 && menuldr == 6){
      if(val_LDR_fermeture > 2){
        val_LDR_fermeture--;  
      }
    }
    //Reglage heure ouverture//
    if(menu == 6 && menumodemarche == 1 && menuprogrammateur == 5 && menuldr == 1){
      if(heureouverture > 0){
        heureouverture--;  
      }
      else{
        heureouverture = 23;
      }
    }
    //Reglage min ouverture//
    if(menu == 6 && menumodemarche == 1 && menuprogrammateur == 6 && menuldr == 1){
      if(minouverture > 0){
        minouverture--;  
      }
      else{
        minouverture = 59;
      }
    }
    //Reglage heure fermeture//
    if(menu == 6 && menumodemarche == 1 && menuprogrammateur == 7 && menuldr == 1){
      if(heurefermeture > 0){
        heurefermeture--;  
      }
      else{
        heurefermeture = 23;
      }
    }
    //Reglage min fermeture//
    if(menu == 6 && menumodemarche == 1 && menuprogrammateur == 8 && menuldr == 1){
      if(minfermeture > 0){
        minfermeture--;  
      }
      else{
        minfermeture = 59;
      }
    }
    
    if(menu == 1 && menumodemarche == 1 && menuprogrammateur == 1 && modedemarche == 4 && menuldr == 1){
      while(digitalRead(boutonbas) == LOW && digitalRead(fdcbas) == HIGH){
        myStepper.step(-1);
      } 
      affichagemenu1(); 
    }
    while (digitalRead(boutonbas) == LOW){
    }
    lcd.clear();
  }
  //Gestion du bouton haut
  if (digitalRead(boutonhaut) == LOW){
    //Navigation dans Menu//
    if(menu != 6 && menu != 1){
      if(menu < 6 && menu > 2 && menumodemarche == 1 && menuprogrammateur == 1 && menuldr == 1){
        menu--;  
      }
      else{
        menu = 5;
      }
    }
    //Navigation dans  Mode de marche//
    if(menu == 6 && menumodemarche != 1 && menuprogrammateur == 1 && menuldr == 1){
      if(menu == 6 && menumodemarche < 5 && menumodemarche > 2){
        menumodemarche--;  
      }
      else{
        menumodemarche = 4;
      }
    }
    //Navigation dans Conf.Programmateur//
    if(menu == 6 && menumodemarche == 1 && menuprogrammateur != 1 && menuprogrammateur < 5 && menuldr == 1){
      if(menu == 6 && menuprogrammateur < 5 && menuprogrammateur > 2){
        menuprogrammateur--;  
      }
      else{
        menuprogrammateur = 4;
      }
    }
    //Navigation dans LDR//
    if(menu == 6 && menumodemarche == 1 && menuprogrammateur == 1 && menuldr != 1 && menuldr < 5){
      if(menu == 6 && menuldr < 5 && menuldr > 2){
        menuldr--;  
      }
      else{
        menuldr = 4;
      }
    }
    //Reglage LDR ouverture//
    if(menu == 6 && menumodemarche == 1 && menuprogrammateur == 1 && menuldr == 5){
      if(val_LDR_ouverture < 1022){
        val_LDR_ouverture++;  
      }
    }
    //Reglage LDR fermeture//
    if(menu == 6 && menumodemarche == 1 && menuprogrammateur == 1 && menuldr == 6){
      if(val_LDR_fermeture < 1022){
        val_LDR_fermeture++;  
      }
    }
    //Reglage heure ouverture//
    if(menu == 6 && menumodemarche == 1 && menuprogrammateur == 5 && menuldr == 1){
      if(heureouverture < 23){
        heureouverture++;  
      }
      else{
        heureouverture = 0;
      }
    }
    //Reglage min ouverture//
    if(menu == 6 && menumodemarche == 1 && menuprogrammateur == 6 && menuldr == 1){
      if(minouverture < 59){
        minouverture++;  
      }
      else{
        minouverture = 0;
      }
    }
    //Reglage heure fermeture//
    if(menu == 6 && menumodemarche == 1 && menuprogrammateur == 7 && menuldr == 1){
      if(heurefermeture < 23){
        heurefermeture++;  
      }
      else{
        heurefermeture = 0;
      }
    }
    //Reglage min fermeture//
    if(menu == 6 && menumodemarche == 1 && menuprogrammateur == 8 && menuldr == 1){
      if(minfermeture < 59){
        minfermeture++;  
      }
      else{
        minfermeture = 0;
      }
    }
    if(menu == 1 && menumodemarche == 1 && menuprogrammateur == 1 && modedemarche == 4 && menuldr == 1){
      while(digitalRead(boutonhaut) == LOW && digitalRead(fdchaut) == HIGH){
        myStepper.step(1);
      } 
      affichagemenu1(); 
    }
    
    while (digitalRead(boutonhaut) == LOW){
    }
    lcd.clear();
  } 
    
  //Menu  
  switch (menu) {
  case 1:   
    affichagemenu1();
    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 ("Retour              ");
    break;
  case 3:
    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 ("Retour              ");
    break;
  case 4:
    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 ("Retour              ");
    break;
  case 5:
    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 ("Retour             <");
    break;
  case 6:
    break;  
  }
  
  //Menu mode marche
  switch (menumodemarche) {
  case 1:
    break;
  case 2:
    lcd.setCursor(0, 0);
    lcd.print ("Select. Mode :");
    lcd.setCursor(0, 1);
    lcd.print ("LDR                <");
    lcd.setCursor(0, 2);
    lcd.print ("Programmateur       ");
    lcd.setCursor(0, 3);
    lcd.print ("Manuel              ");
    break;
  case 3:
    lcd.setCursor(0, 0);
    lcd.print ("Select. Mode :");
    lcd.setCursor(0, 1);
    lcd.print ("LDR                 ");
    lcd.setCursor(0, 2);
    lcd.print ("Programmateur      <");
    lcd.setCursor(0, 3);
    lcd.print ("Manuel              ");
    break;
  case 4:
    lcd.setCursor(0, 0);
    lcd.print ("Select. Mode :");
    lcd.setCursor(0, 1);
    lcd.print ("LDR                 ");
    lcd.setCursor(0, 2);
    lcd.print ("Programmateur       ");
    lcd.setCursor(0, 3);
    lcd.print ("Manuel             <");
    break;
  }
  
  //Menu programmateur
  switch (menuprogrammateur) {
  case 1:
    break;
  case 2:
    lcd.setCursor(0, 0);
    lcd.print ("Conf. Programmateur");
    lcd.setCursor(0, 1);
    lcd.print ("Heure ouverture    <");
    lcd.setCursor(0, 2);
    lcd.print ("Heure fermeture     ");
    lcd.setCursor(0, 3);
    lcd.print ("Retour              ");
    break;
  case 3:
    lcd.setCursor(0, 0);
    lcd.print ("Conf. Programmateur");
    lcd.setCursor(0, 1);
    lcd.print ("Heure ouverture     ");
    lcd.setCursor(0, 2);
    lcd.print ("Heure fermeture    <");
    lcd.setCursor(0, 3);
    lcd.print ("Retour              ");
    break;
  case 4:
    lcd.setCursor(0, 0);
    lcd.print ("Conf. Programmateur");
    lcd.setCursor(0, 1);
    lcd.print ("Heure ouverture     ");
    lcd.setCursor(0, 2);
    lcd.print ("Heure fermeture     ");
    lcd.setCursor(0, 3);
    lcd.print ("Retour             <");
    break;
  case 5:
    lcd.setCursor(0, 0);
    lcd.print ("Heure ouverture");
    if(heureouverture < 10){
      lcd.setCursor(7, 2);
      lcd.print ("0");
      lcd.setCursor(8, 2);
      lcd.print (heureouverture);
      lcd.setCursor(7, 3);
      lcd.write(byte(0));
      lcd.setCursor(8, 3);
      lcd.write(byte(0));
    }
    else{
      lcd.setCursor(7, 2);
      lcd.print (heureouverture); 
      lcd.setCursor(7, 3);
      lcd.write(byte(0));
      lcd.setCursor(8, 3);
      lcd.write(byte(0));  
    }
    lcd.setCursor(9, 2);
    lcd.print (":");
    if (minouverture < 10){
      lcd.setCursor(10, 2);
      lcd.print ("0");
      lcd.setCursor(11, 2);
      lcd.print (minouverture);
    }
    else{
      lcd.setCursor(10, 2);
      lcd.print (minouverture);
    } 
    break;
  case 6:
    lcd.setCursor(0, 0);
    lcd.print ("Heure ouverture");
    if(heureouverture < 10){
      lcd.setCursor(7, 2);
      lcd.print ("0");
      lcd.setCursor(8, 2);
      lcd.print (heureouverture);
    }
    else{
      lcd.setCursor(7, 2);
      lcd.print (heureouverture);  
    }
    lcd.setCursor(9, 2);
    lcd.print (":");
    if (minouverture < 10){
      lcd.setCursor(10, 2);
      lcd.print ("0");
      lcd.setCursor(11, 2);
      lcd.print (minouverture);
      lcd.setCursor(10, 3);
      lcd.write(byte(0));
      lcd.setCursor(11, 3);
      lcd.write(byte(0));
    }
    else{
      lcd.setCursor(10, 2);
      lcd.print (minouverture);
      lcd.setCursor(10, 3);
      lcd.write(byte(0));
      lcd.setCursor(11, 3);
      lcd.write(byte(0));
    }  
    break; 
  case 7:
    lcd.setCursor(0, 0);
    lcd.print ("Heure fermeture");
    if(heurefermeture < 10){
      lcd.setCursor(7, 2);
      lcd.print ("0");
      lcd.setCursor(8, 2);
      lcd.print (heurefermeture);
      lcd.setCursor(7, 3);
      lcd.write(byte(0));
      lcd.setCursor(8, 3);
      lcd.write(byte(0));
    }
    else{
      lcd.setCursor(7, 2);
      lcd.print (heurefermeture); 
      lcd.setCursor(7, 3);
      lcd.write(byte(0));
      lcd.setCursor(8, 3);
      lcd.write(byte(0));  
    }
    lcd.setCursor(9, 2);
    lcd.print (":");
    if (minfermeture < 10){
      lcd.setCursor(10, 2);
      lcd.print ("0");
      lcd.setCursor(11, 2);
      lcd.print (minfermeture);
    }
    else{
      lcd.setCursor(10, 2);
    lcd.print (minfermeture);
    } 
    break;
  case 8:
    lcd.setCursor(0, 0);
    lcd.print ("Heure fermeture");
    if(heurefermeture < 10){
      lcd.setCursor(7, 2);
      lcd.print ("0");
      lcd.setCursor(8, 2);
      lcd.print (heurefermeture);
    }
    else{
      lcd.setCursor(7, 2);
      lcd.print (heurefermeture);  
    }
    lcd.setCursor(9, 2);
    lcd.print (":");
    if (minfermeture < 10){
      lcd.setCursor(10, 2);
      lcd.print ("0");
      lcd.setCursor(11, 2);
      lcd.print (minfermeture);
      lcd.setCursor(10, 3);
      lcd.write(byte(0));
      lcd.setCursor(11, 3);
      lcd.write(byte(0));
    }
    else{
      lcd.setCursor(10, 2);
      lcd.print (minfermeture);
      lcd.setCursor(10, 3);
      lcd.write(byte(0));
      lcd.setCursor(11, 3);
      lcd.write(byte(0));
    } 
    break;   
  }
  
  //Menu LDR
  switch (menuldr) {
  case 1:
    break;
  case 2:
    lcd.setCursor(0, 0);
    lcd.print ("Conf. LDR");
    lcd.setCursor(0, 1);
    lcd.print ("LDR ouverture      <");
    lcd.setCursor(0, 2);
    lcd.print ("LDR fermeture       ");
    lcd.setCursor(0, 3);
    lcd.print ("Retour              ");
    break;
  case 3:
    lcd.setCursor(0, 0);
    lcd.print ("Conf. LDR");
    lcd.setCursor(0, 1);
    lcd.print ("LDR ouverture       ");
    lcd.setCursor(0, 2);
    lcd.print ("LDR fermeture      <");
    lcd.setCursor(0, 3);
    lcd.print ("Retour              ");
    break;
  case 4:
    lcd.setCursor(0, 0);
    lcd.print ("Conf. LDR");
    lcd.setCursor(0, 1);
    lcd.print ("LDR ouverture       ");
    lcd.setCursor(0, 2);
    lcd.print ("LDR fermeture       ");
    lcd.setCursor(0, 3);
    lcd.print ("Retour             <");
    break;
  case 5:
    lcd.setCursor(0, 0);
    lcd.print ("Val. LDR ouverture");
    lcd.setCursor(8, 2);
    lcd.print (val_LDR_ouverture);
    lcd.setCursor(8, 3);
    if(val_LDR_ouverture < 10){
      lcd.setCursor(8, 3);
      lcd.write(byte(0));
    }
    else if(val_LDR_ouverture > 9 && val_LDR_ouverture < 100){
      lcd.setCursor(8, 3);
      lcd.write(byte(0));
      lcd.setCursor(9, 3);
      lcd.write(byte(0));
    }
    else{
      lcd.setCursor(8, 3);
      lcd.write(byte(0));
      lcd.setCursor(9, 3);
      lcd.write(byte(0));
      lcd.setCursor(10, 3);
      lcd.write(byte(0));
    }
    break;
  case 6:
      lcd.setCursor(0, 0);
      lcd.print ("Val. LDR fermeture");
      lcd.setCursor(8, 2);
      lcd.print (val_LDR_fermeture);
      lcd.setCursor(8, 3);
      if(val_LDR_fermeture < 10){
        lcd.setCursor(8, 3);
        lcd.write(byte(0));
      }
      else if(val_LDR_fermeture > 9 && val_LDR_fermeture < 100){
        lcd.setCursor(8, 3);
        lcd.write(byte(0));
        lcd.setCursor(9, 3);
        lcd.write(byte(0));
      }
      else{
        lcd.setCursor(8, 3);
        lcd.write(byte(0));
        lcd.setCursor(9, 3);
        lcd.write(byte(0));
        lcd.setCursor(10, 3);
        lcd.write(byte(0));
      }
    break;    
  }
  
  //Gestion ouverture et fermeture si en Mode LDR
  if(valeurLDR >= val_LDR_ouverture && modedemarche == 2 && menuprogrammateur == 1 && menu == 1  && menuldr == 1){
      etatporte = 1;
    }
  if(valeurLDR <= val_LDR_fermeture && modedemarche == 2 && menuprogrammateur == 1 && menu == 1  && menuldr == 1){
      etatporte = 0;
    } 
  if(modedemarche == 2  && menuldr == 1 && menu == 1 && menuprogrammateur == 1 && (refreshLDRms > nbcyclerefresh || refrechchgetat == !etatporte)){
    if(modedemarche == 2  && menuldr == 1 && menu == 1 && menuprogrammateur == 1){
      refrechchgetat = etatporte;
      affichageautomatique(valeurLDR);
    }
  } 
  while(etatporte == 1 && digitalRead(fdchaut) == HIGH && modedemarche == 2 && menu == 1){
    myStepper.step(1);
  }
  while(etatporte == 0 && digitalRead(fdcbas) == HIGH && modedemarche == 2 && menu == 1){
    myStepper.step(-1);
    }
  refreshLDRms++;
  
  //Gestion ouverture et fermeture si en Mode programmateur
  unsigned long ouverturesec = (minouverture*60) + (heureouverture*3600);
  unsigned long fermeturesec = (minfermeture*60) + (heurefermeture*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 == 3 && menu == 1){
    if(heuresec > ouverturesec && heuresec < fermeturesec  && modedemarche == 3 && menu == 1){
        etatporte = 1;
      }
    else{
        etatporte = 0;
      }
  }
  if(ouverturesec > fermeturesec && modedemarche == 3 && menu == 1){
    if(modedemarche == 3 && menu == 1 && (heuresec > ouverturesec && heuresec > fermeturesec)||(heuresec < ouverturesec && heuresec < fermeturesec)){
        etatporte = 1;
      }
    if(heuresec > fermeturesec && heuresec < ouverturesec  && modedemarche == 3 && menu == 1){
        etatporte = 0;
      }
  }
  while(etatporte == 1 && digitalRead(fdchaut) == HIGH && modedemarche == 3 && menu == 1){
    myStepper.step(1);
  }
  while(etatporte == 0 && digitalRead(fdcbas) == HIGH && modedemarche == 3 && menu == 1){
    myStepper.step(-1);
    }
  
  //Mise au repos du moteur PAP
  moteurrepos();  
}

void affichagemenu1(){
  affichageheure();
    if(modedemarche == 2){
      lcd.setCursor(5, 1);
      lcd.print ("Mode : LDR        "); 
      lcd.setCursor(0, 3);
      lcd.print ("Ouv.");
      lcd.setCursor(4, 3);
      lcd.write(byte(1));
      lcd.setCursor(5, 3);
      lcd.print(val_LDR_ouverture);
      lcd.setCursor(11, 3);
      lcd.print ("Fer.");
      lcd.setCursor(15, 3);
      lcd.write(byte(1));
      lcd.setCursor(16, 3);
      lcd.print(val_LDR_fermeture);
    }
    else if (modedemarche == 3){
      lcd.setCursor(0, 2);
      lcd.print ("H. ouverture : ");
      if(heureouverture < 10){
        lcd.setCursor(15, 2);
        lcd.print ("0");
        lcd.setCursor(16, 2);
        lcd.print (heureouverture);
      }
      else{
        lcd.setCursor(15, 2);
        lcd.print (heureouverture);  
      }
      lcd.setCursor(17, 2);
      lcd.print (":");
      if (minouverture < 10){
        lcd.setCursor(18, 2);
        lcd.print ("0");
        lcd.setCursor(19, 2);
        lcd.print (minouverture);
      }
      else{
        lcd.setCursor(18, 2);
        lcd.print (minouverture);
      } 
      lcd.setCursor(0, 3);
      lcd.print ("H. fermeture : ");
      if(heurefermeture < 10){
        lcd.setCursor(15, 3);
        lcd.print ("0");
        lcd.setCursor(16, 3);
        lcd.print (heurefermeture);
      }
      else{
        lcd.setCursor(15, 3);
        lcd.print (heurefermeture);  
      }
      lcd.setCursor(17, 3);
      lcd.print (":");
      if (minfermeture < 10){
        lcd.setCursor(18, 3);
        lcd.print ("0");
        lcd.setCursor(19, 3);
        lcd.print (minfermeture);
      }
      else{
        lcd.setCursor(18, 3);
        lcd.print (minfermeture);
      }
      lcd.setCursor(0, 1);
      lcd.print ("Mode : Programmateur");
    }
    else if (modedemarche == 4){
      lcd.setCursor(3, 1);
      lcd.print ("Mode : Manuel");
      lcd.setCursor(0,2);
      lcd.print("Pos. porte : ");  
      if(digitalRead(fdchaut) == LOW){
       lcd.setCursor(13,2);
       lcd.print("Ouverte");  
      }
      else if(digitalRead(fdcbas) == LOW){
        lcd.setCursor(13,2);
        lcd.print("Fermer "); 
      }
      else{
        lcd.setCursor(13,2);
        lcd.print(" ...   ");
      }
      lcd.setCursor(0,3);
      lcd.print("Bouton : ");
      if (digitalRead(boutonselect) == LOW){
        lcd.setCursor(9,3);
        lcd.print("Monter  ");
      }
      else if (digitalRead(boutonbas) == LOW){
        lcd.setCursor(9,3);
        lcd.print("Descente");
      }
      else{
        lcd.setCursor(9,3);
        lcd.print("Repos   ");  
      }
    }  
}

int affichageautomatique (int valeurLDR){
  lcd.setCursor(3,2);
  lcd.print("Val. LDR "); 
  lcd.setCursor(11,2);
  lcd.write(byte(1) );
  if(valeurLDR < 100){
    lcd.setCursor(13,2); 
    lcd.print(valeurLDR);
    lcd.setCursor(15,2); 
    lcd.print("   ");
  }
  else if(valeurLDR >= 100 && valeurLDR < 1000){
    lcd.setCursor(13,2); 
    lcd.print(valeurLDR);
    lcd.setCursor(16,2); 
    lcd.print("   ");
  }
  else{
    lcd.setCursor(13,2); 
    lcd.print(valeurLDR);    
  } 
  refreshLDRms = 0;     
}

//Affichage de l'heure
void affichageheure(){
  t = rtc.getTime();
  String hour;
  String min;
  String sec;
  hour = String(t.hour);
  min = String(t.min);
  sec = String(t.sec);
  
  if(t.hour<10)
  {
    hour = "0"+hour;
    lcd.setCursor(6, 0);
    lcd.print (hour+":");
  }else
  {
    lcd.setCursor(6, 0);
    lcd.print (hour+":");
  }
  if(t.min<10)
  {
    min = "0"+min;
    lcd.setCursor(9, 0);
    lcd.print (min+":");
  }else
  {
    lcd.setCursor(9, 0);
    lcd.print (min+":");
  }
  if(t.sec<10)
  {
    sec = "0"+sec;
    lcd.setCursor(12, 0);
    lcd.print (sec);
  }else
  {
    lcd.setCursor(12, 0);
    lcd.print (sec);
  }
}

//Sauvegarde sur RAM DS1302
void sauvegarde (){
  rtc.writeProtect(false);
  int valeurLDRouverture = val_LDR_ouverture; 
  byte v_1LDRouverture = lowByte(valeurLDRouverture); 
  byte v_2LDRouverture = highByte(valeurLDRouverture); 
  int valeurLDRfermeture = val_LDR_fermeture; 
  byte v_1LDRfermeture = lowByte(valeurLDRfermeture); 
  byte v_2LDRfermeture = highByte(valeurLDRfermeture); 
  ramBuffer.cell[0] = 99;
  ramBuffer.cell[1] = modedemarche;
  ramBuffer.cell[2] = heureouverture;
  ramBuffer.cell[3] = minouverture;
  ramBuffer.cell[4] = heurefermeture;
  ramBuffer.cell[5] = minfermeture;
  ramBuffer.cell[6] = v_1LDRouverture;
  ramBuffer.cell[7] = v_2LDRouverture;
  ramBuffer.cell[8] = v_1LDRfermeture;
  ramBuffer.cell[9] = v_2LDRfermeture;
  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(" ");
}

//Mise au repos du moteur PAP
void moteurrepos (){
   digitalWrite (8, LOW);
   digitalWrite (9, LOW);  
   digitalWrite (10, LOW);
   digitalWrite (11, LOW);  
}

 


 

Cet article a 8 commentaires

  1. Billy

    Bonjour
    Super le tuto c’est se que je chercher
    Pourriez-vous me donnez des liens pour acheter les composants nécessaires au tuto
    Cordialement
    Merci

    1. steven

      Bonjour,
      Vous disposez des composants nécessaires dans le descriptif.
      Après, vous êtes libre de commander sur des plateformes françaises
      Ou à l’étranger si vous voulez des tarifs avantageux.
      Cordialement,

  2. Elo

    Bonjour je débute et je voudrais essayer de faire un portier automatique mais j’ai une question (sûrement bête) concernant le schéma de câblage : est ce que chaque câble= une couleur différente ? Je fais référence au câble noir sur le schéma qui est branché a plusieurs éléments.
    Merci d’avance

    1. steven

      Bonjour,
      Chaque câble à une couleur différence pour déjà éviter des erreurs de câblage lors de la lecture d’un schéma.
      Après le câble Noir et généralement la Masse (GND) il montre qu’il faut connecter tous les éléments qui sont dessus ensemble.
      Cordialement,

  3. ritonduino

    Bonjour.
    Juste une remarque : les liens fournis pour télécharger les librairies (DS1302, LiquidCrystal_I2C) pointent tous deux vers la même librairie LiquidCrystal_I2C.

    1. steven

      Bonjour,
      Merci, j’ai effectué la correction.
      Cordialement,

  4. Barnard

    Très beau projet que je suis en train d’essayer de mettre en œuvre. Je suis totalement novice concernant l’Arduino et la programmation.
    J’ai copié / collé le code et lorsque je fais « vérifier le code » il m’est indiqué :
    redefinition of ‘void setup()’ (en m’indiquant la ligne 39)
    Pouvez-vous m’indiquer ce qui ne va pas ?
    Cdt

    1. steven

      Bonjour,
      Vous avez du mal copier le code ou à la suite de l’exemple de base.
      Car le message indique que vous avez 2 fois la fonction void setup dans votre code.
      Il faut bien effacer complètement le code exemple de votre nouveau projet avant de copier le mien.
      Cordialement,

Laisser un commentaire