#include <Adafruit_SSD1306.h>

#define nombreDePixelsEnLargeur 128        // Taille de l'écran OLED, en pixel, au niveau de sa largeur
#define nombreDePixelsEnHauteur 64         // Taille de l'écran OLED, en pixel, au niveau de sa hauteur
#define brocheResetOLED         -1         // Reset de l'OLED partagé avec l'Arduino (d'où la valeur à -1, et non un numéro de pin)
#define adresseI2CecranOLED     0x3C       // Adresse de "mon" écran OLED sur le bus i2c (généralement égal à 0x3C ou 0x3D)
#define dirPin 1                           // broche de sens du moteur
#define stepPin 2                          // broche de pas
#define stepsPerRevolution 200             // Nombre de pas pour réaliser un tour
#define bPot A0                            // Broche potentiomètre
#define bp1 12                             // Bouton pussoir (simule la cellule)
#define relaisnf 4                         // Relais boucle de sécuritée
#define bp2 8                              // bouton poussoir marche reset
#define bp3 7                              // bouton Arret
#define SSD1306_BLACK 0                    // Draw 'off' pixels
#define SSD1306_WHITE 1                    // Draw 'on' pixels
#define SSD1306_INVERSE 2                  // Invert pixels
#define relaisverin 10                     // relais commande vérin"
#define bPot2 A1
#define AU 3   //test AU

int hyst1 = 190;                           //valeurs hystérésis pour niveau silicone
int hyst2 = 5;
int Pot;                                   // Valeur du potentiomètre
int dsignal;                               // Durée de la moitiée de la fréquence de fonctionnement du moteur
int compteur;                              // nombres de pas réaliser pour un cycle moteur
//int tempscycle = 500000;                 // Durée du temps d'un cycle moteur (en microsecondes) (pas fonctionnel)
int nbrplateautotal = 273;                 // nombre de plateau à nettoyer
int nbrplateausuivant = 0;                 // nombre de plateau nettoyer
uint8_t nivbarre = 126;
int def = 0;                               //default silicone
float vitesse = 0;

Adafruit_SSD1306 oled(nombreDePixelsEnLargeur, nombreDePixelsEnHauteur, &Wire, brocheResetOLED);

void setup()
{
  pinMode(AU, INPUT);           //test AU
  attachInterrupt(digitalPinToInterrupt(AU), stop, FALLING);  //test AU
  oled.begin(SSD1306_SWITCHCAPVCC, adresseI2CecranOLED);  //Démarrage de l'écran OLED
  oled.clearDisplay();
  oled.setTextColor(SSD1306_WHITE);
  oled. setTextSize(1);
  Serial.begin(115200);
  pinMode(stepPin, OUTPUT);                               // Entrée/Sortie
  pinMode(dirPin, OUTPUT);
  pinMode(bp1, INPUT);
  pinMode(bp2, INPUT);
  pinMode(bp3, INPUT);
  pinMode(relaisnf, OUTPUT);
  pinMode(relaisverin, OUTPUT);

  Serial.println("Appuyer sur bouton marche");

  oled.setCursor(1, 15);
  oled.print("Appuyer sur bouton   marche");
  oled.display();
  dns();                                              // appel de la fonction dns(démarrage niveau silicone)

  while (digitalRead(bp2) == LOW)                     // blocage du système si le pb2(marche) n'est pas actionner
  {

  }
  Serial.println("Pret a démarrer");
  delay(500);
  cleardemmarage();
  oled. setTextSize(3);
  oled.setCursor(10, 0);
  oled.print("Depart");
  oled.display();
  delay(1000);
  cleardepart();                                   // remise a zero de l'écran
  dhe();                                           // dhe(démarrage haut écran)
}

void loop()
{
  digitalWrite(dirPin, HIGH);                     // Sens du moteur

  niv();                                          //appel de la fonction qui gère la jauge de niveau du silicone
  float Pot2 = analogRead(bPot2) - 190; //500;       // lecture de la broche bPot2(A1) qui simule la jauge de silicone //-190 est pour l'adapatation du potentiomètre et de la résisatnce actuelle
  Pot = analogRead(bPot);//analogRead(bPot);      // Lecture de la valeur du potentiomètre bPot(A0) qui permet de regler la vitesse du moteur

  Pot = Pot * -14 + 16500;                 // Calcul de la moitier de la fréquence de fonctionnement du moteur
  dsignal = round(Pot);                    // Arrondi de la valeur Pot
  compteur = 500000 / (dsignal * dsignal);       // Calcul du nombre de cycle moteur à réaliser
  rpm();                                   // calcul est affichage de la vitesse du moteur sur l'écran

  while (digitalRead(bp1) == HIGH & nbrplateausuivant < nbrplateautotal & nbrplateausuivant >= 0 & def == 0 & Pot2 >= 190)   // la cellule détecte un plateau ? il y a du silicone ? (a modifier remplacement de la varable def par la lecture directement du potentiomètre pour savoir s'il y a du silicone)
  {
    digitalWrite(relaisverin, HIGH);            // pilotage du relais qui permet de controler la sortie des vérins
    compteur == compteur--;
    for (compteur ; compteur >= 0 ; compteur--) // <Cycle moteur
    {
      digitalWrite(stepPin, HIGH);             // Commande du moteur
      delayMicroseconds(dsignal);
      digitalWrite(stepPin, LOW);              // Commande du moteur
      delayMicroseconds(dsignal);

      if (compteur == 1)
      {
        nbrplateausuivant = nbrplateausuivant + 1;
        rem();
      }
    }
    delay(70);
    digitalWrite(relaisverin, LOW);              // arret du pilotage du relais ce qui fait rentrer les vérins a leurs positions initiales
    if (nbrplateausuivant == nbrplateautotal)
    {
      digitalWrite(relaisnf, HIGH);
      delay(200);
    }
  }
  if (digitalRead(bp2) == HIGH)                 // si bp2 est appuyé remise a zéro du comptage des plateau et fermeture du relaisnf de la boucle de sécuritée du trieur
  {
    nbrplateausuivant = 0;
    digitalWrite(relaisnf, LOW);
    rem();                                     // actualisation du nombre de plateaux après la remise a zéro
  }

  if (digitalRead(bp3) == HIGH)                 // si bp3 est appuyer (arret) ouverture boucle de sécu du trieur et blocage du système
  {
    nbrplateausuivant = 10000000;
    digitalWrite(relaisnf, HIGH);
    Serial.println("Arret machine");
    delay(200);
    digitalWrite(relaisnf, LOW);
  }
  hyst();

  oled.display();
}

