Add First Implementation

Author: GatCode

examples/basic/basic.ino

@@ -0,0 +1,28 @@
+#include "HX711.h"
+#include "ScaleStabilizer.h"
+
+// Scale
+const int DOUT_PIN = 23;
+const int SCK_PIN = 22;
+HX711 scale;
+
+// Scale Stabilizer
+const int WINDOW_SIZE = 10;
+const double WEIGHT_THRESHOLD = 0.01;
+ScaleStabilizer stabilizer;
+
+void setup() {
+  Serial.begin(115200);
+  
+  scale.begin(DOUT_PIN, SCK_PIN);
+  scale.set_scale(720);
+  scale.tare();
+
+  stabilizer.begin(WINDOW_SIZE, WEIGHT_THRESHOLD);
+}
+
+void loop() {
+  double adcReading = scale.get_units();
+  stabilizer.add(adcReading);
+  Serial.println(stabilizer.getStablilizedReading());
+}

library.json

@@ -0,0 +1,22 @@
+{
+  "name": "ScaleStabilizer",
+  "version": "1.0.0",
+  "description": "A library to stabilize load cell readings",
+  "keywords": "scale, load cell, HC711",
+  "repository":
+  {
+    "type": "git",
+    "url": "https://github.com/GatCode/ScaleStabilizer.git"
+  },
+  "authors":
+  [
+    {
+      "name": "GatCode",
+      "email": "gatcode@wdw.one",
+      "url": "https://www.gatcode.com",
+      "maintainer": true
+    }
+  ],
+  "license": "MIT",
+  "platforms": "*"
+}

library.properties

@@ -0,0 +1,8 @@
+name=ScaleStabilizer
+version=1.0.0
+author=GatCode <gatcode@wdw.one>
+maintainer=GatCode <gatcode@wdw.one>
+sentence=A library to stabilize load cell readings.
+paragraph=A library to stabilize load cell readings.
+category=Sensors
+url=https://github.com/GatCode/ScaleStabilizer

src/ScaleStabilizer.cpp

@@ -0,0 +1,118 @@
+#include "ScaleStabilizer.h"
+
+/*!
+ * @brief simple average calculation
+ */
+double ScaleStabilizer::getAvg() {
+  double sum = 0;
+  
+  for (int i = 0; i < _windowSize; i++) {
+    sum += _window[i];
+  }
+
+  return sum / _windowSize;
+}
+
+/*!
+ * @brief checks if all the elements in the moving _window are the same
+ */
+bool ScaleStabilizer::isBufferMonotone() {
+  for (int i = 0; i < _windowSize; i++) {
+    if (_window[i] != _window[0]) {
+      break;
+    }
+  }
+}
+
+/*!
+ * @brief init of the stabilizer
+ */
+void ScaleStabilizer::begin(int windowSize, double weightThreshold) {
+  _windowSize = windowSize;
+  _weightThreshold = weightThreshold;
+  _window = new double[_windowSize];
+  _forceOverwrite = _windowSize;
+  _currentReadingIdx = 0;
+  _lastOutputValue = 0.0;
+}
+
+/*!
+ * @brief add a new ADC reading to the moving _window by replacing the olest one
+ * but if the moving _window is empty or needs to be overwritten, force overwrite is executed
+ */
+void ScaleStabilizer::add(double reading) {
+  if (_forceOverwrite > 0 || isBufferMonotone()) {
+    int oldestReadingIdx = (_currentReadingIdx + 1) % _windowSize;
+    _window[oldestReadingIdx] = reading;
+    _currentReadingIdx = oldestReadingIdx;
+    _forceOverwrite--;
+    return;
+  }
+
+  if (abs(reading - getAvg()) < _weightThreshold) {
+    int oldestReadingIdx = (_currentReadingIdx + 1) % _windowSize;
+    _window[oldestReadingIdx] = reading;
+    _currentReadingIdx = oldestReadingIdx;
+    return;
+  }
+
+   // reading index just before the last one
+  int nextToLastReadingIdx = _currentReadingIdx - 1 < 0 ? _windowSize : (_currentReadingIdx - 1) % _windowSize; 
+
+  if (abs(_window[nextToLastReadingIdx] - getAvg()) > _weightThreshold) {
+    // replace 75% of the data in the filter _window with fresh readings
+    _forceOverwrite = _windowSize * 0.75;
+  }
+
+  // everything else is probably just noise
+}
+
+/*!
+ * @brief returns the stabilized average reading from the moving _window
+ */
+double ScaleStabilizer::getStablilizedReading(double displayResolution, int decimalPlaces) {
+  // find min and max values
+  int minIdx = 0;
+  int maxIdx = 0;
+  for (int i = 0; i < _windowSize; i++) {
+    if (_window[i] < minIdx) {
+      minIdx = i;
+    }
+    if (_window[i] > maxIdx) {
+      maxIdx = i;
+    }
+  }
+
+  // remove min and max from measurements
+  double sum = 0;
+  for (int i = 0; i < _windowSize; i++) {
+    if (i == minIdx || i == maxIdx) {
+      continue;
+    }
+    sum += _window[i];
+  }
+
+  // calc cleaned average
+  double cleanedAverage = sum / (_windowSize - 2);
+
+  // remove negative numbers and set to 0 if close to 0
+  if (cleanedAverage < 0.5) {
+    cleanedAverage = 0.0;
+  }
+
+  // round to given decimal places
+  float scale = pow(10, decimalPlaces);
+  cleanedAverage = round(cleanedAverage * scale) / scale;
+
+  // perform the output flicker reduction
+  if (_lastOutputValue == cleanedAverage) {
+    return cleanedAverage;
+  }
+  
+  if(abs(cleanedAverage - _lastOutputValue) < displayResolution) {
+    return _lastOutputValue; // probably was just noise - return the old measurement
+  }
+
+  _lastOutputValue = cleanedAverage;
+  return cleanedAverage;
+}

src/ScaleStabilizer.h

@@ -0,0 +1,49 @@
+#ifndef SCALESTABILIZER_H
+#define SCALESTABILIZER_H
+
+#include "Arduino.h"
+
+class ScaleStabilizer {
+private:
+  double* _window;
+  int _windowSize;
+  double _weightThreshold;
+  int _forceOverwrite;
+  int _currentReadingIdx;
+  double _lastOutputValue;
+
+  /*!
+   * @brief Returns the average
+   * @return Returns the average of the moving window
+   */
+  double getAvg();
+
+  /*!
+   * @brief Returns true if moving window contains monotone elements 
+   * @return True if all elements have the same value
+   */
+  bool isBufferMonotone();
+
+public:
+  /*!
+   * @brief ScaleStabilizer begin initializer
+   * @param windowSize represents the size of the moving window
+   * @param weightThreshold represents the weight/noise threshold - e.g. 0.1g
+   */
+  void begin(int windowSize, double weightThreshold);
+
+  /*!
+   * @brief Adds the given reading to the moving window
+   * @param reading ADC value/reading
+   */
+  void add(double reading);
+
+  /*!
+   * @brief Returns the stabilized load cell reading
+   * @param displayResolution represents the output resolution - e.g. 0.1g accuracy
+   * @param decimalPlaces represents the decimal places present in the output
+   */
+  double getStablilizedReading(double displayResolution = 0.1, int decimalPlaces = 1);
+};
+
+#endif