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/STL/type_traits> // std::enable_if, std::is_constructible
#include <AH/STL/utility> // std::forward
#include <AH/Settings/SettingsWrapper.hpp>
 
BEGIN_AH_NAMESPACE
 
template <uint8_t FilterShiftFactor, class FilterType, class AnalogType>
struct MaximumFilteredAnalogIncRes {
    constexpr static uint8_t value =
        min(sizeof(FilterType) * CHAR_BIT - ADC_BITS - FilterShiftFactor,
            sizeof(AnalogType) * CHAR_BIT - ADC_BITS);
};
 
template <class MappingFunction, uint8_t Precision = 10,
          uint8_t FilterShiftFactor = ANALOG_FILTER_SHIFT_FACTOR,
          class FilterType = ANALOG_FILTER_TYPE, class AnalogType = analog_t,
          uint8_t IncRes = MaximumFilteredAnalogIncRes<
              FilterShiftFactor, FilterType, AnalogType>::value>
class GenericFilteredAnalog {
  public:
    GenericFilteredAnalog(pin_t analogPin, MappingFunction mapFn,
                          AnalogType initial = 0)
        : analogPin(analogPin), mapFn(std::forward<MappingFunction>(mapFn)),
          filter(increaseBitDepth<ADC_BITS + IncRes, Precision, AnalogType,
                                  AnalogType>(initial)) {}
 
    GenericFilteredAnalog(ArduinoPin_t analogPin, MappingFunction mapFn,
                          AnalogType initial = 0)
        : GenericFilteredAnalog(pin_t(analogPin),
                                std::forward<MappingFunction>(mapFn), initial) {
    }
 
    void reset(AnalogType value = 0) {
        AnalogType widevalue = increaseBitDepth<ADC_BITS + IncRes, Precision,
                                                AnalogType, AnalogType>(value);
        filter.reset(widevalue);
        hysteresis.setValue(widevalue);
    }
 
    void resetToCurrentValue() {
        AnalogType widevalue = getRawValue();
        filter.reset(widevalue);
        hysteresis.setValue(widevalue);
    }
 
    void map(MappingFunction fn) { mapFn = std::forward<MappingFunction>(fn); }
 
    MappingFunction &getMappingFunction() { return mapFn; }
    const MappingFunction &getMappingFunction() const { return mapFn; }
 
    bool update() {
        AnalogType input = getRawValue(); // read the raw analog input value
        input = filter.filter(input);     // apply a low-pass EMA filter
        input = mapFnHelper(input);       // apply the mapping function
        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 {
        AnalogType value = ExtIO::analogRead(analogPin);
#ifdef ESP8266
        if (value > 1023)
            value = 1023;
#endif
        return increaseBitDepth<ADC_BITS + IncRes, ADC_BITS, AnalogType>(value);
    }
 
    constexpr static AnalogType getMaxRawValue() {
        return (1ul << (ADC_BITS + IncRes)) - 1ul;
    }
 
    static void setupADC() {
#if HAS_ANALOG_READ_RESOLUTION
        analogReadResolution(ADC_BITS);
#endif
    }
 
  private:
    template <typename M = MappingFunction>
    typename std::enable_if<std::is_constructible<bool, M>::value,
                            AnalogType>::type
    mapFnHelper(AnalogType input) {
        return bool(mapFn) ? mapFn(input) : input;
    }
 
    template <typename M = MappingFunction>
    typename std::enable_if<!std::is_constructible<bool, M>::value,
                            AnalogType>::type
    mapFnHelper(AnalogType input) {
        return mapFn(input);
    }
 
  private:
    pin_t analogPin;
    MappingFunction mapFn;
 
    using EMA_t = EMA<FilterShiftFactor, AnalogType, FilterType>;
 
    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");
    static_assert(EMA_t::supports_range(AnalogType(0), getMaxRawValue()),
                  "Error: EMA filter type doesn't support full ADC range");
 
    EMA_t filter;
    Hysteresis<ADC_BITS + IncRes - Precision, AnalogType, AnalogType>
        hysteresis;
};
 
template <uint8_t Precision = 10,
          uint8_t FilterShiftFactor = ANALOG_FILTER_SHIFT_FACTOR,
          class FilterType = ANALOG_FILTER_TYPE, class AnalogType = analog_t,
          uint8_t IncRes = MaximumFilteredAnalogIncRes<
              FilterShiftFactor, FilterType, AnalogType>::value>
class FilteredAnalog
    : public GenericFilteredAnalog<AnalogType (*)(AnalogType), Precision,
                                   FilterShiftFactor, FilterType, AnalogType,
                                   IncRes> {
  public:
    FilteredAnalog(pin_t analogPin, AnalogType initial = 0)
        : GenericFilteredAnalog<AnalogType (*)(AnalogType), Precision,
                                FilterShiftFactor, FilterType, AnalogType,
                                IncRes>(analogPin, nullptr, initial) {}
 
    FilteredAnalog(ArduinoPin_t analogPin, AnalogType initial = 0)
        : FilteredAnalog(pin_t(analogPin), initial) {}
 
    FilteredAnalog() : FilteredAnalog(NO_PIN) {}
 
    using MappingFunction = AnalogType (*)(AnalogType);
 
    void invert() {
        constexpr AnalogType maxval = FilteredAnalog::getMaxRawValue();
        this->map([](AnalogType val) -> AnalogType { return maxval - val; });
    }
};
 
END_AH_NAMESPACE
 
AH_DIAGNOSTIC_POP()