/*
    SimpleClock.cpp

    Shows a (fast) running clock with big numbers on a 2004 LCD.
    https://wokwi.com/projects/346661429974139474

    Copyright (C) 2022  Armin Joachimsmeyer
    [email protected]

    This file is part of LCDBigNumbers https://github.com/ArminJo/LCDBigNumbers.

    LCDBigNumbers is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program. If not, see <http://www.gnu.org/licenses/gpl.html>.

    La siguiente readactacion y configuracion a partir del menu fue realizada por
    Marcos Antonio Rguez. B. Con afan altruista comparto mis progresos para beneficio común.
    Mejora y amplia este archivo. No olvides resaltar los trabajos anteriores y sobre todo nunca
    encierres el conocimiento.

p
*/
#include <Wire.h>

#include <extEEPROM.h>    //https://github.com/PaoloP74/extEEPROM  
extEEPROM myEEPROM(kbits_256, 1, 64, 0x50);

#include <Arduino.h>


#include <LiquidCrystal_I2C.h>
#define LCD_I2C_ADDRESS 0x27    // Default LCD address is 0x27 for a 20 chars and 4 line / 2004 display
#define LCD_COLUMNS 20
#define LCD_ROWS 4
LiquidCrystal_I2C lcd(LCD_I2C_ADDRESS, LCD_COLUMNS, LCD_ROWS); // LCD_COLUMNS and LCD_ROWS are set by LCDBigNumbers.hpp depending on the defined display


////#include <LiquidCrystal_I2C_Menu.h>
//LiquidCrystal_I2C_Menu lcd(0x27, 20, 2);

#include <HX711.h>

/*
  #include <LiquidCrystal.h>

  const int rs = 10, en = 16, d4 = 4, d5 = 5, d6 = 6, d7 = 7;
  LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
*/

// the 8 arrays that form each segment of the custom numbers
byte bar1[8] =
{
  B11100,
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
  B11100
};
byte bar2[8] =
{
  B00111,
  B01111,
  B01111,
  B01111,
  B01111,
  B01111,
  B01111,
  B00111
};
byte bar3[8] =
{
  B11111,
  B11111,
  B00000,
  B00000,
  B00000,
  B00000,
  B11111,
  B11111
};
byte bar4[8] =
{
  B11110,
  B11100,
  B00000,
  B00000,
  B00000,
  B00000,
  B11000,
  B11100
};
byte bar5[8] =
{
  B01111,
  B00111,
  B00000,
  B00000,
  B00000,
  B00000,
  B00011,
  B00111
};
byte bar6[8] =
{
  B00000,
  B00000,
  B00000,
  B00000,
  B00000,
  B00000,
  B11111,
  B11111
};
byte bar7[8] =
{
  B00000,
  B00000,
  B00000,
  B00000,
  B00000,
  B00000,
  B00111,
  B01111
};
byte bar8[8] =
{
  B11111,
  B11111,
  B00000,
  B00000,
  B00000,
  B00000,
  B00000,
  B00000
};


HX711 basculaA;

#define SCKa  A0 //const int
#define DOUTa  A1 //const int


HX711 basculaB;

#define SCKb  A2 //const int 
#define DOUTb A3  //const int 


// Parámetro para calibrar el peso y el sensor

float calibracionA = 419;//416;//   270000////  272498 // Celda Arduino 20Kg 220000 / 272498 / 229886
float calibracionB = 419;// 270000 // //

//bool Intro_Calib = false;
bool Calib_A = false;
bool Calib_B = false;
/*
  float pesoKg ; //
  int  pesoG = pesoKg*1000;
*/
bool refact = false;
int number;
//float pesoPositivo = 0;

// Botones.
int tara = 5;
int modo  = 6 ;
int ref_Peso = 7;
int atras_salida = 8; // back_exit
//int escala  = 11 ;

//Salidas.
int ledPin =  10;
int buzzer = 9 ;
// Menu///

//String pesa[] = {"A Pesar", "Menu"}; // Estado 0.
//int sizepesa = sizeof(pesa) / sizeof(pesa[0]);

String menu[] = {"Modo", "Referencia Peso", "Configuracion"}; // Estado 0  "Pesar" ,"Calibracion"
int sizemenu = sizeof(menu) / sizeof(menu[0]);

String modo1[] = {"Modo 1", "Modo 2", "Modo 3", "Modo 4", "Modo 5"}; // Estado 1
int sizemodo = sizeof(modo1) / sizeof(modo1[0]);

String refpeso[] = {"Ref.A1", "Ref.A2", "Ref.A3", "Ref.A4", "Ref.B1", "Ref.B2", "Ref.B3", "Ref.B4"}; // Estado 2
int sizepeso = sizeof(refpeso) / sizeof(refpeso[0]);

String conf[] = {"Por defecto", "Modificar", "Atras"}; // Estado 3   //6
int sizeconf = sizeof(conf) / sizeof(conf[0]);

String mod [] = {"Calibar A", "Calibar B", "A4", "B4", "Atras"}; // Estado 4  // 5
int sizemod = sizeof(mod) / sizeof(mod[0]);
/*
  String change_val  [] = {"Selecciona","Modifica","Atras"}; // sub Estado 01
  int sizechange = sizeof (change_val) / sizeof (change_val[0]);  */

int modoCon = 1; // Contador para modos
float peso1 ;
float peso2 ;

float PesoTotal ;

bool modAct1 = false;
bool modAct2 = false;
bool modAct3 = false;
bool modAct4 = false;
bool modAct5 = false;

// Para Encoder más swich

int pinA = 2; // Conectado a CLK on KY-040 // Inicial en 6//3 pinCLK
int pinB = 3; // Conectado a DT on KY-040 // inicial en 5//2 pinDT
int pinEnt = 4;  // Conectado a SW on KY-040 // Inicial en 4//4 pinSW

