Como hacer un PANEL ELECTRONIC de precios para GRIFOS

Hoy les mostraré una maqueta de un panel de precios para gasolineras. En este panel, podemos ver el precio del Diesel, luego los precios de la Gasolina 95, 90 y 84. Más abajo tenemos una pantalla con tres pulsadores, que nos permiten configurar los precios de manera fácil. Para demostrar cómo funciona, haremos un ejemplo cambiando el precio de la Gasolina de  84.

Al iniciar, la pantalla solicita una clave de acceso. Una vez ingresada correctamente, podemos navegar por el menú principal para modificar los precios. Bajamos hasta la opción de la Gasolina 84 y ajustamos el precio. Mientras lo hacemos, el cambio también se refleja en el display principal. Este proyecto está construido con un ESP32 y programado en el IDE de Arduino. A lo largo del video, les explicaré el esquemático electrónico, el diseño de la PCB y la estructura del panel.

1. Tensión de alimentación……………………….…………12VDC
2. Corriente de alimentación………………….……………850mA
3. Entradas digitales “Pulsadores” 12VDC………………3
4. Puerto usb de programación……………………………..1
5. Comunicación I2C…………………………………………………Sí
6. Comunicación Wifi…………………………………………………Sí
7. Comunicación Bluetooth…………………………………………….Sí
8. Dimensiones…………………………………….…….………220x100mm
9. Empotrable…………………………………………….………Sí
10. Entorno de programación………………………..……..Arduino IDE
11. Condiciones ambientales min………………………….-10°
12. Condiciones ambientales max…………………..…….55°

//librerias
#define EEPROM_SIZE 64
#include <EEPROM.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);

//▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
//PINES DE ENTRADA DE LOS PULSADORES         █
const int in_A = 34;    //ADD                █
const int in_B = 32;    //LESS               █
const int swPin = 35;   //OK                 █
bool btnpress = false;  //memoria boton OK   █
//▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█

//▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
//PINES DE SALIDA PARA CONTROLAR LOS Displays
byte clockpin = 27;  //Cuando ay que leer los bit      SH
byte data = 12;      //Envio datos                     DS
byte latch = 14;     //indica pin de salida en el chip ST

//▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄

//======================== DATOS CONVERSION ENTEROS A BINARIOS =================================
const int NUM[] = {
  191,  //Numero 0 en binario es : 10111111 = 0
  134,  //Numero 1 en binario es : 10000110 = 1
  219,  //Numero 2 en binario es : 11011011 = 2
  207,  //Numero 3 en binario es : 11001111 = 3
  230,  //Numero 4 en binario es : 11100110 = 4
  237,  //Numero 5 en binario es : 11101101 = 5
  253,  //Numero 6 en binario es : 11111101 = 6
  135,  //Numero 7 en binario es : 10000111 = 7
  255,  //Numero 8 en binario es : 11111111 = 8
  239,  //Numero 9 en binario es : 11101111 = 9
  191,  //Numero 0 en binario es : 10111111 = 10
};
//==============================================================================================

///////////////////////////////////// VARIABLES PARA CONTEO DE DISPLAYS /////////////////////////////

//Display de precios
byte contador_fatal = 0;  // se usa directo al display
byte contador_dieselPro_DISPLAY[4] = { 0, 0, 0, 0 };
byte contador_gasolina95_DISPLAY[4] = { 0, 0, 0, 0 };
byte contador_gasolina90_DISPLAY[4] = { 0, 0, 0, 0 };
byte contador_gasolina84_DISPLAY[4] = { 0, 0, 0, 0 };

//MEMORIA
int contador_dieselPro_M = 0;   //Memoria incapacitantes
int contador_gasolina95_M = 0;  //Memoria leve
int contador_gasolina90_M = 0;  //Memoria incidentes
int contador_gasolina84_M = 0;  //Memoria subestandard

// Variables para almacenar el estado de la contraseña
int password[4] = { 0, 0, 0, 0 };
int currentDigit = 0;
int currentPosition = 0;

// Contraseña correcta
const int correctPassword[4] = { 0, 0, 0, 0 };
bool isCorrect = false;

