HX711_2_loadcells_128x64_V1.03.ino

/*
 Basic 2 loadcell program measuring belt tesion for 3D printers
 Optimized for Arduino Nano board
 Maximum loadcell weight 2 Kg
 HX711.DOUT  - we use digital pins
 HX711.PD_SCK - we use digital pins
 HX711 XWF is set @ 10 samples/second (standard setting)
 pin A4 I2C SDA for Oled display
 pin A5 I2C SLC for Oled display
 Calibration can only start when two HX711 are connected to the Nano
 Version V1.03 16-6-2023
 Use IDE 2.1.0
 */
 
#include <U8glib.h>             //Oli Kraus U8G version 1.19.1 from library manager
#include <Wire.h>               //inbox
#include <EEPROM.h>             //inbox
#include <HX711.h>              //BOGDE HX711 version 0.7.5 from library manager
#include <JC_Button.h>          //Jack Christensen version 2.1.2 from library manager

HX711 Scale1; // Loadcell_1 hardware check
HX711 Scale2; // Loadcell_2 hardware check

// HX711 circuit wiring
const int Loadcell_1_DOUT_PIN = 7;
const int Loadcell_1_SCK_PIN = 6;
const int Loadcell_2_DOUT_PIN = 4;
const int Loadcell_2_SCK_PIN = 5;

int ValueA1, ValueA2;               // stores the low value of the ramp
int ValueB1, ValueB2;               // stores the high value of the ramp
int ValueATemp1, ValueATemp2;       // stores the temp low value of the ramp
int ValueOut1, ValueOut2;           // the output value in grams
int ForceValueRaw1, ForceValueRaw2; // the raw value from the HX711
int ForceTemp1, ForceTemp2;         // Value without zero-ing value
int ForceZero1, ForceZero2;         // Zero-ing value
int CalibWeight = 100;              // Calibration weight at first calibration. Can be altered during calibration sequence and stored in EEprom
long Address = 0;                   // Starting at the first byte on the eeprom
int CountValue = 1;
bool Reverse =  0;                  // Reverse is used for swapping the loadcell collums in the display
//int LoadBRX;                        // calibration value coming from serial read //debug

//---button settings -----------

#define RIGHT_PIN 8        //from Arduino pin to ground
#define DOWN_PIN 9         //from Arduino pin to ground
#define LEFT_PIN 10        //from Arduino pin to ground
#define SELECT_PIN 11      //from Arduino pin to ground
#define UP_PIN 12          //from Arduino pin to ground
//-
#define PULLUP true        //To keep things simple, we use the Arduino's internal pullup resistor.
#define INVERT true        //Since the pullup resistor will keep the pin high unless the switch is closed, this is negative logic, i.e. a high state means the button is NOT pressed. (Assuming a normally open switch.)
#define DEBOUNCE_MS 20     //A debounce time of 20 milliseconds usually works well for tactile button switches.
//-
#define REPEAT_FIRST1 500   //ms required before repeating on long press
#define REPEAT_INCR1 100    //repeat interval for long press
#define MIN_COUNT1 0
#define MAX_COUNT1 20000
#define REPEAT_FIRST2 500   //ms required before repeating on long press
#define REPEAT_INCR2 100    //repeat interval for long press
#define MIN_COUNT2 0
#define MAX_COUNT2 20000
//-
enum {WAIT1, INCR1, DECR1, WAIT2, INCR2, DECR2};         //The possible states for the state machine
uint8_t STATE1, STATE2;                                  //The current state machine state
int PulseCounter1, PulseCounter2, PulseCounter3;         //The number that is adjusted
int lastPulseCounter1, lastPulseCounter2 = 0;            //Previous value of count (initialized to ensure it's different when the sketch starts)
unsigned long rpt1 = REPEAT_FIRST1;                      //A variable time that is used to drive the repeats for long presses
unsigned long rpt2 = REPEAT_FIRST2;                      //A variable time that is used to drive the repeats for long presses

// buttons used for calibration and tare function
Button btnUP(UP_PIN, PULLUP, INVERT, DEBOUNCE_MS);         //raise the calibration weight value
Button btnDOWN(DOWN_PIN, PULLUP, INVERT, DEBOUNCE_MS);     //lower the calibration weight value
Button btnLEFT(LEFT_PIN, PULLUP, INVERT, DEBOUNCE_MS);     //controlling calibration step value from 1-10-50-200
Button btnRIGHT(RIGHT_PIN, PULLUP, INVERT, DEBOUNCE_MS);   //step through calibration sequence
Button btnSELECT(SELECT_PIN, PULLUP, INVERT, DEBOUNCE_MS); //return to main menu and tare function