//Contadores para desplazarse por los menus
int Estado = 0;
int Sig_Estado = 1;

//Variables
int contador = 0;       //Esta variable en 0 se posicionara en el primer elemento del Menu principal
int A_estado_actual;
int A_ultimo_estado;
/*int SW_estado_actual;
  int SW_ultimo_estado;
  int velocidad_scroll = 300; */

bool Pesando = false;

int Pos = 0; // Es el que indica la posicion del encoder
int PosMax;
int PosAux = 0;
int cursorPos = 0;
int XYPos = 0;
int n;


unsigned long time;
unsigned long t;
unsigned long tEnt;
bool C = true;
bool D = true;
bool E = false;
bool Ent = false ;  //Esta variable de retorno en false asegurando que el boton del Encoder aun no se ha oprimido

String linea1, linea2;
int seleccion = 0;

int MaxPos = 7;
int MinPos = 1;

// Condicinales para botones
bool Et = false; // para tara
bool Em = false; // para modo
bool Erf = false; // para referencia de peso
bool Eas = false; // para atras/salida

int ContExit = 0;



// Para diferenciar tiempo de swich pulsado util para entrar y salir de menus.
int tiempo = 0;
int tiempo2 = 0;
int tiempo3 = 0;
int pinEntState = 0;
// Parametro desplaamiento de la coma para escala/unidades de peso.
int movi = 0;

// Pesos de referncia
int a1 = 5000;
int a2 = 1000;
int a3 = 500;
int a4;
int b1 = 2500;
int b2 = 1000;
int b3 = 500;
int b4;

// direccionado referencia segun basculas
int RefA;
int RefB;

int Val;
int Valor;
bool change = false;

void setup() {

  Serial.begin(9600);

  // initialize the LED pin as an output:

  pinMode(tara, INPUT);
  pinMode(ref_Peso, INPUT);
  pinMode(modo, INPUT);
  pinMode(atras_salida, INPUT);
  //pinMode(escala, INPUT);

  pinMode(ledPin, OUTPUT);
  pinMode(buzzer, OUTPUT);


  // Encoder 1
  pinMode(pinA, INPUT); //Derecha pinCLK
  pinMode(pinB, INPUT); //Izquierda pinDT
  pinMode(pinEnt, INPUT); //Enter pinSW

  Wire.begin();

  lcd.init();


  // assignes each segment a write number
  lcd.createChar(1, bar1);
  lcd.createChar(2, bar2);
  lcd.createChar(3, bar3);
  lcd.createChar(4, bar4);
  lcd.createChar(5, bar5);
  lcd.createChar(6, bar6);
  lcd.createChar(7, bar7);
  lcd.createChar(8, bar8);

  lcd.setCursor(1, 0);
  lcd.print("Bascula de Emilio");
  lcd.setCursor(0, 1);
  lcd.print("Al estilo de Marcos");

  // Iniciar sensor
  basculaA.begin(DOUTa, SCKa);
  basculaB.begin(DOUTb, SCKb);

  delay(500);

  basculaA.set_scale(calibracionA); // Establecemos la escala en canal 1
  basculaB.set_scale(calibracionB);
  // Iniciar la tara
  // No tiene que haber nada sobre el peso
  basculaA.tare();
  basculaB.tare();

  Serial.print("Estado");
  Serial.print(Estado);

  Serial.println("Pos");
  Serial.print(Pos);
  delay(500);
  lcd.clear();
  refact = true;
  RefA = a1;
  RefB = b1;
  Pesando = false;
  fn_menu(XYPos, menu, sizemenu);       //Iniciamos presentando el pesa como contador=0 mostrara el primer elemento y enviara a pesar
  A_ultimo_estado = digitalRead(pinA);   //Leemos el estado de la salida del Encoder usando el pin CLK

} // fin void Setup


void custom0(int col)
{ // uses segments to build the number 0
  lcd.setCursor(col, 0);
  lcd.write(2);
  lcd.write(8);
  lcd.write(1);
  lcd.setCursor(col, 1);
  lcd.write(2);
  lcd.write(6);
  lcd.write(1);
}

void custom1(int col)
{
  lcd.setCursor(col, 0);
  lcd.write(32);
  lcd.write(32);
  lcd.write(1);
  lcd.setCursor(col, 1);
  lcd.write(32);
  lcd.write(32);
  lcd.write(1);
}

void custom2(int col)
{
  lcd.setCursor(col, 0);
  lcd.write(5);
  lcd.write(3);
  lcd.write(1);
  lcd.setCursor(col, 1);
  lcd.write(2);
  lcd.write(6);
  lcd.write(6);
}

void custom3(int col)
{
  lcd.setCursor(col, 0);
  lcd.write(5);
  lcd.write(3);
  lcd.write(1);
  lcd.setCursor(col, 1);
  lcd.write(7);
  lcd.write(6);
  lcd.write(1);
}

void custom4(int col)
{
  lcd.setCursor(col, 0);
  lcd.write(2);
  lcd.write(6);
  lcd.write(1);
  lcd.setCursor(col, 1);
  lcd.write(32);
  lcd.write(32);
  lcd.write(1);
}

void custom5(int col)
{
  lcd.setCursor(col, 0);
  lcd.write(2);
  lcd.write(3);
  lcd.write(4);
  lcd.setCursor(col, 1);
  lcd.write(7);
  lcd.write(6);
  lcd.write(1);
}

void custom6(int col)
{
  lcd.setCursor(col, 0);
  lcd.write(2);
  lcd.write(3);
  lcd.write(4);
  lcd.setCursor(col, 1);
  lcd.write(2);
  lcd.write(6);
  lcd.write(1);
}

void custom7(int col)
{
  lcd.setCursor(col, 0);
  lcd.write(2);
  lcd.write(8);
  lcd.write(1);
  lcd.setCursor(col, 1);
  lcd.write(32);
  lcd.write(32);
  lcd.write(1);
}

