mup_rain_ad.h

// mup_rain_ad.h
#pragma once
 
#include "scheduler.h"
#include "sensors.h"
 
namespace ustd {
 
// clang-format off
// clang-format on
class RainAD {
  private:
    String RainAD_VERSION = "0.1.0";
    Scheduler *pSched;
    int tID;
    String name;
    uint8_t analogPort;
    uint8_t digitalPort;
    bool digitalState;
    double RainADvalue;
    unsigned long basePollRate = 500000L;
    uint32_t pollRateMs = 2000;
    uint32_t lastPollMs = 0;
    bool bActive = 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 rainSensor = ustd::sensorprocessor(4, 600, 0.005);
 
    RainAD(String name, uint8_t analogPort, uint8_t digitalPort, FilterMode filterMode = FilterMode::MEDIUM)
        : name(name), analogPort(analogPort), digitalPort(digitalPort), filterMode(filterMode) {
        setFilterMode(filterMode, true);
    }
 
    ~RainAD() {
    }
 
    double getUnitRain() {
        return RainADvalue;
    }
 
    void begin(Scheduler *_pSched, uint32_t _pollRateMs = 2000) {
        pSched = _pSched;
        pollRateMs = _pollRateMs;
 
        auto ft = [=]() { this->loop(); };
        tID = pSched->add(ft, name, basePollRate);
 
        pinMode(digitalPort, INPUT_PULLUP);
        digitalState = digitalRead(digitalPort);  // this is inverse logic, but we initialise with the opposite value to cause an initial publish...
 
        auto fnall = [=](String topic, String msg, String originator) {
            this->subsMsg(topic, msg, originator);
        };
        pSched->subscribe(tID, name + "/sensor/#", fnall);
        bActive = true;
    }
 
    void setFilterMode(FilterMode mode, bool silent = false) {
        switch (mode) {
        case FAST:
            filterMode = FAST;
            rainSensor.update(1, 15, 0.001);
            break;
        case MEDIUM:
            filterMode = MEDIUM;
            rainSensor.update(4, 300, 0.005);
            break;
        case LONGTERM:
        default:
            filterMode = LONGTERM;
            rainSensor.update(50, 600, 0.01);
            break;
        }
        if (!silent)
            publishFilterMode();
    }
 
  private:
    void publishRain() {
        char buf[32];
        sprintf(buf, "%5.3f", RainADvalue);
        pSched->publish(name + "/sensor/unitrain", buf);
        if (digitalState) {
            strcpy(buf, "ON");
        } else {
            strcpy(buf, "OFF");
        }
        pSched->publish(name + "/binary_sensor/rain", 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) {
                bool hasChanged = false;
                lastPollMs = millis();
                double val = 1.0 - (analogRead(analogPort) / (adRange - 1.0));
                if (rainSensor.filter(&val)) {
                    RainADvalue = val;
                    hasChanged = true;
                }
                bool st = !digitalRead(digitalPort);  // inverse logic.
                if (st != digitalState) {
                    digitalState = st;
                    hasChanged = true;
                }
                if (hasChanged) publishRain();
            }
        }
    }
 
    void subsMsg(String topic, String msg, String originator) {
        if (topic == name + "/sensor/unitrain/get" || topic == name + "/sensor/rain/get") {
            publishRain();
        } 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);
                }
            }
        }
    };
};  // rainAD
 
}  // namespace ustd