#include "ExponentialFilter.h"

#define analogInput A0
#define periodInput A1

ExponentialFilter lowPassFilter;

bool toggle;

double input;
double output;

const double amplitude = 50.0;
const double reference = 50.0;

void setup() {
  Serial.begin(38400);
  pinMode(LED_BUILTIN, OUTPUT);
  lowPassFilter.cutoffFrequency(1.0);
}

void loop() {
  int timeValue = analogRead(periodInput);
  double period = map(timeValue, 0, 1023, 10, 1000) * 0.000001;
  double input = SineWave(PhaseGenerator(period));
  if (input > 100.0) input = 100.0;
  if (input < 0.0) input = 0.0;
  lowPassFilter.filter(input);
  SerialPlot(lowPassFilter.input, lowPassFilter.output);
  digitalWrite(LED_BUILTIN, toggle);
}

double SineWave(double period) {
  double sineValue = sin(period * 1.0 * TWO_PI / 360.0 );
  output = amplitude * sineValue + reference;
  return output;
}

double PhaseGenerator(double delayTime) {
  static double phase;
  static unsigned long lastTime;
  static double elapsedTime;
  unsigned long currTime = micros();
  unsigned long deltaTime = currTime - lastTime;
  elapsedTime += deltaTime * 0.000001;
  lastTime = currTime;
  if (elapsedTime < delayTime) return phase;
  elapsedTime = 0.0;
  phase = phase + 0.1;
  if (phase < 360.0) return phase;
  phase = 0.0;
  return phase;
}

void SerialPlot(double input, double output) {
  static unsigned long startTime;
  unsigned long currTime = millis();
  if (currTime - startTime < 50UL) return;
  toggle = !toggle;
  startTime = currTime;
  Serial.println(
    "Input:" + String(input, 3)
    + ",Output:" + String(output, 3)
  );
}


sketch.ino

diagram.json

# Low-pass filter

Vout(t) = Vi(1-exp(-ωt))

yᵢ = α * xᵢ + (1 - α) * yᵢ-₁;
    = yᵢ-₁ + α * (xᵢ - yᵢ-₁);
   += α * (xᵢ - yᵢ-₁);

where
α   = ∆ₜ / (RC + ∆ₜ)

# RC time constant
τ = RC [seconds]
  = 1 / 2πƒ
  = t / 2π

Recalling that
α   = ∆ₜ / ((1 / 2πƒ) + ∆ₜ)
    = ∆ₜ / ((1+2πƒ∆ₜ) / 2πƒ)
    = ∆ₜ 2πƒ / (1+2πƒ∆ₜ)

README.md

libraries.txt

Wave

wave.chip.json

#include "ExponentialFilter.h"

#define analogInput A0
#define periodInput A1

ExponentialFilter lowPassFilter;

bool toggle;

double input;
double output;

const double amplitude = 50.0;
const double reference = 50.0;

void setup() {
  Serial.begin(38400);
  pinMode(LED_BUILTIN, OUTPUT);
  lowPassFilter.cutoffFrequency(100.0);
}

void loop() {
  int timeValue = analogRead(periodInput);
  long period = map(timeValue, 0, 1023, 1, 10);
  double input = SineWave(PhaseGenerator(), period);
  if (input > 100.0) input = 100.0;
  if (input < 0.0) input = 0.0;
  lowPassFilter.filter(input);
  SerialPlot(lowPassFilter.input, lowPassFilter.output);
  digitalWrite(LED_BUILTIN, toggle);
}

double SineWave(double period, double freq) {
  double sineValue = sin(period * freq * TWO_PI / 360.0 );
  output = amplitude * sineValue + reference;
  return output;
}

double PhaseGenerator() {
  static double phase;
  static unsigned long lastTime;
  static double elapsedTime;
  unsigned long currTime = micros();
  unsigned long deltaTime = currTime - lastTime;
  elapsedTime += deltaTime * 0.000001;
  lastTime = currTime;
  if (elapsedTime < 0.001) return phase;
  elapsedTime = 0.0;
  phase = phase + 1.0;
  if (phase < 360.0) return phase;
  phase = 0.0;
  return phase;
}