void custom8(int col)
{
  lcd.setCursor(col, 0);
  lcd.write(2);
  lcd.write(3);
  lcd.write(1);
  lcd.setCursor(col, 1);
  lcd.write(2);
  lcd.write(6);
  lcd.write(1);
}

void custom9(int col)
{
  lcd.setCursor(col, 0);
  lcd.write(2);
  lcd.write(3);
  lcd.write(1);
  lcd.setCursor(col, 1);
  lcd.write(7);
  lcd.write(6);
  lcd.write(1);
}

//} // fin void Setup


void printNumber(int value, int col) {

  if (value == 0) {
    custom0(col);
  } if (value == 1) {
    custom1(col);
  } if (value == 2) {
    custom2(col);
  } if (value == 3) {
    custom3(col);
  } if (value == 4) {
    custom4(col);
  } if (value == 5) {
    custom5(col);
  } if (value == 6) {
    custom6(col);
  } if (value == 7) {
    custom7(col);
  } if (value == 8) {
    custom8(col);
  } if (value == 9) {
    custom9(col);
  }
}
///A
unsigned long address = 0;
const unsigned int maxDataSize = 1024;  //0x8000;   // 32 k bytes (32768 = 0x8000) = 256 kbits

byte data[maxDataSize] = {'p', 'i', 'p', 'p', 'o'};
unsigned int dataSize = 5;

void eprom_read_write(bool write)
{
  byte i2cStat = 0;
  if (write) {
    i2cStat = myEEPROM.write(address, data, dataSize);
  } else {
    memset(data, 0, maxDataSize);
    i2cStat = myEEPROM.read(address, data, dataSize);
  }
  if ( i2cStat != 0 ) {
    //there was a problem
    Serial.print(F("I2C Problem: ")); //SerialUS
    if ( i2cStat == EEPROM_ADDR_ERR) {
      Serial.println(F("Wrong address"));
    } else {
      Serial.print(F("I2C error: "));
      Serial.print(i2cStat);
      Serial.println(F(""));
    }
  }
}
///A

//}// fin void Setup

