#include "ExponentialFilter.h"

#define BUTTON_PIN A0

#define MIN_INPUT 0.0
#define MAX_INPUT 1.0

const float lowerThreshold = 0.293 * (MAX_INPUT - MIN_INPUT);
const float upperThreshold = 0.707 * (MAX_INPUT - MIN_INPUT);

trigger_t trigger {
  lowerThreshold, upperThreshold, GTLT
};

ExponentialFilter expDebounce;
bool toggle;

void setup() {
  Serial.begin(115200);
  pinMode(BUTTON_PIN, INPUT);
  pinMode(LED_BUILTIN, OUTPUT);

  expDebounce.mode(AUTO);               // Exponential Filter in Auto Mode
  expDebounce.cutoffTime(MS2S(2000));   // Debounce Period = 20 milliseconds
  expDebounce.init(1.0);                // INPUT = 0.0, INPUT_PULLUP = 1.0
}

void loop() {
  expDebounce.expFilter(!digitalRead(BUTTON_PIN));
  expDebounce.schmittTrigger(&trigger);
  if (trigger.upperRising) toggle = !toggle;
  digitalWrite(LED_BUILTIN, toggle);

  Serial.println(
    "Input:" + String(expDebounce.input, 3)
    + ", Output:" + String(expDebounce.output, 3)
    + ", Trigger:" + String(trigger.trigger, 3)
  );
}

sketch.ino

diagram.json

/*
  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 FULLY_CHARGED     99.3    // Pencent
#define FULLY_DISCHARGED  0.7     // Pencent
#define CUTOFF            70.7    // Pencent
#define TRACTIONAL        63.2    // Pencent

#define S2MS(sec) (sec * 1000)
#define S2US(sec) (sec * 1000000)
#define MS2S(ms) (ms * 0.001)
#define US2S(us) (us * 0.000001)

enum mode_t : bool {
  AUTO,
  MANUAL
};

enum operation_t : uint8_t {
  LT,
  GT,
  LE,
  GE
};

enum doubleOperation_t : uint8_t {
  LTGT,
  GTLT,
  LEGE,
  GELE
};

const operation_t comparation[4][2] = {
  {LT, GT}, // LTGT
  {GT, LT}, // GTLT
  {LE, GE}, // LEGE
  {GE, LE}  // GELE
};

typedef struct {
  float lowerThreshold;
  float upperThreshold;
  doubleOperation_t operation;

  bool trigger;
  bool lowerRising;
  bool upperRising;
} trigger_t;


class ExponentialFilter {
  private:
    float _timeConstant;
    float _input;
    float _output;
    bool _mode;

    unsigned long _lastTime;

    bool internalTriggerCompare(trigger_t *trigger);
    bool internalCompare(float a, float b, operation_t operation);
  public:
    float &input;
    float &output;

    ExponentialFilter();
    void cutoffTime(float time);
    void cutoffFrequency(float cutoffFrequency);
    void timeConstant(float timeConstant);
    void mode(bool mode);
    void init(float input);
    float expFilter(float input);
    bool schmittTrigger(trigger_t *trigger);
};

#endif // EXPONENTIALFILTER_H

ExponentialFilter.h

/*
  MIT License
  Copyright (c) 2024 MicroBeaut
*/

#include "ExponentialFilter.h"

ExponentialFilter::ExponentialFilter(): output(_output), input(_input) {
  cutoffTime(1);
  _mode = AUTO;
}


void ExponentialFilter::init(float input) {
  _output = (float)input;
}


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::expFilter(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(trigger_t *trigger) {
  trigger->lowerRising = false;
  trigger->upperRising = false;
  bool prevTrigger = trigger->trigger;
  trigger->trigger = internalTriggerCompare(trigger);
  trigger->upperRising = trigger->trigger == true & prevTrigger == false;
  trigger->lowerRising = trigger->trigger == false & prevTrigger == true;
  return trigger->trigger;
}

bool ExponentialFilter::internalTriggerCompare(trigger_t *trigger) {
  if (internalCompare( _output, trigger->upperThreshold, comparation[trigger->operation][1])) return true;
  if (internalCompare(_output, trigger->lowerThreshold, comparation[trigger->operation][0])) return false;
  return trigger->trigger;
}

bool ExponentialFilter::internalCompare(float a, float b, operation_t 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;
  }
}