////////////////////////DIRECCION PARA ALMACENAR EN LA MENORIA EEPROM
unsigned int direc_dieselPro = 0;    // Direccion EEPROM para almacenar precio Diesel pro
unsigned int direc_gasolina95 = 8;   // Direccion EEPROM para almacenar gasolina 95
unsigned int direc_gasolina90 = 16;  // Direccion EEPROM para almacenar gasolina 90
unsigned int direc_gasolina84 = 32;  // Direccion EEPROM para almacenar gasolina 84

//▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
//----------------------------------------------------------------------MENUS-------------------------------------------------------------------------------
String menu1[] = { "DIESEL PRO", "GASOLINA 95", "GASOLINA 90", "GASOLINA 84", "Atras" };  //Palabras del menu principal
int sizemenu1 = sizeof(menu1) / sizeof(menu1[0]);

String linea1, linea2;  //lines o filas del lcd 16x2
int level_menu = 0;     // para ubicarnos en un menú

int contador = 0;  // CONTADOR PARA EL DESPLAZAMIENTO ENTRE LOS MENUS

byte flecha[] = { B10000, B11000, B11100, B11110, B11100, B11000, B10000, B00000 };  //Creamos un array de 8 posiciones para la flecha del menu
//▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄

void setup() {
  EEPROM.begin(EEPROM_SIZE);
  // Serial.begin(9600);

  pinMode(in_A, INPUT);
  pinMode(in_B, INPUT);
  pinMode(swPin, INPUT);

  // OUTPUTS to 74HC959
  pinMode(clockpin, OUTPUT);
  pinMode(data, OUTPUT);
  pinMode(latch, OUTPUT);

  lcd.init();
  lcd.backlight();
  lcd.createChar(0, flecha);  //Caracter personalizado

  contador_dieselPro_M = EEPROM.read(direc_dieselPro);
  contador_gasolina95_M = EEPROM.read(direc_gasolina95);
  contador_gasolina90_M = EEPROM.read(direc_gasolina90);
  contador_gasolina84_M = EEPROM.read(direc_gasolina84);

  init_displays();
  cont();
  updateLCD();
}
void loop() {

  selectOption();  //Funcion para detectar cuando se Presionar el pusador de OK

  //███████████████████████████████████ PANTALLA PRINCIPAL ██████████████████████████████████████████
  if (level_menu == 0) {

    if (digitalRead(in_B) == HIGH) {
      if (password[currentPosition] > 0) {
        password[currentPosition]--;
      } else {
        password[currentPosition] = 9;
      }
      updateLCD();
      delay(250);  // Debouncing
    }

    if (btnpress) {
      if (currentPosition < 3) {
        currentPosition++;
      } else {
        verifyPassword();
        currentPosition = 0;  // Resetear para ingresar una nueva contraseña
      }
      updateLCD();
      btnpress = false;
    }

    if (digitalRead(in_A) == HIGH) {
      if (password[currentPosition] < 9) {
        password[currentPosition]++;
      } else {
        password[currentPosition] = 0;
      }
      updateLCD();
      delay(250);  // Debouncing
    }

    if (isCorrect == true) {  // si se presiona el pulsador de OK nos llevará al menu principal
      level_menu = 1;
      fn_menu(contador, menu1, sizemenu1);
    }
  }  //███████████████████████████████████████████████████████████████████████████████████████████████

  //███████████████████████████████████ MENU 1 PRINCIPAL ██████████████████████████████████████████
  if (level_menu == 1) {  //Esta variable corresponde al nivel principal del menu. level_menu = 1.

    if (fnSwitch(sizemenu1)) {              //Esta funcion muestra en el LCD el menu en el que estamos
      fn_menu(contador, menu1, sizemenu1);  //Esta funcion muestra la posicion dentro de ese menu segun el valor de la variable contador
    }

    if (btnpress) {  //Verificamos si el boton del encoder fue oprimido. btnpress == true

      // DIESEL PRO
      if (contador == 0) {
        //contador = contador_dieselPro_M;
        lcd.clear();

        // Variables para manejar los dígitos
        int digitoActivo = 0;  // Dígito actual (0: unidades, 1: decenas, 2: centenas, 3: millares)
        bool salir = false;    // Control para salir del bucle

        do {
          // Actualizamos los dígitos en el arreglo según el contador
          contador_dieselPro_DISPLAY[0] = contador_dieselPro_M % 10;          // Unidades
          contador_dieselPro_DISPLAY[1] = (contador_dieselPro_M / 10) % 10;   // Decenas
          contador_dieselPro_DISPLAY[2] = (contador_dieselPro_M / 100) % 10;  // Centenas
          contador_dieselPro_DISPLAY[3] = (contador_dieselPro_M / 1000);      // Millares

          lcd.setCursor(0, 0);
          lcd.print("DIESEL PRO");

          // Mostrar el precio completo en el LCD
          lcd.setCursor(0, 1);
          lcd.print("Precio: ");
          lcd.print(contador_dieselPro_DISPLAY[3]);  // Millares
          lcd.print(contador_dieselPro_DISPLAY[2]);  // Centenas
          lcd.print(contador_dieselPro_DISPLAY[1]);  // Decenas
          lcd.print(contador_dieselPro_DISPLAY[0]);  // Unidades

          // Mostrar el dígito activo en el LCD
          lcd.setCursor(0, 2);
          lcd.print("Digito: ");
          lcd.print(digitoActivo);

          // Incrementar o decrementar el dígito activo
          if (digitalRead(in_A) == HIGH) {  // Incrementar
            if (contador_dieselPro_DISPLAY[digitoActivo] < 9) {
              contador_dieselPro_DISPLAY[digitoActivo]++;
            } else {
              contador_dieselPro_DISPLAY[digitoActivo] = 0;  // Reinicia si llega a 9
            }
            delay(200);  // Pequeña espera para evitar múltiples incrementos
          }

          if (digitalRead(in_B) == HIGH) {  // Decrementar
            if (contador_dieselPro_DISPLAY[digitoActivo] > 0) {
              contador_dieselPro_DISPLAY[digitoActivo]--;
            } else {
              contador_dieselPro_DISPLAY[digitoActivo] = 9;  // Reinicia si llega a 0
            }
            delay(200);  // Pequeña espera para evitar múltiples decrementos
          }

          // Cambiar el dígito activo
          if (digitalRead(swPin) == HIGH) {  // Selección de dígito
            if (digitoActivo < 3) {
              digitoActivo++;  // Cambia al siguiente dígito
            } else {
              salir = true;  // Salimos del bucle al confirmar el último dígito
            }
            delay(200);
          }

          // Actualizamos el contador según los valores de los dígitos

          contador_dieselPro_M = contador_dieselPro_DISPLAY[3] * 1000 + contador_dieselPro_DISPLAY[2] * 100 + contador_dieselPro_DISPLAY[1] * 10 + contador_dieselPro_DISPLAY[0];

          // Mostrar los dígitos en el display de 7 segmentos
          cont();

        } while (!salir);  // Se repite mientras no se confirme el último dígito

        delay(500);

        // Guardamos el valor final en la EEPROM
        EEPROM.put(direc_dieselPro, contador_dieselPro_M);
        EEPROM.commit();
        // Regresamos al menú principal
        contador = 0;
        fn_menu(contador, menu1, sizemenu1);
        level_menu = 1;
      }

      // > GASOLINA 95
      if (contador == 1) {
        //contador = contador_gasolina95_M;
        lcd.clear();
        int digitoActivo = 0;  // Dígito actual (0: unidades, 1: decenas, 2: centenas, 3: millares)
        bool salir = false;    // Control para salir del bucle

        do {
          // Actualizamos los dígitos en el arreglo según el contador
          contador_gasolina95_DISPLAY[0] = contador_gasolina95_M % 10;          // Unidades
          contador_gasolina95_DISPLAY[1] = (contador_gasolina95_M / 10) % 10;   // Decenas
          contador_gasolina95_DISPLAY[2] = (contador_gasolina95_M / 100) % 10;  // Centenas
          contador_gasolina95_DISPLAY[3] = (contador_gasolina95_M / 1000);      // Millares

          lcd.setCursor(0, 0);
          lcd.print("DIESEL PRO");

          // Mostrar el precio completo en el LCD
          lcd.setCursor(0, 1);
          lcd.print("Precio: ");
          lcd.print(contador_gasolina95_DISPLAY[3]);  // Millares
          lcd.print(contador_gasolina95_DISPLAY[2]);  // Centenas
          lcd.print(contador_gasolina95_DISPLAY[1]);  // Decenas
          lcd.print(contador_gasolina95_DISPLAY[0]);  // Unidades

          // Mostrar el dígito activo en el LCD
          lcd.setCursor(0, 2);
          lcd.print("Digito: ");
          lcd.print(digitoActivo);

          // Incrementar o decrementar el dígito activo
          if (digitalRead(in_A) == HIGH) {  // Incrementar
            if (contador_gasolina95_DISPLAY[digitoActivo] < 9) {
              contador_gasolina95_DISPLAY[digitoActivo]++;
            } else {
              contador_gasolina95_DISPLAY[digitoActivo] = 0;  // Reinicia si llega a 9
            }
            delay(200);  // Pequeña espera para evitar múltiples incrementos
          }

          if (digitalRead(in_B) == HIGH) {  // Decrementar
            if (contador_gasolina95_DISPLAY[digitoActivo] > 0) {
              contador_gasolina95_DISPLAY[digitoActivo]--;
            } else {
              contador_gasolina95_DISPLAY[digitoActivo] = 9;  // Reinicia si llega a 0
            }
            delay(200);  // Pequeña espera para evitar múltiples decrementos
          }

          // Cambiar el dígito activo
          if (digitalRead(swPin) == HIGH) {  // Selección de dígito
            if (digitoActivo < 3) {
              digitoActivo++;  // Cambia al siguiente dígito
            } else {
              salir = true;  // Salimos del bucle al confirmar el último dígito
            }
            delay(200);
          }

          // Actualizamos el contador según los valores de los dígitos

          contador_gasolina95_M = contador_gasolina95_DISPLAY[3] * 1000 + contador_gasolina95_DISPLAY[2] * 100 + contador_gasolina95_DISPLAY[1] * 10 + contador_gasolina95_DISPLAY[0];

          // Mostrar los dígitos en el display de 7 segmentos
          cont();

        } while (!salir);  // Se repite mientras no se confirme el último dígito

        delay(500);
        EEPROM.put(direc_gasolina95, contador_gasolina95_M);  // Se agrega a EEPROM con la dirección primero y valor de la variable después
        EEPROM.commit();
        contador = 1;
        fn_menu(contador, menu1, sizemenu1);
        level_menu = 1;
      }

      //> GASOLINA 90
      if (contador == 2) {
        contador = contador_gasolina90_M;
        lcd.clear();
       int digitoActivo = 0;  // Dígito actual (0: unidades, 1: decenas, 2: centenas, 3: millares)
        bool salir = false;    // Control para salir del bucle

        do {
          // Actualizamos los dígitos en el arreglo según el contador
          contador_gasolina90_DISPLAY[0] = contador_gasolina90_M % 10;          // Unidades
          contador_gasolina90_DISPLAY[1] = (contador_gasolina90_M / 10) % 10;   // Decenas
          contador_gasolina90_DISPLAY[2] = (contador_gasolina90_M / 100) % 10;  // Centenas
          contador_gasolina90_DISPLAY[3] = (contador_gasolina90_M / 1000);      // Millares

          lcd.setCursor(0, 0);
          lcd.print("DIESEL PRO");

          // Mostrar el precio completo en el LCD
          lcd.setCursor(0, 1);
          lcd.print("Precio: ");
          lcd.print(contador_gasolina90_DISPLAY[3]);  // Millares
          lcd.print(contador_gasolina90_DISPLAY[2]);  // Centenas
          lcd.print(contador_gasolina90_DISPLAY[1]);  // Decenas
          lcd.print(contador_gasolina90_DISPLAY[0]);  // Unidades

          // Mostrar el dígito activo en el LCD
          lcd.setCursor(0, 2);
          lcd.print("Digito: ");
          lcd.print(digitoActivo);

          // Incrementar o decrementar el dígito activo
          if (digitalRead(in_A) == HIGH) {  // Incrementar
            if (contador_gasolina90_DISPLAY[digitoActivo] < 9) {
              contador_gasolina90_DISPLAY[digitoActivo]++;
            } else {
              contador_gasolina90_DISPLAY[digitoActivo] = 0;  // Reinicia si llega a 9
            }
            delay(200);  // Pequeña espera para evitar múltiples incrementos
          }

          if (digitalRead(in_B) == HIGH) {  // Decrementar
            if (contador_gasolina90_DISPLAY[digitoActivo] > 0) {
              contador_gasolina90_DISPLAY[digitoActivo]--;
            } else {
              contador_gasolina90_DISPLAY[digitoActivo] = 9;  // Reinicia si llega a 0
            }
            delay(200);  // Pequeña espera para evitar múltiples decrementos
          }

          // Cambiar el dígito activo
          if (digitalRead(swPin) == HIGH) {  // Selección de dígito
            if (digitoActivo < 3) {
              digitoActivo++;  // Cambia al siguiente dígito
            } else {
              salir = true;  // Salimos del bucle al confirmar el último dígito
            }
            delay(200);
          }

          // Actualizamos el contador según los valores de los dígitos

          contador_gasolina90_M = contador_gasolina90_DISPLAY[3] * 1000 + contador_gasolina90_DISPLAY[2] * 100 + contador_gasolina90_DISPLAY[1] * 10 + contador_gasolina90_DISPLAY[0];

          // Mostrar los dígitos en el display de 7 segmentos
          cont();

        } while (!salir);  // Se repite mientras no se confirme el último dígito
        delay(500);
        EEPROM.put(direc_gasolina90, contador_gasolina90_M);  // Se agrega a EEPROM con la dirección primero y valor de la variable después
        EEPROM.commit();
        contador = 2;
        fn_menu(contador, menu1, sizemenu1);
        level_menu = 1;
      }
      //> GASOLINA 84
      if (contador == 3) {
        contador = contador_gasolina84_M;
        lcd.clear();
       int digitoActivo = 0;  // Dígito actual (0: unidades, 1: decenas, 2: centenas, 3: millares)
        bool salir = false;    // Control para salir del bucle

        do {
          // Actualizamos los dígitos en el arreglo según el contador
          contador_gasolina84_DISPLAY[0] = contador_gasolina84_M % 10;          // Unidades
          contador_gasolina84_DISPLAY[1] = (contador_gasolina84_M / 10) % 10;   // Decenas
          contador_gasolina84_DISPLAY[2] = (contador_gasolina84_M / 100) % 10;  // Centenas
          contador_gasolina84_DISPLAY[3] = (contador_gasolina84_M / 1000);      // Millares

          lcd.setCursor(0, 0);
          lcd.print("DIESEL PRO");

          // Mostrar el precio completo en el LCD
          lcd.setCursor(0, 1);
          lcd.print("Precio: ");
          lcd.print(contador_gasolina84_DISPLAY[3]);  // Millares
          lcd.print(contador_gasolina84_DISPLAY[2]);  // Centenas
          lcd.print(contador_gasolina84_DISPLAY[1]);  // Decenas
          lcd.print(contador_gasolina84_DISPLAY[0]);  // Unidades

          // Mostrar el dígito activo en el LCD
          lcd.setCursor(0, 2);
          lcd.print("Digito: ");
          lcd.print(digitoActivo);

          // Incrementar o decrementar el dígito activo
          if (digitalRead(in_A) == HIGH) {  // Incrementar
            if (contador_gasolina84_DISPLAY[digitoActivo] < 9) {
              contador_gasolina84_DISPLAY[digitoActivo]++;
            } else {
              contador_gasolina84_DISPLAY[digitoActivo] = 0;  // Reinicia si llega a 9
            }
            delay(200);  // Pequeña espera para evitar múltiples incrementos
          }

          if (digitalRead(in_B) == HIGH) {  // Decrementar
            if (contador_gasolina84_DISPLAY[digitoActivo] > 0) {
              contador_gasolina84_DISPLAY[digitoActivo]--;
            } else {
              contador_gasolina84_DISPLAY[digitoActivo] = 9;  // Reinicia si llega a 0
            }
            delay(200);  // Pequeña espera para evitar múltiples decrementos
          }

          // Cambiar el dígito activo
          if (digitalRead(swPin) == HIGH) {  // Selección de dígito
            if (digitoActivo < 3) {
              digitoActivo++;  // Cambia al siguiente dígito
            } else {
              salir = true;  // Salimos del bucle al confirmar el último dígito
            }
            delay(200);
          }

          // Actualizamos el contador según los valores de los dígitos

          contador_gasolina84_M = contador_gasolina84_DISPLAY[3] * 1000 + contador_gasolina84_DISPLAY[2] * 100 + contador_gasolina84_DISPLAY[1] * 10 + contador_gasolina84_DISPLAY[0];

          // Mostrar los dígitos en el display de 7 segmentos
          cont();

        } while (!salir);  // Se repite mientras no se confirme el último dígito
        delay(500);
        EEPROM.put(direc_gasolina84, contador_gasolina84_M);  // Se agrega a EEPROM con la dirección primero y valor de la variable después
        EEPROM.commit();
        contador = 3;
        fn_menu(contador, menu1, sizemenu1);
        level_menu = 1;
      }
      //>Atras
      if (contador == 4) {
        contador = 0;
        level_menu = 0;
        isCorrect = false;
        password[0] = 0;
        password[1] = 0;
        password[2] = 0;
        password[3] = 0;
        updateLCD();
      }
      btnpress = false;  //  Nos aseguramos que esta variable de retorno de la funcion selectOption() vuelva a su estado inicial
    }
  }  //██████████████████████████████████████████████████████████████████████████████████████████████████████████████

}  //██████████████████████████████████████████████████████████████████████████████████████████████████████████████

