mup_switch.h

// mup_switch.h - muwerk switch applet
#pragma once
 
#include "scheduler.h"
 
namespace ustd {
 
#if defined(__ESP32__) || defined(__ESP__)
#define G_INT_ATTR IRAM_ATTR
#else
#define G_INT_ATTR
#endif
 
#define USTD_SW_MAX_IRQS (10)
 
volatile unsigned long pSwIrqCounter[USTD_SW_MAX_IRQS] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
volatile unsigned long pSwLastIrq[USTD_SW_MAX_IRQS] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
volatile unsigned long pSwDebounceMs[USTD_SW_MAX_IRQS] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 
void G_INT_ATTR ustd_sw_irq_master(uint8_t irqno) {
    unsigned long curr = millis();
    noInterrupts();
    if (pSwDebounceMs[irqno]) {
        if (timeDiff(pSwLastIrq[irqno], curr) < pSwDebounceMs[irqno]) {
            interrupts();
            return;
        }
    }
    ++pSwIrqCounter[irqno];
    pSwLastIrq[irqno] = curr;
    interrupts();
}
 
void G_INT_ATTR ustd_sw_irq0() {
    ustd_sw_irq_master(0);
}
void G_INT_ATTR ustd_sw_irq1() {
    ustd_sw_irq_master(1);
}
void G_INT_ATTR ustd_sw_irq2() {
    ustd_sw_irq_master(2);
}
void G_INT_ATTR ustd_sw_irq3() {
    ustd_sw_irq_master(3);
}
void G_INT_ATTR ustd_sw_irq4() {
    ustd_sw_irq_master(4);
}
void G_INT_ATTR ustd_sw_irq5() {
    ustd_sw_irq_master(5);
}
void G_INT_ATTR ustd_sw_irq6() {
    ustd_sw_irq_master(6);
}
void G_INT_ATTR ustd_sw_irq7() {
    ustd_sw_irq_master(7);
}
void G_INT_ATTR ustd_sw_irq8() {
    ustd_sw_irq_master(8);
}
void G_INT_ATTR ustd_sw_irq9() {
    ustd_sw_irq_master(9);
}
 
void (*ustd_sw_irq_table[USTD_SW_MAX_IRQS])() = {ustd_sw_irq0, ustd_sw_irq1, ustd_sw_irq2, ustd_sw_irq3, ustd_sw_irq4,
                                                 ustd_sw_irq5, ustd_sw_irq6, ustd_sw_irq7, ustd_sw_irq8, ustd_sw_irq9};
 
unsigned long getSwResetIrqCount(uint8_t irqno) {
    unsigned long count = (unsigned long)-1;
    noInterrupts();
    if (irqno < USTD_SW_MAX_IRQS) {
        count = pSwIrqCounter[irqno];
        pSwIrqCounter[irqno] = 0;
    }
    interrupts();
    return count;
}
 
// clang-format off
// clang-format on
class Switch {
  public:
    static const char *version;  // = "0.1.0";
    enum Mode {
        Default,     
        Rising,      
        Falling,     
        Flipflop,    
        Timer,       
        Duration,    
        BinarySensor 
    };
 
  private:
    Scheduler *pSched;
    int tID;
 
    String name;
    uint8_t port;
    Mode mode;
    bool activeLogic;
    String customTopic;
    int8_t interruptIndex;
    unsigned long debounceTimeMs;
 
    bool useInterrupt = false;
    uint8_t ipin = 255;
    unsigned long lastChangeMs = 0;
    int physicalState = -1;
    int logicalState = -1;
    bool overriddenPhysicalState = false;
    bool overridePhysicalActive = false;
 
    bool bCounter = false;
    unsigned long counter = 0;
 
    bool flipflop = true;  // This starts with 'off', since state is initially changed once.
    unsigned long activeTimer = 0;
    unsigned long timerDuration = 1000;  // ms
    unsigned long startEvent = 0;        // ms
    unsigned long durations[2] = {3000, 30000};
 
    unsigned long lastStatePublish = 0;  
    unsigned int stateRefresh = 0;       
    bool initialStatePublish = false;
    bool initialStateIsPublished = false;
 
