#include "HX711_ADC.h"
#include <LiquidCrystal_I2C.h>
HX711_ADC LoadCell(9, 8);
LiquidCrystal_I2C lcd(0x27,16,2);
const int buzzer = 11;
int button1 = 2;
int button2 = 3;
int button3 = 4;
int button4 = 5;
int taree = 6;
int num = 1;
int buttonState = 0;          
int buttonState1 = 0;
float alarm1 = 0;
float alarm2 = 0;
float z1 = 28.3495;


unsigned long prevTime1 = millis();
unsigned long prevTime2 = millis();

long Time1 = 3000;
long Time2 = 1000;
void setup()
{
  pinMode (button1, INPUT_PULLUP);
  pinMode (button2, INPUT_PULLUP);
  pinMode (button3, INPUT_PULLUP);
  pinMode (button4, INPUT_PULLUP);
  pinMode(buzzer, OUTPUT);
  pinMode (taree, INPUT_PULLUP);
  Serial.begin(9600);
  lcd.init();
  lcd.backlight();
  lcd.clear();
  lcd.setCursor(1, 0);
  lcd.print("Weighing Scale");
  lcd.setCursor(3, 1);
  lcd.print("With Alarm");
  delay(2500);
  lcd.clear();
  delay(150);
  lcd.setCursor(3, 0);
  lcd.print("Taring");
  delay(200);
  lcd.setCursor(9, 0);
  lcd.print(".");
  delay(200);
  lcd.setCursor(10, 0);
  lcd.print(".");
  delay(200);
  lcd.setCursor(11, 0);
  lcd.print(".");
  delay(200);
  lcd.setCursor(12, 0);
  lcd.print(".");
  delay(200);
  delay(1000);
  lcd.clear();
  LoadCell.begin(); 
  LoadCell.start(1000);
  LoadCell.setCalFactor(0.42);
  
   
  

}
void loop() {
 unsigned long currentTime = millis();
 static unsigned long currentTime1 = millis();
 LoadCell.update(); 
 float i = LoadCell.getData(); 
 float z = i/28.3495;
 if(digitalRead(button3) == LOW){
 alarm1=0;
 alarm2=0;
 lcd.clear();}

 buttonState = digitalRead(button2);
   buttonState1 = digitalRead(button1);

       if(buttonState == 0)      
       currentTime1 = millis();
       if(buttonState1 == 0)
       currentTime1 = millis();

 switch(num){
  case 1:
  {
   if(millis() - currentTime1 >= 4000) // else
    { num = 1;
 }  
   else
     num = num; 
  break;
}
case 2:
{
  if(digitalRead(button1) == LOW){alarm1 = alarm1+1;
  delay(75);}
  else if(digitalRead(button2) == LOW){alarm1 = alarm1-1;
  delay(75);}
 if(digitalRead(button3) == LOW)
 alarm1=0;
  lcd.setCursor(1, 0);
  lcd.print("Set for Gram");
  lcd.setCursor(0, 1); // set cursor to secon row
  lcd.print(alarm1, 0); // print out the retrieved value to the second row
  lcd.print("g ");
  
  alarm2 = alarm1/z1;
  lcd.setCursor(9, 1);
  lcd.print(alarm2, 1);
  lcd.print("oz ");

   if(millis() - currentTime1 >= 8000) 
     { num = 1;
     lcd.clear();
 lcd.setCursor(1, 0);
 lcd.print("Weighing Scale");
 delay(500);
 lcd.clear();}    
   else
     num = num;   
  break;}
  case 3:
 {
  if(digitalRead(button1) == LOW){alarm2 = alarm2+1;
  delay(75);}
  else if(digitalRead(button2) == LOW){alarm2 = alarm2-1;
  delay(75);}

lcd.setCursor(1, 0);
  lcd.print("Set for Ounce");
 lcd.setCursor(0, 1); // set cursor to secon row
  lcd.print(alarm1, 0); // print out the retrieved value to the second row
  lcd.print("g  ");
  alarm1 = alarm2 * z1;
  lcd.setCursor(9, 1);
  lcd.print(alarm2, 1);
  lcd.print("oz ");

   if(digitalRead(button3) == LOW)
 alarm2=0;

 if(millis() - currentTime1 >= 4000) // else
     { num = 1;
     lcd.clear();
 lcd.setCursor(1, 0);
 lcd.print("Weighing Scale");
 delay(500);
 lcd.clear();}    
   else
     num = num; 
  break;}
  }

 



  if (digitalRead (taree) == LOW)
  {
    lcd.clear();
    lcd.setCursor(3, 0);
  lcd.print("Taring");
  delay(200);
  lcd.setCursor(9, 0);
  lcd.print(".");
  delay(200);
  lcd.setCursor(10, 0);
  lcd.print(".");
  delay(200);
  lcd.setCursor(11, 0);
  lcd.print(".");
  delay(200);
  lcd.setCursor(12, 0);
  lcd.print(".");
  delay(200);
  delay(500);
    LoadCell.start(1000);
    lcd.setCursor(0, 0);
    lcd.print("                ");
    lcd.clear();
  }
 if (digitalRead (button4) == LOW){{if(num>2) num = 1;
 else num++;
 currentTime1 = millis();
 delay (300);
 lcd.clear();
 delay (300);
}
if (num==3)
{ lcd.setCursor(1, 0);
 lcd.print("Set for Ounce");
 delay(500);
 lcd.clear();}
 
 else if (num==2)
 {lcd.setCursor(1, 0);
 lcd.print("Set for Gram");
 delay(500);
 lcd.clear();}
 else if (num==1)
 {
 lcd.setCursor(1, 0);
 lcd.print("Weighing Scale");
 delay(500);
 lcd.clear();}
 }

if(currentTime - prevTime1 > Time1){
  
  if(i>alarm1 && alarm1>0 )
  {
  noTone(buzzer);
   delay(300);
  tone(buzzer,250);
  delay(300);
  noTone(buzzer);
   delay(300);
  tone(buzzer,450); 
  delay(300);
  noTone(buzzer);
   delay(300);}
   
  prevTime1 = currentTime;
  }
  if(i<-0.9){i==i;} 
  else if(-0.9<i && i<0.1){i=0;}
  
  if(currentTime - prevTime2 > Time2){
  if (i>=3000 && num<4)
  {
    lcd.clear();
    delay(500);
    num=4;
  }else if(num==4 && i<3000){
    num=1;
    lcd.clear();
    delay(1000);
  }
   if(num==1){
    lcd.setCursor(1, 0);
   lcd.print("Weighing Scale");
   lcd.setCursor(0,1);
   lcd.print(i, 0);
   lcd.print("g  ");
   lcd.setCursor(9,1);
   lcd.print(z, 1);
   lcd.print("oz ");}
prevTime2 = currentTime;
   if(num==4){
  lcd.setCursor(0, 0);
  lcd.print("  Over Loaded   "); 
  delay(500);
  lcd.clear();
  delay(500);}

  
  }
  Serial.print(currentTime);
  Serial.print("    ");
  Serial.print(millis());
  Serial.print("    ");
  Serial.print(prevTime2);
  Serial.println("    ");
}

