You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
362 lines
9.4 KiB
362 lines
9.4 KiB
/*
|
|
|
|
LED MODULE
|
|
|
|
Copyright (C) 2016-2019 by Xose Pérez <xose dot perez at gmail dot com>
|
|
|
|
*/
|
|
|
|
#if LED_SUPPORT
|
|
|
|
#include "broker.h"
|
|
#include "relay.h"
|
|
|
|
#include "led.h"
|
|
#include "led_config.h"
|
|
|
|
// LED helper class
|
|
|
|
led_t::led_t() :
|
|
pin(GPIO_NONE),
|
|
inverse(false),
|
|
mode(LED_MODE_MANUAL),
|
|
relayID(0)
|
|
{}
|
|
|
|
led_t::led_t(unsigned char id) :
|
|
pin(_ledPin(id)),
|
|
inverse(_ledInverse(id)),
|
|
mode(_ledMode(id)),
|
|
relayID(_ledRelay(id))
|
|
{
|
|
if (pin != GPIO_NONE) {
|
|
pinMode(pin, OUTPUT);
|
|
}
|
|
}
|
|
|
|
bool led_t::status() {
|
|
bool result = digitalRead(pin);
|
|
return inverse ? !result : result;
|
|
}
|
|
|
|
bool led_t::status(bool new_status) {
|
|
digitalWrite(pin, inverse ? !new_status : new_status);
|
|
return new_status;
|
|
}
|
|
|
|
bool led_t::toggle() {
|
|
return status(!status());
|
|
}
|
|
|
|
led_delay_t::led_delay_t(unsigned long on_ms, unsigned long off_ms) :
|
|
on(microsecondsToClockCycles(on_ms * 1000)),
|
|
off(microsecondsToClockCycles(off_ms * 1000))
|
|
{}
|
|
|
|
// For relay-based modes
|
|
bool _led_update = false;
|
|
|
|
// For network-based modes, cycle ON & OFF (time in milliseconds)
|
|
// XXX: internals convert these to clock cycles, delay cannot be longer than 25000 / 50000 ms
|
|
const led_delay_t _ledDelays[] {
|
|
{100, 100}, // Autoconfig
|
|
{100, 4900}, // Connected
|
|
{4900, 100}, // Connected (inverse)
|
|
{100, 900}, // Config / AP
|
|
{900, 100}, // Config / AP (inverse)
|
|
{500, 500} // Idle
|
|
};
|
|
|
|
std::vector<led_t> _leds;
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
unsigned char _ledCount() {
|
|
return _leds.size();
|
|
}
|
|
|
|
const led_delay_t& _ledModeToDelay(LedMode mode) {
|
|
static_assert(
|
|
(sizeof(_ledDelays) / sizeof(_ledDelays[0])) <= static_cast<int>(LedMode::None),
|
|
"LedMode mapping out-of-bounds"
|
|
);
|
|
return _ledDelays[static_cast<int>(mode)];
|
|
}
|
|
|
|
void _ledBlink(led_t& led, const led_delay_t& delays) {
|
|
static auto clock_last = ESP.getCycleCount();
|
|
static auto delay_for = delays.on;
|
|
|
|
const auto clock_current = ESP.getCycleCount();
|
|
if (clock_current - clock_last >= delay_for) {
|
|
delay_for = led.toggle() ? delays.on : delays.off;
|
|
clock_last = clock_current;
|
|
}
|
|
}
|
|
|
|
inline void _ledBlink(led_t& led, const LedMode mode) {
|
|
_ledBlink(led, _ledModeToDelay(mode));
|
|
}
|
|
|
|
#if WEB_SUPPORT
|
|
|
|
bool _ledWebSocketOnKeyCheck(const char * key, JsonVariant& value) {
|
|
return (strncmp(key, "led", 3) == 0);
|
|
}
|
|
|
|
void _ledWebSocketOnVisible(JsonObject& root) {
|
|
if (_ledCount() > 0) {
|
|
root["ledVisible"] = 1;
|
|
}
|
|
}
|
|
|
|
void _ledWebSocketOnConnected(JsonObject& root) {
|
|
if (!_ledCount()) return;
|
|
JsonArray& leds = root.createNestedArray("ledConfig");
|
|
for (unsigned char id = 0; id < _ledCount(); ++id) {
|
|
JsonObject& led = leds.createNestedObject();
|
|
led["mode"] = getSetting({"ledMode", id}, _leds[id].mode);
|
|
led["relay"] = getSetting<unsigned char>({"ledRelay", id}, _leds[id].relayID);
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
#if BROKER_SUPPORT
|
|
void _ledBrokerCallback(const String& topic, unsigned char, unsigned int) {
|
|
|
|
// Only process status messages for switches
|
|
if (topic.equals(MQTT_TOPIC_RELAY)) {
|
|
ledUpdate(true);
|
|
}
|
|
|
|
}
|
|
#endif // BROKER_SUPPORT
|
|
|
|
#if MQTT_SUPPORT
|
|
void _ledMQTTCallback(unsigned int type, const char * topic, const char * payload) {
|
|
|
|
if (type == MQTT_CONNECT_EVENT) {
|
|
char buffer[strlen(MQTT_TOPIC_LED) + 3];
|
|
snprintf_P(buffer, sizeof(buffer), PSTR("%s/+"), MQTT_TOPIC_LED);
|
|
mqttSubscribe(buffer);
|
|
}
|
|
|
|
if (type == MQTT_MESSAGE_EVENT) {
|
|
|
|
// Only want `led/+/<MQTT_SETTER>`
|
|
const String magnitude = mqttMagnitude((char *) topic);
|
|
if (!magnitude.startsWith(MQTT_TOPIC_LED)) return;
|
|
|
|
// Get led ID from after the slash when t is `led/<LED_ID>`
|
|
unsigned int ledID = magnitude.substring(strlen(MQTT_TOPIC_LED) + 1).toInt();
|
|
if (ledID >= _ledCount()) {
|
|
DEBUG_MSG_P(PSTR("[LED] Wrong ledID (%d)\n"), ledID);
|
|
return;
|
|
}
|
|
|
|
// Check if LED is managed
|
|
if (_leds[ledID].mode != LED_MODE_MANUAL) return;
|
|
|
|
// Get value based on relays payload logic (0 / off, 1 / on, 2 / toggle)
|
|
const auto value = relayParsePayload(payload);
|
|
|
|
// Action to perform is also based on relay constants ... TODO generic enum?
|
|
if (value == RelayStatus::TOGGLE) {
|
|
_leds[ledID].toggle();
|
|
} else {
|
|
_leds[ledID].status(value == RelayStatus::ON);
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
#endif
|
|
|
|
void _ledConfigure() {
|
|
for (unsigned char id = 0; id < _leds.size(); ++id) {
|
|
_leds[id].mode = getSetting({"ledMode", id}, _ledMode(id));
|
|
_leds[id].relayID = getSetting<unsigned char>({"ledRelay", id}, _ledRelay(id));
|
|
}
|
|
_led_update = true;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
void ledUpdate(bool do_update) {
|
|
_led_update = do_update;
|
|
}
|
|
|
|
void ledSetup() {
|
|
|
|
size_t leds = 0;
|
|
|
|
#if LED1_PIN != GPIO_NONE
|
|
++leds;
|
|
#endif
|
|
#if LED2_PIN != GPIO_NONE
|
|
++leds;
|
|
#endif
|
|
#if LED3_PIN != GPIO_NONE
|
|
++leds;
|
|
#endif
|
|
#if LED4_PIN != GPIO_NONE
|
|
++leds;
|
|
#endif
|
|
#if LED5_PIN != GPIO_NONE
|
|
++leds;
|
|
#endif
|
|
#if LED6_PIN != GPIO_NONE
|
|
++leds;
|
|
#endif
|
|
#if LED7_PIN != GPIO_NONE
|
|
++leds;
|
|
#endif
|
|
#if LED8_PIN != GPIO_NONE
|
|
++leds;
|
|
#endif
|
|
|
|
_leds.reserve(leds);
|
|
|
|
for (unsigned char id=0; id < leds; ++id) {
|
|
_leds.emplace_back(id);
|
|
}
|
|
|
|
_ledConfigure();
|
|
|
|
#if MQTT_SUPPORT
|
|
mqttRegister(_ledMQTTCallback);
|
|
#endif
|
|
|
|
#if WEB_SUPPORT
|
|
wsRegister()
|
|
.onVisible(_ledWebSocketOnVisible)
|
|
.onConnected(_ledWebSocketOnConnected)
|
|
.onKeyCheck(_ledWebSocketOnKeyCheck);
|
|
#endif
|
|
|
|
#if BROKER_SUPPORT
|
|
StatusBroker::Register(_ledBrokerCallback);
|
|
#endif
|
|
|
|
|
|
DEBUG_MSG_P(PSTR("[LED] Number of leds: %d\n"), _leds.size());
|
|
|
|
// Main callbacks
|
|
espurnaRegisterLoop(ledLoop);
|
|
espurnaRegisterReload(_ledConfigure);
|
|
|
|
}
|
|
|
|
void ledLoop() {
|
|
|
|
const auto wifi_state = wifiState();
|
|
|
|
for (auto& led : _leds) {
|
|
|
|
if (led.mode == LED_MODE_WIFI) {
|
|
|
|
if ((wifi_state & WIFI_STATE_WPS) || (wifi_state & WIFI_STATE_SMARTCONFIG)) {
|
|
_ledBlink(led, LedMode::NetworkAutoconfig);
|
|
} else if (wifi_state & WIFI_STATE_STA) {
|
|
_ledBlink(led, LedMode::NetworkConnected);
|
|
} else if (wifi_state & WIFI_STATE_AP) {
|
|
_ledBlink(led, LedMode::NetworkConfig);
|
|
} else {
|
|
_ledBlink(led, LedMode::NetworkIdle);
|
|
}
|
|
|
|
}
|
|
|
|
if (led.mode == LED_MODE_FINDME_WIFI) {
|
|
|
|
if ((wifi_state & WIFI_STATE_WPS) || (wifi_state & WIFI_STATE_SMARTCONFIG)) {
|
|
_ledBlink(led, LedMode::NetworkAutoconfig);
|
|
} else if (wifi_state & WIFI_STATE_STA) {
|
|
if (relayStatus(led.relayID)) {
|
|
_ledBlink(led, LedMode::NetworkConnected);
|
|
} else {
|
|
_ledBlink(led, LedMode::NetworkConnectedInverse);
|
|
}
|
|
} else if (wifi_state & WIFI_STATE_AP) {
|
|
if (relayStatus(led.relayID)) {
|
|
_ledBlink(led, LedMode::NetworkConfig);
|
|
} else {
|
|
_ledBlink(led, LedMode::NetworkConfigInverse);
|
|
}
|
|
} else {
|
|
_ledBlink(led, LedMode::NetworkIdle);
|
|
}
|
|
|
|
}
|
|
|
|
if (led.mode == LED_MODE_RELAY_WIFI) {
|
|
|
|
if ((wifi_state & WIFI_STATE_WPS) || (wifi_state & WIFI_STATE_SMARTCONFIG)) {
|
|
_ledBlink(led, LedMode::NetworkAutoconfig);
|
|
} else if (wifi_state & WIFI_STATE_STA) {
|
|
if (relayStatus(led.relayID)) {
|
|
_ledBlink(led, LedMode::NetworkConnected);
|
|
} else {
|
|
_ledBlink(led, LedMode::NetworkConnectedInverse);
|
|
}
|
|
} else if (wifi_state & WIFI_STATE_AP) {
|
|
if (relayStatus(led.relayID)) {
|
|
_ledBlink(led, LedMode::NetworkConfig);
|
|
} else {
|
|
_ledBlink(led, LedMode::NetworkConfigInverse);
|
|
}
|
|
} else {
|
|
_ledBlink(led, LedMode::NetworkIdle);
|
|
}
|
|
|
|
}
|
|
|
|
// Relay-based modes, update only if relays have been updated
|
|
if (!_led_update) continue;
|
|
|
|
if (led.mode == LED_MODE_FOLLOW) {
|
|
led.status(relayStatus(led.relayID));
|
|
}
|
|
|
|
if (led.mode == LED_MODE_FOLLOW_INVERSE) {
|
|
led.status(!relayStatus(led.relayID));
|
|
}
|
|
|
|
if (led.mode == LED_MODE_FINDME) {
|
|
bool status = true;
|
|
for (unsigned char relayID = 0; relayID < relayCount(); ++relayID) {
|
|
if (relayStatus(relayID)) {
|
|
status = false;
|
|
break;
|
|
}
|
|
}
|
|
led.status(status);
|
|
}
|
|
|
|
if (led.mode == LED_MODE_RELAY) {
|
|
bool status = false;
|
|
for (unsigned char relayID = 0; relayID < relayCount(); ++relayID) {
|
|
if (relayStatus(relayID)) {
|
|
status = true;
|
|
break;
|
|
}
|
|
}
|
|
led.status(status);
|
|
}
|
|
|
|
if (led.mode == LED_MODE_ON) {
|
|
led.status(true);
|
|
}
|
|
|
|
if (led.mode == LED_MODE_OFF) {
|
|
led.status(false);
|
|
}
|
|
|
|
}
|
|
|
|
_led_update = false;
|
|
|
|
}
|
|
|
|
#endif // LED_SUPPORT
|