void SerialPlot(double input, double output) {
  static unsigned long startTime;
  unsigned long currTime = millis();
  if (currTime - startTime < 10UL) return;
  toggle = !toggle;
  startTime = currTime;
  Serial.println(
    "Input:" + String(input, 3)
    + ",Output:" + String(output, 3)
  );
}


wave.chip.c


#define buttonPin A0  // Define the Button readState pin.
#define factorPin A1
#define ledPin    7   // Define the LED output pin.

#define OR |
#define AND &

#define DEBOUNCE_PERIOD 10UL  // Debounce Delay 10 milliseconds

#define pi 3.14159265359f

#pragma region INSTANT_DEBOUNCE
typedef struct {
  private:
    bool input;
    bool pressedState;
    unsigned long startTime;
    unsigned long instantPeriod;

  public:
    bool state;
    bool pressed;

    void mode(uint8_t inputMode, unsigned long period = DEBOUNCE_PERIOD);
    bool instant(bool bounce);
} debounce_t;

void debounce_t::mode(uint8_t inputMode, unsigned long period) {
  // When the input Mode is set to INPUT,
  // the Pressed state will be "true"
  pressedState = inputMode == INPUT;
  // When the input Mode is set to INPUT,
  // the released state will be "false"
  state = !pressedState;
  input = state;
  instantPeriod = period;
}

bool debounce_t::instant(bool bounce) {
  unsigned long currentTime = millis();
  bool prevInput = input;
  input = bounce;
  if (input == pressedState) {
    pressed = state != pressedState;
    state = input;
  } else {
    if (input != prevInput) {
      startTime = currentTime;
    }
    if (input != state) {
      unsigned long elapsedTime = currentTime - startTime;
      if (elapsedTime >= instantPeriod) {
        state = input;
      }
    }
  }
  return pressed;
}
#pragma endregion INSTANT_DEBOUNCE

bool toggle;

debounce_t debounce;

float input;
float output;
float factor;

float elapsedTime;

unsigned long prevTime;

float tMax = 100.0F;
bool trigger;

unsigned long startCapture;

void setup() {
  Serial.begin(115200);
  pinMode(buttonPin, INPUT_PULLUP);
  pinMode(ledPin, OUTPUT);
  debounce.mode(INPUT_PULLUP);
  factor = 0.05;
}

// α  = (2π•ΔT•F) /  (2π•ΔT•F) + 1
//    =
void loop() {
  unsigned long currTime = micros();
  float deltaTime = (currTime - prevTime) * 0.000001;
  prevTime = currTime;
  bool prevState = debounce.state;
  bool value = digitalRead(buttonPin);
  bool pressed = debounce.instant(value);
  if (!debounce.state) {
    input = tMax;
    toggle = !toggle;

  } else {
    input = 0.0F;
  }
  // input = map(analogRead(A2), 0, 1023, 0, 10000) * 0.01F;
  if (debounce.state & !prevState) startCapture = micros();


  long raw = analogRead(factorPin);
  // α  = (2π•ΔT•F) / (2π•ΔT•F) + 1
  float dbt = map(raw, 0, 1023, 10, 3000) * 0.001F;
  float freq = 1 / dbt;
  float rc = 2.0f * pi * freq * deltaTime;
  float alpha = rc / ( rc + 1);
  output += alpha * (input - output);

  // https://en.wikipedia.org/wiki/RC_circuit
  // fully charged (99.3%)
  // fully discharged (0.7%)
  float TH = 99.3F;
  float TL = 0.7F;
  bool prevTrigger = trigger;
  trigger = SchmittTrigger(output, TL, TH);
  digitalWrite(ledPin, trigger);

  SerialPlot(input, output, factor, trigger, dbt, TH, TL);
}

void SerialPlot(float input, float output, float factor, bool state, float time, float TH, float TL) {
  static unsigned long startTime;
  if (millis() - startTime >= 1) {
    startTime = millis();
    Serial.println(
      "TH:" + String(TH, 2)
      + ", TL:" + String(TL, 2)
      + ", INPUT:" + String(input, 2)
      + ", OUTPUT:" + String(output, 2)
      + ", State:" + String(state * 100.0, 2)
      + ", Time:" + String(time / 5, 2)
    );
  }
}

bool SchmittTrigger(float output, float TL, float TH) {
  // // TRUE when fully charged
  // // FALSE when fully discarged
  // if (output < TL) return false;
  // else if (output > TH) return true;

  // TRUE when fully charged
  // FALSE when fully discarged
  if (output > TL ) return false;
   if (output < TH) return true;
}