//---------------------------------------end button-------------------------------------------

U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NONE | U8G_I2C_OPT_DEV_0); //I2C OLED display driver line

void setup()
{
  Scale1.begin(Loadcell_1_DOUT_PIN, Loadcell_1_SCK_PIN);
  Scale2.begin(Loadcell_2_DOUT_PIN, Loadcell_2_SCK_PIN);
 
  //read the data from the EEprom and put it in the variables
  ValueA1 = (EEPROMReadlong(0)); // read the EEprom value
  ValueB1 = (EEPROMReadlong(4)); // read the EEprom value
  ValueA2 = (EEPROMReadlong(8)); // read the EEprom value
  ValueB2 = (EEPROMReadlong(12)); // read the EEprom value
  CalibWeight = (EEPROMReadlong(16)); // read the EEprom value
  //------------------------------------------------------------

  Serial.begin(9600);
  Serial.println("2 x LOAD CELL READER");
  Serial.println("Version 1.02     ");
  Serial.println("Jupa Creations");
  Serial.println("The Netherlands");
  Serial.print("CalibWeight-"); Serial.println(CalibWeight);
  Serial.print("ValueA1 "); Serial.println(ValueA1);
  Serial.print("ValueB1 "); Serial.println(ValueB1);
  Serial.print("ValueA2 "); Serial.println(ValueA2);
  Serial.print("ValueB2 "); Serial.println(ValueB2);

  PulseCounter1 = 0;  // for calibration value up or down
  PulseCounter2 = 0;  // for calibration sequence
  PulseCounter3 = 0;  // for calibration value up/down counter pre set
  
  ForceZero1 = 0;
  ForceZero2 = 0;
  ValueOut1 = 0;
  ValueOut2 = 0;
  Reverse = 1; // Reverse is used for swapping the collums in the display. If value is 0 we look from the rear of the machine. If value is 1 we look from the front of the machine.
}

void loop()//---------------------------------------------------------------
{
  // picture loop
  u8g.firstPage();
  do
  {
    draw();
  } while ( u8g.nextPage() );

  // rebuild the picture after some delay
  delay(10);

  if (CalibWeight >= 10000 && CalibWeight < 0 )
{
  CalibWeight = 9999; //prevention for corrupted eeprom value
}
// do we need a negative trap too?
//read the push buttons
btnUP.read();
btnDOWN.read();
btnLEFT.read();
btnRIGHT.read();
btnSELECT.read();

// a counter to raise or lower the calibration value step by step or quickly
if (PulseCounter1 != lastPulseCounter1)
{ //print the count if it has changed
  lastPulseCounter1 = PulseCounter1;
  //Serial.println(PulseCounter1, DEC); //debug
}

switch (STATE1)
{
  case WAIT1:                              //wait for a button event
    if (btnUP.wasPressed())
        STATE1 = INCR1;
      else if (btnDOWN.wasPressed())
        STATE1 = DECR1;
      else if (btnUP.wasReleased())         //reset the long press interval
        rpt1 = REPEAT_FIRST1;
      else if (btnDOWN.wasReleased())
        rpt1 = REPEAT_FIRST1;
      else if (btnUP.pressedFor(rpt1))
      { //check for long press
        rpt1 += REPEAT_INCR1;                //increment the long press interval
        STATE1 = INCR1;
      }
      else if (btnDOWN.pressedFor(rpt1))
      {
        rpt1 += REPEAT_INCR1;
        STATE1 = DECR1;
      }
      break;

    case INCR1:                                //increment the counter
      PulseCounter1 = min(PulseCounter1++, MAX_COUNT1);      //but not more than the specified maximum
      STATE1 = WAIT1;
      CalibWeight = CalibWeight + CountValue;
      break;

    case DECR1:                                //decrement the counter
      PulseCounter1 = max(PulseCounter1--, MIN_COUNT1);      //but not less than the specified minimum
      STATE1 = WAIT1;
      CalibWeight = CalibWeight - CountValue;
      break;
  }

  if (btnRIGHT.wasReleased()) // calibration menu counter
{ //If the button was released pulse counter
  PulseCounter2++;
}

if (btnLEFT.wasReleased()) //
{ //If the button was released
  PulseCounter3++;
}

if (PulseCounter3 == 0)
{
  CountValue = 1;
}

if (PulseCounter3 == 1)
{
  CountValue = 10;
}

if (PulseCounter3 == 2)
{
  CountValue = 50;
}

if (PulseCounter3 == 3)
{
  CountValue = 100;
}

if (PulseCounter3 == 4)
{
  CountValue = 200;
}

if (PulseCounter3 == 5)
{
  PulseCounter3 = 0;
}

if (btnSELECT.wasReleased()) // reset to main screen and zero the counters
{ //If the button was released
  PulseCounter2 = 0;
  PulseCounter3 = 0;
}
  //----------------------------------------------------

  // force calculation in grams //////////////////////
  ForceValueRaw1 = (Scale1.read() / 128); // raw value from loadcell divided by 128
                   ForceTemp1 = ((CalibWeight - 0.0) / (ValueB1 - ValueA1)) * ((ForceValueRaw1) - ValueA1) + 0.0;
                   ValueOut1 = ForceTemp1 - ForceZero1;
                   if (ValueOut1 <= 2 && ValueOut1 >= -2) //zero point blockout
{
  ValueOut1 = 0;
}

// force calculation in grams //////////////////////
ForceValueRaw2 = (Scale2.read() / 128); // raw value from loadcell divided by 128
                 ForceTemp2 = ((CalibWeight - 0.0) / (ValueB2 - ValueA2)) * ((ForceValueRaw2) - ValueA2) + 0.0;
                 ValueOut2 = ForceTemp2 - ForceZero2;
                 if (ValueOut2 <= 2 && ValueOut2 >= -2) //zero point blockout
{
  ValueOut2 = 0;
}
}  // end void loop---------------------------------------------------------------------------------------------------------

