//******************************************************************************************
// TIME LAPS
// Page descriptive sur http://www.rotilom.com/F6IDT/sequenceur.htm 

// Mode d'emploi:
//
// A la mise sous tension, l'afficheur indique la durée mémorisée en secondes.
// En appuyant sur le bouton, le décomptage démarre. Arrivé à zéro,
// affichage Clic et collage du relais "FOCUS" pendant 1/2 seconde
// puis collage du relais "RIDEAU" pendant 1/2 seconde.
// Le cycle redémarre automatiquement jusqu'à la mise hors tension.
// Un interrupteur permet de diminuer la luminosité de l'afficheur pendant
// le décomptage sauf pendant la seconde où s'opèrent la mise au point
// et la prise de vue.
//
// Pour modifier le temps, après la mise sous tension, il suffit de tourner
// le bouton dans un sens ou dans l'autre et ensuite d'appuyer dessus pour
// mettre en mémoire et démarrer le décomptage.
// Pendant le décomptage, le codeur et son poussoir sont inactifs.
// Pour régler au mieux la précision, il faut utiliser un chronomètre et ajuster
// la valeur numérique à la ligne 115.
//******************************************************************************
#include <TM1637Display.h>  // Gestion de l'afficheur.
#include <EEPROM.h>         // Réservation d'espace dans l'EEPROM.

byte bouton_dim = 5;        // Inverseur diminution luminosité affichage.
byte bouton_codeur = 6;     // Validation par appui sur le bouton du codeur.
byte codeur_dwn = 7;        // Décrémentation menu sens descente.
byte codeur_up = 8;         // Incrémentation menu sens montée.
byte relais_focus = 9;      // Sortie pour le relais mise au point (FOCUS).
byte relais_rideau = 10;    // Sortie pour le relais déclanchement (RIDEAU).

#define CLK 2               // Synchro horloge de l'afficheur.
#define DIO 3               // Données de l'afficheur.

uint8_t seg_on[] = { 0xff, 0xff, 0xff, 0xff }; // Tous les segments allumés pour test
const uint8_t SEG_Clic[] =
{
SEG_A | SEG_D | SEG_E | SEG_F, // C
SEG_E | SEG_F,                 // l
SEG_E,                         // i
SEG_D | SEG_E | SEG_G          // c
};

TM1637Display display(CLK, DIO); // Raccordement de l'afficheur.

int sec;    // Variables secondes.

bool clkState  = LOW; // Etat impulsion encodeur.
bool clkLast  = HIGH; // Etat dernière impulsion encodeur.
bool swState  = LOW;  // Etat interpulse encodeur.
bool swLast  = LOW;   // Etat dernière interpulse encodeur.
//************************************************************************
void setup()        // Direction et attribution des pins.
{
  pinMode(codeur_dwn, INPUT); 
  pinMode(codeur_up, INPUT);
  pinMode(bouton_codeur, INPUT);
  pinMode(bouton_dim, INPUT);
  pinMode(relais_focus, OUTPUT);
  pinMode(relais_rideau, OUTPUT);
  sec = 10;
  display.setBrightness(5);              // Réglage luminosité sur l'afficheur.
  EEPROM.get(05,sec);                    // Lecture des secondes mémorisées dans l'EEprom.
  display.setSegments(seg_on);           // Test afficheur
  delay(1000); 
  display.showNumberDec(sec);            // Affichage du temps enregistré.
//  if (digitalRead(bouton_codeur)==HIGH)  // Si le temps enregistré convient, on appui sur le bouton,
//  {
//  sec = sec + 1;                         // on ajoute 1 seconde.
//  decompt();                             // et on passe au décomptage, sinon on tourne le bouton.
//  }
}
      
//********************************************************************
void loop()    // Modification du temps
{
clkState = digitalRead(codeur_dwn);    // Suivant sens de rotation.
  if ((clkLast == LOW) && (clkState == HIGH))
  {  
    if (digitalRead(codeur_up) == HIGH)
      {
        sec--;                  // Décrémentation des secondes.
        if (sec < 0)            // pour éviter les chiffres négatifs.
          {  
           sec = 0;
          }
       }         
    else
      {
        sec++;                   // Incrémentation des secondes. 
      }
     display.showNumberDec(sec); // Affichage des secondes
     delay(50);
  }
  
clkLast = clkState;                     // Mémorisation de l'ancienne position du codeur.
 
  if (digitalRead(bouton_codeur)==HIGH) // Quand le temps a été choisi, on appuie sur le bouton.
   {
    EEPROM.put(05, sec);                // le temps est mémorisé dans l'EEprom,
    sec = sec + 1;                      // on ajoute 1 seconde     
    decompt();                          // et on passe au décomptage.
   }
}
//*****************************************************************
void decompt()  // Sous-programme de décomptage
{
  if (digitalRead(bouton_dim)==LOW)   // Si l'inverseur est sur DIM,
  {
   display.setBrightness(0);          // on diminue la luminosité de l'afficheur   
  }
sec--;
display.showNumberDec(sec);           // Affichage des secondes restantes.
delay (982);                          // VALEUR A AJUSTER suivant la dérive constatée.
    if ((sec)== 1)                    // Si on arrive à la fin du décomptage,
     {                    
      photo();                        // on prend la photo,
      EEPROM.get(05,sec);             // Lecture des secondes mémorisées dans l'EEprom. 
      display.showNumberDec(sec);     // Affichage du temps enregistré moins 1 seconde.
    if (digitalRead(bouton_dim)==LOW) // Si l'inverseur est sur DIM,
    {
     display.setBrightness(0);        // on diminue la luminosité de l'afficheur   
    }  
      decompt();                      // et on repasse au décomptage.      
     }
decompt();                            // sinon on continue à décompter.
}
//*****************************************************************
void photo()    // Prise de vue.
{
  display.setBrightness(5);           // Allumage afficheur
  display.setSegments(SEG_Clic);      // Affiche "Clic".
  digitalWrite (relais_focus, HIGH);  // On actionne le relais FOCUS,
  delay(500);                         // 1/2 seconde pour la mise au point.
  digitalWrite (relais_rideau, HIGH); // On actionne le relais RIDEAU,
  delay(500);                         // 1/2 seconde pour le déclanchement.
  digitalWrite (relais_focus, LOW);   // Relais FOCUS au repos.
  digitalWrite (relais_rideau, LOW);  // Relais RIDEAU au repos.
}