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

*/

#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 menu1[] = {"Modo","Referencia Peso","Escala","Calibracion","Configuracion","Pesar"}; // Estado 1
int sizemenu = sizeof(menu1) / sizeof(menu1[0]);

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

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

String escal[] = {"Dk", "Kg", "G", "Dg", "Cg", "Mg", "No decimales"}; // Estado 4
int sizeescal = sizeof(escal) / sizeof(escal[0]);

String calib[] = {"Calibar A", "Calibar B",}; // Estado 5
int sizecalib = sizeof(calib) / sizeof(calib[0]);

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



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 = 0;

//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 = 0;
int PosMax = 7;
int PosAux = 0;
//boolean aux = false;
int cursorPos = 0;
int XYPos = 0;


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 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 activacion al pulsar boton escala
bool Escal = true;
// Medidas de peso/ Escalas de pesado

bool Mg ;
bool Dg ;
bool Cg ;
bool G  ;
bool Kg = true;
bool Dk ;
// Contador para escalas

int  contescal = 1;
int  contescal1 = 1; // unidades
int  contescal2 = 0; // decimales

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

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


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");
  //delay(1000);
  //lcd.clear();


  // 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();
  Escal = true;

  contescal = 1;

  refact = true;
  RefA = a1;
  RefB = b1;
  Pesando = true ;
 // modAct1 = true;
  //PrintPeso();
  fn_menu(XYPos, menu1, 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
 // 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();
  // Menud();
  //PrintPeso();
  //}




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

  do {

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

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

    if (Estado == 0) {
      MaxPos = 11;
      MinPos = 0;
      //Pesando = false;
      t = time;

      if (Encomovi(sizepesa)) {
        fn_menu(XYPos, pesa, sizepesa);

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

      if (Ent) {

        if (XYPos == 0 ) {
          Serial.println("A Pesar ");
          Pesando = true;
          Estado = 2;
          XYPos = 0;
        }

        if (XYPos == 1) {
          Pesando = false;
          Serial.println("Estado  ");
          Serial.print(Estado);
          Estado = 1;
          XYPos = 0;
        }

        Ent = false;
        //
      }
    }




    //////////////////////////////////////////////////////////////////////////////////

    /////////////////////////////////////////////////////////////////////////////////
    //menu  {"Modo","Referencia Peso","Escala","Calibracion","Configuracion", "Pesar"}
    if (Estado == 1) {
      MaxPos = 7 ;
      MinPos = 0 ;
      if (Encomovi(sizemenu)) {
        fn_menu(XYPos, menu1, sizemenu);
      }

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


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


        if (XYPos == 2) {
          XYPos = 0;
          fn_menu(XYPos, escal, sizeescal);
          Estado = 4;
        }

        if (XYPos == 3) {
          XYPos = 0;
          fn_menu(XYPos, calib, sizecalib);
          Estado = 5;
        }


        if (XYPos == 4) {
          XYPos = 0;
          fn_menu(XYPos, conf, sizeconf);
          Estado = 6;
        }

        if (XYPos == 5) {
          XYPos = 0;
          fn_menu(XYPos, pesa, sizepesa);
          //Estado = 6;
          Estado = 0;
        }
        Ent = false;
      }

    }
    /////////////////////////////////////////////////////////////////////////////////////
//SubMenu Modo {"Momo 1","Modo 2","Modo 3","Modo 4","Modo 5"}
    if (Estado == 2) {
      MaxPos = 6;
      MinPos = 0;
      //modAct1 = true;
      refact = true;
      
      if (Pesando == true && Eas == true){
        Pesando = false;
        (modAct1,modAct2,modAct3,modAct4,modAct5) = false;
        fn_menu(XYPos, menu1, sizemenu);
        A_ultimo_estado = digitalRead(pinA);
      }
      
      if (modoCon == 1) {
        modAct1 = true;
        (modAct2,modAct3,modAct4,modAct5) = false;
        Serial.println("En modo 1");
      }

      if (Encomovi(sizemodo)) {
        fn_menu(XYPos, modo1, sizemodo);
      }

      if (Ent) {
        Pesando = true;

        if (XYPos == 0) {
          modAct1  = true;
          (modAct2,modAct3,modAct4,modAct5) = false;
          XYPos = 1;} 
       /*
        if (modoCon == 1) {
          modAct1 = true;
          (modAct2,modAct3,modAct4,modAct5) = false;
          Serial.println("En modo 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); //0
                printNumber(c, 3); //4  3
                printNumber(d, 6); //7  6
                printNumber(u, 9); //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");
                }
            

                refact = true;
                if (refact == true ){ 
                  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);



        if (XYPos == 1) {
          modAct2 = true ;
          (modAct1,modAct3,modAct4,modAct5) = false;
          XYPos = 2;}  
         /*
        if (modoCon == 1) {
          modAct2 = true;
          (modAct1,modAct3,modAct4,modAct5) = false;
          Serial.println("En modo 2");
        }  
         */
             do{
                exit();
                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); //0
                printNumber(c, 3); //4  3
                printNumber(d, 6); //7  6
                printNumber(u, 9); //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");
                }

                refact = true;
                if (refact == true ){ 
                    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);   


        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); //0
                printNumber(c, 3); //4  3
                printNumber(d, 6); //7  6
                printNumber(u, 9); //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");
                }
            
                refact = true;
                if (refact == true ){ 
                  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);



        if (XYPos == 3) {
          lcd.clear();
          modAct4 = true ;
          (modAct1,modAct2,modAct3,modAct5) = false; 
          XYPos = 4;}
             do{ 
                exit();
                Botons();
                peso1 = basculaA.get_units(4), 5;
                peso2 = basculaB.get_units(4), 5;
                //PesoTotal = (peso1 + peso2);

                
                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("modAct4 ");
                Serial.println("Peso 1 ");
                Serial.println (peso1,3);
                Serial.println("Peso 2 ");
                Serial.println (peso2,3);

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

                if (peso1*1000 >= 1000 ){ 
                  lcd.setCursor(12, 1);
                  lcd.print("K");
                }
            
                refact = true;
                if (refact == true ){ 
                  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 >= 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();
                  }
                }
        
              } while (modAct4 == true);

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

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

                
                lcd.setCursor(15, 0);
                lcd.print("M:");
                lcd.setCursor(17, 0);
                lcd.print("A≠B");

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

                Serial.println("modAct5 ");
                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");
                }
            
                
                refact = true;
                if (refact == true ){ 
                  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 (modAct5 == true);

        Ent = false;

      }

    }


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


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

      if (Ent) {
        //if(Estado == 3 && Ent == true){
        if (XYPos == 0) {
          // if (Ent == true){
          // pesoRef1;
          RefA = a1;
          //XYPos = 0;
          XYPos = 1;
        }


        if (XYPos == 1) {
          // if (Ent == true){
          //pesoRef2;
          RefA = a2;
          //XYPos = 1;
          XYPos = 2;
        }


        if (XYPos == 2) {
          //if (Ent == true){
          //pesoRef3;
          RefA = a3;
          //XYPos = 1;
          XYPos = 3;
        }


        if (XYPos == 3) {
          // if (Ent == true){
          //pesoRef4;
          RefB = b1;
          //XYPos = 1;
          XYPos = 4;
        }

        if (XYPos == 4) {
          //if (Ent == true){
          //pesoRef5;
          RefB = b2;
          //XYPos = 1;
          XYPos = 5;
        }


        if (XYPos == 5) {
          // if (Ent == true){
          //pesoRef6;
          RefB = b3;
          //XYPos = 1;
          Estado = 0;
        }

        Ent = false;
      }

    }


