/*
     minuterie exposition tubes uv pour procédés photographique
*/

#include <Wire.h>
#include <LiquidCrystal_I2C.h>


#define pinArduinoRaccordementSignalSW  2       // La pin D2 de l'Arduino recevra la ligne SW du module KY-040
#define pinArduinoRaccordementSignalCLK 3       // La pin D3 de l'Arduino recevra la ligne CLK du module KY-040
#define pinArduinoRaccordementSignalDT  4       // La pin D4 de l'Arduino recevra la ligne D
#define uvc61 5      // relais pour les leds UV 650 nm
#define uvc62 6
#define uvc63 7
#define uvc64 8
#define uvc81 9     // relais pour les leds UV 810 nm
#define uvc82 10
#define uvc83 11
#define uvc84 12


#define MAX_Process  20                        // nombre de procédés différents

char description [20][35] = {
  "Cyanotype", "Van Dijck Brown", "Gomme bichromatee", "Puretch trame",
  "Puretch image", "Tok solar trame", "Tok solar image", "Film ..... trame",
  "Film ...... image", "Plaque verte trame", "Plaque verte image", "essai_6  5 sec",
  "essai_6 10 sec", "essai_6 20 sec", "essai_6 40 sec", "essai_6 80 sec",
  "essai_8  5 sec", "essai_8 10 sec", "essai_8 20 sec", "essai_8 40 sec"
};     // nom du procédé
int exposition6 [20] = {
  101, 102, 103, 104,
  105, 106, 107, 108,
  109, 110, 15, 5,
  10, 20, 40, 80,
  0, 0, 0, 0
};     //exposition led 625nm  en secondes
int exposition8 [20] = {
  21, 22, 3, 14,
  125, 16, 37, 18,
  109, 10, 8, 0,
  0, 0, 0, 0,
  5, 10, 20, 40
};             //exposition led 815nm  en secondes

int Program_index = 0 ;
bool changeindex = 0;
int Expose = 0;
// int etatPrecedentLigneSW;           // Cette variable nous permettra de stocker le dernier état de la ligne SW, afin de le comparer à l'actuel
int typeDexposition = 0;                   // Cette variable nous permettra de compter combien de crans ont été parcourus, sur l'encodeur
int Exp6 = 0;      //temps exposition 650 nm
int Exp8 = 0;      //temps exposition 810 nm
bool Stop6 = 0;    //fin exposition 650 nm
bool Stop8 = 0;    //fin exposition 810 nm                                     // (sachant que nous compterons dans le sens horaire, et décompterons dans le sens antihoraire)

LiquidCrystal_I2C lcd(0x27, 20, 4);

void setup ()
{
  Serial.begin(115200);
  lcd.init();
  lcd.backlight();

  pinMode(pinArduinoRaccordementSignalSW, INPUT_PULLUP);
  pinMode(pinArduinoRaccordementSignalDT, INPUT);
  pinMode(pinArduinoRaccordementSignalCLK, INPUT);
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(uvc61, OUTPUT);
  pinMode(uvc62, OUTPUT);
  pinMode(uvc63, OUTPUT);
  pinMode(uvc64, OUTPUT);
  pinMode(uvc81, OUTPUT);
  pinMode(uvc82, OUTPUT);
  pinMode(uvc83, OUTPUT);
  pinMode(uvc84, OUTPUT);
  digitalWrite(uvc61, LOW);
  digitalWrite(uvc62, LOW);
  digitalWrite(uvc63, LOW);
  digitalWrite(uvc64, LOW);
  digitalWrite(uvc81, LOW);
  digitalWrite(uvc82, LOW);
  digitalWrite(uvc83, LOW);
  digitalWrite(uvc84, LOW);
  delay (250);
  // Mémorisation de la valeur initiale de la ligne SW, au démarrage du programme
  // etatPrecedentLigneSW  = digitalRead(pinArduinoRaccordementSignalSW);
  attachInterrupt(digitalPinToInterrupt(pinArduinoRaccordementSignalCLK), changementDetecteSurLigneCLK, FALLING); // FALLING => détecte tout front descendant
  attachInterrupt(digitalPinToInterrupt(pinArduinoRaccordementSignalSW), changementDetecteSurLigneSW, FALLING);    // CHANGE => détecte tout changement d'état

  lcd.setCursor(0, 0);
  lcd.print(" BOX EXPOSITION UV");
  affiche_lcd(0);
}