/////////////////////////////////////////////
#include "HX711.h"

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


#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 // poner 2 en el de Emilio
LiquidCrystal_I2C myLCD(LCD_I2C_ADDRESS, LCD_COLUMNS, LCD_ROWS); // LCD_COLUMNS and LCD_ROWS are set by LCDBigNumbers.hpp depending on the defined display

// 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 DOUTa  A1 //const int
 #define SCKa  A0 //const int

 HX711 basculaB;

 #define DOUTb  A3 //const int
 #define SCKb  A2 //const int
 
// Parámetro para calibrar el peso y el sensor

#define calibracionA 229886  // Celda Arduino 20Kg 220000 / 229886
int PosMax;
int Peso;
float pesoKg; // 
int pesoG;
int number;
float pesoPositivo = 0;
int ledPin =  11;
byte modo ;
int tara = 7;
int modo = 8;
int escala = 9;
int Exit = 10;

int Tara = 0;
//int Modo;
int peso1;
int peso2;
int tara1;
int tara2;
int total1;
int total2;

float pesoRef;
int PesoTotal;

long escala; 

// Para Encoder más swichs varios 

int pinEnt = 4;  // Conectado a SW on KY-040 // Inicial en 4//4
int pinA = 5; // Conectado a CLK on KY-040 // Inicial en 6//2
int pinB = 6; // Conectado a DT on KY-040 // inicial en 5//3
int Pos = 0; // Es el que indica la posocionn del encoder
int aux = 0;
//boolean aux = false;
int cursorPos = 0;