void updateLCD() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Ingrese Contra:");
  lcd.setCursor(0, 1);

  for (int i = 0; i < 4; i++) {
    if (i == currentPosition) {
      lcd.print(password[i]);
    } else {
      lcd.print("*");  // Mostrar asteriscos para los dígitos confirmados
    }
    lcd.print(" ");
  }
}

void verifyPassword() {
  isCorrect = true;

  for (int i = 0; i < 4; i++) {
    if (password[i] != correctPassword[i]) {
      isCorrect = false;
      break;
    }
  }

  lcd.clear();
  lcd.setCursor(0, 0);

  if (isCorrect) {
    lcd.print("Contra correct");
  } else {
    lcd.print("Contra Incorrect");
  }

  delay(2000);  // Esperar 2 segundos antes de resetear
}

void selectOption() {  //funcion para leer el pulsador de ok
  if (digitalRead(swPin) == HIGH) {
    delay(500);
    btnpress = true;
  }
}

void fn_contador_INC_DEC() {  // FUNCION INCREMENTAR Y DECREMENTAR

  if (digitalRead(in_A) == HIGH) {
    contador++;
    delay(250);
  } else if (digitalRead(in_B) == HIGH) {
    contador--;
    delay(250);
  }

  /*if (contador > 9) {
    contador = 9;
  }*/
  if (contador < 0) {
    contador = 0;
  }
}

