FilteredAnalog.hpp

Go to the documentation of this file.

#pragma once
 
#include <AH/Settings/Warnings.hpp>
AH_DIAGNOSTIC_WERROR() // Enable errors on warnings
 
#include <AH/Filters/EMA.hpp>
#include <AH/Filters/Hysteresis.hpp>
#include <AH/Hardware/ExtendedInputOutput/ExtendedInputOutput.hpp>
#include <AH/Hardware/Hardware-Types.hpp>
#include <AH/Math/IncreaseBitDepth.hpp>
#include <AH/Math/MinMaxFix.hpp>
#include <AH/Settings/SettingsWrapper.hpp>
 
BEGIN_AH_NAMESPACE
 
template <uint8_t Precision = 10,
          uint8_t FilterShiftFactor = ANALOG_FILTER_SHIFT_FACTOR,
          class FilterType = ANALOG_FILTER_TYPE, class AnalogType = analog_t,
          uint8_t IncRes =
              min(sizeof(FilterType) * CHAR_BIT - ADC_BITS - FilterShiftFactor,
                  sizeof(AnalogType) * CHAR_BIT - ADC_BITS)>
class FilteredAnalog {
  public:
    FilteredAnalog(pin_t analogPin) : analogPin(analogPin) {}
 
    using MappingFunction = AnalogType (*)(AnalogType);
 
    void map(MappingFunction fn) { mapFn = fn; }
 
    void invert() {
        constexpr AnalogType maxval = (1UL << (ADC_BITS + IncRes)) - 1;
        map([](AnalogType val) -> AnalogType { return maxval - val; });
    }
 
    bool update() {
        AnalogType input = getRawValue(); // read the raw analog input value
        input = filter.filter(input);     // apply a low-pass EMA filter
        if (mapFn)                        // If a mapping function is specified,
            input = mapFn(input);         // apply it
        return hysteresis.update(input);  // apply hysteresis, and return true
        // if the value changed since last time
    }
 
    AnalogType getValue() const { return hysteresis.getValue(); }
 
    float getFloatValue() const {
        return getValue() * (1.0f / (ldexpf(1.0f, Precision) - 1.0f));
    }
 
    AnalogType getRawValue() const {
        return increaseBitDepth<ADC_BITS + IncRes, ADC_BITS, AnalogType,
                                AnalogType>(ExtIO::analogRead(analogPin));
    }
 
    static void setupADC() {
#if HAS_ANALOG_READ_RESOLUTION
        analogReadResolution(ADC_BITS);
#endif
    }
 
  private:
    const pin_t analogPin;
 
    MappingFunction mapFn = nullptr;
 
    static_assert(
        ADC_BITS + IncRes + FilterShiftFactor <= sizeof(FilterType) * CHAR_BIT,
        "Error: FilterType is not wide enough to hold the maximum value");
    static_assert(
        ADC_BITS + IncRes <= sizeof(AnalogType) * CHAR_BIT,
        "Error: AnalogType is not wide enough to hold the maximum value");
    static_assert(
        Precision <= ADC_BITS + IncRes,
        "Error: Precision is larger than the increased ADC precision");
 
    EMA<FilterShiftFactor, FilterType> filter;
    Hysteresis<ADC_BITS + IncRes - Precision, AnalogType, AnalogType>
        hysteresis;
};
 
END_AH_NAMESPACE
 
AH_DIAGNOSTIC_POP()