mup_light.h

// mup_light.h - muwerk light applet
 
#pragma once
 
#include "helper/light_controller.h"
#include "scheduler.h"
 
namespace ustd {
// clang-format off
// clang-format on
 
class Light {
  public:
    static const char *version;  // = "0.1.0";
 
  private:
    // muwerk task management
    Scheduler *pSched;
    int tID;
 
    // device configuration
    String name;
 
    // hardware configuration
    uint8_t port;
    bool activeLogic = false;
    uint16_t pwmrange;
    uint8_t channel;
    LightController light;
 
  public:
    Light(String name, uint8_t port, bool activeLogic = false, uint8_t channel = 0)
        : name(name), port(port), activeLogic(activeLogic), channel(channel) {
    }
 
    void begin(Scheduler *_pSched, bool initialState = false) {
        pSched = _pSched;
        tID = pSched->add([this]() { this->light.loop(); }, name, 50000L);
 
        pSched->subscribe(tID, name + "/light/#", [this](String topic, String msg, String orig) {
            this->light.commandParser(topic.substring(name.length() + 7), msg);
        });
 
        // prepare hardware
#if defined(__ESP32__)
        pinMode(port, OUTPUT);
// use first channel of 16 channels (started from zero)
#define LEDC_TIMER_BITS 10
// use 5000 Hz as a LEDC base frequency
#define LEDC_BASE_FREQ 5000
        ledcSetup(channel, LEDC_BASE_FREQ, LEDC_TIMER_BITS);
        ledcAttachPin(port, channel);
#else
        pinMode(port, OUTPUT);
#endif
#ifdef __ESP__
        pwmrange = 1023;
#else
        pwmrange = 255;
#endif
 
        // start light controller
        light.begin([this](bool state, double level, bool control,
                           bool notify) { this->onLightControl(state, level, control, notify); },
                    initialState);
    }
 
    void set(bool state) {
        light.set(state);
    }
 
    void setMode(LightController::Mode mode, unsigned int interval_ms = 1000,
                 double phase_unit = 0.0, String pattern = "") {
        light.setMode(mode, interval_ms, phase_unit, pattern);
    }
 
    void setMinMaxWaveBrightness(double minBrightness, double maxBrightness) {
        light.setMinMaxWaveBrightness(minBrightness, maxBrightness);
    }
 
#ifdef USTD_FEATURE_HOMEASSISTANT
    void registerHomeAssistant(HomeAssistant *pHass, String human = "", String icon = "",
                               String attribs = "", bool dimmable = true) {
        pHass->addLight(name, human, dimmable ? HomeAssistant::LightDim : HomeAssistant::Light,
                        icon, attribs);
    }
#endif
  private:
    void onLightControl(bool state, double level, bool control, bool notify) {
        if (control) {
            if (state && level == 1.0) {
                // led is on at maximum brightness
#ifdef __ESP32__
                ledcWrite(channel, activeLogic ? pwmrange : 0);
#else
                digitalWrite(port, activeLogic ? HIGH : LOW);
#endif
            } else if (state && level > 0.0) {
                // led is dimmed
                uint16_t bri = (uint16_t)(level * (double)pwmrange);
                if (bri) {
                    if (!activeLogic)
                        bri = pwmrange - bri;
#if defined(__ESP32__)
                    ledcWrite(channel, bri);
#else
                    analogWrite(port, bri);
#endif
                } else {
                    light.forceState(false, 0.0);
                    onLightControl(false, 0.0, control, notify);
                }
            } else {
                // led is off
#ifdef __ESP32__
                ledcWrite(channel, activeLogic ? 0 : pwmrange);
#else
                digitalWrite(port, activeLogic ? LOW : HIGH);
#endif
            }
        }
        if (notify) {
#ifdef __ARDUINO__
            pSched->publish(name + "/light/unitbrightness", String(level, 3));
#else
            char buf[32];
            sprintf(buf, "%5.3f", level);
            pSched->publish(name + "/light/unitbrightness", buf);
#endif
            pSched->publish(name + "/light/state", state ? "on" : "off");
        }
    }
};
 
const char *Light::version = "0.1.0";
 
}  // namespace ustd