Add a minimum run interval to all filters.

Author: ademuri

examples/exponential-moving-average/exponential-moving-average.ino

@@ -8,6 +8,7 @@ void setup() {
   pinMode(kInputPin, INPUT_PULLUP);
   input = new ExponentialMovingAverageFilter<uint32_t>(filter_functions::ForAnalogRead<kInputPin>(), 255);
   input->SetLogToSerial(true);
+  input->SetMinRunInterval(50);
 
   pinMode(kLedPin, OUTPUT);
 }
@@ -16,5 +17,4 @@ void loop() {
   input->Run();
   digitalWrite(kLedPin, input->GetFilteredValue() > 511);
   Serial.flush();
-  delay(50);
 }

src/filter.h

@@ -36,6 +36,14 @@ class Filter {
   // Returns the output of the filter, converted.
   OutputType GetFilteredValue();
 
+  // Instructs the filter to run no more frequently than this delay. This can be
+  // used to run the filter at a defined rate, which can make the filter more
+  // consistent.
+  //
+  // One way to use this is to measure how long your main loop typically takes,
+  // and set this to value several times that.
+  void SetMinRunInterval(uint32_t interval_millis);
+
   // Controls whether to log the input and output values of this filter. Values
   // are logged to Serial in the form <input> <output>. Both input and output
   // are converted before logging. These values can be graphed using the
@@ -79,6 +87,7 @@ class Filter {
   static OutputType NoOpConvert(InputType input);
 
   InputType filtered_value_ = 0;
+  uint32_t min_run_interval_ = 0;
   uint32_t run_at_ = 0;
   bool log_to_serial_ = false;
 
@@ -111,6 +120,8 @@ void Filter<InputType, OutputType>::Run() {
     if (log_to_serial_) {
       LogState();
     }
+    // Note: if min_run_interval_ is 0 (default), this will have no effect
+    SetRunDelayInMillis(min_run_interval_);
   }
 }
 
@@ -124,6 +135,16 @@ OutputType Filter<InputType, OutputType>::GetFilteredValue() {
   return Convert_(filtered_value_);
 }
 
+template <typename InputType, typename OutputType>
+void Filter<InputType, OutputType>::SetMinRunInterval(
+    uint32_t interval_millis) {
+  min_run_interval_ = interval_millis;
+
+  if (run_at_ - millis() > interval_millis) {
+    run_at_ = millis() + interval_millis;
+  }
+}
+
 template <typename InputType, typename OutputType>
 void Filter<InputType, OutputType>::SetRunDelayInMillis(uint32_t delay) {
   run_at_ = millis() + delay;

test/filter-test.cpp

@@ -0,0 +1,53 @@
+#include "gtest/gtest.h"
+
+#include <cstdio>
+#include "../src/exponential-moving-average-filter.h"
+#include "run-data-test.h"
+
+namespace filter_test {
+
+TEST(Filter, SetMinRunInterval_default) {
+  // Filter that returns the sensor value immediately
+  ExponentialMovingAverageFilter<uint32_t> *input = new ExponentialMovingAverageFilter<uint32_t>(analogRead, 255);
+  std::vector<InputOutput<uint32_t>> data = {
+    {1, 1, 1},
+    {2, 1, 2},
+    {3, 1, 3},
+    {4, 1, 4},
+    {5, 1, 5},
+  };
+  RunDataTest(input, data);
+}
+
+TEST(Filter, SetMinRunInterval_10) {
+  // Filter that returns the sensor value immediately
+  ExponentialMovingAverageFilter<uint32_t> *input = new ExponentialMovingAverageFilter<uint32_t>(analogRead, 255);
+  input->SetMinRunInterval(10);
+  std::vector<InputOutput<uint32_t>> data = {
+    {1, 1, 1},
+    {2, 9, 1},
+
+    {1, 1, 1},
+    {2, 9, 1},
+
+    {3, 10, 3},
+  };
+  RunDataTest(input, data);
+}
+
+TEST(Filter, SetMinRunInterval_updates) {
+  ExponentialMovingAverageFilter<uint32_t> *input = new ExponentialMovingAverageFilter<uint32_t>(analogRead, 255);
+  input->SetMinRunInterval(10);
+  input->SetMillis(0);
+  analogReadValue = 1;
+  input->Run();
+  EXPECT_EQ(input->GetFilteredValue(), 1);
+
+  input->SetMinRunInterval(5);
+  input->SetMillis(5);
+  analogReadValue = 2;
+  input->Run();
+  EXPECT_EQ(input->GetFilteredValue(), 2);
+}
+
+}

test/run-data-test.h

@@ -47,9 +47,9 @@ void RunDataTest(Filter<uint32_t, O>* filter,
       analogReadValue = point.input;
       filter->Run();
 
-      EXPECT_LE(point.lower_bound, filter->GetFilteredValue())
+      EXPECT_GE(filter->GetFilteredValue(), point.lower_bound)
           << debug_stream.str();
-      EXPECT_GE(point.upper_bound, filter->GetFilteredValue())
+      EXPECT_LE(filter->GetFilteredValue(), point.upper_bound)
           << debug_stream.str();
 
       millis++;