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

// Configuración de pines para el encoder rotatorio
const int pinCLK = 2;
const int pinDT = 3;
const int pinSW = 4;

// Crear objeto LCD 20x4
LiquidCrystal_I2C lcd(0x27, 20, 4);

// Variable para almacenar la opción seleccionada
int opcionSeleccionada = 0;

// Arreglo con las opciones de menú
String opciones[] = {"1.Medir Continua", "2.Medir Alterna", "3.Impedancias", "4.Frecuencia", "5.Temp y otros"};

// Variables para almacenar los valores de las mediciones
float medicion1Valor = 0.0;
float medicion2Valor = 0.0;
float medicion3Valor = 0.0;
float medicion4Valor = 0.0;
float medicion5Valor = 0.0;
float medicion6Valor = 0.0;
float medicion7Valor = 0.0;
float medicion8Valor = 0.0;
float medicion9Valor = 0.0;
float medicion10Valor = 0.0;
float medicion11Valor = 0.0; // Nueva medición para el submenú 1
float medicion12Valor = 0.0; // Nueva medición para el submenú 2
float medicion13Valor = 0.0; // Nueva medición para el submenú 3
float medicion14Valor = 0.0; // Nueva medición para el submenú 4
float medicion15Valor = 0.0; // Nueva medición para el submenú 5
float medicion16Valor = 0.0; // Nueva medición adicional para el submenú 2
float medicion17Valor = 0.0; // Nueva medición adicional para el submenú 2

bool enMedicion = false;
int submenuActual = 0;

void setup() {
  // Inicializar LCD
  lcd.init();
  lcd.backlight();

  // Configurar pines del encoder como entrada
  pinMode(pinCLK, INPUT);
  pinMode(pinDT, INPUT);
  pinMode(pinSW, INPUT_PULLUP);

  // Mostrar la opción inicial en el LCD
  lcd.setCursor(0, 0);
  lcd.print("Seleccione Med.:");
  lcd.setCursor(0, 1);
  lcd.print(opciones[opcionSeleccionada]);
}

void loop() {
  // Leer el estado del encoder rotatorio
  bool clkState = digitalRead(pinCLK);
  bool dtState = digitalRead(pinDT);

  // Detectar giro del encoder
  if (clkState != dtState) {
    if (dtState) {
      opcionSeleccionada++;
    } else {
      opcionSeleccionada--;
    }

    // Mantener la opción dentro del rango válido
    opcionSeleccionada = constrain(opcionSeleccionada, 0, 4);

    // Mostrar la nueva opción en el LCD
    lcd.setCursor(0, 1);
    lcd.print("                    "); // Limpiar línea
    lcd.setCursor(0, 1);
    lcd.print(opciones[opcionSeleccionada]);
  }

  // Detectar pulsación del botón del encoder
  if (digitalRead(pinSW) == LOW) {
    if (enMedicion) {
      // Regresar al menú principal
      enMedicion = false;
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Seleccione submenu:");
      lcd.setCursor(0, 1);
      lcd.print(opciones[opcionSeleccionada]);
    } else {
      // Mostrar el submenú correspondiente
      submenuActual = opcionSeleccionada;
      mostrarSubmenu(submenuActual);
    }
  }

  // Actualizar las mediciones en tiempo real
  if (enMedicion) {
    switch (submenuActual) {
      case 0:
        medicion1Valor = VOLTAJE_DC();
        medicion2Valor = CORRIENTE_DC();
        medicion11Valor = POTENCIA__DC();
        lcd.setCursor(0, 1);
        lcd.print("M1: ");
        lcd.print(medicion1Valor);
        lcd.setCursor(0, 2);
        lcd.print("M2: ");
        lcd.print(medicion2Valor);
        lcd.setCursor(0, 3);
        lcd.print("M11: ");
        lcd.print(medicion11Valor);
        break;
      case 1:
        medicion3Valor = VOLTAJE__AC();
        medicion4Valor = CORRIENTE__AC();
        medicion12Valor = POTENCIA__AC();
        medicion16Valor = COSFI_FACTOR(); // Nueva medición adicional para el submenú 2
        medicion17Valor = Energia___Consumo(); // Nueva medición adicional para el submenú 2
        lcd.setCursor(0, 1);
        lcd.print("M3: ");
        lcd.print(medicion3Valor);
        lcd.setCursor(0, 2);
        lcd.print("M4: ");
        lcd.print(medicion4Valor);
        lcd.setCursor(0, 3);
        lcd.print("M12: ");
        lcd.print(medicion12Valor);
        lcd.setCursor(10, 1); // Mover el cursor a la columna 15 de la línea 3
        lcd.print("M16: ");
        lcd.print(medicion16Valor);
        lcd.setCursor(10, 2); // Mover el cursor a la columna 15 de la línea 3
        lcd.print("M17: ");
        lcd.print(medicion17Valor);
        break;
      case 2:
        medicion5Valor = RESISTENCIA___CONTINUIDAD();
        medicion6Valor = INDUCTANCIA_BOBINA();
        medicion13Valor = CAPACITANCIA_CAPACITOR();
        lcd.setCursor(0, 1);
        lcd.print("M5: ");
        lcd.print(medicion5Valor);
        lcd.setCursor(0, 2);
        lcd.print("M6: ");
        lcd.print(medicion6Valor);
        lcd.setCursor(0, 3);
        lcd.print("M13: ");
        lcd.print(medicion13Valor);
        break;
      case 3:
        medicion7Valor = FRECUENCIA__ONDAS();
        medicion8Valor = OTROS1();
        medicion14Valor = leerMedicion14();
        lcd.setCursor(0, 1);
        lcd.print("M7: ");
        lcd.print(medicion7Valor);
        lcd.setCursor(0, 2);
        lcd.print("M8: ");
        lcd.print(medicion8Valor);
        lcd.setCursor(0, 3);
        lcd.print("M14: ");
        lcd.print(medicion14Valor);
        break;
      case 4:
        medicion9Valor = TEMPERATURA();
        medicion10Valor = OTROS3();
        medicion15Valor = leerMedicion15();
        lcd.setCursor(0, 1);
        lcd.print("M9: ");
        lcd.print(medicion9Valor);
        lcd.setCursor(0, 2);
        lcd.print("M10: ");
        lcd.print(medicion10Valor);
        lcd.setCursor(0, 3);
        lcd.print("M15: ");
        lcd.print(medicion15Valor);
        break;
    }
  }

  delay(100); // Pequeño retraso para no saturar el procesador
}

