#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)
}