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

LiquidCrystal_I2C lcd(0x27, 16, 2);

//--------------------------------------------------------------------
#define clk 7
#define dt  12
#define btnsw  4
//--------------------------------------------------------------------
#define Ledred 13
#define btnnext 10

// Configuracion entradas pines de los motores------------------------
// Pines para el eje Y------------------------------------------------
#define dirPinY 6
#define stepPinY 3
#define enablePinY 8

// Pines para el eje X
#define dirPinX 5
#define stepPinX 2
#define enablePinX 8
// Configuración de motores
AccelStepper stepperY(1, stepPinY, dirPinY);
AccelStepper stepperX(1, stepPinX, dirPinX);

//--------------------------------------------------------------------


//Variables para los diferentes estados Menus/Submenus----------------
int MainMenuEn = 0;
int MotorYEn = 0;
int MotorXEn = 0;

//Variables StepperY--------------------------------------------------
int NmotorY = 0;
int repeticionesY = 0;

//Variables StepperX--------------------------------------------------
int NmotorX = 0;
int repeticionesX = 0;

//Estados de encoder--------------------------------------------------
int clkOld = 0;
int estadoclk = digitalRead(clk);
int estadodt = digitalRead(dt);
int delayEn = 2;

//Variable que declara los diferentes estados-------------------------
enum MenuState {MAIN_MENU , MOTOR_Y , MOTOR_YR, REPETICIONES_Y, MOTOR_X , MOTOR_XR , REPETICIONES_X, INICIAR_CICLO};
//Indica que estado se muestra primero
MenuState currentState = MAIN_MENU;


void setup()
{

  Serial.begin(9600);
  lcd.init();
  lcd.backlight();
  //lcd.clear();

  pinMode(clk, INPUT);
  clkOld = digitalRead(clk);
  pinMode(dt, INPUT);
  pinMode(btnsw, INPUT_PULLUP);
  pinMode(btnnext, INPUT_PULLUP);
  pinMode(Ledred, OUTPUT);
//Motores---------------------------------------------
  pinMode(enablePinY, OUTPUT);
  pinMode(enablePinX, OUTPUT);
  digitalWrite(enablePinY, HIGH);
  digitalWrite(enablePinX, HIGH);

  stepperY.setMaxSpeed(2000);
  stepperY.setAcceleration(2000);

  stepperX.setMaxSpeed(2000);
  stepperX.setAcceleration(2000);
//----------------------------------------------------

}



void loop() 
//Muestra el estado actual (currentState).
{
switch (currentState) 
            {
              case MAIN_MENU: //Menu principal
                mainMenu();
              break;

              case MOTOR_Y:   //Menu motor_Y
                motorY();
              break;

              case MOTOR_YR:  //Configurar nuemero de pasos motor_Y
                motorYR();
              break;

              case REPETICIONES_Y:  //Configurar nuemero de pasos motor_Y
                repeticiones_Y();
              break;

              case MOTOR_X:   //Menu motor_X
                motorX();
              break;

              case MOTOR_XR:  //Configurar nuemero de pasos motor_X
                motorXR();
              break;

              case REPETICIONES_X:  //Configurar nuemero de pasos motor_Y
               repeticiones_X();
              break;

              case INICIAR_CICLO: //Inicia los ciclos configurados.
                iniciarciclo();
              break;

              default: break;
          
            }
  
}
///FUNCIONES-que forman el los diferentes estados////////
/////////////////////////////////////////////////////////
void mainMenu() 
{
//----------Encoder control------------------------------
            int estadoclk = digitalRead(clk);
            int estadodt = digitalRead(dt);

              if (clkOld == 1 && estadoclk == 0) {
                if (estadodt == 0) {
                  MainMenuEn--;
                } else {
                  MainMenuEn++;
                }
                lcd.clear();
              }

              delay(delayEn);
              clkOld = estadoclk;

//----------Limite de casos del switch-------------------
            int casos = 3;
              if (MainMenuEn < 0) MainMenuEn = casos - 1;
              if (MainMenuEn > casos - 1) MainMenuEn = 0;
//-------------------------------------------------------
switch (MainMenuEn) 
            {
       
              case 0:
                
                lcd.setCursor(0, 0);
                lcd.print("MotorY");
                //lcd.setCursor(15, 1);
                //lcd.print("1");
                if (digitalRead(btnsw) == 0){
                ledlcdclear();
                currentState = MOTOR_Y;

                }
                break;

              case 1:
                lcd.setCursor(0, 0);
                lcd.print("MotorX");
                //lcd.setCursor(15, 1);
                //lcd.print("2");
                if (digitalRead(btnsw) == 0){
                ledlcdclear();
                currentState = MOTOR_X;

                }
                break;

              case 2:
                lcd.setCursor(1, 0);
                lcd.print("Iniciar ciclo!");
                //lcd.setCursor(15, 1);
                //lcd.print("3");
                if (digitalRead(btnsw) == 0){
                ledlcdclear();
                currentState = INICIAR_CICLO;

                }
                break;
               default: break;
            }
}