backup.md

/*
  MIT License
  Copyright (c) 2024 MicroBeaut
*/

#ifndef EXPONENTIALFILTER_H
#define EXPONENTIALFILTER_H

#include <Arduino.h>

#ifndef TWO_PI
#define TWO_PI 6.283185307179586476925286766559
#endif  // TWO_PI

#define S2MS(sec) (sec * 1000)
#define S2US(sec) (sec * 1000000)
#define MS2S(ms) (ms * 0.001)
#define US2S(us) (us * 0.000001)

/// @brief The Trigger states
enum ExpModes {
  AUTO,
  MANUAL
};


/// @brief The State Event Arguments
enum StateEventArgs {
  /// @brief Maintained the last state
  NONE_TRIGGER,
  /// @brief The output has met the lower trigger setting.
  LOWER_TRIGGER,
  /// @brief The output has met the upper trigger setting.
  UPPER_TRIGGER
};


enum ExpOperations {
  /// @brief Less Than
  LT,
  /// @brief Greater Than
  GT,
  /// @brief Less than or Equal to
  LE,
  /// @brief Greater than or Equal to
  GE
};


/// @brief Comparing the upper and lower thresholds for a trigger using exponential double operations.
enum ExpDoubleOperations {
  /// @brief If the output is less than the upper threshold setting, set the trigger state to false;
  /// @brief if output is greater than the lower threshold setting, set the trigger state to true.
  LTGT,
  /// @brief If the output is greater than the upper threshold setting, set the trigger state to false;
  /// @brief if output is less than the lower threshold setting, set the trigger state to true.
  GTLT,
  /// @brief If the output is less than or equal to the upper threshold setting, set the trigger state to false;
  /// @brief if the output is greater than or equal to the lower threshold setting, set the trigger state to true.
  LEGE,
  /// @brief If the output is greater than or equal to the upper threshold setting, set the trigger state to false;
  /// @brief if output is less than or equal to the lower threshold setting, set the trigger state to true.
  GELE
};


/// @brief The index compares a trigger's upper and lower thresholds using exponential double operations.
const ExpOperations mapOperations[4][2] = {
  {LT, GT}, // LTGT
  {GT, LT}, // GTLT
  {LE, GE}, // LEGE
  {GE, LE}  // GELE
};


/// @brief The Exponential Trigger Members
typedef struct {
  /// @brief Lower Threshold Setting
  float lowerThreshold;
  /// @brief Upper Threshold Setting
  float upperThreshold;
  /// @brief Comparing the upper and lower thresholds operations.
  ExpDoubleOperations operation;
  /// @brief Trigger State
  bool trigger;
  /// @brief Lower Trigger State
  bool lowerTrigger;
  /// @brief Upper Trigger State
  bool upperTrigger;
} ExpTrigger;


/// @brief Exponential Event Argument
typedef struct {
  /// @brief Exponential Id
  uint8_t id;
  /// @brief Exponential Input
  float input;
  /// @brief Exponential Output
  float output;
  /// @brief Exponential Time Const (RC)
  float timeConstant;

  StateEventArgs state;
} ExpEventArgs;


typedef void (*ExpCallbackFunction)(ExpEventArgs);
class ExponentialFilter {
  private:
    float _timeConstant;
    float _input;
    float _output;
    bool _trigger;
    bool _mode;
    uint8_t _id;
    ExpCallbackFunction _function;

    unsigned long _lastTime;

    bool internalTriggerCompare(ExpTrigger *trigger);
    bool internalCompare(float a, float b, ExpOperations operation);
    void internalOnTrigger(ExpTrigger *trigger);
  public:
    float &input;
    float &output;
    bool &trigger;
    uint8_t &id;

