/*
   ******************************************
   *           Module de réglage            *
   *             des courses                *
   *            de sero-moteur              *
   *                                        *
   *   Application => réglage des angles    *
   *            des aiguillages             *
   * Lecture des valeurs sur écran Oled I2C *
   ******************************************

   !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
   ! Licence d’utilisation – Philippe Guenet                                                     !
   !                                                                                             !
   ! Ce code est librement téléchargeable pour un usage personnel et non commercial.             !
   !                                                                                             !
   ! Toute utilisation commerciale, professionnelle ou rémunérée est interdite.                  !
   !                                                                                             !
   ! La redistribution, la copie publique ou l’intégration dans un autre projet                  !
   ! sont interdites.                                                                            !
   !                                                                                             !
   ! Aucune modification ou adaptation n’est autorisée sans l’accord écrit préalable             !
   ! de l’auteur.                                                                                !
   !                                                                                             !
   ! L’auteur conserve tous les droits de propriété intellectuelle sur ce code.                  !
   !                                                                                             !
   ! L’auteur ne saurait être tenu responsable d’aucun dommage résultant de                      !
   ! l’utilisation de ce code.                                                                   !
   !                                                                                             !
   ! L’utilisation du code vaut acceptation de ces conditions.                                   !
   !                                                                                             !
   ! © Philippe Guenet – Tous droits réservés - [email protected] - https://wgnt-train.fr   !
   !                                                                                             !
   !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
*/

#include <Wire.h>                      // Librairie pour I2C
#include <Adafruit_GFX.h>              // Librairie graphique de base
#include <Adafruit_SSD1306.h>          // Librairie pour l'OLED
#include <Servo.h>                     // Librairie standard pour le servomoteur

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64

// Initialisation de l'écran OLED
// Vérifiez les broches SCL/SDA pour Tiny88 (exemple : SDA = A4, SCL = A5)
Adafruit_SSD1306 oled(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

// Définition des pins (à adapter selon votre câblage sur Tiny88)
const int potPin = A1;    // Pin du potentiomètre
const int buttonPin = 2;  // Pin du bouton poussoir
const int servoPin = 9;   // Pin du servomoteur
const int ledPin = 13;    // LED utilisée pour indiquer le mode

// Définition des constantes pour les angles
const int angleMini = 500;
const int angleMaxi = 2500;
const int angleMilieu = (angleMini + angleMaxi) / 2;

Servo monServo;

// Variables pour le mode "hold" et le clignotement de la LED
bool holdMode = false;
unsigned long lastBlinkMillis = 0;
const unsigned long BLINK_INTERVAL = 300; // Intervalle clignotement en ms
bool ledState = LOW;

// Variables pour la gestion des rebonds du bouton
unsigned long lastDebounceTime = 0;
unsigned long debounceDelay = 10;  // Délai de debounce en ms
int lastButtonState = HIGH;        // État précédent du bouton (PULLUP)
int buttonState;                   // État actuel du bouton

void setup() {
  Serial.begin(9600);
  Serial.print(F("Gestion servomoteur PG/20260125"));
   
  // Initialisation du bouton (sans Bounce2)
  pinMode(buttonPin, INPUT_PULLUP);
 
  // Initialisation du servomoteur 2
  if (!monServo.attached()) {monServo.attach(servoPin); delay(200);} 

  // Initialisation de la LED
  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, LOW);

  // Initialisation de l'écran OLED
  // Vérifiez l'adresse I2C (0x3C ou 0x3D selon votre OLED)
  if(!oled.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println(F("SSD1306 allocation failed"));
    for(;;);
  } // Fin de if(!oled.begin(SSD1306_SWITCHCAPVCC, 0x3C))
  oled.clearDisplay();
  oled.setTextSize(1);
  oled.setTextColor(WHITE);
  oled.setCursor(10, 0);
  oled.println(F("Gestion servomoteur"));
  oled.setCursor(30, 10);
  oled.println(F("PG/20260125"));
  oled.setCursor(50, 20);
  oled.println(F("PRET"));
  oled.display();

  monServo.writeMicroseconds(angleMilieu);
  delay(500);
} // Fin de setup()

void loop() {
  // Lecture de l'état du bouton
  int reading = digitalRead(buttonPin);

  // Gestion des rebonds
  if (reading != lastButtonState) {
    lastDebounceTime = millis();
  } // Fin de if (reading != lastButtonState)

  if ((millis() - lastDebounceTime) > debounceDelay) {
    if (reading != buttonState) {
      buttonState = reading;
      if (buttonState == LOW) { // Appui détecté (PULLUP)
        holdMode = !holdMode;
        if (holdMode) {
          monServo.writeMicroseconds(angleMilieu);
          afficherAngle(angleMilieu);
          lastBlinkMillis = millis();
          ledState = HIGH;
          digitalWrite(ledPin, ledState);
        } else {
          ledState = LOW;
          digitalWrite(ledPin, ledState);
        } // Fin de if (holdMode)
      } // Fin de if (buttonState == LOW)
    } // Fin de if (reading != buttonState)
  } // Fin de if ((millis() - lastDebounceTime) > debounceDelay) 
  lastButtonState = reading;

  // Clignotement de la LED en mode hold
  if (holdMode) {
    unsigned long now = millis();
    if (now - lastBlinkMillis >= BLINK_INTERVAL) {
      lastBlinkMillis = now;
      ledState = !ledState;
      digitalWrite(ledPin, ledState);
    } // Fin de if (now - lastBlinkMillis >= BLINK_INTERVAL)
    monServo.writeMicroseconds(angleMilieu);
    afficherAngle(angleMilieu);
  } else {
    // Mode normal : lecture du potentiomètre
    int potValue = analogRead(potPin);
    int servoValue = map(potValue, 0, 1023, angleMini, angleMaxi);
    monServo.writeMicroseconds(servoValue);
    afficherAngle(servoValue);
  } // Fin de if (holdMode)

  delay(100);
} // in de loop()

void afficherAngle(int angle) {
  oled.clearDisplay();
  oled.setCursor(0, 0);
  oled.print(F("Angle : "));
  oled.println(angle);
  oled.display();
} // Fin de procédure afficherAngle(int angle)