/*
  Horloge binaire
  Utilise 3 74HC595 pour gérer l'affichage Heure minutes secondes
  On gère l'affichage sur colonnes separees pour les dizaines et les unites, afin de faciliter la lecture
*/

//Pin connected to latch pin (ST_CP) of 74HC595
const int latchPin = 8;
//Pin connected to clock pin (SH_CP) of 74HC595
const int clockPin = 12;
////Pin connected to Data in (DS) of 74HC595
const int dataPin = 11;

//Pin recevant les ticks d'horloge (1Hz)
const int Clock = 3;

//Pin boutton poussoir reglage heure
const int BouttonH = 7;
const int BouttonM = 6;

const int MULTIPLEX = 5; //delai de boucle pour le multiplexage en milliseconde

// On garde l'état précédent de la clock : S'il était à 0 et que la clock est à 1, on est sur un nouveau top, sinon, c'est toujours le même top.
int last_state = 0;
int cur_state = 0; //l'etat actuel de la Clock
int demisec = 0;
int increment = 0; //s'il faut incrémenter le compteur, increment vaut 1.

//On gère les dizaines et les unités séparement car elles ne font pas parties de la meme colonne d'affichage.
int HeureD = 0;
int HeureU = 0;
int MinuteD = 0;
int MinuteU = 0;
int SecondeD = 0;
int SecondeU = 0;

//Variables pour les conversion binaires
int bSecondeD = 0;
int bSeconde = 0;
int bMinuteD = 0;
int bMinute = 0;
int bHeureD = 0;
int bHeure = 0;

//Variables d'etat des boutons
int sBouttonH = 1; //etat du boutton de reglage heure (1 = relache)
int clkBouttonH = 0; //on memorise depuis combien de top est appuyé le bouton
int sBouttonM = 1;
int clkBouttonM = 0;

//variable pour le multiplexage :
// on n'eclaire pas toutes les leds en meme temps, on le fait bloc par blog (HH, puis MM, puis SS)
int multiplex = 0;

//Variable de debug : Si debug = 1, alors on active le port serie.
int debug = 0;

void setup() {
  pinMode(latchPin, OUTPUT);
  pinMode(dataPin, OUTPUT);  
  pinMode(clockPin, OUTPUT);
  pinMode(Clock, INPUT);
  pinMode(BouttonH, INPUT);
  if(debug == 1)
    Serial.begin(9600);
  last_state = digitalRead(Clock);
}

