#include <Keypad.h>

const int A_plus_pin = 26;    // Pin para A+
const int A_minus_pin = 25;   // Pin para A-
const int B_plus_pin = 27;    // Pin para B+
const int B_minus_pin = 14;   // Pin para B-

const int stepsPorRevolucion = 200;  // Número de pasos por revolución
int posicionActual = 0; // Posición actual del motor en grados

const byte ROWS = 4; // Cuatro filas
const byte COLS = 4; // Cuatro columnas
// Define los símbolos en los botones del teclado
char hexaKeys[ROWS][COLS] = {
  {'1','2','3', 'A'},
  {'4','5','6', 'B'},
  {'7','8','9', 'C'},
  {'*','0','#', 'D'}
};
// Conecta los pines del teclado a los pines del ESP32
byte rowPins[ROWS] = {4, 33, 34, 35}; // Pines de las filas conectados a los pines GPIO del ESP32
byte colPins[COLS] = {5, 18, 19, 21}; // Pines de las columnas conectados a los pines GPIO del ESP32

// Crea el objeto de teclado
Keypad customKeypad = Keypad(makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS); 

void setup() {
  // Configurar los pines como salidas
  pinMode(A_plus_pin, OUTPUT);
  pinMode(A_minus_pin, OUTPUT);
  pinMode(B_plus_pin, OUTPUT);
  pinMode(B_minus_pin, OUTPUT);
  Serial.begin(9600); // Inicia la comunicación serial
}

void loop() {
  char customKey = customKeypad.getKey();
  
  if (customKey) {
    Serial.print("Tecla presionada: ");
    Serial.println(customKey);
    
    // Restablece la posición actual si no es una de las teclas esperadas
    if (customKey != 'A' && customKey != 'B' && customKey != 'C') {
      posicionActual = 0;
    }

    switch (customKey) {
      case 'A': // Si se ingresa 'A', gira a -90 grados
        girar(-90 - posicionActual);
        posicionActual = -90;
        break;
      case 'B': // Si se ingresa 'B', gira a 0 grados
        girar(-posicionActual);
        posicionActual = 0;
        break;
      case 'C': // Si se ingresa 'C', gira a 90 grados
        girar(90 - posicionActual);
        posicionActual = 90;
        break;
    }
  }
  else {
    Serial.println("Esperando entrada...");
  }
}
void girar(float grados) {
  // Calcular la cantidad de pasos necesarios para girar los grados deseados
  long pasosAMover = stepsPorRevolucion * grados / 360.0;

  // Realizar el movimiento
  if (pasosAMover > 0) {
    for (long i = 0; i < pasosAMover; i++) {
      paso(1); // Girar en sentido horario
      delayMicroseconds(100000); // Aumenta este valor para reducir la velocidad
    }
  } else {
    for (long i = 0; i > pasosAMover; i--) {
      paso(-1); // Girar en sentido antihorario
      delayMicroseconds(100000); // Aumenta este valor para reducir la velocidad
    }
  }
}

void paso(int direccion) {
  // Secuencia de activación de bobinas para un paso (puedes ajustarla según tu motor)
  static const int secuenciaPasos[4][4] = {
    {HIGH, LOW, HIGH, LOW},   // Paso 1: A+ y B- activos
    {LOW, HIGH, HIGH, LOW},   // Paso 2: A- y B+ activos
    {LOW, HIGH, LOW, HIGH},   // Paso 3: A+ y B+ activos
    {HIGH, LOW, LOW, HIGH}    // Paso 4: A- y B- activos
  };

  static int indicePaso = 0;

  // Avanzar al siguiente paso en la secuencia
  indicePaso = (indicePaso + direccion) % 4;
  if (indicePaso < 0) {
    indicePaso += 4; // Asegura que el índice de paso sea positivo
  }

  // Activar las bobinas según la secuencia actual
  digitalWrite(A_plus_pin, secuenciaPasos[indicePaso][0]);
  digitalWrite(A_minus_pin, secuenciaPasos[indicePaso][1]);
  digitalWrite(B_plus_pin, secuenciaPasos[indicePaso][2]);
  digitalWrite(B_minus_pin, secuenciaPasos[indicePaso][3]);
}