//  ++++++ functions +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//This function will write a 4 byte (32bit) long to the eeprom at the specified Address to adress + 3.
void EEPROMWritelong(int Address, long value)
{
  //Decomposition from a long to 4 bytes by using bitshift. One = Most significant -> Four = Least significant byte
  byte four = (value & 0xFF);
  byte three = ((value >> 8) & 0xFF);
  byte two = ((value >> 16) & 0xFF);
  byte one = ((value >> 24) & 0xFF);

  //Write the 4 bytes into the eeprom memory.
  EEPROM.write(Address, four);
  EEPROM.write(Address + 1, three);
  EEPROM.write(Address + 2, two);
  EEPROM.write(Address + 3, one);
}

//This function will return a 4 byte (32bit) long from the eeprom at the specified Address to adress + 3.
long EEPROMReadlong(long Address)
{
  //Read the 4 bytes from the eeprom memory.
  long four = EEPROM.read(Address);
  long three = EEPROM.read(Address + 1);
  long two = EEPROM.read(Address + 2);
  long one = EEPROM.read(Address + 3);
  //Return the recomposed long by using bitshift.
  return ((four << 0) & 0xFF) + ((three << 8) & 0xFFFF) + ((two << 16) & 0xFFFFFF) + ((one << 24) & 0xFFFFFFFF);
}