void fn_menu(int pos, String menus[], byte sizemenu) {  // funcion de desplazamiento de los menús
  lcd.clear();
  linea1 = "";
  linea2 = "";

  if ((pos % 2) == 0) {

    lcd.setCursor(0, 0);
    lcd.write(byte(0));
    linea1 = menus[pos];

    if (pos + 1 != sizemenu) {
      linea2 = menus[pos + 1];
    }

  } else {
    linea1 = menus[pos - 1];
    lcd.setCursor(0, 1);
    lcd.write(byte(0));
    linea2 = menus[pos];
  }

  lcd.setCursor(1, 0);
  lcd.print(linea1);

  lcd.setCursor(1, 1);
  lcd.print(linea2);
}

bool fnSwitch(byte sizemenu) {  //Lee las señales de los pulsadores, exepto el de ok
  bool retorno = false;
  if (digitalRead(in_A) == HIGH || digitalRead(in_B) == HIGH) {
    if (digitalRead(in_A) == HIGH) {
      contador++;
      delay(250);
    } else if (digitalRead(in_B) == HIGH) {
      contador--;
      delay(250);
    }

    if (contador <= 0) {
      contador = 0;
    }

    if (contador >= sizemenu - 1) {
      contador = sizemenu - 1;
    }

    retorno = true;
  }
  return retorno;
}