void loop()  {

  time = millis(); // Registra el tiempo en todo el programa


  Botons();
  Encoder(); 

  do {

    Selection();                   //Funcion para detectar cuando se oprime el encoder.  btnpress == true

    /////////////////////////////////////////////////////////////////////////////////
    //menu  {"Modo","Referencia Peso","Calibracion","Configuracion", "Pesar"}
    if (Estado == 0) {

      /*
        t = time;
        if (time - t > 4000) {
         Estado = 2;
         Pesando = true;
         modAct1 = true;
         Serial.println("Inicio automatico");
        } */

      if (Encomovi(sizemenu)) {  // els
        fn_menu(XYPos, menu, sizemenu);
      }

      if (Ent) {

        if (XYPos == 0) {
          XYPos = 0;
          fn_menu(XYPos, modo1, sizemodo);
          Estado = 1;
        }


        if (XYPos == 1) {
          XYPos = 0;
          fn_menu(XYPos, refpeso, sizepeso );
          Estado = 2;
        }


        if (XYPos == 2) {
          XYPos = 0;
          fn_menu(XYPos, conf, sizeconf);
          Estado = 3;
        }

        Ent = false;
      }

    }
    /////////////////////////////////////////////////////////////////////////////////////
    //SubMenu Modo {"Momo 1","Modo 2","Modo 3","Modo 4","Modo 5"}
    if (Estado == 1) {  // else
      //MaxPos = 6;
      // MinPos = 0;
      //modAct1 = true;
      refact = true;
      //lcd.clear();
      if (Encomovi(sizemodo)) {
        fn_menu(XYPos, modo1, sizemodo);
      }

      if (Ent) {
        //Pesando = true;

        if (XYPos == 0) {
          lcd.clear();
          modAct1 = true;
          (modAct2, modAct3, modAct4, modAct5) = false;
          XYPos = 1;
        }

        do {
          Botons();
          peso1 = basculaA.get_units(4), 5;

          int m, c, d, u, number;

          if (number < 40000) { //pesoG
            m = 0;
          }

          if (number >= 1000) {
            m = (number - (number % 1000)) / 1000;
            number = number % 1000;
          } else {
            m = 0;
          }

          if (number > 99) {
            c = (number - (number % 100)) / 100;
            number = number % 100;
          } else {
            c = 0;
          }

          if (number > 9) {
            d = (number - (number % 10)) / 10;
            number = number % 10;
          } else {
            d = 0;
          }

          u = number;
          number =  (peso1 * 1000);
          lcd.setCursor(15, 0);
          lcd.print("M:");
          lcd.setCursor(17, 0);
          lcd.print("A  ");

          Serial.println("modAct1 ");
          Serial.println (peso1, 3);

          printNumber(m, 0 + n); //0
          printNumber(c, 3 + n); //4  3
          printNumber(d, 6 + n); //7  6
          printNumber(u, 9 + n); //10  9

          if (number >= 1 or number <= 999 ) {//&& G == true) { //pesoG

            lcd.setCursor(12, 1);
            lcd.print("G");
          }

          if (number >= 1000 ) { //&& Kg == true) {
            lcd.setCursor(12, 1);
            lcd.print("K");
            n = 0;
          }

          if (number >= 10000 ) {
            n = 1;
          }

          //refact = true;
          if (refact == true ) {
            lcd.setCursor(15, 1);
            lcd.print("R:");
            lcd.setCursor(17, 1);
            lcd.print("A  ");
            if (number >= RefA) {
              delay(500);
              lcd.clear();
              noTone(buzzer);
              delay(50);
              tone(buzzer, 250);
              delay(50);
              noTone(buzzer);
              delay(50);
              tone(buzzer, 450);
              delay(50);
              noTone(buzzer);
              lcd.setCursor(1, 0);
              lcd.print("Peso en A OK ");
              lcd.setCursor(1, 1);
              lcd.print("Retire Bote ");
              lcd.setCursor(1, 2);
              lcd.print(peso1, 3);
              delay(500);
              lcd.clear();
            }
          }

        } while (modAct1 == true or modoCon == 1 && Pesando == true); // or modoCon == 1);


        if (XYPos == 1) {
          modAct2 = true ;
          (modAct1, modAct3, modAct4, modAct5) = false;
          XYPos = 2;
        }

        do {
          Botons();
          peso2 = basculaB.get_units(4), 5;

          int m, c, d, u, number;

          if (number < 40000) { //pesoG
            m = 0;
          }

          if (number >= 1000) {
            m = (number - (number % 1000)) / 1000;
            number = number % 1000;
          } else {
            m = 0;
          }

          if (number > 99) {
            c = (number - (number % 100)) / 100;
            number = number % 100;
          } else {
            c = 0;
          }

          if (number > 9) {
            d = (number - (number % 10)) / 10;
            number = number % 10;
          } else {
            d = 0;
          }

          u = number;
          number =  (peso2 * 1000);
          lcd.setCursor(15, 0);
          lcd.print("M:");
          lcd.setCursor(17, 0);
          lcd.print("B  ");

          Serial.println("modAct2 ");
          Serial.println (peso2, 3);

          printNumber(m, 0 + n); //0
          printNumber(c, 3 + n); //4  3
          printNumber(d, 6 + n); //7  6
          printNumber(u, 9 + n); //10  9

          if (number >= 1 or number <= 999 ) {//&& G == true) { //pesoG

            lcd.setCursor(12, 1);
            lcd.print("G");
          }

          if (number >= 1000 ) { //&& Kg == true) {
            lcd.setCursor(12, 1);
            lcd.print("K");
            n = 0;
          }

          if (number >= 10000 ) {
            n = 1;
          }

          if (refact == true ) {
            lcd.setCursor(15, 1);
            lcd.print("R:");
            lcd.setCursor(17, 1);
            lcd.print("B  ");
            if (number >= RefB) {
              delay(500);
              lcd.clear();
              noTone(buzzer);
              delay(50);
              tone(buzzer, 250);
              delay(50);
              noTone(buzzer);
              delay(50);
              tone(buzzer, 450);
              delay(50);
              noTone(buzzer);
              lcd.setCursor(1, 0);
              lcd.print("Peso en B OK ");
              lcd.setCursor(1, 1);
              lcd.print("Retire Bote ");
              lcd.setCursor(1, 2);
              lcd.print(peso2, 3);
              delay(500);
              lcd.clear();
            }
          }

        } while (modAct2 == true or modoCon == 2 && Pesando == true); // or modoCon == 2);



        if (XYPos == 2) {
          modAct3 = true;
          (modAct1, modAct2, modAct4, modAct5) = false;
          XYPos = 3;
        }

        do {
          Botons();
          peso1 = basculaA.get_units(4), 5;
          peso2 = basculaB.get_units(4), 5;
          PesoTotal = (peso1 + peso2);

          int m, c, d, u, number;

          if (number < 40000) { //pesoG
            m = 0;
          }

          if (number >= 1000) {
            m = (number - (number % 1000)) / 1000;
            number = number % 1000;
          } else {
            m = 0;
          }

          if (number > 99) {
            c = (number - (number % 100)) / 100;
            number = number % 100;
          } else {
            c = 0;
          }

          if (number > 9) {
            d = (number - (number % 10)) / 10;
            number = number % 10;
          } else {
            d = 0;
          }

          u = number;
          number =  (PesoTotal * 1000);
          lcd.setCursor(15, 0);
          lcd.print("M:");
          lcd.setCursor(17, 0);
          lcd.print("A+B");

          Serial.println("modAct3 ");
          Serial.println (PesoTotal, 3);

          printNumber(m, 0 + n); //0
          printNumber(c, 3 + n); //4  3
          printNumber(d, 6 + n); //7  6
          printNumber(u, 9 + n); //10  9

          if (number >= 1 or number <= 999 ) {
            lcd.setCursor(12, 1);
            lcd.print("G");
          }

          if (number >= 1000 ) {
            lcd.setCursor(12, 1);
            lcd.print("K");
            n = 0;
          }

          if (number >= 10000 ) {
            n = 1;
          }

          // refact = true;
          if (refact == true ) {
            lcd.setCursor(15, 1);
            lcd.print("R:");
            lcd.setCursor(17, 1);
            lcd.print("A  ");
            if (number >= RefA) {
              delay(500);
              lcd.clear();
              noTone(buzzer);
              delay(50);
              tone(buzzer, 250);
              delay(50);
              noTone(buzzer);
              delay(50);
              tone(buzzer, 450);
              delay(50);
              noTone(buzzer);
              lcd.setCursor(1, 0);
              lcd.print("Peso en Bascula OK ");
              lcd.setCursor(1, 1);
              lcd.print("Retire Bote ");
              lcd.setCursor(1, 2);
              lcd.print(PesoTotal, 3);
              delay(500);
              lcd.clear();
            }
          }

        } while (modAct3 == true or modoCon == 3 && Pesando == true); // or modoCon == 3);



        if (XYPos == 3) {
          lcd.clear();
          if (modAct4 == true ) { //;
            (modAct1, modAct2, modAct3, modAct5) = false;
            XYPos = 4; //else if  (modAct5 == true){
          }
        }


        if (XYPos == 4) {
          lcd.clear();
          modAct5 = true;
          (modAct1, modAct2, modAct3, modAct4) = false;
          Estado = 2;

        }

        do {
          Botons();
          peso1 = basculaA.get_units(4), 5;
          peso2 = basculaB.get_units(4), 5;

          lcd.setCursor(15, 0);
          lcd.print("M:");
          lcd.setCursor(17, 0);
          lcd.print("AyB");

          lcd.setCursor(0, 0);
          lcd.print(peso1, 3);
          lcd.setCursor(0, 1);
          lcd.print(peso2, 3);

          Serial.println (peso1, 3);
          Serial.println (peso2, 3);

          if (peso1 * 1000 >= 1 or peso1 * 1000 <= 999 ) {
            lcd.setCursor(12, 0);
            lcd.print("G");
          }

          if (peso1 * 1000 >= 1000 ) {
            lcd.setCursor(12, 0);
            lcd.print("K");
          }

          if (peso2 * 1000 >= 1 or peso2 * 1000 <= 999 ) {
            lcd.setCursor(12, 1);
            lcd.print("G");
          }

          if (peso2 * 1000 >= 1000) {
            lcd.setCursor(12, 1);
            lcd.print("K");
          }

          if (refact == true && modAct4 == true) {
            lcd.setCursor(15, 1);
            lcd.print("R:");
            lcd.setCursor(17, 1);
            lcd.print("A=B");
            if (peso1 * 1000 >= RefA) {
              delay(500);
              lcd.clear();
              noTone(buzzer);
              delay(50);
              tone(buzzer, 250);
              delay(50);
              noTone(buzzer );
              delay(50);
              tone(buzzer, 450 );
              delay(50 );
              lcd.setCursor(1, 0);
              lcd.print("Peso en A OK ");
              lcd.setCursor(1, 1 );
              lcd.print("Retire Bote");
              lcd.setCursor(1, 2);
              lcd.print(peso1, 3);
              delay(500);
              lcd.clear();
            }

            if (peso2 * 1000 >= RefA) {
              delay(500 );
              lcd.clear();
              noTone(buzzer);
              delay(50);
              tone(buzzer, 250);
              delay(50);
              noTone(buzzer);
              delay(50);
              tone(buzzer, 450);
              delay(50);
              noTone(buzzer);
              lcd.setCursor(1, 0);
              lcd.print("Peso en B OK");
              lcd.setCursor(1, 1);
              lcd.print("Retire Bote");
              lcd.setCursor(1, 2);
              lcd.print(peso2, 3);
              delay(500);
              lcd.clear();

            }
          }

          if (refact == true && modAct5 == true) {
            lcd.setCursor(15, 1);
            lcd.print("R:");
            lcd.setCursor(17, 1);
            lcd.print("A#B");

            if (peso1 * 1000 >= RefA) {
              delay(500);
              lcd.clear();
              noTone(buzzer);
              delay(50);
              tone(buzzer, 250);
              delay(50);
              noTone(buzzer);
              delay(50);
              tone(buzzer, 450);
              delay(50);
              noTone(buzzer);
              lcd.setCursor(1, 0);
              lcd.print("Peso en A OK ");
              lcd.setCursor(1, 1);
              lcd.print("Retire Bote ");
              lcd.setCursor(1, 2);
              lcd.print(peso1, 3);
              delay(500);
              lcd.clear();
            }

            if (peso2 * 1000 >= RefB) {
              delay(500);
              lcd.clear();
              noTone(buzzer);
              delay(50);
              tone(buzzer, 250);
              delay(50);
              noTone(buzzer);
              delay(50);
              tone(buzzer, 450);
              delay(50);
              noTone(buzzer);
              lcd.setCursor(1, 0);
              lcd.print("Peso en B OK ");
              lcd.setCursor(1, 1);
              lcd.print("Retire Bote ");
              lcd.setCursor(1, 2);
              lcd.print(peso2, 3);
              delay(500);
              lcd.clear();
            }
          }

        } while (modAct4 == true or modoCon == 4 or modAct5 == true or modoCon == 5 && Pesando == true); // or modoCon == 5);

        Ent = false;

      }

    }

    //SubMenu refpeso {"Ref.A1","Ref.A2","Ref.A3","Ref.B1","Ref.B2","Ref.B3"}
    if (Estado == 2) { // els
      //MaxPos = 5;
      //MinPos = 0;


      if (Encomovi(sizepeso)) {
        fn_menu(XYPos, refpeso, sizepeso);
      }

      if (Ent) {
        //if(Estado == 3 && Ent == true){
        if (XYPos == 0) {
          lcd.clear();
          RefA = a1;
          lcd.setCursor(0, 0);
          lcd.print("Referencia A = a1");
          delay(1000);
          lcd.clear();
          XYPos = 0;
          fn_menu(XYPos, menu, sizemenu);
          Estado = 0;
        }


        if (XYPos == 1) {
          lcd.clear();
          RefA = a2;
          lcd.setCursor(0, 0);
          lcd.print("Referencia A = a2");
          delay(1000);
          lcd.clear();
          XYPos = 0;
          fn_menu(XYPos, menu, sizemenu);
          Estado = 0;
        }


        if (XYPos == 2) {
          lcd.clear();
          RefA = a3;
          lcd.setCursor(0, 0);
          lcd.print("Referencia A = a3");
          delay(1000);
          lcd.clear();
          XYPos = 0;
          fn_menu(XYPos, menu, sizemenu);
          Estado = 0;
        }


        if (XYPos == 3) {
          lcd.clear();
          RefA = a4;
          lcd.setCursor(0, 0);
          lcd.print("Referencia A = a4");
          delay(1000);
          lcd.clear();
          XYPos = 0;
          fn_menu(XYPos, menu, sizemenu);
          Estado = 0;
        }

        if (XYPos == 4) {
          lcd.clear();
          RefB = b1;
          lcd.setCursor(0, 0);
          lcd.print("Referencia B = b1");
          delay(1000);
          lcd.clear();
          XYPos = 0;
          fn_menu(XYPos, menu, sizemenu);
          Estado = 0;
        }


        if (XYPos == 5) {
          lcd.clear();
          RefB = b2;
          lcd.setCursor(0, 0);
          lcd.print("Referencia B = b2");
          delay(1000);
          lcd.clear();
          XYPos = 0;
          fn_menu(XYPos, menu, sizemenu);
          Estado = 0;
        }

        if (XYPos == 6) {
          lcd.clear();
          RefB = b3;
          lcd.setCursor(0, 0);
          lcd.print("Referencia B = b3");
          delay(1000);
          lcd.clear();
          XYPos = 0;
          fn_menu(XYPos, menu, sizemenu);
          Estado = 0;
        }

        if (XYPos == 7) {
          lcd.clear();
          RefB = b4;
          lcd.setCursor(0, 0);
          lcd.print("Referencia B = b4");
          delay(1000);
          lcd.clear();
          XYPos = 0;
          fn_menu(XYPos, menu, sizemenu);
          Estado = 0;
        }

        Ent = false;
      }

    }

    //Submenu conf[] = {"Por defecto", "Modificar", "Descartar", "Atras"};
    if (Estado == 3) { //if (Estado == 6) {  // else

      if (Encomovi(sizeconf)) {
        fn_menu(XYPos, conf, sizeconf);
      }

      if (Ent) {

        //if(Estado == 5 && Ent == true){
        if (XYPos == 0) {


          if (Ent) {

            a1 = 5000;
            a2 = 1000;
            a2 = 1000;
            a3 = 500;
            a4;
            b1 = 2500;
            b2 = 1000;
            b3 = 500;
            b4;
            RefA = a1;
            RefB = b2;
            calibracionA = 419;//416;//   270000////  272498 // Celda Arduino 20Kg 220000 / 272498 / 229886
            calibracionB = 419;

            lcd.setCursor(0, 5);
            lcd.print("Configuracion");
            lcd.setCursor(1, 5);
            lcd.print("Restaurada");
            delay(500);
            lcd.clear();
          }
          XYPos = 1;
          //XYPos = 0;
        }

        if (XYPos == 1) {
          //mod;
          //if (Ent == true){
          //lcd.setCursor(0,0);
          //lcd.print("Modificar");
          delay(500);
          // lcd.clear();
          XYPos = 0;
          fn_menu(XYPos, mod, sizemod);
          Estado = 4;

          //XYPos = 2;
          //Serial.print(Valor);

        }
        /*
                  if (XYPos == 2) {
                  lcd.print("Descarta");
                  delay(500);
                  lcd.clear();
                  XYPos = 0;
                  fn_menu(XYPos, menu, sizemenu);
                  Estado = 0;
                } */

        if (XYPos == 2) {
          // lcd.print("Atras");
          delay(500);
          //  lcd.clear();
          XYPos = 0;
          fn_menu(XYPos, menu, sizemenu);
          Estado = 0;
        }

        Ent = false;

      }

    }

    ///// Estado 4 mod
    if (Estado == 4) {
      //lcd.clear();
      /*
        int dm1, m1, c1, d1, u1, Valor;
        dm1 = Valor / 10000;
        m1 = Valor / 1000;
        c1 = (Valor - m1 * 100) / 10;
        d1 = (Valor - c1 * 100) / 10;
        u1 = (Valor - d1 * 100) / 10;
        Valor = (dm1 + m1 + c1 + d1 + u1);
        Pos = 0;
        MinPos = 0;
        MaxPos = 4;
      */

      if (Encomovi(sizemod)) {
        fn_menu(XYPos, mod, sizemod);
      }

      if (Ent) {

        if (XYPos == 0) {

          //change = true;
          //Pos = 0;
          Serial.println(Pos);
          Valor = calibracionA;
          if (!Valor) {
            calibracionA = Valor;
          }
          Pos = 0;
          Estado = 5;

          //XYPos = 1;
        }

        if (XYPos == 1) {
          Valor = calibracionB;
          if (!Valor) {
            calibracionB = Valor;
          }
          //change = true;
          // XYPos = 2;
          //Pos = 1;
        }

        if (XYPos == 2) {
          Valor = a4;
          if (!Valor) {
            a4 = Valor;
          }
          change = true;
          //XYPos = 3;
          //Pos = 2;
        }

        if (XYPos == 3) {
          Valor = b4;
          if (!Valor) {
            b4 = Valor;
          }
          change = true;
          //XYPos = 4;
          //Pos = 3;
        }

        if (XYPos == 4) {
          XYPos = 0;
          fn_menu(XYPos, menu, sizemenu);
          Estado = 0;
        }
        Ent = false;
        //lcd.clear();
      }
    } // Fin Estado 4
  }  while (Pesando == false); // Fin estado 4  y engloba do {}

  if (Estado == 5) {
       Botons();
       Encoder(); 
   do {

      Selection(); //Serial.println(Pos);
      
      //////////////
      // Selection();
      //Encoder(); //{
      // }//;
      //fn_changeval(Pos,Val,Valor);
      fn_valmodif();
      // }//;
      // Selection();
      // fn_valmodif();
      int dm1, m1, c1, d1, u1, Valor, ValorN ;
      dm1 = Valor / 10000;
      m1 = Valor / 1000;
      c1 = (Valor - m1 * 100) / 10;
      d1 = (Valor - c1 * 100) / 10;
      u1 = (Valor - d1 * 100) / 10;
      Valor = (dm1, m1, c1, d1, u1);
      Pos = 0;
      MinPos = 0;
      MaxPos = 5;

      if (Ent) {

        if (Pos == 0) {
          lcd.clear();
          change = true;
          //Serial.println(dm1);
          lcd.setCursor(6, 0);
          lcd.print("^    ");
          if (Ent) {
            dm1 = Val ;
            if (!Val or Ent) {
              Val = dm1;
              // Pos = 1;
              Serial.println(dm1);
            }
            //  Ent = false;

            //}
          }
        }

        if (Pos == 1) {
          //Serial.println(Pos);
          lcd.setCursor(7, 0)  ;
          lcd.print(" ^   ");
          // if (Ent) {
          m1 = Val;
          if (!Val or Ent) {
            Val = m1;
            //Pos = 2;
          }
          // Ent = false;
          // }
        }

        if  (Pos == 2) {
          Serial.println(Pos);
          lcd.setCursor(8, 0);
          lcd.print("  ^  ");
          // if (Ent) {
          c1 = Val;
          if (!Val or Ent) {
            Val = c1 ;
            //Pos = 3;
          }
          //Ent = false;
          //}
        }

        if (Pos == 3) {
          Serial.println(Pos);
          lcd.setCursor(9, 0);
          lcd.print("   ^ ");
          // if (Ent) {
          d1 = Val;
          if (!Val or Ent) {
            Val = d1;
            // Pos = 4;
          }
          // Ent = false;
          // }
        }

        if (Pos == 4) {
          Serial.println(Pos);
          lcd.setCursor(10, 0);
          lcd.print("    ^");
          // if (Ent) {
          u1 = Val;
          if (!Val or Ent) {
            Val = u1;
            //Pos = 0;
          } 
        }

        if (Pos == 5) {
          Serial.println(Pos);
          lcd.setCursor(10, 0);
          lcd.print("     ");
          // if (Ent) {
         // if ( Ent) {
            if(!Valor){
              Valor = ValorN;
            //Pos = 0;
            }

            if (Ent){
              ValorN = Valor;

            }
          } 

          change = false;
          //}
        }

        lcd.setCursor(0, 1);
        lcd.print("Valor:");
        lcd.setCursor(7, 1);
        lcd.print(Valor);
        lcd.print(dm1);
        lcd.setCursor(8, 1);
        lcd.print(m1);
        lcd.setCursor(9, 1);
        lcd.print(c1);
        lcd.setCursor(10, 1);
        lcd.print(d1);
        lcd.setCursor(11, 1);
        lcd.print(u1);
        Ent = false;
        //return Valor;
        // change = false;
        //////////////
    } while (change == true); // Fin de do 
    
  } // Fin Estado 5
        //} while (change == true);
   //  Ent = false;



  //}  while (Pesando == false); // Fin estado 5
 
  //Botons();
}// Fin de void loop
//}// Fin do
//} //Fin if  (Ent == true)
//}//