//SubMenu escal {"Dk","Kg","G","Dg","Cg","Mg","No decimales"}
    if (Estado == 4) {
      MaxPos = 6;
      MinPos = 0;

      if (Encomovi(sizeescal)) {
        fn_menu(XYPos, escal, sizeescal);
      }

      if (Ent) {


        //if(Estado == 4 && Ent == true){
        if (XYPos == 0) {
          //if (Ent == true){
          Dk = true;
          //(Kg,G,Dg,Cg,Mg) == false;
          // XYPos = 0;
          contescal1 = 1;
          Escal = true,
          XYPos = 1;
          //}
          if ( Dk == true) {
            // (Kg,G,Dg,Cg,Mg) == false;
            (Kg, G) = false;
          }

        }


        if (XYPos == 1) {
          //if (Ent == true){
          Kg = true;
          //XYPos = 1;
          contescal1 = 2;
          //Escal = true,
          XYPos = 2;
          //}
          if (Kg == true) {
            //(Dk,G,Dg,Cg,Mg) == false;
            (Dk, G) = false;
          }
        }


        if (XYPos == 2) {
          //if (Ent == true){
          G = true;
          //XYPos = 1;
          contescal1 = 3;
          //Escal = true,
          XYPos = 3;
          // }
          if (G == true) {
            //(Dk,Kg,Dg,Cg,Mg) == false;
            (Dk, Kg) = false;
          }
        }


        if (XYPos == 3) {
          // if (Ent == true){
          Dg = true;
          //XYPos = 1;
          contescal2 = 1;
          //Escal = true,
          XYPos = 4;
          //}
          if (Dg == true) {
            //(Dk,Kg,G,Cg,Mg) == false;
            (Cg, Mg) = false;
          }
        }


        if (XYPos == 4) {
          //if (Ent == true){
          Cg = true;
          //XYPos = 1;
          contescal2 = 2;
          //Escal = true,
          XYPos = 5;
          //}
          if (Cg == true) {
            //(Dk,Kg,G,Dg,Mg) == false;
            (Dg, Mg) = false;
          }
        }


        if (XYPos == 5) {
          // if (Ent == true){
          Mg = true;
          //XYPos = 1;
          contescal2 = 3;
          //Escal = true,
          XYPos = 6;
          //}
          if (Mg == true) {
            //(Dk,Kg,G,Dg,Mg) == false;
            (Dg, Cg) = false;
          }
        }


        if (XYPos == 6) {
          //(Dk,Kg,G,Dg,Cg) == false;
          (Dg, Cg, Mg) = false;
          contescal2 = 0;
          //Escal = true,
          Estado = 0;
        }

        Ent = false;
      }
      // if(Estado == 4 && Ent == false){
      // }
    }