void mostrarSubmenu(int submenu) {
  enMedicion = true;
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(opciones[submenu]);
  lcd.setCursor(15, 3);
  lcd.print("Atras");
}


                         // Funciones para leer las mediciones 
                        // Funciones para leer las mediciones 
                       // Funciones para leer las mediciones 
                      // Funciones para leer las mediciones 
                     // Funciones para leer las mediciones 

float VOLTAJE_DC() {
  // Código para leer la medición 1
   //VOLTIMETRO
const int voltajeMax =25000 ;
int lecturaDigitalVoltaje; // 1023
float VOLTAJE;
lecturaDigitalVoltaje = analogRead(A0);
VOLTAJE = map(lecturaDigitalVoltaje, 0, 1023, 0, voltajeMax) / 1000.0;
  return VOLTAJE;
}

float CORRIENTE_DC() {
  // Código para leer la medición 2
   //AMPERIMETRO DC
float sensibilidad = 0.100;
float lecturadigitalCorriente;
float CORRIENTE;
lecturadigitalCorriente = analogRead(A1)*(5.0/1023.0);
CORRIENTE =(lecturadigitalCorriente-2.499)/sensibilidad;
  return CORRIENTE;
}

float VOLTAJE__AC() {
  // Código para leer la medición 3
#define ZMPT101B_PIN A2  // Pin analógico para la lectura del sensor ZMPT101B
#define NUM_MUESTRAS 100 // Número de muestras a promediar

  float sumaVoltajes = 0;

  // Realizar múltiples lecturas y calcular la suma
  for (int i = 0; i < NUM_MUESTRAS; i++) {
    int lectura = analogRead(ZMPT101B_PIN);
    sumaVoltajes += (lectura * 5.0) / 1023.0; // Convertir a voltaje (asumiendo referencia de 5V)
    delay(1); // Pequeño retraso entre lecturas
  }

  // Calcular el promedio de las lecturas
  float voltajePromedio = sumaVoltajes*50.0 / NUM_MUESTRAS;

  return voltajePromedio;
}

float CORRIENTE__AC() {
  // Código para leer la medición 4
#define SCT013_PIN A3  // Pin analógico para la lectura del sensor SCT-013
#define NUM_MUESTRAS 100 // Número de muestras a promediar
#define FACTOR_CONVERSION 0.0334 // Factor de conversión para el SCT-013 (100A = 50mA)

  float sumaCorrientes = 0;

  // Realizar múltiples lecturas y calcular la suma
  for (int i = 0; i < NUM_MUESTRAS; i++) {
    int lectura = analogRead(SCT013_PIN);
    float voltajeSensor = (lectura * 5.0) / 1023.0; // Convertir a voltaje (asumiendo referencia de 5V)
    float corrienteAC = voltajeSensor / FACTOR_CONVERSION; // Convertir voltaje a corriente
    sumaCorrientes += corrienteAC;
    delay(1); // Pequeño retraso entre lecturas
  }

  // Calcular el promedio de las lecturas
  float corrientePromedio = sumaCorrientes / NUM_MUESTRAS;

  return corrientePromedio;
}

