//ADOLFO DANIEL ALUMNO DE UPTEX
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <ESP32Servo.h>

LiquidCrystal_I2C lcd(0x27, 20, 4);

const int botonStart = 35;
const int botonStop = 34;
const int botonIncrementarGrados = 19;
const int botonDecrementarGrados = 18;
const int botonIncrementarVelocidad = 2;
const int botonDecrementarVelocidad = 15;
const int botonIncrementarRep = 17;
const int botonDecrementarRep = 16;
const int servoPin = 12;

int grados = 80;
int velocidad = 1;
int repeticiones = 1;

const int maxGrados = 150;
const int minGrados = 80;
const int maxVelocidad = 10;
const int minVelocidad = 1;
const int maxRepeticiones = 10;
const int minRepeticiones = 1;

Servo myServo;
bool servoActivo = false;

// Variables de estado para evitar cambios repetidos en los botones
bool estadoBotonStartAnterior = HIGH;
bool estadoBotonStopAnterior = HIGH;
bool estadoBotonIncrementarGradosAnterior = HIGH;
bool estadoBotonDecrementarGradosAnterior = HIGH;
bool estadoBotonIncrementarVelocidadAnterior = HIGH;
bool estadoBotonDecrementarVelocidadAnterior = HIGH;
bool estadoBotonIncrementarRepAnterior = HIGH;
bool estadoBotonDecrementarRepAnterior = HIGH;

void setup() {
  pinMode(botonIncrementarGrados, INPUT);
  pinMode(botonDecrementarGrados, INPUT);
  pinMode(botonIncrementarVelocidad, INPUT);
  pinMode(botonDecrementarVelocidad, INPUT);
  pinMode(botonStart, INPUT_PULLUP);
  pinMode(botonStop, INPUT_PULLUP);
  pinMode(botonIncrementarRep, INPUT);
  pinMode(botonDecrementarRep, INPUT);

  myServo.attach(servoPin, 500, 2400);
  lcd.init();
  lcd.backlight();

  lcd.setCursor(4, 1);
  lcd.print("Bienvenido");
  delay(2000);

  actualizarLCD();
}

void actualizarLCD() {
  lcd.clear();
  lcd.setCursor(2, 2);
  lcd.print("Grados");
  lcd.setCursor(10, 2);
  lcd.print("Rep.");
  lcd.setCursor(16, 2);
  lcd.print("Vel.");

  lcd.setCursor(2, 3);
  lcd.print(grados);
  lcd.setCursor(10, 3);
  lcd.print(repeticiones);
  lcd.setCursor(17, 3);
  lcd.print(velocidad);
}

void loop() {
  int estadoBotonIncrementarGrados = digitalRead(botonIncrementarGrados);
  int estadoBotonDecrementarGrados = digitalRead(botonDecrementarGrados);
  int estadoBotonIncrementarVelocidad = digitalRead(botonIncrementarVelocidad);
  int estadoBotonDecrementarVelocidad = digitalRead(botonDecrementarVelocidad);
  int estadoBotonIncrementarRep = digitalRead(botonIncrementarRep);
  int estadoBotonDecrementarRep = digitalRead(botonDecrementarRep);
  int estadoBotonStart = digitalRead(botonStart);
  int estadoBotonStop = digitalRead(botonStop);

  // Manejo de estado de botón Start y Stop con debounce
  if (estadoBotonStart == LOW && estadoBotonStartAnterior == HIGH && !servoActivo) {
    servoActivo = true;
    delay(200);
  }
  estadoBotonStartAnterior = estadoBotonStart;

  if (estadoBotonStop == LOW && estadoBotonStopAnterior == HIGH) {
    servoActivo = false;
    myServo.write(minGrados);
    delay(200);
  }
  estadoBotonStopAnterior = estadoBotonStop;

  // Solo permitir ajustes si el servo no está activo
  if (!servoActivo) {
    // Control de grados con debounce
    if (estadoBotonIncrementarGrados == HIGH && estadoBotonIncrementarGradosAnterior == LOW && grados < maxGrados) {
      grados++;
      lcd.setCursor(2, 3);
      lcd.print(grados);
      lcd.print("   ");
    }
    estadoBotonIncrementarGradosAnterior = estadoBotonIncrementarGrados;

    if (estadoBotonDecrementarGrados == HIGH && estadoBotonDecrementarGradosAnterior == LOW && grados > minGrados) {
      grados--;
      lcd.setCursor(2, 3);
      lcd.print(grados);
      lcd.print("   ");
    }
    estadoBotonDecrementarGradosAnterior = estadoBotonDecrementarGrados;

    // Control de velocidad con debounce
    if (estadoBotonIncrementarVelocidad == HIGH && estadoBotonIncrementarVelocidadAnterior == LOW && velocidad < maxVelocidad) {
      velocidad++;
      lcd.setCursor(17, 3);
      lcd.print(velocidad);
      lcd.print("   ");
    }
    estadoBotonIncrementarVelocidadAnterior = estadoBotonIncrementarVelocidad;

    if (estadoBotonDecrementarVelocidad == HIGH && estadoBotonDecrementarVelocidadAnterior == LOW && velocidad > minVelocidad) {
      velocidad--;
      lcd.setCursor(17, 3);
      lcd.print(velocidad);
      lcd.print("   ");
    }
    estadoBotonDecrementarVelocidadAnterior = estadoBotonDecrementarVelocidad;

    // Control de repeticiones con debounce
    if (estadoBotonIncrementarRep == HIGH && estadoBotonIncrementarRepAnterior == LOW && repeticiones < maxRepeticiones) {
      repeticiones++;
      lcd.setCursor(10, 3);
      lcd.print(repeticiones);
      lcd.print("   ");
    }
    estadoBotonIncrementarRepAnterior = estadoBotonIncrementarRep;

    if (estadoBotonDecrementarRep == HIGH && estadoBotonDecrementarRepAnterior == LOW && repeticiones > minRepeticiones) {
      repeticiones--;
      lcd.setCursor(10, 3);
      lcd.print(repeticiones);
      lcd.print("   ");
    }
    estadoBotonDecrementarRepAnterior = estadoBotonDecrementarRep;
  }

  // Movimiento del servo
  if (servoActivo) {
    lcd.setCursor(4, 0);
    lcd.print("Moviendo Servo    ");
    
    for (int i = 0; i < repeticiones; i++) {
      for (int pos = minGrados; pos <= grados; pos++) {
        myServo.write(pos);
        delay(100 / velocidad);
      }
      for (int pos = grados; pos >= minGrados; pos--) {
        myServo.write(pos);
        delay(100 / velocidad);
      }
    }
    servoActivo = false;
    lcd.setCursor(4, 0);
    lcd.print("Servo en reposo   ");
  } else {
    lcd.setCursor(4, 0);
    lcd.print("Servo en reposo   ");
  }
}