void loop()
{
  if (changeindex == 1)
  {
    affiche_lcd(typeDexposition);
    changeindex = 0;
  }

  if (Expose == 1)
  {
    if (Exp6 > 0)
    {
      Allume650();
      Exp6 --;
    }
    else
      Eteint650();
    if (Exp8 > 0)
    {
      Allume810();
      Exp8 --;
    }
    else
      Eteint810();

    Serial.print(F("Exp6 "));
    Serial.print(Exp6);
    Serial.print(F("   Exp8 "));
    Serial.println(Exp8);
    delay(100);
  }

  if (Exp6 == 0 && Exp8 == 0)
  {
    // Eteint650();
    // Eteint810();
    Expose = 0;
    digitalWrite(LED_BUILTIN, LOW);
  }
}

void eff_ligne (int ligne)
{
  lcd.setCursor(0, ligne - 1);
  lcd.print( "                   ");
}

void affiche_lcd(int index) {
  eff_ligne(2);
  eff_ligne(3);
  eff_ligne(4);
  lcd.setCursor(0, 1);
  lcd.print(description[index]);
  lcd.setCursor (0, 2);
  lcd.print(exposition6[index]);
  lcd.setCursor (0, 3);
  lcd.print(exposition8[index]);
}

void changementDetecteSurLigneCLK() {
  // Lecture de la ligne DT, issue du KY-040, et arrivant sur l'arduino
  int etatActuelDeLaLigneDT  = digitalRead(pinArduinoRaccordementSignalDT);
  int etatActuelDeLaLigneCLK = LOW;
  // Nota : ici, la ligne CLK est forcément au niveau bas (0V), du fait qu'on entre dans cette routine
  //        que sur front descendant de CLK (donc passage de 1 à 0)

  // On compare ensuite l'état des lignes CLK et DT
  // ----------------------------------------------
  // Nota : - si CLK est différent de DT, alors cela signifie que nous avons tourné l'encodeur dans le sens horaire
  //        - si CLK est égal à DT, alors cela signifie que nous avons tourné l'encodeur dans le sens antihoraire

  if (etatActuelDeLaLigneCLK != etatActuelDeLaLigneDT) {
    // CLK différent de DT => cela veut dire que nous tournons dans le sens horaire
    // Alors on incrémente le typeDexposition
    typeDexposition++;
    if (typeDexposition > (MAX_Process - 1))  {
      typeDexposition = 0;
    }
  }
  else {
    // CLK est identique à DT => cela veut dire que nous tournons dans le sens antihoraire
    // Alors on décrémente le typeDexposition
    typeDexposition--;
    if (typeDexposition < 0 )  {
      typeDexposition = MAX_Process - 1;
    }

  }
  changeindex = true;

}


// ====================================================
// Routine d'interruption : changementDetecteSurLigneSW
// ====================================================
void changementDetecteSurLigneSW() {

  // On lit le nouvel état de la ligne SW
  // int etatActuelDeLaLigneSW = digitalRead(pinArduinoRaccordementSignalSW);

  // On mémorise le nouvel état de la ligne SW, puisqu'il vient de changer (sans quoi nous ne serions pas dans cette routine d'interruption)
  // etatPrecedentLigneSW = etatActuelDeLaLigneSW;

  // Puis on affiche le nouvel état de SW sur le moniteur série de l'IDE Arduino
  // if (etatActuelDeLaLigneSW == LOW)
  Expose = 1;
  Exp6 = exposition6[typeDexposition];
  Exp8 = exposition8[typeDexposition];
  digitalWrite(LED_BUILTIN, HIGH);
}

// Nota : en pratique, sans "filtre anti-rebond", vous noterez qu'il y a parfois pas mal de comptes/décomptes non souhaités, en l'état
void Allume650()
{
  digitalWrite(uvc61, HIGH);
  digitalWrite(uvc62, HIGH);
  digitalWrite(uvc63, HIGH);
  digitalWrite(uvc64, HIGH);
}

void Eteint650()
{
  digitalWrite(uvc61, LOW);
  digitalWrite(uvc62, LOW);
  digitalWrite(uvc63, LOW);
  digitalWrite(uvc64, LOW);
}
void Allume810()
{
  digitalWrite(uvc81, HIGH);
  digitalWrite(uvc82, HIGH);
  digitalWrite(uvc83, HIGH);
  digitalWrite(uvc84, HIGH);
}

void Eteint810()
{
  digitalWrite(uvc81, LOW);
  digitalWrite(uvc82, LOW);
  digitalWrite(uvc83, LOW);
  digitalWrite(uvc84, LOW);
}