// 1 ////
////////////////////////////////////////////////////////
//MENU MOTOR Y__________________________________________
void motorY() 
{
//----------Encoder control-----------------------------
            int estadoclk = digitalRead(clk);
            int estadodt = digitalRead(dt);
            if (clkOld == 1 && estadoclk == 0) {
                if (estadodt == 0) {
                  MotorYEn--;
                } else {
                  MotorYEn++;
                }
                lcd.clear();
                }

              delay(delayEn);
              clkOld = estadoclk;
//------------------------------------------------------

//--------Limite de casos del switch--------------------
          int casos = 3;
              if (MotorYEn < 0) MotorYEn = casos - 1;
              if (MotorYEn > casos - 1) MotorYEn = 0;
//------------------------------------------------------
switch (MotorYEn)
            {
              case 0:
                lcd.setCursor(0, 0);
                lcd.print("LARGO:");
                lcd.setCursor(8, 0);
                lcd.print(NmotorY);
                lcd.setCursor(0, 1);
                lcd.print("Press to Config!");
                
                if (digitalRead(btnsw) == 0){
                ledlcdclear();
                    lcd.setCursor(4, 1);
                    lcd.print("           ");
                currentState = MOTOR_YR;
                }
                break;

              case 1:
                lcd.setCursor(0, 0);
                lcd.print("Copias_Y:");
                lcd.setCursor(14, 0);
                lcd.print(repeticionesY);
                lcd.setCursor(0, 1);
                lcd.print("Press to Config!");
                if (digitalRead(btnsw) == 0) {
                ledlcdclear();
                currentState = REPETICIONES_Y;
                }
                break;

              case 2:
                lcd.setCursor(0, 0);
                lcd.print("Back");
                if (digitalRead(btnsw) == 0) {
                ledlcdclear();
                currentState = MAIN_MENU;
                }
                break;

              default: break;
            }
}

// 2 /////////////////////////////////////////////////////
//CONTROL DE PASOS MOTOR Y--------------------------------
void motorYR()
{ 
              //Encoder control---------------------------
              int estadoclk = digitalRead(clk);
              int estadodt = digitalRead(dt);

              if (clkOld == 1 && estadoclk == 0) {
                if (estadodt == 0) {
                  NmotorY--;
                } else {
                  NmotorY++;
                }
                delay(delayEn);
              }
                clkOld = estadoclk;

              //Muestra los signos + y - delante del los valores '000'-----
              //int displayValue = NmotorX;
              int displayValue = NmotorY;
                  if (NmotorY < 0) {
                    lcd.setCursor(0, 1);
                    lcd.print("-");
                    displayValue = abs(NmotorY);
                  } else {
                    lcd.setCursor(0, 1);
                    lcd.print("+");
                  }

                  if (displayValue < 10) {
                    lcd.print("00");
                  } else if (displayValue < 100) {
                    lcd.print("0");
                  }

                  lcd.print(displayValue);

                  if (digitalRead(btnsw) == 0) {
                    lcd.clear();
                    ledlcdclear();
                    currentState = MOTOR_Y;
                    MainMenuEn = 1;
                  }
}