void loop() {
  
// est-on sur un nouveau top ?
cur_state = digitalRead(Clock);

//est-ce qu'un boutton est appuyé ?
sBouttonH = digitalRead(BouttonH);
if(sBouttonH == 1)//si le boutton H a ete relache, on remet tout a 0
  clkBouttonH = 0;
sBouttonM = digitalRead(BouttonM);
if(sBouttonM == 1)//si le boutton M a ete relache, on remet tout a 0
  clkBouttonM = 0;

if(debug == 1)
Serial.println("debut top");

if((cur_state == 1) && (last_state == 0)) // Si l'horloge viens de passer à 1, on est sur un top
demisec = demisec++;
if(demisec > 1)
//On a besoin de 2 tops pour une seconde
  {
    increment = 1; // on va donc pouvoir incrementer le compteur
    last_state = cur_state; //on met à jour last_state
    //Et on en profite pour vérifier depuis combien de temps le bouton est appuyé
    if(sBouttonH == 0)
      {
        clkBouttonH = clkBouttonH++;
        //si Le bouton était déjà appuyé la seconde precedente, alors on incremente.
        if(clkBouttonH > 2)
          {
            //on incremente l'heure
              if(HeureU < 11)
                 HeureU = HeureU++;
               if(HeureU == 4 && HeureD == 2) //minuit, on remet tout à 0
                 {
                     HeureU = 0;
                     HeureD = 0;
                 }
               else if(HeureU == 10)
                 {
                     HeureD = HeureD++;
                     HeureU = 0;
                 }
          }
      }
      //idem pour les minutes
          if(sBouttonM == 0)
      {
        clkBouttonM = clkBouttonM++;
        //si Le bouton était déjà appuyé la seconde precedente, alors on incremente.
        if(clkBouttonM > 2)
          {
            //on incremente les minutes
              if(MinuteU < 11)
               MinuteU = MinuteU ++;
              if(MinuteU == 10)
               {
                 MinuteD = MinuteD++;
                 MinuteU = 0;
               }
             if(MinuteD == 6) //on ne depasse pas les 60 minutes...
               {
                 MinuteD = 0;
               }
          }
      }
          
  }
 else
   {
     last_state = cur_state; //sinon, on se contente de rafraichir last_state
   }
  
 
/// Si on doit incrémenter l'horloge : 
if(increment == 1)
{
  
  if(SecondeU < 11)
    SecondeU = SecondeU ++;
  if(SecondeU == 10)
    {
      SecondeD = SecondeD++;
      SecondeU = 0;
    }
   if(SecondeD == 6)
     {
       SecondeD = 0; //on remet le compteur des secondes à 0;
       if(MinuteU < 11)
         MinuteU = MinuteU ++;
       if(MinuteU == 10)
         {
           MinuteD = MinuteD++;
           MinuteU = 0;
         }
       
       if(MinuteD == 6)
         {
           MinuteD = 0;
             if(HeureU < 11)
               HeureU = HeureU++;
             if(HeureU == 4 && HeureD == 2) //minuit, on remet tout à 0
               {
                   HeureU = 0;
                   HeureD = 0;
               }
             else if(HeureU == 10)
               {
                   HeureD = HeureD++;
                   HeureU = 0;
               }
         }
           
     }
  //on a finit d'incrementer, on repasse donc le flag increment à 0
  increment = 0;
  //On repasse demisec = 0
  demisec = 0;
  //on met à jour l'affichage
  if(debug == 1)
  {
    Serial.print(HeureD);
    Serial.print(HeureU);
    Serial.print(":");
    Serial.print(MinuteD);
    Serial.print(MinuteU);
    Serial.print(":");
    Serial.print(SecondeD);
    Serial.println(SecondeU); 
  }
  
  //on convertis l'affichage en binaire , de maniere a ce que les dizaines et unites tiennent sur 1 octet
  bSecondeD = SecondeD << 4; //decalage a gauche de 4 bit pour les dizaines
  bSeconde = bSecondeD | SecondeU;  //OU logique pour "assembler" les dizaines et les unites
  bMinuteD = MinuteD << 4;
  bMinute = bMinuteD | MinuteU;
  bHeureD = HeureD << 4;
  bHeure = bHeureD | HeureU;
  if(debug == 1)
  {
    Serial.print("Binaire Heures:Minutes:Secondes  ");
    Serial.print(bHeure,BIN);
    Serial.print(":");
    Serial.print(bMinute,BIN);
    Serial.print(":");
    Serial.println(bSeconde,BIN);
    Serial.print("Etat du bouton Heures :");
    Serial.println(sBouttonH);
    Serial.print("Etat du bouton Minutes :");
    Serial.println(sBouttonM);
  }
}  
  ////on envoie l'heure sur le 74HC595
  digitalWrite(latchPin, LOW);
  //on multiplexe l'affichage
  
  if(multiplex == 0)
  {
    shiftOut(dataPin, clockPin, MSBFIRST, bHeure);//on envoie les heures
    shiftOut(dataPin, clockPin, MSBFIRST, 0);//on envoie les minutes
    shiftOut(dataPin, clockPin, MSBFIRST, 0);//on envoie les secondes
  }
  if(multiplex == 1)
  {
    shiftOut(dataPin, clockPin, MSBFIRST, 0);//on envoie les heures
    shiftOut(dataPin, clockPin, MSBFIRST, bMinute);//on envoie les minutes
    shiftOut(dataPin, clockPin, MSBFIRST, 0);//on envoie les secondes
  }
  if(multiplex == 2)
  {
    shiftOut(dataPin, clockPin, MSBFIRST, 0);//on envoie les heures
    shiftOut(dataPin, clockPin, MSBFIRST, 0);//on envoie les minutes
    shiftOut(dataPin, clockPin, MSBFIRST, bSeconde);//on envoie les secondes
  }
  multiplex = multiplex++;
  if(multiplex>2)
    multiplex = 0;
  /* 
  // shift the bytes out:
  shiftOut(dataPin, clockPin, MSBFIRST, bHeure);//on envoie les heures
  shiftOut(dataPin, clockPin, MSBFIRST, bMinute);//on envoie les minutes
  shiftOut(dataPin, clockPin, MSBFIRST, bSeconde);//on envoie les secondes
  */
  digitalWrite(latchPin, HIGH);
  if(debug == 1)
  {
  
  Serial.print("multiplex : ");
  Serial.println(multiplex);
  }


//on attend quelques millisecondes, pour pas saturer l'arduino (surtout utile en cas d'utilisation du port serie)
  delay(MULTIPLEX);

}