light_controller.h

// light_controller.h - controller for light related operations
 
#pragma once
 
#include "ustd_platform.h"
#include "mupplet_core.h"
 
namespace ustd {
 
class LightController {
  public:
    enum Mode {
        Passive, 
        Blink,   
        Wave,    
        Pulse,   
        Pattern  
    };
 
#if defined(__ESP__) || defined(__UNIXOID__)
    typedef std::function<void(bool state, double level, bool control, bool notify)> T_CONTROL;
#elif defined(__ATTINY__)
    typedef void (*T_CONTROL)(bool state, double level, bool control, bool notify);
#else
    typedef ustd::function<void(bool state, double level, bool control, bool notify)> T_CONTROL;
#endif
 
  private:
    // controller state
    Mode mode;
    bool state;
    double brightlevel;
    // configuration
    T_CONTROL controller;
    unsigned long interval = 1000;
    double phase = 0.0;
    double minWaveBrightness = 0.0;
    double maxWaveBrightness = 1.0;
    String pattern = "";
    // runtime
    unsigned long uPhase = 0;
    unsigned long oPeriod = 0;
    unsigned long startPulse = 0;
    unsigned int patternPointer = 0;
 
  public:
    LightController() {
    }
 
    void begin(T_CONTROL controller, bool initialState = false) {
        this->controller = controller;
        mode = Passive;
        state = !initialState;
        set(initialState);
    }
 
    void loop() {
        if (mode == Mode::Passive)
            return;
        unsigned long period = (millis() + uPhase) % (2 * interval);
        if (mode == Mode::Pulse) {
            if (millis() - startPulse < interval) {
                set(true, true);
            } else {
                set(false, true);
                setMode(Mode::Passive);
            }
        }
        if (mode == Mode::Blink) {
            if (period < oPeriod) {
                set(false, true);
            } else {
                if (period > interval && oPeriod < interval) {
                    set(true, true);
                }
            }
        }
        if (mode == Mode::Wave) {
            unsigned long period = (millis() + uPhase) % (2 * interval);
            double br = 0.0;
            if (period < interval) {
                br = (double)period / (double)interval;
            } else {
                br = (double)(2 * interval - period) / (double)interval;
            }
            br = br * (maxWaveBrightness - minWaveBrightness) + minWaveBrightness;
            brightness(br, true);
        }
        if (mode == Mode::Pattern) {
            if (period < oPeriod) {
                if (patternPointer < pattern.length()) {
                    char c = pattern[patternPointer];
                    if (c == 'r') {
                        patternPointer = 0;
                        c = pattern[patternPointer];
                    }
                    if (c == '+') {
                        set(true, true);
                    }
                    if (c == '-') {
                        set(false, true);
                    }
                    if (c >= '0' && c <= '9') {
                        double br = (double)(c - '0') * 0.1111;
                        brightness(br, true);
                    }
                    ++patternPointer;
                } else {
                    patternPointer = 0;
                    set(false, true);
                    setMode(Mode::Passive);
                }
            }
        }
        oPeriod = period;
    }
 
    bool commandParser(String command, String args) {
        if (command == "set") {
            double br;
            br = parseUnitLevel(args);
            brightness(br);
            return true;
        }
        if (command == "mode/set") {
            char msgbuf[128];
            memset(msgbuf, 0, 128);
            strncpy(msgbuf, args.c_str(), 127);
            char *p = strchr(msgbuf, ' ');
            char *p2 = nullptr;
            char *p3 = nullptr;
            if (p) {
                *p = 0;
                ++p;
                p2 = strchr(p, ',');
                if (p2) {
                    *p2 = 0;
                    ++p2;
                    p3 = strchr(p2, ',');
                    if (p3) {
                        *p3 = 0;
                        ++p3;
                    }
                }
            }
            int t = 1000;
            double phs = 0.0;
            if (!strcmp(msgbuf, "passive")) {
                setMode(Mode::Passive);
            } else if (!strcmp(msgbuf, "pulse")) {
                if (p)
                    t = atoi(p);
                setMode(Mode::Pulse, t);
            } else if (!strcmp(msgbuf, "blink")) {
                if (p)
                    t = atoi(p);
                if (p2)
                    phs = atof(p2);
                setMode(Mode::Blink, t, phs);
            } else if (!strcmp(msgbuf, "wave")) {
                if (p)
                    t = atoi(p);
                if (p2)
                    phs = atof(p2);
                setMode(Mode::Wave, t, phs);
            } else if (!strcmp(msgbuf, "pattern")) {
                if (p && strlen(p) > 0) {
                    if (p2)
                        t = atoi(p2);
                    if (p3)
                        phs = atof(p3);
                    setMode(Mode::Pattern, t, phs, p);
                }
            }
            return true;
        }
        if (command == "unitbrightness/get") {
            controller(state, brightlevel, false, true);
            return true;
        }
        return false;
    }
 
    void set(bool state) {
        // clang-format off
        // clang-format on
        set(state, false);
    }
 
    void brightness(double level) {
        brightness(level, false);
    }
 
    void setMode(Mode mode, unsigned int interval_ms = 1000, double phase_unit = 0.0,
                 String pattern = "") {
        this->mode = mode;
        if (mode == Mode::Passive)
            return;
        phase = phase_unit;
        if (phase < 0.0)
            phase = 0.0;
        if (phase > 1.0)
            phase = 1.0;
        interval = interval_ms;
        if (interval < 100)
            interval = 100;
        if (interval > 100000)
            interval = 100000;
        startPulse = millis();
        uPhase = (unsigned long)(2.0 * (double)interval * phase);
        oPeriod = (millis() + uPhase) % interval;
        if (mode == Mode::Pattern) {
            this->pattern = pattern;
            patternPointer = 0;
        }
    }
 
    void setMinMaxWaveBrightness(double minBrightness, double maxBrightness) {
        if (minBrightness < 0.0 || minBrightness > 1.0)
            minBrightness = 0.0;
        if (maxBrightness < 0.0 || maxBrightness > 1.0)
            maxBrightness = 1.0;
        if (minBrightness >= maxBrightness) {
            minBrightness = 0.0;
            maxBrightness = 1.0;
        }
        minWaveBrightness = minBrightness;
        maxWaveBrightness = maxBrightness;
    }
 
    void forceState(bool state, double brightlevel) {
        this->state = state;
        this->brightlevel = brightlevel < 0.0 ? 0.0 : brightlevel > 1.0 ? 1.0
                                                                        : brightlevel;
    }
 
  private:
    void set(bool _state, bool _automatic) {
        if (_state == state)
            return;
        if (!_automatic)
            mode = Mode::Passive;
        // if we want to preserve the brightness level, we need to change this
        brightlevel = _state ? 1.0 : 0.0;
        state = _state;
        controller(state, brightlevel, true, !_automatic);
    }
 
    void brightness(double _brightlevel, bool _automatic) {
        if (_brightlevel < 0.0)
            _brightlevel = 0.0;
        if (_brightlevel > 1.0)
            _brightlevel = 1.0;
        if (brightlevel == _brightlevel)
            return;
        if (!_automatic)
            mode = Mode::Passive;
        brightlevel = _brightlevel;
        state = _brightlevel > 0.0;
        controller(state, brightlevel, true, !_automatic);
    }
};
 
}  // namespace ustd