added library and documentation

Author: JPGC04

pio_workspace/lib/HX711_ADC-master/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

pio_workspace/lib/HX711_ADC-master/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Olav Kallhovd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pio_workspace/lib/HX711_ADC-master/README.md

@@ -0,0 +1,72 @@
+Latest release and change log here: https://github.com/olkal/HX711_ADC/releases
+
+This an Arduino library for the HX711 24-bit ADC for weight scales.
+Data retrieval from the HX711 is done without blocking the mcu, also on the 10SPS rate setting and with Multiple HX711's performing conversions simultaneously.
+Tare function can also be performed without blocking the mcu.
+ 
+Filtering and smoothing: "Moving average" method from a rolling data set combined with removal of high/low outliers is used for the retrieved value.
+
+Selectable values in the config.h file:
+- Moving average data set of 1, 2, 4, 8, 16, 32, 64 or 128 samples (default:16).
+- Ignore high outlier; one sample is added to the data set, the peak high value of all samples in the data set is ignored (default:1)
+- Ignore low outlier; one sample is added to the data set, the peak low value of all samples in the data set is ignored (default:1)
+- Enable delay for writing to sck pin. This could be required for faster mcu's like the ESP32 (default: no delay)
+- Disable interrupts when sck pin is high. This could be required to avoid "power down mode" if you have some other time consuming (>60µs) interrupt routines running (default: interrupts enabled)
+
+Caution: using a high number of samples will smooth the output value nicely but will also increase settling time and start-up/tare time (but not response time). It will also eat some memory.
+
+Important: The HX711 sample rate can be set to 10SPS or 80SPS (samples per second) by pulling pin 15 high (80SPS) or low (10SPS), ref HX711 data sheet.
+On fabricated HX711 modules there is usually a solder jumper on the PCB for pin 15 high/low. The rate setting can be checked by measuring the voltage on pin 15.
+ADC noise is worst on the 80SPS rate. Unless very quick settling time is required, 10SPS should be the best sample rate for most applications.
+
+Start up and tare: from start-up/reset, the tare function seems to be more accurate if called after a "pre-warm-up" period running conversions continuously for a few seconds. See example files.
+
+Hardware and ADC noise:
+Wires between HX711 and load cell should be twisted and kept as short as possible.
+Most available HX711 modules seems to follow the reference design, but be aware that some modules are poorly designed with under-sized capacitors, and noisy readings.
+The Sparkfun module seems to differ from most other available modules as it has some additional components for noise reduction. 
+
+To get started: Install the library from Arduino Library Manager. Begin with the Calibration.ino example file, then move on to the Read_1x_load_cell.ino example file.
+
+If you need to keep the tare/zero-offset value after a device reboot, please see example Persistent_zero_offset.ino example file.
+
+HX711_ADC Library Documentation
+```
+Initialization:
+ begin(): Initializes the communication with the HX711 and sets the gain to 128 (default).
+ begin(uint8_t gain): Initializes the communication with the HX711 and sets the gain (32, 64, or 128).
+ Tare (Zero Point Calibration):
+ tare(): Performs tare operation (blocking, waits until finished).
+ tareNoDelay(): Initiates tare operation (non-blocking, continues in background).
+ getTareStatus(): Returns true if the tare operation is complete.
+
+Data Acquisition:
+ update(): Reads a new weight sample (blocking, waits for conversion).
+ dataWaitingAsync(): Checks if new weight data is available (non-blocking).
+ updateAsync(): Reads new weight data if available (non-blocking, called after dataWaitingAsync).
+ getData(): Returns the latest weight value (after applying calibration and filtering).
+
+Calibration:
+ setCalFactor(float cal): Sets the calibration factor for weight conversion (weight = raw data / calFactor).
+ getCalFactor(): Returns the current calibration factor.
+ getNewCalibration(float known_mass): Calculates and sets a new calibration factor based on a known mass.
+
+Other Functions:
+ setSamplesInUse(int samples): Sets the number of samples used for averaging and filtering (rounded down).
+ getSamplesInUse(): Returns the current number of samples in use.
+ resetSamplesIndex(): Resets the index for the dataset.
+ refreshDataSet(): Refreshes the entire dataset with new conversions (blocking).
+ getDataSetStatus(): Checks if the dataset is filled with conversions.
+ getSignalTimeoutFlag(): Indicates if the HX711 communication timed out.
+ setReverseOutput(): Reverses the output value (positive/negative).
+ getTareOffset(): Gets the current tare offset (raw data value).
+ setTareOffset(long newoffset): Sets a new tare offset (raw data value).
+ powerUp(): Powers up the HX711 chip.
+ powerDown(): Powers down the HX711 chip.
+ getReadIndex(): Returns the current dataset read index (debugging).
+ getConversionTime(): Returns the latest conversion time in milliseconds (debugging).
+ getSPS(): Estimates the HX711 conversions per second (debugging).
+ getTareTimeoutFlag(): Returns the tare operation timeout flag (debugging).
+ disableTareTimeout(): Disables the tare operation timeout.
+ getSettlingTime(): Calculates the estimated settling time based on conversion time and sample count (debugging).
+```

pio_workspace/lib/HX711_ADC-master/examples/Calibration/Calibration.ino

@@ -0,0 +1,223 @@
+/*
+   -------------------------------------------------------------------------------------
+   HX711_ADC
+   Arduino library for HX711 24-Bit Analog-to-Digital Converter for Weight Scales
+   Olav Kallhovd sept2017
+   -------------------------------------------------------------------------------------
+*/
+
+/*
+   This example file shows how to calibrate the load cell and optionally store the calibration
+   value in EEPROM, and also how to change the value manually.
+   The result value can then later be included in your project sketch or fetched from EEPROM.
+
+   To implement calibration in your project sketch the simplified procedure is as follow:
+       LoadCell.tare();
+       //place known mass
+       LoadCell.refreshDataSet();
+       float newCalibrationValue = LoadCell.getNewCalibration(known_mass);
+*/
+
+#include <HX711_ADC.h>
+#if defined(ESP8266)|| defined(ESP32) || defined(AVR)
+#include <EEPROM.h>
+#endif
+
+//pins:
+const int HX711_dout = 4; //mcu > HX711 dout pin
+const int HX711_sck = 5; //mcu > HX711 sck pin
+
+//HX711 constructor:
+HX711_ADC LoadCell(HX711_dout, HX711_sck);
+
+const int calVal_eepromAdress = 0;
+unsigned long t = 0;
+
+void setup() {
+  Serial.begin(57600); delay(10);
+  Serial.println();
+  Serial.println("Starting...");
+
+  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");
+    while (1);
+  }
+  else {
+    LoadCell.setCalFactor(1.0); // user set calibration value (float), initial value 1.0 may be used for this sketch
+    Serial.println("Startup is complete");
+  }
+  while (!LoadCell.update());
+  calibrate(); //start calibration procedure
+}
+
+void loop() {
+  static boolean newDataReady = 0;
+  const int serialPrintInterval = 0; //increase value to slow down serial print activity
+
+  // 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 i = LoadCell.getData();
+      Serial.print("Load_cell output val: ");
+      Serial.println(i);
+      newDataReady = 0;
+      t = millis();
+    }
+  }
+
+  // receive command from serial terminal
+  if (Serial.available() > 0) {
+    char inByte = Serial.read();
+    if (inByte == 't') LoadCell.tareNoDelay(); //tare
+    else if (inByte == 'r') calibrate(); //calibrate
+    else if (inByte == 'c') 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("***");
+}