// Start By The Name Of Allah
// Digital Scale Machine with Unit Change
// By: Imran Sharif
// Technical Minds 
//=================================================================
#include <LiquidCrystal_I2C.h>
#include <HX711_ADC.h>
#include <EEPROM.h>
#include <Wire.h> 

LiquidCrystal_I2C lcd(0x27, 20, 4);   // 16x2
HX711_ADC LoadCell(4, 5);             // parameters: dt pin, sck pin

const int calVal_eepromAdress = 0;
unsigned long t = 0;

const int unit_pin = 2;               //Unit Change Switch Pin
const int tare_pin = 3;               // Tare Switch Pin

boolean bUnit_g = true;

//================================================================= 
void setup()
{  
    Serial.begin(9600); delay(10);
    Serial.println();
    Serial.println("Starting...");
    pinMode(unit_pin, INPUT_PULLUP);
    pinMode(tare_pin, INPUT_PULLUP);
     
    // initialize the LCD
    lcd.init();
    // Turn on the blacklight and print a message.
    lcd.backlight();
    lcd.setCursor(4, 0);
    lcd.print("ENGSOLEX");
    lcd.setCursor(1, 1);
    lcd.print("Weighing Scales"); 
    delay(2000);
    lcd.clear(); 
    //Start weighing: 
    LoadCell.begin();
    //LoadCell.setReverseOutput(); //uncomment to turn a negative output value to positive
    unsigned long stabilizingtime = 2000; // preciscion right after power-up can be improved by adding a few seconds of stabilizing time
    boolean _tare = true; //set this to false if you don't want tare to be performed in the next step
    LoadCell.start(stabilizingtime, _tare);
    if (LoadCell.getTareTimeoutFlag() || LoadCell.getSignalTimeoutFlag())
    {
        Serial.println("Timeout, check MCU>HX711 wiring and pin designations"); 
    lcd.setCursor(1, 1);
    lcd.print("Check Load Cell");
        while (1);
    }
    else
    {
        LoadCell.setCalFactor(1.0); // 420.0 user set calibration value (float), initial value 1.0 may be used for this sketch
        Serial.println("Startup is complete");
    }
   }
 