  public:
    Switch(String name, uint8_t port, Mode mode = Mode::Default, bool activeLogic = false,
           String customTopic = "", int8_t interruptIndex = -1, unsigned long debounceTimeMs = 0)
        : name(name), port(port), mode(mode), activeLogic(activeLogic), customTopic(customTopic),
          interruptIndex(interruptIndex), debounceTimeMs(debounceTimeMs) {
    }
 
    virtual ~Switch() {
        if (useInterrupt)
            detachInterrupt(ipin);
    }
 
    void setDebounce(long ms) {
        if (ms < 0)
            ms = 0;
        if (ms > 1000)
            ms = 1000;
        debounceTimeMs = (unsigned long)ms;
    }
 
    void activateCounter(bool bActive) {
        bCounter = bActive;
        if (bCounter) {
            counter = 0;
            publishCounter();
        }
    }
 
    void setTimerDuration(unsigned long ms) {
        timerDuration = ms;
    }
 
    void setMode(Mode newmode, unsigned long duration = 0) {
        if (useInterrupt)
            flipflop = false;  // This starts with 'off', since state is
                               // initially changed once.
        else
            flipflop = true;  // This starts with 'off', since state is
                              // initially changed once.
        activeTimer = 0;
        timerDuration = duration;
        physicalState = -1;
        logicalState = -1;
        overriddenPhysicalState = false;
        overridePhysicalActive = false;
        lastChangeMs = 0;
        mode = newmode;
        if (mode == Mode::BinarySensor) {
            initialStateIsPublished = false;
            initialStatePublish = true;
            stateRefresh = 600;
        }
        startEvent = (unsigned long)-1;
    }
 
    void begin(Scheduler *_pSched) {
        pSched = _pSched;
 
        pinMode(port, INPUT_PULLUP);
        setMode(mode);
 
        if (interruptIndex >= 0 && interruptIndex < USTD_SW_MAX_IRQS) {
            ipin = digitalPinToInterrupt(port);
            switch (mode) {
            case Mode::Falling:
                attachInterrupt(ipin, ustd_sw_irq_table[interruptIndex], FALLING);
                break;
            case Mode::Rising:
                attachInterrupt(ipin, ustd_sw_irq_table[interruptIndex], RISING);
                break;
            default:
                attachInterrupt(ipin, ustd_sw_irq_table[interruptIndex], CHANGE);
                break;
            }
            pSwDebounceMs[interruptIndex] = debounceTimeMs;
            useInterrupt = true;
        }
 
        readState();
 
        auto ft = [=]() { this->loop(); };
        tID = pSched->add(ft, name, 50000);
 
        auto fnall = [=](String topic, String msg, String originator) {
            this->subsMsg(topic, msg, originator);
        };
        pSched->subscribe(tID, name + "/#", fnall);
        pSched->subscribe(tID, "mqtt/state", fnall);
    }
 
    void setLogicalState(bool newLogicalState) {
        if (logicalState != newLogicalState) {
            logicalState = newLogicalState;
            publishLogicalState(logicalState);
            if (bCounter) {
                if (logicalState) {
                    counter += 1;
                    publishCounter();
                }
            }
        }
    }
 
    void setStateRefresh(int logicalStateRefreshEverySecs) {
        stateRefresh = logicalStateRefreshEverySecs;
    }
 
    void setToggle() {
        setPhysicalState(!physicalState, true);
    }
 
    void setPulse() {
        setPhysicalState(true, true);
        setPhysicalState(false, true);
    }
 
  private:
    unsigned long getTimestamp() {
#if defined(__ARDUINO__) || defined(__ARM__) || defined(__RISC_V__)
        return pSched->getUptime();
#else
        return (unsigned long)time(nullptr);
#endif
    }
 
    void publishCounter() {
        char buf[32];
        sprintf(buf, "%ld", counter);
        if (bCounter) {
            pSched->publish(name + "/switch/counter", buf);
            pSched->publish(name + "/sensor/counter", buf);
        } else {
            pSched->publish(name + "/switch/counter", "NaN");
            pSched->publish(name + "/sensor/counter", "NaN");
        }
    }
 