//--------====================================================================================================================================================================================================================
void draw(void)
{
  // graphic commands to redraw the complete screen should be placed here
  u8g.setFont(u8g_font_6x12); //set font type and size
 
  if (PulseCounter2 == 1)
    // we have pushed the ">" button the first time.
    // in this state if needed you can change the calibration weight.
    // use the up and down button to change the value.
    // single press for one step
    // hold press for quick steps
    // if the value is correct just proceed to next step
    // use ">" button when ready
  {
    u8g.setPrintPos(0, 10);
    u8g.print("Calibration weight ");
    u8g.setPrintPos(0, 25);
    u8g.print(CalibWeight, 1);
    u8g.setPrintPos(40, 25);
    u8g.print("Grams");
    u8g.setPrintPos(76, 25);
    u8g.print("CV=");
    u8g.setPrintPos(95, 25);
    u8g.print(CountValue);
    u8g.setPrintPos(0, 40);
    u8g.print("Use + - < button");
    u8g.setPrintPos(0, 60);
    u8g.print("Ready? > button");
    ValueA1 = ForceValueRaw1; //read the current value LC1 without load
  }

  //Calib loadcell 1
  if (PulseCounter2 == 2) // we have pushed the ">" button once with no load.
  {
    u8g.setPrintPos(0, 10);
    u8g.print("Place Weight on LC 1");
    u8g.setPrintPos(0, 23);
    u8g.print("Raw value LC 1");
    u8g.setPrintPos(0, 36);
    u8g.print(ForceValueRaw1);
    u8g.setPrintPos(0, 60);
    u8g.print("Press > button");
    ValueB1 = ForceValueRaw1; //read the current value LC1 with load
  }

  if (PulseCounter2 == 3) // We have pushed the ">" button with a calibration weight on the loadcell.
  {
    u8g.setPrintPos(0, 10);
    u8g.print("LC 1 finished");
    u8g.setPrintPos(0, 23);
    u8g.print("Raw value LC 1");
    u8g.setPrintPos(0, 36);
    u8g.print(ForceValueRaw1);
    u8g.setPrintPos(0, 49);
    u8g.print("Remove Weight");
    u8g.setPrintPos(0, 60);
    u8g.print("Press > button");
    ValueA2 = ForceValueRaw2; //read the current value LC2 without load
  }

  //Calib loadcell 2
  if (PulseCounter2 == 4) // Push the ">" button once with no weight.
  {
    u8g.setPrintPos(0, 10);
    u8g.print("Place Weight on LC 2");
    u8g.setPrintPos(0, 23);
    u8g.print("Raw value LC 2");
    u8g.setPrintPos(0, 36);
    u8g.print(ForceValueRaw2);
    u8g.setPrintPos(0, 60);
    u8g.print("Press > button");
    ValueB2 = ForceValueRaw2; //read the current value LC2 with load
  }

  if (PulseCounter2 == 5) // Push the ">" button once with a calibration weght on the loadcell.
  {
    u8g.setPrintPos(0, 10);
    u8g.print("LC 2 finished");
    u8g.setPrintPos(0, 23);
    u8g.print("Raw value LC 2");
    u8g.setPrintPos(0, 36);
    u8g.print(ForceValueRaw2);
    u8g.setPrintPos(0, 49);
    u8g.print("Remove Weight");
    u8g.setPrintPos(0, 60);
    u8g.print("Press > button");
  }

  if (PulseCounter2 == 6)
  {
    u8g.setPrintPos(0, 10);
    u8g.print("Calibration finished");
    u8g.setPrintPos(0, 28);
    u8g.print("to save values");
    u8g.setPrintPos(0, 60);
    u8g.print("Press > button");
  }

  if (PulseCounter2 == 7)
  {
    PulseCounter2 = 0;
    // store data to the eeprom
    EEPROMWritelong(Address, ValueA1);  //Save calibration value A1 to the internal EEprom
    Address += 4;
    EEPROMWritelong(Address, ValueB1);  //Save calibration value B1to the internal EEprom
    Address += 4;
    EEPROMWritelong(Address, ValueA2);  //Save calibration value A2 to the internal EEprom
    Address += 4;
    EEPROMWritelong(Address, ValueB2);  //Save calibration value B2 to the internal EEprom
    Address += 4;
    EEPROMWritelong(Address, CalibWeight);  //Save calibration weigth value to the internal EEprom
    Address += 4;
    delay(10);
  }

  if (PulseCounter2 == 0)
  {
    if (Reverse == 0) // display mounted with view from the front is Reverse (0) mode with view from rear = normal (1)
    {
    u8g.setPrintPos(20, 10);
    u8g.print("LC-L");
    u8g.setPrintPos(20, 25);
    u8g.print(ValueOut1);
    u8g.setPrintPos(20, 40);
    u8g.print("grams");
    
    u8g.setPrintPos(76, 10);
    u8g.print("LC-R");
    u8g.setPrintPos(76, 25);
    u8g.print(ValueOut2);
    u8g.setPrintPos(76, 40);
    u8g.print("grams");
    }
    else
    {
    u8g.setPrintPos(20, 10);
    u8g.print("LC-L");
    u8g.setPrintPos(20, 25);
    u8g.print(ValueOut2);
    u8g.setPrintPos(20, 40);
    u8g.print("grams");
    
    u8g.setPrintPos(76, 10);
    u8g.print("LC-R");
    u8g.setPrintPos(76, 25);
    u8g.print(ValueOut1);
    u8g.setPrintPos(76, 40);
    u8g.print("grams");
    }

    u8g.setPrintPos(60, 10);
    u8g.print("I");
    u8g.setPrintPos(60, 20);
    u8g.print("I");
    u8g.setPrintPos(60, 30);
    u8g.print("I");
    u8g.setPrintPos(60, 40);
    u8g.print("I");
    u8g.setPrintPos(60, 50);
    u8g.print("I");

    u8g.setPrintPos(20, 60);
    u8g.print("Jupa Creations");
  }
  
  if (btnSELECT.pressedFor(3000))// && (PulseCounter2 == 0))
  {
   ForceZero1 = ForceTemp1; // write current value to compensate the zero offset.
   ForceZero2 = ForceTemp2; // write current value to compensate the zero offset.
   u8g.setPrintPos(120, 10);
   u8g.print("T");
      u8g.setPrintPos(120, 20);
   u8g.print("a");
      u8g.setPrintPos(120, 30);
   u8g.print("r");
      u8g.setPrintPos(120, 40);
   u8g.print("e");
   PulseCounter2 = 0;
  }
}

// Copyright by Jupa Creations The Netherlands 2022
// www.jupacreations.com