unsigned long time;
unsigned long t;
unsigned long tEnt;
bool C = true;
bool D = true;
bool E = false;
bool Ent = false;
int EncMenu = Pos;

bool Em = false;
bool Et = false;

bool Enter = false;

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

void setup() {
    Serial.begin(9600);
    
    // initialize the LED pin as an output:
    pinMode(ledPin, OUTPUT);
    pinMode(tara, INPUT);
    pinMode(modo, INPUT);

    pinMode(pinA,INPUT); //Derecha
    pinMode(pinB,INPUT); //Izquierda
    pinMode(pinEnt,INPUT);//Enter
    Serial.print("Encoder Position");
    Serial.println(Pos);//Contador para la posición
    
    /* 
    basculaA.power_down();
    delay(1000);
    basculaA.power_up();
    while(!basculaA.is_ready()) {}
    basculaA.set_offset( 0 );
    basculaA.set_scale ( 1.000 );
   */
    myLCD.init();
    myLCD.clear();
    myLCD.backlight();

    // assignes each segment a write number
    myLCD.createChar(1,bar1);
    myLCD.createChar(2,bar2);
    myLCD.createChar(3,bar3);
    myLCD.createChar(4,bar4);
    myLCD.createChar(5,bar5);
    myLCD.createChar(6,bar6);
    myLCD.createChar(7,bar7);
    myLCD.createChar(8,bar8);
    
    myLCD.setCursor(1, 0);
    myLCD.print("Bascula de Emilio");
    myLCD.setCursor(0, 1);
    myLCD.print("Al estilo de Marcos");
    delay(3000);
    myLCD.clear();

    
     // Iniciar sensor
    basculaA.begin(DOUTa,SCKa);
    // basculaA.power_down();
    delay(1000);
    //basculaA.power_up();
    //while(!basculaA.is_ready()) {}
        
    //basculaA.set_offset( 0 );
    // Aplicar la calibración 
    // Obtener una lectura de referencia
    long zero_factor = basculaA.read_average();
    // Mostrar la primera desviación
    Serial.print("Zero factor: ");
    Serial.println(zero_factor);
    delay(1500);
    Serial.println("HX711 programa de calibracion");
    Serial.println("Quita cualquier peso de la bascula");
    Serial.println("Una vez empiece a mostrar informacion de medidas");
    Serial.println("coloca un peso conocido encima de la bascula");
    Serial.println("Presiona + para incrementar el factor de calibracion");
    Serial.println("Presiona - para disminuir el factor de calibracion");
    delay(1500);
    
    
    basculaA.set_scale(calibracionA);
    
    // Iniciar la tara
    // No tiene que haber nada sobre el peso
    basculaA.tare();
   
    // Obtener una lectura de referencia
    //long zero_factor = basculaA.read_average();
    // Mostrar la primera desviación
    //Serial.print("Zero factor: ");
    //Serial.println(zero_factor);
    //myLCD.setCursor(0,0);
    //myLCD.print("Raw Value");  
}


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

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

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

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

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

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

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

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

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

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

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);
  }      
}  
    