void init_displays() {
  contador_gasolina84_DISPLAY[0] = contador_gasolina84_M % 10;          //unidades
  contador_gasolina84_DISPLAY[1] = (contador_gasolina84_M / 10) % 10;   //decenas
  contador_gasolina84_DISPLAY[2] = (contador_gasolina84_M / 100) % 10;  //centenas
  contador_gasolina84_DISPLAY[2] = (contador_gasolina84_M / 100);       //centenas

  contador_gasolina90_DISPLAY[0] = contador_gasolina90_M % 10;          //unidades
  contador_gasolina90_DISPLAY[1] = (contador_gasolina90_M / 10) % 10;   //decenas
  contador_gasolina90_DISPLAY[2] = (contador_gasolina90_M / 100) % 10;  //centenas
  contador_gasolina90_DISPLAY[2] = (contador_gasolina90_M / 100);       //centenas

  contador_gasolina95_DISPLAY[0] = contador_gasolina95_M % 10;          //unidades
  contador_gasolina95_DISPLAY[1] = (contador_gasolina95_M / 10) % 10;   //decenas
  contador_gasolina95_DISPLAY[2] = (contador_gasolina95_M / 100) % 10;  //centenas
  contador_gasolina95_DISPLAY[2] = (contador_gasolina95_M / 100);       //centenas

  contador_dieselPro_DISPLAY[0] = contador_dieselPro_M % 10;
  contador_dieselPro_DISPLAY[1] = (contador_dieselPro_M / 10) % 10;
  contador_dieselPro_DISPLAY[2] = (contador_dieselPro_M / 100) % 10;
  contador_dieselPro_DISPLAY[2] = (contador_dieselPro_M / 1000);
}