//SubMenu calib {"Calibar A","Calibar B","Descartar","Atras"}
    if (Estado == 5 ) {
      MaxPos = 3;
      MinPos = 0;


      if (Encomovi(sizecalib)) {
        fn_menu(XYPos, calib, sizecalib);
      }

      if (Ent) {

        // if(Estado == 6 && Ent == true){
        if (XYPos == 0) {
          //if (Ent == true){
          Calib_A = true;
          //calibA();
          //XYPos = 0;
          XYPos = 1;
        }


        if (XYPos == 1) {
          // if (Ent == true){
          Calib_B = true;
          //calibB();
          //XYPos = 1;
          XYPos = 2;
        }


        if (XYPos == 2) {
          // descarta();
          //if (Ent == true){
          Serial.println("Descarta");
          //XYPos = 1;
          XYPos = 3;
        }


        if (XYPos == 3) {
          //atras();
          //if (Ent == true){
          Serial.println("Atras");
          Estado = 0;
          //XYPos = 1;
        }


        Ent = false;

      }
    }

//SubMenu pesa  {"A Pesar","Menu"}
    if (Estado == 6) {
      MaxPos = 1 ;
      MinPos = 0;
      t = time;
      if (time - t >3000){
        Pesando = true;
        Estado = 2;
        XYPos = 1;
      }

      if (Encomovi(sizepesa)) {
        fn_menu(XYPos, pesa, sizepesa);
      }

      if (Ent) {

        //if(Estado == 5 && Ent == true){
        if (XYPos == 0) {
          // defol;
          //if (Ent == true){
          Serial.println("A Pesar");
          Pesando = true;
          Estado = 2;
          XYPos = 1;
          //XYPos = 0;
        }


        if (XYPos == 1) {
          //mod;
          //if (Ent == true){
          Serial.println("Menu");
          //XYPos = 1;
          Estado = 1;
          XYPos = 0;
        }

        Ent = false;

      }

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


void Configu() {

}
/////////

/////////

/*

     int menu;
     String arrayMenu[] = {"A","B","A+B","A y B"};
     int size = sizeof(arrayMenu) / sizeof(arrayMenu[0]);
     Encoder();

     if(menu == -1)Sig_Estado = 1;
     else if(menu == 1)Sig_Estado = 31;
     else if(menu == 2)Sig_Estado = 32;
     else if(menu == 3)Sig_Estado = 33;
     else if(menu == 4)Sig_Estado = 34;
     //Sig_Estado = 4;

*/
//}////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(){
 // Pesando = true;
 // modAct1 = true;
 // BigNumber = true ; 
//  while  ( Pesando == true) {
    //lcd.setCursor(15, 0);
   // lcd.print("M:");
    //Botons();
  /*  
      if (Ent ) {
        if(Pesando==true){
          Pesando = false;
         
          }
         Ent = false;
        }
         



    //Pesando = false;
    //}
    
    if (modAct0 == true ){
        Pesando = false;
        Estado = 1;
      } 

 
    if ((Pesando == true) &&((!Ent) or (!Botons) or (!Encoder))) {
      Pesando = false;
      //fn_menu(XYPos,menu1,sizemenu); //Iniciamos presentando el menu principal como contador=0 mostrara el primer elemento del Menu
      Estado = 0;
    } 

    //float peso;
    //int pesoG = (pesoKg*1000);
    //int gramos= grados*100.0; // centGrados=2756


    peso1 = basculaA.get_units(5), 5;
    peso2 = basculaB.get_units(5), 5;
    PesoTotal = (peso1 + peso2);
   // modAct1 = true;

    //if (modAct1 == true or  modAct2 == true or modAct3 == true) {
       //BigNumber = true; 
      //if (modAct1 == true){
        
     // } 
     if (BigNumber == true){
          
          int m, c, d, u, number;
          //number = 
      
          //pesoG =  (peso1 or peso2 or PesoTotal);
          //number = pesoG*1000;


          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;

          printNumber(m, 0); //0
          printNumber(c, 3); //4  3
          printNumber(d, 6); //7  6
          printNumber(u, 9); //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");
          }
      
        
          if   (modAct1 == true) {
            number =  (peso1*1000);
            lcd.setCursor(15, 0);
            lcd.print("M:");
            lcd.setCursor(17, 0);
            lcd.print("A");
           // number = peso1*1000;
            Serial.println("modAct1 ");
              //  delayMicroseconds(10);
            Serial.println (peso1,3);
            //printNumber(m,0);
            //printNumber(c,3);
            //printNumber(d,6);
           // printNumber(u,9);
          } 

          if (modAct2 == true) {
          // number =  peso2;
            lcd.setCursor(15, 0);
            lcd.print("M:");
            lcd.setCursor(17, 0);
            lcd.print("B");
            number = peso2*1000 ;
            Serial.println(peso2,3);
          }

          if (modAct3 == true) {
            //number =  PesoTotal;
            lcd.setCursor(15, 0);
            lcd.print("M:");
            lcd.setCursor(17, 0);
            lcd.print("A+B");
            number = PesoTotal*1000 ; 
            Serial.println(PesoTotal,3);
          }
      //}    
     // printNumber(m,0);
      // printNumber(c,3);
      //printNumber(d,6);
      //printNumber(u,9);
   } 

   // BigNumber = false;
    

    if (modAct4 == true) {
      BigNumber = false; 
      lcd.setCursor(0, 0);
      lcd.print(peso1,3);
      lcd.setCursor(0, 1);
      lcd.print(peso2,3);
      lcd.setCursor(15, 0);
      lcd.print("M:");
      lcd.setCursor(17, 0);
      lcd.print("AyB");
      Serial.println(peso1 );
      Serial.println (peso2 );
    }

    if (modAct5 == true) {
      BigNumber = true; 
      lcd.setCursor(0, 0);
      lcd.print(peso1,3);
      lcd.setCursor(0, 1);
      lcd.print(peso2,3);
      lcd.setCursor(15, 0);
      lcd.print("M:");
      lcd.setCursor(17, 0);
      lcd.print("A≠B");
    }

     if (refact == true) {
      lcd.setCursor(14, 1);
      lcd.print("R:");


      if (RefA == a1) {
        lcd.setCursor(16, 1);
        lcd.print("a1");
      }
      if (RefA == a2 ) {
        lcd.setCursor(16, 1);
        lcd.print("a2");
      }
      if (RefA == a3 ) {
        lcd.setCursor(16, 1);
        lcd.print("a3");
      }
      if (RefB == b1 ) {
        lcd.setCursor(18, 1);
        lcd.print("b1");
      }
      if (RefB == b2) {
        lcd.setCursor(18, 1);
        lcd.print("b2");
      }
      if (RefB == b3) {
        lcd.setCursor(18, 1);
        lcd.print("b3");
      }
    }

    if ( refact == false) {
      lcd.setCursor(15, 1);
      lcd.print("    ");
    }

*

 // } //Final de while o if (Pesando == true)

}


/////////
void RefPeso() {

  /////////Insertar valor ref
  //int change_mass(int value, int unit, bool op)
  //     int pesoRef (int value, int unit, bool op)
  /* {
      if(op){
        value += 1;
      else

        value -= 1;

      value = (value + 10) % 10;

      switch(unit)
      {
        case -1:
          lcd.setCursor(11, 1);
          break;

        case 0:
          lcd.setCursor(9, 1);
          break;

        case 1:
          lcd.setCursor(8, 1);
          break;
      }

      lcd.print(value);
      return value;
    } */
  ////////Fin Insertar valor ref

}

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

}