void clear() {                              // Fonction qui permet de reset l'écran
  for (byte numeroLigne = 0 ; numeroLigne < nombreDePixelsEnHauteur ; numeroLigne++ ) {
    for (byte numeroColonne = 0 ; numeroColonne < nombreDePixelsEnLargeur ; numeroColonne++) {
      oled.drawPixel(numeroColonne, numeroLigne, 1);          // On demande l'allumage de chaque pixel, un à un, avec la commande : drawPixel(posX,posY,couleur);
    }
  }
  oled.display();
}

void cleardepart() {                      //Fonction d'affichage
  for (byte numeroLigne = 0 ; numeroLigne < 24 ; numeroLigne++) {
    for (byte numeroColonne = 0 ; numeroColonne < nombreDePixelsEnLargeur ; numeroColonne++) {
      oled.drawPixel(numeroColonne, numeroLigne, SSD1306_BLACK);              // On demande l'allumage de chaque pixel, un à un, avec la commande : drawPixel(posX,posY,couleur);
    }
    delayMicroseconds(10);
    oled.display();
  }
}

void cleardemmarage() {                  //Fonction d'affichage
  for (byte numeroLigne = 15 ; numeroLigne < 30 ; numeroLigne++) {
    for (byte numeroColonne = 0 ; numeroColonne < nombreDePixelsEnLargeur ; numeroColonne++) {
      oled.drawPixel(numeroColonne, numeroLigne, SSD1306_BLACK);
    }
    delayMicroseconds(10);
    oled.display();
  }
}

void dns() {                          //Fonction d'affichage
  oled.drawRoundRect(0, 44, 128, 20, 1, 1);
  oled.display();
}

void dhe() {                         //Fonction d'affichage
  oled.drawRoundRect(0, 0, 48, 20, 1, 1);
  oled.drawRoundRect(47, 0, 80, 20, 1, 1);
  oled.setTextColor(SSD1306_WHITE);
  oled.setTextSize(2);
  oled.setCursor(90, 3);
  oled.drawLine(84, 17, 89, 4, SSD1306_WHITE);
  oled.print(nbrplateautotal);
  for (byte numeroLigne = 45 ; numeroLigne < 64 ; numeroLigne++ ) {
    for (byte numeroColonne = 1 ; numeroColonne < nivbarre + 1 ; numeroColonne++) {
      oled.drawPixel(numeroColonne, numeroLigne, 1);          // On demande l'allumage de chaque pixel, un à un, avec la commande : drawPixel(posX,posY,couleur);
    }
  }
  oled.display();                                             //Rafraichisement de l'écran
}

void rem() {                                                //affichage nombre de plateau et pourcentage d'avencement
  static int lastNbrPlateauSuivant = -1;
  if (nbrplateausuivant != lastNbrPlateauSuivant) {
    lastNbrPlateauSuivant = nbrplateausuivant;
    oled.fillRect(2, 3, 45, 16, SSD1306_BLACK);
    oled.fillRect(48, 3, 35, 16, SSD1306_BLACK);
    oled.setCursor(2, 3);
    oled.setTextSize(2);
    int pp = round((float)nbrplateausuivant / nbrplateautotal * 100);
    oled.print(pp);
    oled.print("%");
    oled.setCursor(49, 3);
    oled.print(nbrplateausuivant);
  }
}

void rpm() {                                                    //Calcul vitesse moteur
  static float lastVitesse = 0;
  long abc = dsignal * 2;
  long abcd = abc * 200;
  float abcde = float(abcd) / 1000000;
  vitesse = 60 / abcde;

  if (vitesse != lastVitesse) {
    lastVitesse = vitesse;
    oled.fillRect(2, 22, 100, 22, SSD1306_BLACK);
    oled.setCursor(2, 22);
    oled.setTextSize(2);
    oled.print(vitesse);
  }
}

void niv() {                                                         // Jauge niveau de silicone
  static uint8_t lastNivBarre = 0;
  float Pot2 = analogRead(A1) / 8.127;
  Pot2 = round(Pot2) ;

  if (Pot2 != lastNivBarre) {
    lastNivBarre = Pot2;
    oled.fillRect(1, 45, 126, 18, SSD1306_BLACK);
    oled.drawRect(0, 44, 128, 20, SSD1306_WHITE);
    oled.fillRect(1, 45, Pot2, 18, SSD1306_WHITE);
  }
}

void stop() {                                                          //AU
  digitalWrite(relaisverin, LOW);
  while (1) {}
}

void hyst()                                                             //Hystérésis pour la mesure du niveau de silicone
{
  int Pot2 = analogRead(A1);
  if (Pot2 >= (hyst1 - hyst2)) {
    digitalWrite(relaisnf, LOW);
  }
  if (Pot2 <= (hyst1 + hyst2)) {
    digitalWrite(relaisnf, HIGH);
  }
}