    /// @brief Initial Exponential Filter
    /// @brief The time constant value set by default is 1.
    ExponentialFilter();
    /// @brief The proposed option allows for the setting of the time constant based on the cutoff time in an exponential manner.
    /// @brief cutoff time = 1/cutoffFrequency
    /// @param cutoffTime
    void cutoffTime(float cutoffTime);
    /// @brief The proposed option allows for the setting of the time constant based on the cutoff frequency in an exponential manner.
    /// @param cutoffFrequency
    void cutoffFrequency(float cutoffFrequency);
    /// @brief The proposed option allows for the setting of the time constant based on the time constant in an exponential manner.
    /// @param timeConstant
    void timeConstant(float timeConstant);
    /// @brief The mode selection is responsible for filtering the input, and by default, it is set to AUTO mode.
    /// @brief If the mode is switched to MANUAL mode, the output is equal to the input.
    /// @param mode
    void mode(bool mode);
    /// @brief The suggested alternative provides the feasibility of commencing the output with a predetermined value.
    /// @param input
    void init(float input);

    /// @brief Implemented the event callback on the trigger changed with the provided ID for the option that features the array input/output.
    /// @param id
    /// @param function
    void eventOnTrigger(uint8_t id, ExpCallbackFunction function);

    /// @brief Exponential filters smooth noisy input signals in signal processing by suppressing noise and producing a stable output
    /// @param input
    /// @Return a stable output in a float data type
    float filter(float input);
    bool schmittTrigger(ExpTrigger *trigger);
};

#endif // EXPONENTIALFILTER_H

ExponentialFilter.h

/*
  MIT License
  Copyright (c) 2024 MicroBeaut
*/

#include "ExponentialFilter.h"

ExponentialFilter::ExponentialFilter(): output(_output), input(_input), id(_id), trigger(_trigger) {
  cutoffTime(1);
  _mode = AUTO;
}


void ExponentialFilter::init(float input) {
  _output = (float)input;
}

void ExponentialFilter::eventOnTrigger(uint8_t id, ExpCallbackFunction function) {
  _id = id;
  _function = function;
}

void ExponentialFilter::cutoffTime(float cutoffTime) {
  _timeConstant = cutoffTime / TWO_PI;
}


void ExponentialFilter::cutoffFrequency(float cutoffFrequency) {
  _timeConstant = 1 / (TWO_PI * cutoffFrequency);
}


void ExponentialFilter::timeConstant(float timeConstant) {
  _timeConstant = timeConstant;
}


void ExponentialFilter::mode(bool mode) {
  _mode = mode;
}


float ExponentialFilter::filter(float input) {
  unsigned long currTime = micros();
  unsigned long elapsedTime = currTime - _lastTime;
  _lastTime = currTime;
  float _deltaTime = elapsedTime * 0.000001;
  _input = input;
  if (_mode == AUTO) {
    float _alpha = _deltaTime / (_timeConstant + _deltaTime);
    if (_alpha > 0.0 and _alpha <= 1.0) {
      _output += _alpha * (_input - _output);
    }
  } else {
    _output = _input;
  }
  return _output;
}


bool ExponentialFilter::schmittTrigger(ExpTrigger *trigger) {
  trigger->lowerTrigger = false;
  trigger->upperTrigger = false;
  bool prevTrigger = trigger->trigger;
  trigger->trigger = internalTriggerCompare(trigger);
  _trigger = trigger->trigger;
  trigger->upperTrigger = trigger->trigger == true & prevTrigger == false;
  trigger->lowerTrigger = trigger->trigger == false & prevTrigger == true;
  internalOnTrigger(trigger);
  return trigger->trigger;
}


void ExponentialFilter::internalOnTrigger(ExpTrigger *trigger) {
  if (_function) {
    ExpEventArgs e = {id: _id, input: _input, output: _output, timeConstant: _timeConstant};
    if (trigger->lowerTrigger) {
      e.state = LOWER_TRIGGER;
      _function(e);
    } else if (trigger->upperTrigger) {
      e.state = UPPER_TRIGGER;
      _function(e);
    }
    e.state = NONE_TRIGGER;
  }
}


bool ExponentialFilter::internalTriggerCompare(ExpTrigger *trigger) {
  if (internalCompare( _output, trigger->upperThreshold, mapOperations[trigger->operation][1])) return true;
  if (internalCompare(_output, trigger->lowerThreshold, mapOperations[trigger->operation][0])) return false;
  return trigger->trigger;
}


bool ExponentialFilter::internalCompare(float a, float b, ExpOperations operation) {
  switch (operation) {
    case LT:
      return a < b;
      break;
    case GT:
      return a > b;
      break;
    case LE:
      return a <= b;
      break;
    case GE:
      return a >= b;
      break;
    default:
      return false;
      break;
  }
}