float RESISTENCIA___CONTINUIDAD() {
  // Código para leer la medición 5

    //OHMIMETRO
int aPinLeitura = A6;
int R1 = 0;
float val = 0;
int Vin = 5;
float Vout = 0.0; 
int R2 = 1000;
float I;
  val = 1.0*analogRead (aPinLeitura);//Recepción analógica de valores por el pino A2
  Vout = (val*Vin)/1024;// Fórmula para calcular o Vout
  R1 = (R2*(Vin-Vout))/Vout; //Fòrmula divisor de tensión
  
  //Buzzer de continuidad
int buzzPin = 13;
int buzzDelay= 1000;
 if (R1>0 && R1<200 )
    { 
  digitalWrite(buzzPin, HIGH);
  delayMicroseconds(buzzDelay);
  digitalWrite(buzzPin, LOW);
  delayMicroseconds(buzzDelay);
    }
     if (R1== 0 || R1>=200)
    {
      digitalWrite(buzzPin, LOW);
  delayMicroseconds(buzzDelay);
  digitalWrite(buzzPin, LOW);
  delayMicroseconds(buzzDelay);
    }
  
  return R1;
}

float INDUCTANCIA_BOBINA() {
  // Código para leer la medición 6
  double pulse, frequency, capacitance, inductance, inductance_mH;
  pinMode(11, INPUT); //Input from the comparator output
  pinMode(12, OUTPUT);//output through a 150 ohm resistor to thr LC circuit

  digitalWrite(12, HIGH);
  delay(5);//give some time to charge inductor.
  digitalWrite(12,LOW);
  delayMicroseconds(100); //make sure resination is measured
  pulse = pulseIn(12,HIGH,5000);//returns 0 if timeout
  if(pulse > 0.1){ //if a timeout did not occur and it took a reading:
    
    
//#error insert your used capacitance value here. Currently using 2uF. Delete this line after that
  capacitance = 2.E-6; // <- insert value here
  
  
  frequency = 1.E6/(2*pulse);
  inductance = 1./(capacitance*frequency*frequency*4.*3.14159*3.14159);//one of my profs told me just do squares like this
  inductance *= 1E6; //note that this is the same as saying inductance = inductance*1E6
  inductance_mH = inductance * 1000; //note that this is the same as saying inductance = inductance*1E6
  }
  return inductance_mH;
}

float FRECUENCIA__ONDAS() {
  // Código para leer la medición 7
  return analogRead(A3) * (5.0 / 1023.0);
}

float OTROS1() {
  // Código para leer la medición 8
  return 0.0 ;
}

float TEMPERATURA() {
  // Código para leer la medición 9
  int temperatura = A7;
  pinMode(temperatura, INPUT);
  float temp=((analogRead(temperatura)*(5.0/1024))-0.5)/0.01;

  return temp;
}


float OTROS3() {
  // Código para leer la medición 10
  return 0.0;
}

// Nuevas funciones para leer las mediciones adicionales
float POTENCIA__DC() {
  // Código para leer la medición 11
    //VATIMETRO DC
  float potenciaDC = VOLTAJE_DC()*CORRIENTE_DC();
  return potenciaDC;
}

float POTENCIA__AC() {
  // Código para leer la medición 12
  //VATIMETRO AC
  float PotenciaAC = VOLTAJE__AC()*CORRIENTE__AC();
  return PotenciaAC;
}

float CAPACITANCIA_CAPACITOR() {
  // Código para leer la medición 13
  //Frecuencimetro y capacimetro
#define MEASURE_PIN 12 // Pin digital conectado a la salida del LM555
float frequencya;
pinMode(MEASURE_PIN, INPUT); // Configurar el pin del LM555 como entrada

  unsigned long pulseWidth = pulseIn(MEASURE_PIN, HIGH);
  if (pulseWidth != 0) {
    float frequencya = 1000000.0 / pulseWidth; // Convertir de microsegundos a Hz

  }
  delay(100); // Pequeño retraso entre mediciones

  float resistor1Value = 10000.0; // Valor de la resistencia R1 en Ohms
  float resistor2Value = 10000.0; // Valor de la resistencia R2 en Ohms
  float capacitance = 1.44 / (resistor1Value * frequencya * (resistor1Value + 2 * resistor2Value));
  return capacitance;
}

float leerMedicion14() {
  // Código para leer la medición 14
  return 0.0;
}

float leerMedicion15() {
  // Código para leer la medición 15
  return 0.0; //analogRead(A3) * (5.0 / 1023.0)
}

// Nuevas funciones para leer las mediciones adicionales del submenú 2
float COSFI_FACTOR() {
  // Código para leer la medición 16
  return 0.0; //analogRead(A3) * (5.0 / 1023.0)
}

float Energia___Consumo() {
  // Código para leer la medición 17
  return 0.0; //analogRead(A3) * (5.0 / 1023.0)
}