void repeticiones_Y()
{
//Encoder control----------------------
                    int estadoclk = digitalRead(clk);
                    int estadodt = digitalRead(dt);

                    if (clkOld == 1 && estadoclk == 0) {
                      if (estadodt == 0) {
                        repeticionesY--;
                      } else {
                        repeticionesY++;
                      }
                      delay(delayEn);
                    }
                    clkOld = estadoclk;

                    //Muestra los signos + y - delante del los valores '000'-----
                        //int displayValue = repeticionesY;
                    int displayValue = repeticionesY;
                        if (repeticionesY < 0) {
                          lcd.setCursor(0, 1);
                          lcd.print("-");
                          displayValue = abs(repeticionesY);
                        } else {
                          lcd.setCursor(0, 1);
                          lcd.print("+");
                        }

                        if (displayValue < 10) {
                          lcd.print("00");
                        } else if (displayValue < 100) {
                          lcd.print("0");
                        }

                        lcd.print(displayValue);

                        if (digitalRead(btnsw) == 0) {
                          lcd.clear();
                          ledlcdclear();
                          currentState = MAIN_MENU;
                          MainMenuEn = 1;
                        }
}

// 1 /////////////////////////////////////////////////////
//MENU MOTOR X--------------------------------------------
void motorX() 
{ 
//--------------Encoder control---------------------------
                int estadoclk = digitalRead(clk);
                int estadodt = digitalRead(dt);
                if (clkOld == 1 && estadoclk == 0) {
                    if (estadodt == 0) {
                      MotorXEn--;
                    } else {
                      MotorXEn++;
                    }
                    lcd.clear();
                    }

                  delay(delayEn);
                  clkOld = estadoclk;
//-------------------------------------------------------

//-------------Limite de casos del switch
                int casos = 3;
                  if (MotorXEn < 0) MotorXEn = casos - 1;
                  if (MotorXEn > casos - 1) MotorXEn = 0;
//-------------------------------------------------------
switch (MotorXEn) 
            {
              case 0:
                lcd.setCursor(0, 0);
                lcd.print("LARGO:");
                lcd.setCursor(8, 0);
                lcd.print(NmotorX);
                lcd.setCursor(0, 1);
                lcd.print("Press to Config!");
                
                if (digitalRead(btnsw) == 0){
                ledlcdclear();
                    lcd.setCursor(4, 1);
                    lcd.print("           ");
                currentState = MOTOR_XR;
                }
                break;

               case 1:
                lcd.setCursor(0, 0);
                lcd.print("Copias_X:");
                lcd.setCursor(14, 0);
                lcd.print(repeticionesX);
                lcd.setCursor(0, 1);
                lcd.print("Press to Config!");
                if (digitalRead(btnsw) == 0) {
                ledlcdclear();
                currentState = REPETICIONES_X;
                }
                break;

              case 2:
                lcd.setCursor(0, 0);
                lcd.print("Back");
                if (digitalRead(btnsw) == 0) {
                ledlcdclear();
                currentState = MAIN_MENU;

                }
                break;

              default: break;
            }

}
// 2 ///////////////////////////////////////////////////
//CONTROL DE PASOS MOTOR X------------------------------
void motorXR() 
{ 
                  //Encoder control----------------------
                    int estadoclk = digitalRead(clk);
                    int estadodt = digitalRead(dt);

                    if (clkOld == 1 && estadoclk == 0) {
                      if (estadodt == 0) {
                        NmotorX--;
                      } else {
                        NmotorX++;
                      }
                      delay(delayEn);
                    }
                    clkOld = estadoclk;

                    //Muestra los signos + y - delante del los valores '000'-----
                        //int displayValue = NmotorX;
                    int displayValue = NmotorX;
                        if (NmotorX < 0) {
                          lcd.setCursor(0, 1);
                          lcd.print("-");
                          displayValue = abs(NmotorX);
                        } else {
                          lcd.setCursor(0, 1);
                          lcd.print("+");
                        }

                        if (displayValue < 10) {
                          lcd.print("00");
                        } else if (displayValue < 100) {
                          lcd.print("0");
                        }

                        lcd.print(displayValue);

                        if (digitalRead(btnsw) == 0) {
                          lcd.clear();
                          ledlcdclear();
                          currentState = MOTOR_X;
                          MainMenuEn = 1;
                        }
}
void repeticiones_X()
{
//Encoder control----------------------
                    int estadoclk = digitalRead(clk);
                    int estadodt = digitalRead(dt);

                    if (clkOld == 1 && estadoclk == 0) {
                      if (estadodt == 0) {
                        repeticionesX--;
                      } else {
                        repeticionesX++;
                      }
                      delay(delayEn);
                    }
                    clkOld = estadoclk;

                    //Muestra los signos + y - delante del los valores '000'-----
                        //int displayValue = repeticionesY;
                    int displayValue = repeticionesX;
                        if (repeticionesX < 0) {
                          lcd.setCursor(0, 1);
                          lcd.print("-");
                          displayValue = abs(repeticionesX);
                        } else {
                          lcd.setCursor(0, 1);
                          lcd.print("+");
                        }

                        if (displayValue < 10) {
                          lcd.print("00");
                        } else if (displayValue < 100) {
                          lcd.print("0");
                        }

                        lcd.print(displayValue);

                        if (digitalRead(btnsw) == 0) {
                          lcd.clear();
                          ledlcdclear();
                          currentState = MAIN_MENU;
                          MainMenuEn = 2;
                        }
}