void printPeso(){
  //if (aux == 0 && Ent == false && Pos == 0){
  /*
  myLCD.setCursor(0,0);
  myLCD.print("              ");
  myLCD.setCursor(0,1);
  lcd.print("              ");
 */
  float pesoKG;
  int m , c, d, u, number;
  pesoG =  pesoKg*1000;
  number = pesoG;
  if(pesoG<40000){ 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;
  
 // myLCD.setCursor(0, 0);
  
  printNumber(m, 0);
  printNumber(c, 4);
  printNumber(d, 7);
  printNumber(u, 10);
  
 //float peso;
 int pesoG= (pesoKg*1000);
 //int gramos= grados*100.0; // centGrados=2756
  pesoKg = basculaA.get_units(10),3; 
  
  //bigNumberLCD.begin(); // Creates custom character used for generating big numbers
  
  //bigNumberLCD.setBigNumberCursor(0);
  //bigNumberLCD.print(pesoG,3); //basculaA.get_units(1), 3
 /*
  myLCD.setCursor(5,1);
  myLCD.print(",");
  bigNumberLCD.setBigNumberCursor(6);
  bigNumberLCD.print(pesoG,3);
  */
  if (pesoKg <=0.999 or pesoKg >= 0.0001){
  myLCD.setCursor(13,1);
  myLCD.print("  ");
  myLCD.setCursor(13,1);
  myLCD.print("G");
   
  }
  
  if (pesoKg >=1.000){
  myLCD.setCursor(13,1);
  myLCD.print("Kg");
  }
  //delay(500);
  
 //}
}

void printModo(){
  myLCD.setCursor(14,0);
  myLCD.print("Md:");
  myLCD.setCursor(17,0);
  myLCD.print("A+B");
}


void printRef(){
  myLCD.setCursor(16,1);
  myLCD.print("R:");
  myLCD.setCursor(18,1);
  myLCD.print("SI");
}


void menuLcd(){
  
   
   myLCD.setCursor(0,0);
   myLCD.print("»");   
  
 
}

void loop() {

  time = millis(); // Registra el tiempo en todo el programa
 //y lo usaré en las distintas instancias.
/*
  //long Now = millis();
  //Tara = digitalRead(tara);
  //float peso;
  // Aplicar calibración
  //long Val = (basculaA.read_average(10)-factor_calibracionA) / factor_calibracionA;
  long Val =(basculaA.read_average(10)-factor_calibracionA) / 2200.000;
  if (Val > 0 ) {GoodValue = Val;}

  if (Now > LastUpdate + 15) { // 50
  Serial.println(GoodValue);
  printPeso();
  LastUpdate = Now;
  
  } */

  if(pesoG >= 0) {  //Remove the error readings of minus values   
    
    //Let's keep this RPM value under control, between 0 and 9999
    pesoG =  (pesoG, 0, 40000);
  }
  //basculaA.set_scale(calibracionA);
  //delay(200);
  //peso = basculaA.get_units((3), 3);
  // Mostrar la información para ajustar el factor de calibración
  Serial.print("Leyendo: ");
  Serial.print(basculaA.get_units(2), 3);
  Serial.print(" kgs");
  Serial.print(" factor_calibracion: ");
  Serial.print(calibracionA);
  Serial.print("Intento Peso en gramos: "); 
  Serial.print(pesoG); 
  Serial.println();
  
 // if(peso >= 0) {  //Remove the error readings of minus values   
    
    //Let's keep this RPM value under control, between 0 and 9999
   // peso = constrain (peso, 0.000, 9999.000);

    //If the engine is not running, print 0
    //if ((micros() - lastPulseTime) < 5e6 ) {
     // peso = peso;
   // }
  swichTime();
  menuLcd();  
  printPeso();
  printModo();
  printRef();
  
/*  
  // Obtener información desde el monitor serie
  if (Serial.available())
  {
    char temp = Serial.read();
    if (temp == '+')
      calibracionA += 10;
    else if (temp == '-')
      calibracionA -= 10;
  }
*/

  //boton tara
  if(Et==false){
    if(digitalRead(tara)==LOW){
      //Serial.println("Enter");
      digitalWrite(ledPin,LOW);
       Et = true;
    }
 }
 
  if(Et == true){
  
  if(digitalRead(tara) == HIGH){
    Serial.println("Bascula puesta a 0.0 KG"); 
    digitalWrite(ledPin,HIGH);
    myLCD.clear();
    myLCD.setCursor(1,0);
    basculaA.tare();
    myLCD.print("Bascula puesta a"); 
    myLCD.setCursor(7,1);
    myLCD.print("0.0 KG");
    delay(3000); 
    myLCD.clear();
    Et = false;
  }
 }



 // Código del encoder
 if (digitalRead(pinA)== 0){
  t=time;
  if(C == true){
    Pos ++;  // pos = pos + 1
    if (Pos>7){Pos--;} //Evito conflicto con Encoder
    Serial.print("Encoder Position: ");
    Serial.println(Pos);
    C = false;
    D = false;
  }
 }

 
 if(digitalRead(pinB)==0){
  t = time;
  if(D == true){
    Pos --; // pos = pos - 1
     if (Pos<-1){Pos ++;}// Evito conflicto con Encoder
         
    Serial.print("Encoder Position");
    Serial.println(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;
 }
 //---------------------------------------------------------------

     //Enter


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


void swichTime(){
  pinEntState = digitalRead(pinEnt);
  
//pasar pista mediante boton
if (pinEntState == HIGH){
    tiempo=millis();
    
    while(pinEntState == HIGH) {
      tiempo2=millis();
      pinEntState = digitalRead(pinEnt);    
      }
      
      tiempo3=tiempo2-tiempo;
      Serial.print(tiempo3);
     
     //1ª posibilidad si está presionado menos de tres segundos next
     
     if (tiempo3 <= 500){
       Serial.println("pulsacion corta");
      
       delay (500);
       }
       
       if (tiempo3 >= 601){
      //comprueba el estado del boton Codigo para diferenciar pulsacion corta ->>   pulsacion larga ->>      
       Serial.println(F("pulsación larga"));
       aux =! aux;// cambia el estado de forma alterna cada vez que se pulsa.          
       Serial.print(" Aux: ");
       Serial.print(aux);
       Serial.print(" Encoder Posicion: ");
       Serial.print(Pos);
       Serial.print(" Estado Ent: ");
       Serial.print(Ent);
       //Ent =! Ent; // para entar en Menu 2º 
       }
     }
   }

   void menud(){PosMax = 6;
    if (Pos == 0){
      myLCD.setCursor (0,0);
      myLCD.print ("A Pesar");
      myLCD.setCursor (0,0);
      myLCD.print("Pon bote a llenar");
      delay(1500);
      myLCD.clear();
      myLCD.print(Peso);
      }

    if (Pos == 1){
      myLCD.setCursor (0,0);
      myLCD.print ("Modo");
      if (Enter == true){
        modo();
        }
     } 

      if (Pos == 2){
      myLCD.setCursor (0,0);
      myLCD.print ("Escala");
      if (Enter == true){
        escala();
        }
      }

      if (Pos == 3){
      myLCD.setCursor (0,0);
      myLCD.print ("Ref. Peso");
      if (Enter == true){
        refPeso();
        }
      }

      if (Pos == 4){
      myLCD.setCursor (0,0);
      myLCD.print ("Configuracion");
      if (Enter == true){
        configu();
        }
      }

        if (Pos == 5){
      myLCD.setCursor (0,0);
      myLCD.print ("Calibración");
      if (Enter == true){
        calib();
        }
      }
    }
   
 /*  void modo (){
    PosMax = 4;
    Pos + 10 = PosAux;
    
    if (PosAux == 11){
     myLCD.setCursor(0,5);
     myLCD.print("A");
      if(Enter == true){
        modoAct = 1;
        Pos -10;}
      }

      if (PosAux == 12){
       myLCD.setCursor(0,5);
       myLCD.print("B");
        if(Enter == true){
          modoAct = 2;
          Pos -11;}
      }
      
      if (PosAux == 13){
       myLCD.setCursor(0,5);
       myLCD.print("A/B");
        if(Enter == true){
          modoAct = 3;
          Pos -12;}
       }

       if (PosAux == 13){
         myLCD.setCursor(0,5);
         myLCD.print("A/B");
          if(Enter == true){
            modoAct = 3;
            Pos -12;}
       } 

       if (PosAux == 13){
         myLCD.setCursor(0,5);
         myLCD.print("A+B");
          if(Enter == true){
            modoAct = 4;
            Pos -13;}
       } 
          
     } */

void escalam(){   
  PosMax =3;
  Pos+20 = PosAux;
   if(PosMax == 21){
    myLCD.setCursor(0,8);
    myLCD.print("Gramos");
     if(Enter==true){
      scalaAct =1;
      Pos = 20;       
     }
    }

    Pos+20 = PosAux;
     if(PosMax == 21){
      myLCD.setCursor(0,8);
      myLCD.print("X Kg");
       if(Enter==true){
        scalaAct =2;
        Pos = 21;       
       }
      } 

      Pos+20 = PosAux;
     if(PosMax == 23){
      myLCD.setCursor(0,8);
      myLCD.print("XX Kg");
       if(Enter==true){
        scalaAct =1;
        Pos = 22;       
       }
      }
      
    }