mup_analog_sensor.h

// mup_analog_sensor_ad.h
#pragma once
 
#include "scheduler.h"
#include "sensors.h"
 
namespace ustd {
 
// clang-format on
class AnalogSensor {
  private:
    String AnalogSensor_VERSION = "0.1.0";
    Scheduler *pSched;
    int tID;
    String name;
    uint8_t analogPort;
    String topicName;
    double analogSensorValue;
    double linTransA = 1.0;  // a*x+b linear transformation of measured values, default no change.
    double linTransB = 0.0;
    unsigned long basePollRate = 500000L;
    uint32_t pollRateMs = 2000;
    uint32_t lastPollMs = 0;
    bool bActive = false;
    bool initialPublish = false;
#ifdef __ESP32__
    double adRange = 4096.0;  // 12 bit default
#else
    double adRange = 1024.0;  // 10 bit default
#endif
 
  public:
    enum FilterMode { FAST,
                      MEDIUM,
                      LONGTERM };
    FilterMode filterMode;
    ustd::sensorprocessor analogSensor = ustd::sensorprocessor(4, 600, 0.005);
 
    AnalogSensor(String name, uint8_t analogPort, FilterMode filterMode = FilterMode::MEDIUM, String topicName = "")
        : name(name), analogPort(analogPort), topicName(topicName), filterMode(filterMode) {
        setFilterMode(filterMode, true);
    }
 
    ~AnalogSensor() {
    }
 
    double getUnitAnalogSensor() {
        return analogSensorValue;
    }
 
    void begin(Scheduler *_pSched, uint32_t _pollRateMs = 2000, double _linTransA = 1.0, double _linTransB = 0.0) {
        pSched = _pSched;
        pollRateMs = _pollRateMs;
        linTransA = _linTransA;
        linTransB = _linTransB;
        initialPublish = false;
 
        auto ft = [=]() { this->loop(); };
        tID = pSched->add(ft, name, basePollRate);
 
        auto fnall = [=](String topic, String msg, String originator) {
            this->subsMsg(topic, msg, originator);
        };
        pSched->subscribe(tID, name + "/sensor/#", fnall);
        pSched->subscribe(tID, name + "/mqtt/state", fnall);
        bActive = true;
    }
 
    void setFilterMode(FilterMode mode, bool silent = false) {
        switch (mode) {
        case FAST:
            filterMode = FAST;
            analogSensor.update(1, 15, 0.001);
            break;
        case MEDIUM:
            filterMode = MEDIUM;
            analogSensor.update(4, 300, 0.005);
            break;
        case LONGTERM:
        default:
            filterMode = LONGTERM;
            analogSensor.update(50, 600, 0.01);
            break;
        }
        if (!silent)
            publishFilterMode();
    }
 
  private:
    void publishAnalogSensor() {
        char buf[32];
        sprintf(buf, "%5.3f", analogSensorValue);
        pSched->publish(name + "/sensor/unitanalogsensor", buf);
        if (topicName != "unitanalogsensor" && topicName != "") {
            pSched->publish(name + "/sensor/" + topicName, buf);
        }
    }
 
    void publishFilterMode() {
        switch (filterMode) {
        case FilterMode::FAST:
            pSched->publish(name + "/sensor/mode", "FAST");
            break;
        case FilterMode::MEDIUM:
            pSched->publish(name + "/sensor/mode", "MEDIUM");
            break;
        case FilterMode::LONGTERM:
            pSched->publish(name + "/sensor/mode", "LONGTERM");
            break;
        }
    }
 
    void loop() {
        if (bActive) {
            if (timeDiff(lastPollMs, millis()) >= pollRateMs || !initialPublish) {
                bool hasChanged = false;
                lastPollMs = millis();
                double val = analogRead(analogPort) / (adRange - 1.0);
                if (val < 0.0) val = 0.0;
                if (val > 1.0) val = 1.0;
                if (linTransA != 1.0 || linTransB != 0.0) {
                    val = linTransA * val + linTransB;
                }
                if (analogSensor.filter(&val) || !initialPublish) {
                    analogSensorValue = val;
                    hasChanged = true;
                }
                if (hasChanged) {
                    publishAnalogSensor();
                    initialPublish = true;
                }
            }
        }
    }
 
    void subsMsg(String topic, String msg, String originator) {
        if (topic == name + "/sensor/unitanalogsensor/get" || topic == name + "/sensor/" + topicName + "/get") {
            publishAnalogSensor();
        } else if (topic == name + "/sensor/mode/get") {
            publishFilterMode();
        } else if (topic == name + "/sensor/mode/set") {
            if (msg == "fast" || msg == "FAST") {
                setFilterMode(FilterMode::FAST);
            } else {
                if (msg == "medium" || msg == "MEDIUM") {
                    setFilterMode(FilterMode::MEDIUM);
                } else {
                    setFilterMode(FilterMode::LONGTERM);
                }
            }
        } else if (topic == name + "mqtt/state") {
            if (msg == "connected") {
                initialPublish = false;  // republish for mqtt.
            }
        }
    };
};  // analogsensorAD
 
}  // namespace ustd