//}////Fin void Menud)
////////////////

// Código del encoder Nº1

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


// Rutina para auto escape si no pulsamos enter o no hay cambio del encoder pasados 30 segundos.

void Selection() {

  if (E == false) {
    if (digitalRead(pinEnt) == LOW) {
      E = true;
    }
  }

  if (E == true) {

    if (digitalRead(pinEnt) == HIGH) {
      E = false;
      //Ent =! Ent;
      Ent = true;
      Serial.println("Ent  ");
      Serial.print(Ent);


      Serial.print("Estado");
      Serial.println(Estado);
      Serial.print("XYPos");
      Serial.println(XYPos);

    }
  }
} // Fin void Selection

void fn_menu(byte XYPos, String menu[], int sizemenu) {
  lcd.clear();
  linea1 = "";
  linea2 = "";

  // if((pos % 2) == 0){
  //if(XYPos == 0){
  if ((XYPos % 2) == 0) {
    lcd.setCursor(0, 0);
    lcd.print("->");
    linea1 = menu[XYPos];

    //if(pos+1 != sizemenu){
    if (XYPos + 1 != sizemenu) {
      linea2 = menu[XYPos + 1];

    }

  } else {
    linea1 = menu[XYPos - 1];
    lcd.setCursor(0, 1);
    lcd.print("->");
    linea2 = menu[XYPos];
  }

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

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

}