    void publishLogicalState(bool lState) {
        String textState;
        String binaryState;
        lastStatePublish = getTimestamp();
        if (lState == true) {
            textState = "on";
            binaryState = "ON";
        } else {
            textState = "off";
            binaryState = "OFF";
        }
        switch (mode) {
        case Mode::Default:
        case Mode::Flipflop:
        case Mode::Timer:
            pSched->publish(name + "/switch/state", textState);
            if (customTopic != "")
                pSched->publish(customTopic, textState);
            break;
        case Mode::Rising:
            if (lState == true) {
                pSched->publish(name + "/switch/state", "trigger");
                if (customTopic != "")
                    pSched->publish(customTopic, "trigger");
            }
            break;
        case Mode::Falling:
            if (lState == false) {
                pSched->publish(name + "/switch/state", "trigger");
                if (customTopic != "")
                    pSched->publish(customTopic, "trigger");
            }
            break;
        case Mode::Duration:
            if (lState == true) {
                startEvent = millis();
            } else {
                if (startEvent != (unsigned long)-1) {
                    unsigned long dt = timeDiff(startEvent, millis());
                    char msg[32];
                    sprintf(msg, "%ld", dt);
                    pSched->publish(name + "/switch/duration", msg);
                    if (dt < durations[0]) {
                        pSched->publish(name + "/switch/shortpress", "trigger");
                    } else if (dt < durations[1]) {
                        pSched->publish(name + "/switch/longpress", "trigger");
                    } else {
                        pSched->publish(name + "/switch/verylongpress", "trigger");
                    }
                }
            }
            break;
        case Mode::BinarySensor:
            pSched->publish(name + "/binary_sensor/state", binaryState);
            if (customTopic != "")
                pSched->publish(customTopic, binaryState);
            break;
        }
    }
 
    void decodeLogicalState(bool physicalState) {
        switch (mode) {
        case Mode::Default:
        case Mode::Rising:
        case Mode::Falling:
        case Mode::Duration:
        case Mode::BinarySensor:
            setLogicalState(physicalState);
            break;
        case Mode::Flipflop:
            if (physicalState == false) {
                flipflop = !flipflop;
                setLogicalState(flipflop);
            }
            break;
        case Mode::Timer:
            if (physicalState == false) {
                activeTimer = millis();
            } else {
                setLogicalState(true);
            }
            break;
        }
    }
 
    void setPhysicalState(bool newState, bool override) {
        if (mode != Mode::Timer) {
            activeTimer = 0;
        }
        if (override) {
            overriddenPhysicalState = physicalState;
            overridePhysicalActive = true;
            if (newState != physicalState) {
                physicalState = newState;
                decodeLogicalState(newState);
            }
        } else {
            if (overridePhysicalActive && newState != overriddenPhysicalState) {
                overridePhysicalActive = false;
            }
            if (overridePhysicalActive)
                return;
            if (newState != physicalState || mode == Mode::Falling || mode == Mode::Rising) {
                if (timeDiff(lastChangeMs, millis()) > debounceTimeMs || useInterrupt) {
                    lastChangeMs = millis();
                    physicalState = newState;
                    decodeLogicalState(physicalState);
                }
            }
        }
    }
 
    void readState() {
        if (useInterrupt) {
            unsigned long count = getSwResetIrqCount(interruptIndex);
            int curstate = digitalRead(port);
            char msg[32];
            if (count) {
                sprintf(msg, "%ld", count);
                pSched->publish(name + "/switch/irqcount/0", msg);
                if (curstate == HIGH)
                    curstate = true;
                else
                    curstate = false;
                switch (mode) {
                case Mode::Rising:
                    for (unsigned long i = 0; i < count; i++) {
                        if (activeLogic) {
                            setPhysicalState(false, false);
                            setPhysicalState(true, false);
                        } else {
                            setPhysicalState(true, false);
                            setPhysicalState(false, false);
                        }
                    }
                    break;
                case Mode::Falling:
                    for (unsigned long i = 0; i < count; i++) {
                        if (activeLogic) {
                            setPhysicalState(true, false);
                            setPhysicalState(false, false);
                        } else {
                            setPhysicalState(false, false);
                            setPhysicalState(true, false);
                        }
                    }
                    break;
                default:
                    bool iState = ((count % 2) == 0);
                    if (curstate)
                        iState = !iState;
                    for (unsigned long i = 0; i < count; i++) {
                        if (activeLogic) {
                            setPhysicalState(iState, false);
                        } else {
                            setPhysicalState(!iState, false);
                        }
                        iState = !iState;
                    }
                    break;
                }
            }
        } else {
            int newstate = digitalRead(port);
            if (newstate == HIGH)
                newstate = true;
            else
                newstate = false;
            if (!activeLogic)
                newstate = !newstate;
            setPhysicalState(newstate, false);
        }
    }
 
