/*

  ============================================
  code is placed under the MIT license
  Copyright (c) 2023 J-M-L
  For the Arduino Forum : https://forum.arduino.cc/u/j-m-l

  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:

  The above copyright notice and this permission notice shall be included in
  all copies or substantial portions of the Software.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  THE SOFTWARE.
  ===============================================


    Câblage

  PIN
   0  NC                        (Rx)
   1  NC                        (Tx)
   2  CLK                       encodeur réglage de l'angle de la vitesse actuelle de la boîte
   3  DT                        encodeur réglage de l'angle de la vitesse actuelle de la boîte
   4  SW                        bouton de l'encodeur sauvegarde des angles de la boîte
   5  pinServo                  pin 5 --- pin contrôle angle servo
   6  7 Segment 'a'             Prévoir résistance de limitation de courant (cf https://eskimon.fr/tuto-arduino-205-afficheurs-7-segments)
   7  7 Segment 'b'             Prévoir résistance de limitation de courant
   8  7 Segment 'c'             Prévoir résistance de limitation de courant
   9  7 Segment 'd'             Prévoir résistance de limitation de courant
  10  7 Segment 'e'             Prévoir résistance de limitation de courant
  11  7 Segment 'f'             Prévoir résistance de limitation de courant
  12  7 Segment 'g'             Prévoir résistance de limitation de courant
  13  Led interne               Allumée quand la confiuration a été modifiée et pas sauvegardée.
  A0  pinPalettePlus            pin A0 --- bouton --- GND
  A1  pinPaletteMoins           pin A1 --- bouton --- GND
  A2
  A3
  A4
  A5

*/

#include <EEPROM.h>
#include <Servo.h>
#include <Encoder.h>                                // https://www.pjrc.com/teensy/td_libs_Encoder.html
#include "simpleBouton.h"                           // cf @bricoleau @ http://forum.arduino.cc/index.php?topic=375232.0

const byte encoderCLKPin = 2;                       // CLK pin de l'encodeur réglage de l'angle du servo
const byte encoderDTPin  = 3;                       // DT  pin de l'encodeur réglage de l'angle du servo
const byte pinValidationReglage = 4;                // SW  pin de l'encodeur réglage de l'angle du servo
const byte pinServo = 5;                            // pin de contrôle du servo
const byte pin7Seg[] = {12, 11, 10, 9, 8, 7, 6};    // les pins de l'afficheur g,f,e,d,c,b,a + pensez aux résistances
const byte pinLed = 13;                             // la LED interne sur la pin 13 pour dire si besoin de sauvegarde
const byte pinPalettePlus = A0;                     // Cablage : pin A0 --- bouton --- GND
const byte pinPaletteMoins = A1;                    // Cablage : pin A1 --- bouton --- GND


// de 0 à 9 sous la forme 0babcdefg et un 11ème vide, sous la forme 0babcdefg
const byte chiffres7Seg[] = {
  /* 0 */ 0b1111110, /* 1 */ 0b0110000, /* 2 */ 0b1101101, /* 3 */ 0b1111001, /* 4 */ 0b0110011,
  /* 5 */ 0b1011011, /* 6 */ 0b0011111, /* 7 */ 0b1110000, /* 8 */ 0b1111111, /* 9 */ 0b1110011,
  /* x */ 0b0000000
};

const int16_t boiteDefaut[] = {700, 930, 1160, 1390, 1620, 1850, 2080};  // les valeurs par défaut d'angles en  µs
constexpr byte nombreDeVitesses = sizeof boiteDefaut / sizeof * boiteDefaut;
const int minAngle = 700;
const int maxAngle = 2300;
const uint32_t motMagique = 0xDED1CACE;
const int adresseDebutEeprom = 0;
const int nbImpulsionsParClickEncodeur = 4; // On a un encodeur qui envoie 4 impulsions par ticks

struct Parametres {
  uint32_t sentinelle;                      // pour savoir si l'EEPROM a déjà été initialisée
  int16_t boite[nombreDeVitesses];          // les valeurs d'angles en µs
};

Parametres parametres;

Servo levierVitesse;

Encoder encodeur(encoderDTPin, encoderCLKPin);                   // pour modifier les réglages
simpleBouton boutonValidationReglage(pinValidationReglage);     // enregistrer les réglages
bool parametresModifies = false;