void cont() {  //funncion salidas para los displays
  digitalWrite(latch, LOW);
  //gasolina84
  shiftOut(data, clockpin, MSBFIRST, NUM[contador_gasolina84_DISPLAY[0]]);
  shiftOut(data, clockpin, MSBFIRST, NUM[contador_gasolina84_DISPLAY[1]]);
  shiftOut(data, clockpin, MSBFIRST, NUM[contador_gasolina84_DISPLAY[2]]);
  shiftOut(data, clockpin, MSBFIRST, NUM[contador_gasolina84_DISPLAY[3]]);

  //gasolina90
  shiftOut(data, clockpin, MSBFIRST, NUM[contador_gasolina90_DISPLAY[0]]);
  shiftOut(data, clockpin, MSBFIRST, NUM[contador_gasolina90_DISPLAY[1]]);
  shiftOut(data, clockpin, MSBFIRST, NUM[contador_gasolina90_DISPLAY[2]]);
  shiftOut(data, clockpin, MSBFIRST, NUM[contador_gasolina90_DISPLAY[3]]);

  //gasolina95
  shiftOut(data, clockpin, MSBFIRST, NUM[contador_gasolina95_DISPLAY[0]]);
  shiftOut(data, clockpin, MSBFIRST, NUM[contador_gasolina95_DISPLAY[1]]);
  shiftOut(data, clockpin, MSBFIRST, NUM[contador_gasolina95_DISPLAY[2]]);
  shiftOut(data, clockpin, MSBFIRST, NUM[contador_gasolina95_DISPLAY[3]]);

  //dieselPro
  shiftOut(data, clockpin, MSBFIRST, NUM[contador_dieselPro_DISPLAY[0]]);
  shiftOut(data, clockpin, MSBFIRST, NUM[contador_dieselPro_DISPLAY[1]]);
  shiftOut(data, clockpin, MSBFIRST, NUM[contador_dieselPro_DISPLAY[2]]);
  shiftOut(data, clockpin, MSBFIRST, NUM[contador_dieselPro_DISPLAY[3]]);

  digitalWrite(latch, HIGH);
}