    void loop() {
        readState();
        if (mode == Mode::Timer && activeTimer) {
            if (timeDiff(activeTimer, millis()) > timerDuration) {
                activeTimer = 0;
                setLogicalState(false);
            }
        }
        if (stateRefresh != 0 || (initialStateIsPublished = false && initialStatePublish == true)) {
            if (mode == Mode::BinarySensor) {
                if (getTimestamp() - lastStatePublish > stateRefresh || (initialStateIsPublished = false && initialStatePublish == true)) {
                    publishLogicalState(logicalState);
                    if (bCounter) publishCounter();
                    initialStateIsPublished = true;
                }
            }
        }
    }
 
    void subsMsg(String topic, String msg, String originator) {
        if (topic == name + "/switch/state/get" || topic == name + "/binary_sensor/state/get") {
            publishLogicalState(logicalState);
        } else if (topic == name + "/switch/counter/get" || topic == name + "/sensor/counter/get") {
            publishCounter();
        } else if (topic == name + "/switch/physicalstate/get") {
            char buf[32];
            if (physicalState)
                sprintf(buf, "on");
            else
                sprintf(buf, "off");
            pSched->publish(name + "/switch/physicalstate", buf);
        } else if (topic == name + "/switch/mode/set") {
            char buf[32];
            memset(buf, 0, 32);
            strncpy(buf, msg.c_str(), 31);
            char *p = strchr(buf, ' ');
            char *p2 = nullptr;
            if (p) {
                *p = 0;
                ++p;
                p2 = strchr(p, ',');
                if (p2) {
                    *p2 = 0;
                    ++p2;
                }
            }
            if (!strcmp(buf, "default")) {
                setMode(Mode::Default);
            } else if (!strcmp(buf, "rising")) {
                setMode(Mode::Rising);
            } else if (!strcmp(buf, "falling")) {
                setMode(Mode::Falling);
            } else if (!strcmp(buf, "flipflop")) {
                setMode(Mode::Flipflop);
            } else if (!strcmp(buf, "binary_sensor")) {
                setMode(Mode::BinarySensor);
            } else if (!strcmp(buf, "timer")) {
                unsigned long dur = 1000;
                if (p)
                    dur = atol(p);
                setMode(Mode::Timer, dur);
            } else if (!strcmp(buf, "duration")) {
                durations[0] = 3000;
                durations[1] = 30000;
                if (p) {
                    durations[0] = atol(p);
                    if (p2)
                        durations[1] = atol(p2);
                }
                if (durations[0] > durations[1]) {
                    durations[1] = (unsigned long)-1;
                }
                setMode(Mode::Duration);
            }
        } else if (topic == name + "/switch/set") {
            char buf[32];
            memset(buf, 0, 32);
            strncpy(buf, msg.c_str(), 31);
            if (!strcmp(buf, "on") || !strcmp(buf, "true")) {
                // setPhysicalState(true, true);
                setLogicalState(true);
            }
            if (!strcmp(buf, "off") || !strcmp(buf, "false")) {
                // setPhysicalState(false, true);
                setLogicalState(false);
            }
            if (!strcmp(buf, "toggle")) {
                setToggle();
            }
            if (!strcmp(buf, "pulse")) {
                setPulse();
            }
        } else if (topic == name + "/switch/debounce/get") {
            char buf[32];
            sprintf(buf, "%ld", debounceTimeMs);
            pSched->publish(name + "/debounce", buf);
        } else if (topic == name + "/switch/debounce/set") {
            long dbt = atol(msg.c_str());
            setDebounce(dbt);
        } else if (topic == "mqtt/state") {
            if (mode == Mode::Default || mode == Mode::Flipflop || mode == Mode::BinarySensor) {
                if (msg == "connected") {
                    publishLogicalState(logicalState);
                    if (bCounter) {
                        publishCounter();
                    }
                }
            }
        } else if (topic == name + "/switch/counter/start") {
            activateCounter(true);
        } else if (topic == name + "/switch/counter/stop") {
            activateCounter(false);
        }
    };
};  // Switch
 
const char *Switch::version = "0.1.0";
 
}  // namespace ustd