simpleBouton boutonPlus(pinPalettePlus);                        // le changement de vitesse +
simpleBouton boutonMoins(pinPaletteMoins);                      // le changement de vitesse -

byte vitesse  = 0;  // vitesse par défaut


void lireParametres() {
  Parametres config;
  EEPROM.get(adresseDebutEeprom, config);
  if (config.sentinelle == motMagique) {
    // on avait en EEPROM une configuration déjà correcte
    parametres = config; // on utilise la config EEPROM comme paramètrage
    Serial.println(F("J'ai relu la config en EEPROM"));
  } else {
    // le mot magique n'est pas là, c'est la première fois qu'on utilise cet Arduino
    parametres.sentinelle = motMagique;
    memcpy(parametres.boite, boiteDefaut, sizeof parametres.boite);
    EEPROM.put(adresseDebutEeprom, parametres); // on met à jour l'EEPROM avec la config par défaut
    Serial.println(F("J'ai établi la configuration par défaut en EEPROM."));
  }
  parametresModifies = false;
}

void sauverReglages() {
  if (parametresModifies) {
    EEPROM.put(adresseDebutEeprom, parametres); // on met à jour l'EEPROM avec la config par défaut
    digitalWrite(pinLed, LOW);
    parametresModifies = false;
    Serial.println(F("J'ai sauvegardé la configuration courante en EEPROM."));
  } else {
    Serial.println(F("Demande de sauvegarde EEPROM ignorée."));
  }
}

void affichageChiffre(byte chiffre) { // de 0 à 9
  if (chiffre >= sizeof chiffres7Seg) chiffre = (sizeof chiffres7Seg) - 1; // le dernier n'a aucun affichage
  for (byte b = 0; b < sizeof pin7Seg; b++) digitalWrite(pin7Seg[b], bitRead(chiffres7Seg[chiffre], b) ? HIGH : LOW);
}


inline void reglerVitesse() {
  levierVitesse.writeMicroseconds(parametres.boite[vitesse]);
  affichageChiffre(vitesse);
  Serial.print(F("Vitesse ")); Serial.print(vitesse);
  Serial.print(F("\tangle ")); Serial.println(parametres.boite[vitesse]);
}

bool modificationEncodeur() {
  long nbImpulsionsEncodeur = encodeur.read();        // la valeur brute en nombre d'impulsions
  long deltaAngle = nbImpulsionsEncodeur / nbImpulsionsParClickEncodeur; // la modification à apporter
  if (deltaAngle != 0) { // on a touché au réglage
    int16_t nouvelleVitesse = parametres.boite[vitesse] + deltaAngle;
    nbImpulsionsEncodeur -= deltaAngle * nbImpulsionsParClickEncodeur; // on conserve ainsi les sous ticks déjà acquis
    encodeur.write(nbImpulsionsEncodeur);
    if (nouvelleVitesse > maxAngle) nouvelleVitesse = maxAngle;
    else if (nouvelleVitesse  < minAngle) nouvelleVitesse = minAngle;
    if (parametres.boite[vitesse] != nouvelleVitesse) {
      // il y a eu un changement
      parametres.boite[vitesse] = nouvelleVitesse;
      parametresModifies = true;
      digitalWrite(pinLed, HIGH);
      reglerVitesse();
      return true;
    }
  }
  return false;
}

void vitessePlus() {
  if (vitesse < nombreDeVitesses - 1) {
    vitesse++;
    reglerVitesse();
  }
}

void vitesseMoins() {
  if (vitesse > 0) {
    vitesse--;
    reglerVitesse();
  }
}

void gestionPalettes() {
  boutonPlus.actualiser();
  if (boutonPlus.vientDEtreEnfonce()) vitessePlus();
  else {
    boutonMoins.actualiser();
    if (boutonMoins.vientDEtreEnfonce()) vitesseMoins();
  }
}

void gestionAngle() {
  if (modificationEncodeur()) {

  }
  boutonValidationReglage.actualiser();
  if (boutonValidationReglage.vientDEtreEnfonce()) sauverReglages();
}

void setup() {
  pinMode(pinLed, OUTPUT);
  digitalWrite(pinLed, LOW);
  for (byte b = 0; b < sizeof pin7Seg; b++) pinMode(pin7Seg[b], OUTPUT);
  Serial.begin(115200);
  lireParametres();
  reglerVitesse();
  levierVitesse.attach(pinServo);
}

void loop() {
  gestionPalettes();
  gestionAngle();
}