////A
//Select


void SelectOption() {


  if (E == false) {
    if (digitalRead(pinEnt) == LOW) {
      //Serial.println("Enter");
      //Ent = false ;
      E = true;
    }
  }

  if (E == true) {

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

      //Ent = true;
    }
  }
} // Fin void select
/////
////A

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

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

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

    }

  } else {
    linea1 = menu1[XYPos - 1];
    lcd.setCursor(0, 1);
    lcd.print("->");
    linea2 = menu1[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
      }
      // XYPos ++ ;
      //Serial.println("Encoder Position: ");
      //Serial.println("XPPos");
      //Serial.print(XYPos);
      // Serial.println("Pos");
      // Serial.print(Pos);
      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
      }
      // XYPos --;

      //Serial.println("Encoder Position"
      //Serial.println("XPPos");
      //Serial.print(XYPos);
      //Serial.println("Pos");
      // Serial.print(Pos);

      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 ++;
      //Serial.println(XYPos);
      delay(250);
    }
    else {
      XYPos --;
      //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 = 0 ;
      
      Pesando = true;
      //PrintPeso();
      //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();
      lcd.setCursor(1, 0);
      lcd.println("Modo ");
      lcd.setCursor(7, 1);
      lcd.print(modoCon);
      Serial.print("Modo Activo");
      Serial.print(modoCon);
      digitalWrite(ledPin, HIGH);



      delay(500);
      digitalWrite(ledPin, LOW);
      //delay(500);
      //Estado = 1;
      // Pesando = true;
      //PrintPeso();
      modoCon  ++;
     // Pesando = true;
      //PrintPeso();
      if (modoCon <= 1) {
        modoCon = 1;
        //Escal = true;
      }
      //if (ModoCon = 1) {
      //  Pesando=true;
     // }
      if (modoCon > 5 ) {
        // Escal = false;
        modoCon= 1;
      }
      //if (ModoCon = 1) {
       Pesando=true;
       //PrintPeso();  
      //}
      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(1, 0);
      lcd.print("Ref. Peso ");
      lcd.setCursor(7, 1);
      lcd.print(RefA, RefB);
      digitalWrite(ledPin, HIGH);
      //!refact ;
      refact = !refact ;

      delay(500);
      digitalWrite(ledPin, LOW);
      //delay(500);
      lcd.clear();
      Pesando = true;
      //PrintPeso();
      Erf = false;
    }
  }
} // Fin void Botons 

  //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);
      Estado --;
      return Estado;

     /* XYPos --;

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

      if ((XYPos == 0) && (digitalRead(atras_salida) == HIGH)) {
        Estado --;

        if (Estado <= 0) {
          Estado = 0;
          Pesando = false;
        }

        if ((Estado == 0) && (digitalRead (atras_salida ) == HIGH)){
          //Estado = 1;
          fn_menu(XYPos,menu1,sizemenu);
          A_ultimo_estado = digitalRead (pinA);
        }
        
      }

      */

      digitalWrite(ledPin, LOW);
      //delay(250);

      Serial.print("XYPos");
      Serial.println(XYPos);
      Serial.print("Estado");
      Serial.println(Estado);
      lcd.clear();
     /* if ( Estado == 0 && XYPos == 0){
        Pesando = false;
        
      } */
    
      Eas = false;
     }

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