//================================================================= 
void loop()
{
    static boolean newDataReady = 0;
    const int serialPrintInterval = 0; //increase value to slow down serial print activity
    
          lcd.setCursor(2, 0);
          lcd.print("CAPACITY 5Kg");
 
    // check for new data/start next conversion:
    if (LoadCell.update()) 
        newDataReady = true;
    
    // get smoothed value from the dataset:
    if (newDataReady) 
    {
        if (millis() > t + serialPrintInterval) 
        {
          float weight_g = LoadCell.getData();
          Serial.print("Load_cell output val: ");
          Serial.println(weight_g);
          newDataReady = 0;
          t = millis();

          if (!bUnit_g)
            weight_g = weight_g / 1000;
          String s = String(weight_g);
          lcd.setCursor(2,1);
          lcd.print(s);
          if (bUnit_g)
          lcd.print("  g");
          else
          lcd.print(" Kg");  
          for (int j=0; j<(16 - 2 - s.length() ); j++) 
             lcd.print(" ");
        }
    }
     if (digitalRead(unit_pin)==LOW)
    {
        delay(25);
        while (digitalRead(unit_pin)==LOW);
        Serial.println("change unit");
        delay(25);
        bUnit_g =  !bUnit_g;
    }
      if (digitalRead(tare_pin)==LOW) {
        LoadCell.tareNoDelay(); //tare
    }
    // check if last tare operation is complete:
    if (LoadCell.getTareStatus() == true) {
          lcd.clear();
          lcd.print("Tare complete"); 
          delay(500);
          lcd.clear();
  } 
  // receive command from serial terminal
  if (Serial.available() > 0) {
    char inByte = Serial.read();
    if (inByte == 't') LoadCell.tareNoDelay(); //tare
    else if (inByte == 'c') calibrate(); //calibrate
    else if (inByte == 'e') changeSavedCalFactor(); //edit calibration value manually
  }

  // check if last tare operation is complete
  if (LoadCell.getTareStatus() == true) {
    Serial.println("Tare complete");
  }    
}
void calibrate() 
{
  Serial.println("***");
  Serial.println("Start calibration:");
  Serial.println("Place the load cell an a level stable surface.");
  Serial.println("Remove any load applied to the load cell.");
  Serial.println("Send 't' from serial monitor to set the tare offset.");

  boolean _resume = false;
  while (_resume == false) {
    LoadCell.update();
    if (Serial.available() > 0) {
      if (Serial.available() > 0) {
        char inByte = Serial.read();
        if (inByte == 't') LoadCell.tareNoDelay();
      }
    }
    if (LoadCell.getTareStatus() == true) {
      Serial.println("Tare complete");
      _resume = true;
    }
  }

  Serial.println("Now, place your known mass on the loadcell.");
  Serial.println("Then send the weight of this mass (i.e. 100.0) from serial monitor.");

  float known_mass = 0;
  _resume = false;
  while (_resume == false) {
    LoadCell.update();
    if (Serial.available() > 0) {
      known_mass = Serial.parseFloat();
      if (known_mass != 0) {
        Serial.print("Known mass is: ");
        Serial.println(known_mass);
        _resume = true;
      }
    }
  }

  LoadCell.refreshDataSet(); //refresh the dataset to be sure that the known mass is measured correct
  float newCalibrationValue = LoadCell.getNewCalibration(known_mass); //get the new calibration value

  Serial.print("New calibration value has been set to: ");
  Serial.print(newCalibrationValue);
  Serial.println(", use this as calibration value (calFactor) in your project sketch.");
  Serial.print("Save this value to EEPROM adress ");
  Serial.print(calVal_eepromAdress);
  Serial.println("? y/n");

  _resume = false;
  while (_resume == false) {
    if (Serial.available() > 0) {
      char inByte = Serial.read();
      if (inByte == 'y') {
#if defined(ESP8266)|| defined(ESP32)
        EEPROM.begin(512);
#endif
        EEPROM.put(calVal_eepromAdress, newCalibrationValue);
#if defined(ESP8266)|| defined(ESP32)
        EEPROM.commit();
#endif
        EEPROM.get(calVal_eepromAdress, newCalibrationValue);
        Serial.print("Value ");
        Serial.print(newCalibrationValue);
        Serial.print(" saved to EEPROM address: ");
        Serial.println(calVal_eepromAdress);
        _resume = true;

      }
      else if (inByte == 'n') {
        Serial.println("Value not saved to EEPROM");
        _resume = true;
      }
    }
  }

  Serial.println("End calibration");
  Serial.println("***");
  Serial.println("To re-calibrate, send 'r' from serial monitor.");
  Serial.println("For manual edit of the calibration value, send 'c' from serial monitor.");
  Serial.println("***");
}

void changeSavedCalFactor() {
  float oldCalibrationValue = LoadCell.getCalFactor();
  boolean _resume = false;
  Serial.println("***");
  Serial.print("Current value is: ");
  Serial.println(oldCalibrationValue);
  Serial.println("Now, send the new value from serial monitor, i.e. 696.0");
  float newCalibrationValue;
  while (_resume == false) {
    if (Serial.available() > 0) {
      newCalibrationValue = Serial.parseFloat();
      if (newCalibrationValue != 0) {
        Serial.print("New calibration value is: ");
        Serial.println(newCalibrationValue);
        LoadCell.setCalFactor(newCalibrationValue);
        _resume = true;
      }
    }
  }
  _resume = false;
  Serial.print("Save this value to EEPROM adress ");
  Serial.print(calVal_eepromAdress);
  Serial.println("? y/n");
  while (_resume == false) {
    if (Serial.available() > 0) {
      char inByte = Serial.read();
      if (inByte == 'y') {
#if defined(ESP8266)|| defined(ESP32)
        EEPROM.begin(512);
#endif
        EEPROM.put(calVal_eepromAdress, newCalibrationValue);
#if defined(ESP8266)|| defined(ESP32)
        EEPROM.commit();
#endif
        EEPROM.get(calVal_eepromAdress, newCalibrationValue);
        Serial.print("Value ");
        Serial.print(newCalibrationValue);
        Serial.print(" saved to EEPROM address: ");
        Serial.println(calVal_eepromAdress);
        _resume = true;
      }
      else if (inByte == 'n') {
        Serial.println("Value not saved to EEPROM");
        _resume = true;
      }
    }
  }
  Serial.println("End change calibration value");
  Serial.println("***");
}