/*
    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. 

*/
#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 pesoRef1;
//int pesoRef2;
//int pesoRef3;
//int pesoRef4;
//float pesoG ;
//bool  BigNumber;
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","Calibracion","Configuracion"}; // Estado 0  "Pesar"
int sizemenu = sizeof(menu) / sizeof(menu[0]);

String modo1[] = {"Modo 1", "Modo 2", "Modo 3", "Modo 4","Modo 5"}; // Estado 1 ,"Atras"
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 calib[] = {"Calibar A", "Calibar B","Atras"}; // Estado 3  // 5
int sizecalib = sizeof(calib) / sizeof(calib[0]);

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

String change_val  [] = {"Selecciona","Modifica","Atras"}; // sub Estado 01
int sizechange = sizeof (change_val) / sizeof (change_val[0]);

String select_val  [] = {"Ref.A4","Ref.B4","Calibracion A","Calibracion B"}; // sub Estado 02 "Ref.A1","Ref.A2","Ref.A3", "Ref.B1","Ref.B2","Ref.B3",
int sizeselect = sizeof (select_val) / sizeof (select_val[0]);

int Tara ;
int modoCon = 1; // Contador para modos
float peso1 ;
float peso2 ;
//int tara1 ;
//int tara2 ;
//int total1 ;
//int total2 ;

//int Pesando = 1;
float PesoTotal ;
//bool modAct0 = false;
bool modAct1 = false;
bool modAct2 = false;
bool modAct3 = false;
bool modAct4 = false;
bool modAct5 = false;
//float pesoRef ;
//int pesoRef;
//long unidMedi ;

// 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; */

//int Pesar = 0 ;
//bool Pesar = false;
bool Pesando = false;

int Pos = 0; // Es el que indica la posicion del encoder
//int aux = 
int PosMax = 7;
int PosAux = 0;
//boolean aux = false;
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;
//int opcion = 0;

//int EncMenu = 0;  // level_menu = 0; //Iniciamos la variable en el menu principal
//int nivel_menu = 0;
//int SigEncMenu = 1;
int MaxPos = 7;
int MinPos = 1;

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

int ContExit = 0;

// Para Encoder 2 más swich



// 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;

// Para cambiar valores.
bool change = false;

// 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;

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  ;
 // modAct1 = true;
  //PrintPeso();
  fn_menu(XYPos, menu, sizemenu);       //Iniciamos presentando el pesa como contador=0 mostrara el primer elemento y enviara a pesar
  //fn_menu(XYPos, pesa, sizepesa);
  A_ultimo_estado = digitalRead(pinA);   //Leemos el estado de la salida del Encoder usando el pin CLK
 // PrintPeso(); 
  /////
} // 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);
  }
}



//}// fin void Setup


void loop() {

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


  Botons();
  Encoder();




  //Mod();
  //Scala();
  //RefPeso();
  //Configu();  
  //Calibra();

  do {

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

    //SubMenu Pesar {"A Pesar", "Menu"}

//menu  {"Modo","Referencia Peso","Calibracion","Configuracion", "Pesar"}
     if (Estado == 0) {
      //MaxPos = 7 ;
      //MinPos = 0 ;
      //Serial.print("Estado ");
      //Serial.print(Estado);
      /*
      t = time;
      if (time - t >4000){
        
        XYPos = 1;
        Pesando = true;
        Estado = 2;
        modAct1 = true;
        Serial.println("Inicio automatico");
      } 
      */
      if (Encomovi(sizemenu)) {
        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, calib, sizecalib);
          Estado = 3;
        }

        if (XYPos == 3) {
          XYPos = 0;
          fn_menu(XYPos, conf, sizeconf);
          Estado = 4;
        }
        
        Ent = false;
      }

    }
    /////////////////////////////////////////////////////////////////////////////////////
//SubMenu Modo {"Momo 1","Modo 2","Modo 3","Modo 4","Modo 5"}
    else if (Estado == 1) {
      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"}
    else if (Estado == 2) {
      //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 calib {"Calibar A","Calibar B","Atras"}
    else if (Estado == 3){ //if (Estado == 5 ) {
      
      if (Encomovi(sizecalib)) {
        fn_menu(XYPos, calib, sizecalib);
      }

      if (Ent) {

          if (XYPos == 0) {
           
          //  if (Ent){ 
             Calib_A = true;
                if (Calib_A == true){
                // Estado = 01;
                
                change = true;
                Valor = calibracionA ;
                 
                  if (!Valor){
                   calibracionA = Valor;

                   Calib_A = false;
                  }
                } 
           // }
  
          }

          if (XYPos == 1) {
          //  if (Ent){ 
             Calib_B = true;
              if (Calib_B == true){
              // Estado = 01;
              // fn_valmodif();
               Valor = calibracionB;
                if (!Valor){
                  calibracionB = Valor;
                  Calib_B = false;
                }
              } 
              //XYPos = 1;
             // XYPos = 2;
           // }
            //Ent = false;
          }

         if (XYPos == 2) {
          Serial.println("Atras");
          XYPos = 0;
          fn_menu(XYPos, menu, sizemenu);
          Estado = 0;
         }


         Ent = false;

        }
      }

//Submenu conf[] = {"Por defecto", "Modificar", "Descartar", "Atras"};
    else if (Estado == 4){ //if (Estado == 6) {
      //MaxPos = 1 ;
     // MinPos = 0;

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

      if (Ent) {

        //if(Estado == 5 && Ent == true){
        if (XYPos == 0) {
          lcd.print("Por Defecto");
          delay(500);
          lcd.clear();
            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;
            }

          XYPos = 1;
          //XYPos = 0;
        }

        if (XYPos == 1) {
          //mod;
          //if (Ent == true){
          lcd.print("Modifica");
          delay(500);
          lcd.clear();
          //XYPos = 1;
          Estado = 02;
          XYPos = 0;
        }

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

        Ent = false;

      }

    }

// Sub Estado 01   
/*
else if (Estado == 01){
    //String change_val  [] = {"Selecciona","Modifica","Atras"}; // sub Estado 01
    //int sizechange = sizeof (change_val) / sizeof (change_val[0]);
    if (Encomovi(sizechange)) {
        fn_menu(XYPos, change_val, sizechange);
      }
    if (Ent){  
      if(XYPos == 0){
        //Valor = a1;
        //change = true;
        XYPos = 0;
        fn_menu(XYPos, select_val, sizeselect);
        Estado = 02;
        
      }

      if (XYPos == 1){
        Valor = seleccion; 
         change = true;
          if (!Valor){
            seleccion = Valor;
          }
      }

      if (XYPos == 2){
        XYPos = 0;
        fn_menu(XYPos, menu, sizemenu);
        Estado = 0;
        
      }

      Ent = false;
    }
 }
*/
//Sub estado 02 select_val  [] = {"Ref.A4","Ref.B4","Calibracion A","Calibracion B"}; 
else if (Estado == 02){

    if (Encomovi(sizeselect)){
      fn_menu(XYPos, select_val, sizeselect);
    }

    if(Ent){
       
       if (XYPos == 0){
        Valor = a4;
        //change = true;
       // return Valor;
       }
     
       if (XYPos == 1){
        Valor = b4;
        //change = true;
        //return Valor;
       }

       if (XYPos == 2){
        Valor = calibracionA;
        //change = true;
       //return Valor;
       }

       if (XYPos == 3){
        Valor = calibracionB;
        //change = true;
        //return Valor;
       }
       
    }

    Ent = false;  
  }


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


void Configu() {

}

//}////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 Mod() {

}
/////////