//SALIDA MOTORES/////////////////////////////////////////                   
//INICIA EL CICLO MOTORES--------------------------------
void iniciarciclo()
{ 
  lcd.setCursor(2,0);
  lcd.print("Pulsa boton!");
  
  if (digitalRead(btnsw) == 0){
  ledlcdclear();
//CICLO MOTOR Y------------------------------------------
 if (repeticionesY >= 0) {
      digitalWrite(enablePinY, LOW);
      for (int i = 0; i < repeticionesY; i++)
      {
      digitalWrite(Ledred, 1);
      lcd.setCursor(2,0);
      lcd.print("||positivo||");
      stepperY.move(NmotorY);
      stepperY.runToPosition();
      lcd.setCursor(0,0);
      lcd.print("               ");
      digitalWrite(Ledred, 0);
      delay(500);
    }
   }
    else if  ( repeticionesY <= 0) {
        for (int i = 0; i > repeticionesY; i--)
         { 
          digitalWrite(Ledred, 1);
          lcd.setCursor(2,0);
          lcd.print("||Negativo||");
          stepperY.move(NmotorY);
          stepperY.runToPosition();
          lcd.setCursor(0,0);
          lcd.print("               ");
          digitalWrite(Ledred, 0);
          delay(250);

        }
        }
//LED Y LCD----------------------------------------------
     
        delay(100);

//CICLO MOTOR X------------------------------------------

if (repeticionesX >= 0) {
      digitalWrite(enablePinX, LOW);
      for (int i = 0; i < repeticionesX; i++){
      digitalWrite(Ledred, 1);
      lcd.setCursor(2,0);
      lcd.print("||positivo||");
      stepperX.move(NmotorX);
      stepperX.runToPosition();
      lcd.setCursor(0,0);
      lcd.print("               ");
      digitalWrite(Ledred, 0);
      delay(500);
    }
   }

    else if  ( repeticionesX <= 0) {
        for (int i = 0; i > repeticionesX; i--)
        {
          digitalWrite(Ledred, 1);
          lcd.setCursor(2,0);
          lcd.print("||Negativo||");
          stepperX.move(NmotorX);
          stepperX.runToPosition();
          lcd.setCursor(0,0);
          lcd.print("               ");
          digitalWrite(Ledred, 0);
          delay(250);

        }
        }
//-------------------------------------------------------
          delay(500);

//LO DEVUELVE AL MAIN_MENU-------------------------------
          delay(100);
          lcd.clear();
          MainMenuEn = 0;
          currentState = MAIN_MENU;
} 
    
    
}

/////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////

void ledlcdclear(){
 if (digitalRead(btnsw) == 0) 
 {
  lcd.clear();
  digitalWrite(Ledred, 1);
  delay(500);
  digitalWrite(Ledred, 0);
 }
}