mup_light_pca9685.h

// light_pca9685.h - muwerk 16 channel light applet using PCA 9685 PWM controller
#pragma once
 
#include "muwerk.h"
#include "mupplet_core.h"
#include "helper/light_controller.h"
#include <Adafruit_PWMServoDriver.h>
 
namespace ustd {
// clang-format off
// clang-format on
class LightsPCA9685 {
  public:
    static const char *version;  // = "0.1.0";
 
  private:
    // muwerk task management
    Scheduler *pSched;
    int tID;
 
    // device configuration
    String name;
 
    // hardware
    Adafruit_PWMServoDriver *pPwm;
    uint8_t addr;
 
    // runtime
    LightController light[16];
    bool activeLogic;
 
  public:
    LightsPCA9685(String name, uint8_t addr = 0x40, bool activeLogic = false)
        : name(name), addr(addr), activeLogic(activeLogic) {
    }
 
    void begin(Scheduler *_pSched, TwoWire *_pWire = nullptr, bool initialState = false) {
        // standard muwerk task initialization
        pSched = _pSched;
        tID = pSched->add([this]() { this->loop(); }, name, 80000L);
 
        // initialize hardware
        pPwm = new Adafruit_PWMServoDriver(addr, _pWire == nullptr ? Wire : *_pWire);
        pPwm->begin();
        pPwm->setPWMFreq(1000);
 
        // subscribe to light messages and pass to light controller
        pSched->subscribe(tID, name + "/light/#", [this](String topic, String msg, String orig) {
            topic = topic.substring(name.length() + 7);
            int iPos = topic.indexOf('/');
            if (iPos == -1) {
                // invalid topic
                return;
            }
            long index = ustd::parseLong(topic.substring(0, iPos), -1);
            if (index < 0 || index > 15) {
                // invalid topic
                return;
            }
            this->light[index].commandParser(topic.substring(iPos + 1), msg);
        });
 
        // start light controller (register hardware implementation)
        for (uint8_t channel = 0; channel < 16; channel++) {
            light[channel].begin(
                [this, channel](bool state, double level, bool control, bool notify) {
                    this->onLightControl(channel, state, level, control, notify);
                },
                initialState);
        }
    }
 
    void set(int8_t channel, bool state) {
        if (channel < 0) {
            for (channel = 0; channel < 16; channel++) {
                light[channel].set(state);
            }
        } else if (channel < 16) {
            light[channel].set(state);
        }
    }
 
    void setMode(int8_t channel, LightController::Mode mode, unsigned int interval_ms = 1000,
                 double phase_unit = 0.0, String pattern = "") {
        if (channel < 0) {
            for (channel = 0; channel < 16; channel++) {
                light[channel].setMode(mode, interval_ms, phase_unit, pattern);
            }
        } else if (channel < 16) {
            light[channel].setMode(mode, interval_ms, phase_unit, pattern);
        }
    }
 
    void setMinMaxWaveBrightness(int8_t channel, double minBrightness, double maxBrightness) {
        if (channel < 0) {
            for (channel = 0; channel < 16; channel++) {
                light[channel].setMinMaxWaveBrightness(minBrightness, maxBrightness);
            }
        } else if (channel < 16) {
            light[channel].setMinMaxWaveBrightness(minBrightness, maxBrightness);
        }
    }
 
#ifdef USTD_FEATURE_HOMEASSISTANT
    void registerHomeAssistant(HomeAssistant *pHass, String human = "", String icon = "",
                               String attribs = "") {
        pHass->addMultiLight(name, 16, human, HomeAssistant::LightDim, icon, attribs);
    }
 
    void registerHomeAssistant(HomeAssistant *pHass, int channel, String human = "",
                               String icon = "", String attribs = "") {
        if (channel >= 0 && channel < 16) {
            pHass->addLight(name, channel, human, HomeAssistant::LightDim, icon, attribs);
        }
    }
#endif
 
  private:
    void loop() {
        for (int channel = 0; channel < 16; channel++) {
            light[channel].loop();
        }
    }
 
    void onLightControl(uint8_t channel, bool state, double level, bool control, bool notify) {
        if (control) {
            uint16_t intensity = level * 4096;
            if (intensity == 0 || state == false) {
                // GPIO mode off
                gpioSet(channel, false);
            } else if (intensity == 4096) {
                // GPIO mode on
                gpioSet(channel, true);
            } else {
                // PWM mode
                pwmSet(channel, intensity);
            }
        }
        if (notify) {
            pSched->publish(name + "/light/" + String(channel) + "/unitbrightness",
                            String(level, 3));
            pSched->publish(name + "/light/" + String(channel) + "/state", state ? "on" : "off");
        }
    }
 
    void gpioSet(uint8_t channel, bool on) {
        if (activeLogic && on) {
            pPwm->setPWM(channel, 4096, 0);
        } else if (activeLogic) {
            pPwm->setPWM(channel, 0, 4096);
        } else if (on) {
            pPwm->setPWM(channel, 0, 4096);
        } else {
            pPwm->setPWM(channel, 4096, 0);
        }
    }
 
    void pwmSet(uint8_t channel, uint16_t intensity) {
        if (activeLogic) {
            pPwm->setPWM(channel, 0, intensity);
        } else {
            pPwm->setPWM(channel, 0, 4096 - intensity);
        }
    }
};
 
const char *LightsPCA9685::version = "0.1.0";
 
}  // namespace ustd