//bool  Encoder(byte sizemenu1){
void Encoder() {
  // Código del encoder Nº1
  //Pos = 0;
  if (digitalRead(pinA) == 0) {
    t = time;
    MaxPos = 4;
    if (C == true) {
      Pos ++;  // pos = pos + 1
      if (Pos > MaxPos) {
        Pos--; //Evito conflicto con Encoder
      }


      Val ++;
      if (Val >= 9) {
        Val = 9;
      }
      C = false;
      D = false;
    }
  }

  if (digitalRead(pinB) == 0) {
    t = time;
    MinPos = 0;
    if (D == true) {
      Pos --; // pos = pos - 1
      if (Pos < MinPos) {
        Pos ++; // Evito conflicto con Encoder
      }

      Val --;
      if (Val <= 0) {
        Val = 0;
      }

      D = false;
      C = false; //Bloquea la lectura del A porque el B llego primero
      // y sino se entra y pasa a la posicon antrior
    }
  }

  if (time - t > 20) { //Tengo que esperar 8ms esta bien lo puedes subir a 10 si va rápido  100 ms para registar nuevamente
    C = true;
    D = true;
  }
} // Fin void Encoder

bool Encomovi(byte sizemenu) {


  bool retorno = false;

  A_estado_actual = digitalRead(pinA);

  if (A_estado_actual != A_ultimo_estado) {

    if (digitalRead(pinB) != A_estado_actual) {       //DT != CLK
      XYPos ++;
      /* Pos ++;
        if (Pos > MaxPos) {
         Pos --; // Evito conflicto con Encoder
        }
        Val ++;
        if (Val <= 0) {
         Val = 0;
        } */
      //Serial.println(XYPos);
      delay(250);
    }
    else {
      XYPos --;
      /* Pos --;
        if (Pos < MinPos) {
         Pos ++; // Evito conflicto con Encoder
        }

        Val --;
        if (Val >= 9) {
         Val = 9;
        } */
      //Serial.println(XYPos);
      delay(250);
    }

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

    if (XYPos >= sizemenu - 1 ) {
      XYPos = sizemenu - 1;
    }
    retorno = true;
  }
  return retorno;
}// Fin Encomovi