void PrintPeso(){

}

/////////
void Scala() {

}

////A
//Select

void SelectOption() {

  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 select
/////

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);

}

////B

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

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

      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
//////C

//////D
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 ++;
      Val ++;
       if (Val<=0){Val = 0;}
      //Serial.println(XYPos);
      delay(250);
    }
    else {
      XYPos --;
      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

//////D
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;
      }
      //if (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.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) {
      digitalWrite(ledPin, LOW);
      Erf = true;
    }
  }

  if (Erf == true) {

    if (digitalRead(ref_Peso) == HIGH) {

      lcd.clear();
      lcd.setCursor(1,0);
      lcd.print("Ref.Peso: ");
      lcd.setCursor(12,0);
      lcd.print("A:");
      lcd.setCursor(14,0);
      lcd.print(RefA);
      lcd.setCursor(12,1);
      lcd.print("B:");
      lcd.setCursor(14,1);
      lcd.print(RefB);
      digitalWrite(ledPin, HIGH);
      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 (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);
      
      Pesando = false; 
      modAct1 = false;
      modAct2 = false;
      modAct3 = false;
      modAct4 = false; 
      modAct5 = false;

      lcd.clear();

      XYPos = 0;
      fn_menu(XYPos, menu, sizemenu);
      Estado = 0;

      digitalWrite(ledPin, LOW);
      //delay(50);
      Serial.print("Estado");
      Serial.println(Estado);
      Serial.print("XYPos");
      Serial.println(XYPos);
      
      Eas = false;
     }

  }
 
// } // Fin void exit 
 } // Fin void Botons ; segundo
 //if (time - t > 20) {
///////// 

void fn_valmodif(){
 //if (Estado == 01){
  MaxPos=3;
  MinPos=0;
  // int Val;
  int m1,c1,d1,u1, Valor;
  Valor = m1+c1+d1+u1;
  m1 = Valor/1000;
  c1 = (Valor-m1*100)/10;
  d1 = (Valor-c1*100)/10;
  u1 = (Valor-d1*100)/10;
 // change = true;
 // lcd.clear();
  if (change == true){
 
 do {
  //  SelectOption();
   // Serial.print("Pos ");
   // Serial.print(Pos);
  switch  (Pos){
     // lcd.clear();
     case 0:
    // if (Pos == 0){ //XYPos == 0
      lcd.setCursor(7,0);
      lcd.print(""); 
      lcd.setCursor(6,0);
      lcd.print("^");
      //lcd.setCursor(6,1);
      //lcd.print(m1);
      //}
      break ; 

      //if (Pos == 1){
      case 1 :
      lcd.setCursor(6,0);
      lcd.print(" ");
      lcd.setCursor(8,0);
      lcd.print(" ");
      lcd.setCursor(7,0);
      lcd.print("^"); 
      
      //lcd.setCursor(7,1);
      //lcd.print(c1);

    // }
    break;

    // if  (Pos == 2){
    case 2:
      lcd.setCursor(7,0);
      lcd.print(" ");
      lcd.setCursor(9,0);
      lcd.print(" ");
      lcd.setCursor(8,0);
      lcd.print("^");
      
      //lcd.setCursor(8,1);
      //lcd.print(d1);

      //}
      break;

    //if (Pos == 3){
      case 3:
      lcd.setCursor(8,0);
      lcd.print(" ");
      lcd.setCursor(9,0);
      lcd.print("^");
      //lcd.setCursor(9,1);
      //lcd.print(u1);

         //Ent = false; 
         //return Valor;
      // }
      //}
    
     //Ent = false;
     break ;
  }
      
     //return Valor ;
     lcd.setCursor(6,1);
     lcd.print(Valor);
   
  }while( change == true);
 
 //} // Fin Estado == 01
 } // Final if  (change == true)
} // Fin void fn_valmodif()


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