Hello everyone,
I am making a weight system for a beehive with an hx711 and four weight sensors. I wanted to know if my circuit is correct because my scale drifts in time. I have connected the DT pin of the HX711 to the D8 pin of the arduino pro micro and the SCK pin to the D7 pin of the arduino. I would like to know if my assembly between the HX711 and the arduino is correct. I connect the module with 5v correctly. I join the diagram of my wiring.
Thank you for your help.
Your topic has been moved to a more suitable location on the forum. Installation and Troubleshooting is not for problems with (nor for advice on) your project.
How much and how fast does it drift/creep?
If you are reading it well enough to notice drift or creep, then the circuit and the code is working pretty well.
These sensors are expected to have some creep, so most uses zero out at the beginning of each measurement session.
Thanks, sorry for the mistake
Thank you Dave for your answer.
I was inspired by this video : weight sensor
At 6:20 he tests the scale and his measurement uncertainty is much lower than mine.
I send you an example where I'm trying to calibrate my scale with a one-kilo packet of rice.
Startup is complete
***
Start calibration:
Place the load cell an a level stable surface.
Remove any load applied to the load cell.
Send 't' from serial monitor to set the tare offset.
Tare complete
Now, place your known mass on the loadcell.
Then send the weight of this mass (i.e. 100.0) from serial monitor.
Known mass is: 1000.00
New calibration value has been set to: 10.10, use this as calibration value (calFactor) in your project sketch.
Save this value to EEPROM adress 0? y/n
Value 10.10 saved to EEPROM address: 0
End calibration
***
To re-calibrate, send 'r' from serial monitor.
For manual edit of the calibration value, send 'c' from serial monitor.
***
Load_cell output val: 1000.69
Load_cell output val: 1000.59
Load_cell output val: 998.81
Load_cell output val: 994.35
Load_cell output val: 991.78
Load_cell output val: 989.30
Load_cell output val: 984.75
Load_cell output val: 984.65
Load_cell output val: 985.34
Load_cell output val: 984.35
Load_cell output val: 983.66
Load_cell output val: 980.98
Load_cell output val: 978.31
Load_cell output val: 973.75
Load_cell output val: 969.79
Load_cell output val: 965.63
Load_cell output val: 960.88
Load_cell output val: 959.19
Load_cell output val: 958.00
Load_cell output val: 957.81
Load_cell output val: 959.89
Load_cell output val: 963.05
Load_cell output val: 965.63
Load_cell output val: 968.21
Load_cell output val: 970.29
Load_cell output val: 969.39
Load_cell output val: 969.10
Load_cell output val: 967.71
Load_cell output val: 967.02
Load_cell output val: 966.82
Load_cell output val: 968.80
Load_cell output val: 969.99
Load_cell output val: 969.99
Load_cell output val: 970.58
Load_cell output val: 969.99
Load_cell output val: 967.02
Load_cell output val: 966.13
Load_cell output val: 966.52
Load_cell output val: 966.92
Load_cell output val: 966.22
Load_cell output val: 964.94
Load_cell output val: 963.65
Load_cell output val: 962.96
Load_cell output val: 963.25
Load_cell output val: 963.25
Load_cell output val: 964.74
Load_cell output val: 966.22
Load_cell output val: 969.00
Load_cell output val: 969.79
Load_cell output val: 971.57
Load_cell output val: 973.55
Load_cell output val: 974.84
Load_cell output val: 974.54
Load_cell output val: 975.63
Load_cell output val: 974.84
Load_cell output val: 972.86
Load_cell output val: 972.56
Load_cell output val: 971.77
Load_cell output val: 971.87
Load_cell output val: 973.06
Load_cell output val: 974.35
Load_cell output val: 975.14
Load_cell output val: 973.75
Load_cell output val: 972.76
Load_cell output val: 972.96
Load_cell output val: 973.26
Load_cell output val: 973.55
Load_cell output val: 972.07
Load_cell output val: 971.28
Load_cell output val: 972.96
Load_cell output val: 975.14
Load_cell output val: 975.34
Load_cell output val: 977.22
Load_cell output val: 977.22
Load_cell output val: 975.53
Load_cell output val: 975.73
Load_cell output val: 974.35
Load_cell output val: 970.38
Load_cell output val: 966.92
Load_cell output val: 966.32
Load_cell output val: 964.54
Load_cell output val: 963.25
Load_cell output val: 960.58
Load_cell output val: 958.50
Load_cell output val: 955.73
Load_cell output val: 957.90
Load_cell output val: 959.79
Load_cell output val: 958.10
Load_cell output val: 956.91
Load_cell output val: 954.64
Load_cell output val: 951.66
Load_cell output val: 948.49
Load_cell output val: 945.03
Load_cell output val: 940.87
Load_cell output val: 937.90
Load_cell output val: 934.83
Load_cell output val: 931.06
Load_cell output val: 923.93
Load_cell output val: 916.60
Load_cell output val: 907.88
Load_cell output val: 900.55
Load_cell output val: 892.93
Load_cell output val: 888.37
Load_cell output val: 882.33
Load_cell output val: 877.38
Load_cell output val: 871.43
Load_cell output val: 867.47
Load_cell output val: 866.88
Load_cell output val: 867.57
Load_cell output val: 868.07
Load_cell output val: 867.18
Load_cell output val: 867.57
Load_cell output val: 866.38
Load_cell output val: 866.18
Load_cell output val: 864.50
Load_cell output val: 863.91
Load_cell output val: 864.40
Load_cell output val: 866.18
Load_cell output val: 867.77
Load_cell output val: 870.15
Load_cell output val: 869.16
Load_cell output val: 865.29
Load_cell output val: 862.92
Load_cell output val: 861.03
Load_cell output val: 859.65
Load_cell output val: 858.46
Load_cell output val: 855.98
Load_cell output val: 854.89
Load_cell output val: 854.99
Load_cell output val: 853.70
Load_cell output val: 853.70
Load_cell output val: 852.81
Load_cell output val: 853.01
Load_cell output val: 855.49
Load_cell output val: 857.86
Load_cell output val: 859.55
Load_cell output val: 859.94
Load_cell output val: 860.74
Load_cell output val: 860.44
Load_cell output val: 860.94
Load_cell output val: 863.31
Load_cell output val: 865.29
Load_cell output val: 865.29
Load_cell output val: 866.09
Load_cell output val: 866.98
Load_cell output val: 866.38
Load_cell output val: 865.59
Load_cell output val: 865.39
Load_cell output val: 863.81
Load_cell output val: 864.20
Load_cell output val: 863.61
Load_cell output val: 862.32
Load_cell output val: 860.44
Load_cell output val: 858.56
Load_cell output val: 857.86
Load_cell output val: 858.16
Load_cell output val: 859.35
Load_cell output val: 861.73
Load_cell output val: 862.42
Load_cell output val: 862.72
Load_cell output val: 865.49
Load_cell output val: 865.79
Load_cell output val: 867.08
Load_cell output val: 870.74
Load_cell output val: 874.50
Load_cell output val: 878.76
Load_cell output val: 884.81
Load_cell output val: 889.46
Load_cell output val: 895.40
Load_cell output val: 900.95
Load_cell output val: 906.00
Load_cell output val: 911.35
Load_cell output val: 917.39
Load_cell output val: 922.44
Load_cell output val: 925.02
Load_cell output val: 927.99
Load_cell output val: 930.27
Load_cell output val: 935.82
Load_cell output val: 939.18
Load_cell output val: 943.64
Load_cell output val: 946.02
Load_cell output val: 948.40
Load_cell output val: 950.57
Load_cell output val: 950.28
Load_cell output val: 947.70
Load_cell output val: 946.02
Load_cell output val: 943.94
Load_cell output val: 944.04
Load_cell output val: 945.03
Load_cell output val: 941.86
Load_cell output val: 936.11
Load_cell output val: 930.27
Load_cell output val: 925.52
Load_cell output val: 917.99
Load_cell output val: 907.98
Load_cell output val: 895.50
Load_cell output val: 884.01
Load_cell output val: 871.34
Load_cell output val: 859.75
Load_cell output val: 845.48
Load_cell output val: 831.12
Load_cell output val: 818.34
Load_cell output val: 807.84
Load_cell output val: 796.06
Load_cell output val: 785.66
And here the code i used just for the test of the scale
/*
-------------------------------------------------------------------------------------
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 = 8; //mcu > HX711 dout pin
const int HX711_sck = 7; //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("***");
}
It isn't the issue, but I'd subtract t from both sides here:
...so you are comparing intervals rather than absolute, rollover susceptible timestamps:
if (millis() - t > serialPrintInterval) {
I'd also set serialPrintInterval above zero to so your results happen at a knowable rate and you can see loaded & unloaded values on the same screen:
const int serialPrintInterval = 1000; //increase value to slow down serial print activity
Does it drop back down to zero when you remove the bag of rice? Or double if you add a second bag?
If so, the code and circuit seem to be working.
What is the calFactor? because it doesn't look like 1 or raw output from the device.
What does your physical setup look like?
If your sensors are bottomed out/aren't properly mounted, it could be that the circuit and code are amplifying noise.
I made the changes in the code. I tried to put a bottle of 1.5kilo and after I put a second and then I remove them as you can see in the values.
I find that the scale drifts a lot compared to the tutorial video.
Startup is complete
***
Start calibration:
Place the load cell an a level stable surface.
Remove any load applied to the load cell.
Send 't' from serial monitor to set the tare offset.
Tare complete
Now, place your known mass on the loadcell.
Then send the weight of this mass (i.e. 100.0) from serial monitor.
Known mass is: 1500.00
New calibration value has been set to: 11.36, use this as calibration value (calFactor) in your project sketch.
Save this value to EEPROM adress 0? y/n
Value 11.36 saved to EEPROM address: 0
End calibration
***
To re-calibrate, send 'r' from serial monitor.
For manual edit of the calibration value, send 'c' from serial monitor.
***
Load_cell output val: 1497.45
Load_cell output val: 1479.13
Load_cell output val: 1476.93
Load_cell output val: 1481.60
Load_cell output val: 1496.74
Load_cell output val: 1506.43
Load_cell output val: 1506.25
Load_cell output val: 1506.34
Load_cell output val: 1440.13
Load_cell output val: 1427.62
Load_cell output val: 1436.34
Load_cell output val: 1407.20
Load_cell output val: 1401.12
Load_cell output val: 1423.84
Load_cell output val: 1402.44
Load_cell output val: 1370.92
Load_cell output val: 1375.41
Load_cell output val: 1365.55
Load_cell output val: 1358.42
Load_cell output val: 1364.85
Load_cell output val: 1412.22
Load_cell output val: 1428.24
Load_cell output val: 1425.95
Load_cell output val: 1403.15
Load_cell output val: 1381.22
Load_cell output val: 1430.00
Load_cell output val: 1450.52
Load_cell output val: 1993.95
Load_cell output val: 2753.38
Load_cell output val: 2761.74
Load_cell output val: 2757.87
Load_cell output val: 2746.33
Load_cell output val: 2743.51
Load_cell output val: 2760.68
Load_cell output val: 2742.46
Load_cell output val: 2730.75
Load_cell output val: 2743.34
Load_cell output val: 2741.31
Load_cell output val: 2739.02
Load_cell output val: 2740.70
Load_cell output val: 2759.71
Load_cell output val: 2735.41
Load_cell output val: 2672.55
Load_cell output val: 2471.97
Load_cell output val: 617.84
Load_cell output val: -19.90
Load_cell output val: -5.19
Load_cell output val: -2.64
Load_cell output val: -12.68
Load_cell output val: -16.91
Load_cell output val: -12.94
Load_cell output val: -8.80
Load_cell output val: -15.94
Load_cell output val: -20.78
Load_cell output val: -15.67
Load_cell output val: -21.31
Load_cell output val: -15.67
Load_cell output val: -16.38
Load_cell output val: -16.91
Load_cell output val: -25.62
Load_cell output val: -29.14
Load_cell output val: -26.06
Load_cell output val: -34.69
Load_cell output val: -34.25
Load_cell output val: -40.68
Load_cell output val: -49.48
Load_cell output val: -32.58
Load_cell output val: -55.65
Load_cell output val: -59.34
Load_cell output val: -36.10
Load_cell output val: -35.04
Load_cell output val: -39.18
Load_cell output val: -43.06
That data looks reasonable. I think the circuit and code seems functional.
From watching the video, it looks like it should work similarly.
The video looks like there's some smoothing in the processing:
...
And the referenced 50kg Load Cells with HX711 and Arduino. 4x, 2x, 1x Diagrams. - Circuit Journal says:
It takes some time for the level to settle back to zero after having a little heavier weight on it. For example, if I step off the scale, it goes quickly back to about 50g. Then it takes some additional time to reach back to zero again.
The library does some internal filtering and smoothing:
The only things I can think of are differences in the smoothing parameters (sampling time? frequency?) and perhaps the board and flooring might be different (more flexible or resilient).
The video looks like it reports every 1/4 sec or so, and smooths between them.
This code looks like it would sample as fast as the board will go, and then report the smoothed data only periodically:
If the sampling is happening much faster than the reporting, then the window would flush out, and the reported readings would be more independent. If you were running your HX711 at 80Hz and the video was running at 10Hz, or if Video's code was structured to throttle the readings like:
if (millis() > t + serialPrintInterval){
LoadCell.update();
float i = LoadCell.getData();
then the video's successive prints would share a lot of the smoothing window and show less variation.
Do you know for sure that your code matches the video's code?
Otherwise, maybe it's mechanical, and the way your board bends, combine with the way the bumps on the sensors interact with the resilience of the flooring might be different.
Thank you very much for you answer.
I use the 1.2.11 version for the calibration script and he used the 1.1.5 version.
I tried with his code (v1.1.5) as below :
//-------------------------------------------------------------------------------------
// HX711_ADC.h
// Arduino master library for HX711 24-Bit Analog-to-Digital Converter for Weigh Scales
// Olav Kallhovd sept2017
// Tested with : HX711 asian module on channel A and YZC-133 3kg load cell
// Tested with MCU : Arduino Nano, ESP8266
//-------------------------------------------------------------------------------------
// This is an example sketch on how to use this library
// Settling time (number of samples) and data filtering can be adjusted in the config.h file
// This example shows how to calibrate the load cell and optionally save the calibration
// value to EEPROM, and also how to change the value.
// The value can later be fetched from EEPROM in your project sketch.
#include <HX711_ADC.h>
#include <EEPROM.h>
//HX711 constructor (dout pin, sck pin):
HX711_ADC LoadCell(8, 7);
int eepromAdress = 0;
long t;
void calibrate() {
Serial.println("***");
Serial.println("Start calibration:");
Serial.println("It is assumed that the mcu was started with no load applied to the load cell.");
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 m = 0;
boolean f = 0;
while (f == 0) {
LoadCell.update();
if (Serial.available() > 0) {
m = Serial.parseFloat();
if (m != 0) {
Serial.print("Known mass is: ");
Serial.println(m);
f = 1;
}
else {
Serial.println("Invalid value");
}
}
}
float c = LoadCell.getData() / m;
LoadCell.setCalFactor(c);
Serial.print("Calculated calibration value is: ");
Serial.print(c);
Serial.println(", use this in your project sketch");
f = 0;
Serial.print("Save this value to EEPROM adress ");
Serial.print(eepromAdress);
Serial.println("? y/n");
while (f == 0) {
if (Serial.available() > 0) {
char inByte = Serial.read();
if (inByte == 'y') {
#if defined(ESP8266)
EEPROM.begin(512);
#endif
EEPROM.put(eepromAdress, c);
#if defined(ESP8266)
EEPROM.commit();
#endif
EEPROM.get(eepromAdress, c);
Serial.print("Value ");
Serial.print(c);
Serial.print(" saved to EEPROM address: ");
Serial.println(eepromAdress);
f = 1;
}
else if (inByte == 'n') {
Serial.println("Value not saved to EEPROM");
f = 1;
}
}
}
Serial.println("End calibration");
Serial.println("For manual edit, send 'c' from serial monitor");
Serial.println("***");
}
void changeSavedCalFactor() {
float c = LoadCell.getCalFactor();
boolean f = 0;
Serial.println("***");
Serial.print("Current value is: ");
Serial.println(c);
Serial.println("Now, send the new value from serial monitor, i.e. 696.0");
while (f == 0) {
if (Serial.available() > 0) {
c = Serial.parseFloat();
if (c != 0) {
Serial.print("New calibration value is: ");
Serial.println(c);
LoadCell.setCalFactor(c);
f = 1;
}
else {
Serial.println("Invalid value, exit");
return;
}
}
}
f = 0;
Serial.print("Save this value to EEPROM adress ");
Serial.print(eepromAdress);
Serial.println("? y/n");
while (f == 0) {
if (Serial.available() > 0) {
char inByte = Serial.read();
if (inByte == 'y') {
#if defined(ESP8266)
EEPROM.begin(512);
#endif
EEPROM.put(eepromAdress, c);
#if defined(ESP8266)
EEPROM.commit();
#endif
EEPROM.get(eepromAdress, c);
Serial.print("Value ");
Serial.print(c);
Serial.print(" saved to EEPROM address: ");
Serial.println(eepromAdress);
f = 1;
}
else if (inByte == 'n') {
Serial.println("Value not saved to EEPROM");
f = 1;
}
}
}
Serial.println("End change calibration value");
Serial.println("***");
}
void setup() {
Serial.begin(9600); delay(10);
Serial.println();
Serial.println("Starting...");
LoadCell.begin();
long stabilisingtime = 2000; // tare preciscion can be improved by adding a few seconds of stabilising time
LoadCell.start(stabilisingtime);
if (LoadCell.getTareTimeoutFlag()) {
Serial.println("Tare timeout, check MCU>HX711 wiring and pin designations");
}
else {
LoadCell.setCalFactor(1.0); // user set calibration value (float)
Serial.println("Startup + tare is complete");
}
while (!LoadCell.update());
calibrate();
}
void loop() {
//update() should be called at least as often as HX711 sample rate; >10Hz@10SPS, >80Hz@80SPS
//longer delay in sketch will reduce effective sample rate (be carefull with delay() in the loop)
LoadCell.update();
//get smoothed value from the data set
if (millis() > t + 250) {
float i = LoadCell.getData();
Serial.print("Load_cell output val: ");
Serial.println(i);
t = millis();
}
//receive from serial terminal
if (Serial.available() > 0) {
float i;
char inByte = Serial.read();
if (inByte == 't') LoadCell.tareNoDelay();
else if (inByte == 'c') changeSavedCalFactor();
}
//check if last tare operation is complete
if (LoadCell.getTareStatus() == true) {
Serial.println("Tare complete");
}
}
And if i tried to make the same experience, i put my bottle of 1.5kilo on the scale and after i get on the scale (my weight is about 80 kilo) i obtain these values :
`Startup + tare is complete
***
Start calibration:
It is assumed that the mcu was started with no load applied to the load cell.
Now, place your known mass on the loadcell,
then send the weight of this mass (i.e. 100.0) from serial monitor.
Known mass is: 1500.00
Calculated calibration value is: 9.95, use this in your project sketch
Save this value to EEPROM adress 0? y/n
Value 9.95 saved to EEPROM address: 0
End calibration
For manual edit, send 'c' from serial monitor
***
Load_cell output val: 1497.79
Load_cell output val: 1470.04
Load_cell output val: 1448.12
Load_cell output val: 1444.40
Load_cell output val: 1434.14
Load_cell output val: 1415.44
Load_cell output val: 1409.61
Load_cell output val: 1433.44
Load_cell output val: 1451.64
Load_cell output val: 1458.88
Load_cell output val: 1462.49
Load_cell output val: 1467.52
Load_cell output val: 1471.64
Load_cell output val: 1468.73
Load_cell output val: 1464.91
Load_cell output val: 1465.21
Load_cell output val: 1461.19
Load_cell output val: 1455.05
Load_cell output val: 1454.75
Load_cell output val: 1453.65
Load_cell output val: 1455.66
Load_cell output val: 1451.03
Load_cell output val: 1449.52
Load_cell output val: 1457.57
Load_cell output val: 1453.55
Load_cell output val: 1455.05
Load_cell output val: 1452.64
Load_cell output val: 1451.13
Load_cell output val: 1451.43
Load_cell output val: 1445.20
Load_cell output val: 1447.51
Load_cell output val: 1452.64
Load_cell output val: 1452.14
Load_cell output val: 1455.05
Load_cell output val: 1454.75
Load_cell output val: 1458.17
Load_cell output val: 1465.51
Load_cell output val: 1459.08
Load_cell output val: 1455.76
Load_cell output val: 1463.50
Load_cell output val: 1462.49
Load_cell output val: 1460.99
Load_cell output val: 1454.85
Load_cell output val: 1454.95
Load_cell output val: 1465.61
Load_cell output val: 1468.43
Load_cell output val: 1470.04
Load_cell output val: 1472.15
Load_cell output val: 1472.35
Load_cell output val: 1471.85
Load_cell output val: 1466.22
Load_cell output val: 1458.47
Load_cell output val: 1452.34
Load_cell output val: 1452.64
Load_cell output val: 1455.86
Load_cell output val: 1454.05
Load_cell output val: 1455.56
Load_cell output val: 1456.06
Load_cell output val: 1461.69
Load_cell output val: 1461.39
Load_cell output val: 1458.47
Load_cell output val: 1467.12
Load_cell output val: 1470.14
Load_cell output val: 1476.57
Load_cell output val: 1481.20
Load_cell output val: 1479.89
Load_cell output val: 1486.83
Load_cell output val: 1486.02
Load_cell output val: 1484.52
Load_cell output val: 1488.44
Load_cell output val: 1483.31
Load_cell output val: 1488.44
Load_cell output val: 1498.39
Load_cell output val: 1495.58
Load_cell output val: 1401.06
Load_cell output val: 1214.24
Load_cell output val: 945.97
Load_cell output val: 680.82
Load_cell output val: 404.41
Load_cell output val: 225.73
Load_cell output val: 52.49
Load_cell output val: 60.63
Load_cell output val: 56.51
Load_cell output val: 43.64
Load_cell output val: 35.70
Load_cell output val: 19.10
Load_cell output val: 18.50
Load_cell output val: 11.76
Load_cell output val: 14.08
Load_cell output val: 1.31
Load_cell output val: -2.61
Load_cell output val: 1.71
Load_cell output val: -2.41
Load_cell output val: -22.82
Load_cell output val: -37.00
Load_cell output val: 145.39
Load_cell output val: 1470.24
Load_cell output val: 4419.76
Load_cell output val: 7333.99
Load_cell output val: 10403.67
Load_cell output val: 12400.39
Load_cell output val: 15175.46
Load_cell output val: 15859.10
Load_cell output val: 15744.87
Load_cell output val: 15763.17
Load_cell output val: 15810.23
Load_cell output val: 15765.89
Load_cell output val: 15753.42
Load_cell output val: 15674.49
Load_cell output val: 15652.27
Load_cell output val: 15627.23
Load_cell output val: 15520.85
Load_cell output val: 15309.89
Load_cell output val: 15183.20
Load_cell output val: 14978.58
Load_cell output val: 14780.10
Load_cell output val: 14576.89
Load_cell output val: 14453.41
Load_cell output val: 14306.41
Load_cell output val: 14277.95
Load_cell output val: 14287.30
Load_cell output val: 14286.60
Load_cell output val: 14277.25
Load_cell output val: 14250.80
Load_cell output val: 14252.71
Load_cell output val: 14219.43
Load_cell output val: 14140.00
Load_cell output val: 14078.96
Load_cell output val: 14069.31
Load_cell output val: 14065.79
Load_cell output val: 14075.04
Load_cell output val: 14142.11
Load_cell output val: 14039.65
Load_cell output val: 13795.72
Load_cell output val: 13512.27
Load_cell output val: 12881.72
Load_cell output val: 12567.40
Load_cell output val: 12313.61
Load_cell output val: 12215.08
Load_cell output val: 12130.61
Load_cell output val: 12216.18
Load_cell output val: 12443.73
Load_cell output val: 12461.52
Load_cell output val: 12169.12
Load_cell output val: 11740.18
Load_cell output val: 11319.88
Load_cell output val: 11081.48
Load_cell output val: 10749.87
Load_cell output val: 10530.37
Load_cell output val: 10415.94
Load_cell output val: 10429.62
Load_cell output val: 10434.64
Load_cell output val: 10302.12
Load_cell output val: 10217.66
Load_cell output val: 10230.43
Load_cell output val: 10304.13
Load_cell output val: 10420.97
Load_cell output val: 10597.23
Load_cell output val: 10923.51
Load_cell output val: 11100.08
Load_cell output val: 11268.00
Load_cell output val: 11332.75
Load_cell output val: 11376.99
Load_cell output val: 11391.27
Load_cell output val: 11393.79
Load_cell output val: 11387.85
Load_cell output val: 11368.75
Load_cell output val: 11361.21
Load_cell output val: 11341.40
Load_cell output val: 11299.57
Load_cell output val: 11239.64
Load_cell output val: 11185.75
Load_cell output val: 11118.48
Load_cell output val: 11067.60
Load_cell output val: 11016.12
Load_cell output val: 10985.65
Load_cell output val: 10949.76
Load_cell output val: 10905.52
Load_cell output val: 10840.06
Load_cell output val: 10792.10
Load_cell output val: 10711.36
Load_cell output val: 10649.32
Load_cell output val: 10607.89
Load_cell output val: 10599.04
Load_cell output val: 10592.00
Load_cell output val: 10581.24
Load_cell output val: 10566.36
Load_cell output val: 10561.94
Load_cell output val: 10567.57
Load_cell output val: 10591.40
Load_cell output val: 10621.36
Load_cell output val: 10658.06
Load_cell output val: 10695.87
Load_cell output val: 10773.09
Load_cell output val: 10851.02
Load_cell output val: 10906.92
Load_cell output val: 10938.50
Load_cell output val: 10958.61
Load_cell output val: 10964.94
Load_cell output val: 10948.95
Load_cell output val: 10921.91
Load_cell output val: 10889.93
Load_cell output val: 10852.43
Load_cell output val: 10820.55
Load_cell output val: 10794.91
Load_cell output val: 10695.77
Load_cell output val: 10486.33
Load_cell output val: 10150.39
Load_cell output val: 9782.68
Load_cell output val: 9616.57
Load_cell output val: 9500.44
My weight is around 10 kilos 
There is an uncertainty due to my floor but i dont understand why there is this difference of weight.
This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.