void  Botons() {
  //boton tara
  if (Et == false) {
    if (digitalRead(tara) == LOW) {
      //Serial.println("Enter");
      digitalWrite(ledPin, LOW);
      Et = true;
    }
  }

  if (Et == true) {

    if (digitalRead(tara) == HIGH) {

      lcd.clear();
      lcd.setCursor(1, 0);
      lcd.print("Basculas puestas a ");
      lcd.setCursor(7, 1);
      lcd.print("0.0 KG");
      digitalWrite(ledPin, HIGH);

      basculaA.tare();
      basculaB.tare();
      //delay(500);
      digitalWrite(ledPin, LOW);
      delay(500);
      lcd.clear();
      Estado = 2 ;

      Pesando = true;
      modAct1 = true;
      Et = false;
    }
  }

  //boton modo
  if (Em  == false) {
    if (digitalRead(modo) == LOW) {
      //Serial.println("Enter");
      digitalWrite(ledPin, LOW);
      Em = true;
    }
  }

  if (Em == true) {

    if (digitalRead(modo) == HIGH) {
      lcd.clear();

      digitalWrite(ledPin, HIGH);

      delay(500);
      digitalWrite(ledPin, LOW);
      modoCon  ++;
      if (modoCon <= 1) {
        modoCon = 1;
      }

      if (modoCon > 5 ) {
        modoCon = 1;
      }
      Pesando = true;

      switch (modoCon) {
        case 1 :

          modAct1 = true;
          modAct2 = false;
          modAct3 = false;
          modAct4 = false;
          modAct5 = false;
          Serial.println("En modo 1");  //switch (var) {case 1:
          break;

        case 2 :
          modAct1 = false;
          modAct2 = true;
          modAct3 = false;
          modAct4 = false;
          modAct5 = false;
          Serial.println("En modo 2");
          break;

        case 3 :
          modAct1 = false;
          modAct2 = false;
          modAct3 = true;
          modAct4 = false;
          modAct5 = false;
          Serial.println("En modo 3");
          break;

        case 4 :
          modAct1 = false;
          modAct2 = false;
          modAct3 = false;
          modAct4 = true;
          modAct5 = false;
          Serial.println("En modo 4");
          break;

        case 5 :
          modAct1 = false;
          modAct2 = false;
          modAct3 = false;
          modAct4 = false;
          modAct5 = true;
          Serial.println("En modo 5");
          break;
      }

      // lcd.clear();

      lcd.setCursor(1, 0);
      lcd.print("Modo ");
      lcd.setCursor(6, 0);
      lcd.print(modoCon);
      delay(750);
      Serial.println("Modo ");
      Serial.println(modoCon);
      lcd.clear();

      Em = false;
    }
  }

  //boton referencia de peso
  if (Erf == false) {
    if (digitalRead(ref_Peso) == LOW) {
      //Serial.println("Enter");
      digitalWrite(ledPin, LOW);
      Erf = true;
    }
  }

  if (Erf == true) {

    if (digitalRead(ref_Peso) == HIGH) {
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Ref.Peso: ");
      lcd.setCursor(9, 0);
      lcd.print("A:");
      lcd.setCursor(11, 0);
      lcd.print(RefA);
      lcd.setCursor(9, 1);
      lcd.print("B:");
      lcd.setCursor(11, 1);
      lcd.print(RefB);
      digitalWrite(ledPin, HIGH);
      //!refact ;
      refact = !refact ;

      digitalWrite(ledPin, LOW);
      delay(1500);
      lcd.clear();
      Erf = false;

      if (refact == false) {
        lcd.setCursor(15, 1);
        lcd.print("     ");
      }
    }
  }
  //} // Fin void Botons ; primero

  //boton atras/salida
  //void exit(){
  if (Eas == false) {
    if (digitalRead(atras_salida) == LOW) {
      //Serial.println("Enter");
      digitalWrite(ledPin, LOW);
      Eas = true;
    }
  }

  if (Eas == true) {

    if (digitalRead(atras_salida) == HIGH) {

      lcd.clear();
      lcd.setCursor(1, 0);
      lcd.print("Atras/Salir ");
      lcd.setCursor(7, 1);
      lcd.print(" < ");
      digitalWrite(ledPin, HIGH);
      delay(500);
      lcd.clear();
      refact = false;
      Pesando = false;


      modAct1 = false;
      //Pesando = false;
      //delay (25);

      modAct2 = false;
      modAct3 = false;
      modAct4 = false;
      modAct5 = false;

      lcd.clear();

      XYPos = 0;
      fn_menu(XYPos, menu, sizemenu);
      Estado - 1;
      /*
        digitalWrite(ledPin, LOW);
        Serial.print("Estado");
        Serial.println(Estado);
        Serial.print("XYPos");
        Serial.println(XYPos); */
      Eas = false;
    }


  }

} // Fin void Botons ; segundo

void fn_valmodif() {
  Pos = 0;
  MaxPos = 4;
  MinPos = 0;
  //Encoder();
  if (change == true) {
    if (Ent) {
      if (Pos == 0) {
        lcd.setCursor(6, 0);
        lcd.print("^    ");
        //Pos = 1;
      }

      if (Pos == 1) {
        lcd.setCursor(7, 0);
        lcd.print(" ^   ");
        //Pos = 2;
      }

      if  (Pos == 2) {
        lcd.setCursor(8, 0);
        lcd.print("  ^  ");
        //Pos = 3;
      }

      if (Pos == 3) {
        lcd.setCursor(9, 0);
        lcd.print("   ^ ");
        //Pos = 4;
      }

      if (Pos == 4) {
        lcd.setCursor(10, 0);
        lcd.print("    ^");
        //Pos = 0;
      }

      Ent = false;
    }
  } //*/
} // Fin fn_valmodif
//---------------------------------------------------------------