mh
/
mhsw-espurna
1
0
Fork 0
Code Releases 0 Activity
Fork of the espurna firmware for `mhsw` switches
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.
3062 Commits
18 Branches
212 MiB
 
 
 
 
 
 
Tree: e26ba9f52e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e26ba9f52e'
${ noResults }
mhsw-espurna/code/espurna/rpnrules.cpp

406 lines
12 KiB
Raw Blame History

/*
RPN RULES MODULE
Use RPNLib library (https://github.com/xoseperez/rpnlib)
Copyright (C) 2019 by Xose Pérez <xose dot perez at gmail dot com>
*/
#include "rpnrules.h"
#if RPN_RULES_SUPPORT
#include "broker.h"
#include "mqtt.h"
#include "ntp.h"
#include "relay.h"
#include "rpc.h"
#include "sensor.h"
#include "terminal.h"
#include "ws.h"
// -----------------------------------------------------------------------------
// Custom commands
// -----------------------------------------------------------------------------
rpn_context _rpn_ctxt;
bool _rpn_run = false;
unsigned long _rpn_delay = RPN_DELAY;
unsigned long _rpn_last = 0;
// -----------------------------------------------------------------------------
bool _rpnWebSocketOnKeyCheck(const char * key, JsonVariant& value) {
return (strncmp(key, "rpn", 3) == 0);
}
void _rpnWebSocketOnConnected(JsonObject& root) {
root["rpnSticky"] = getSetting("rpnSticky", 1 == RPN_STICKY);
root["rpnDelay"] = getSetting("rpnDelay", RPN_DELAY);
JsonArray& rules = root.createNestedArray("rpnRules");
unsigned char i = 0;
String rule = getSetting({"rpnRule", i});
while (rule.length()) {
rules.add(rule);
rule = getSetting({"rpnRule", ++i});
}
#if MQTT_SUPPORT
i=0;
JsonArray& topics = root.createNestedArray("rpnTopics");
JsonArray& names = root.createNestedArray("rpnNames");
String rpn_topic = getSetting({"rpnTopic", i});
while (rpn_topic.length() > 0) {
String rpn_name = getSetting({"rpnName", i});
topics.add(rpn_topic);
names.add(rpn_name);
rpn_topic = getSetting({"rpnTopic", ++i});
}
#endif
}
#if MQTT_SUPPORT
void _rpnMQTTSubscribe() {
unsigned char i = 0;
String rpn_topic = getSetting({"rpnTopic", i});
while (rpn_topic.length()) {
mqttSubscribeRaw(rpn_topic.c_str());
rpn_topic = getSetting({"rpnTopic", ++i});
}
}
void _rpnMQTTCallback(unsigned int type, const char * topic, const char * payload) {
if (type == MQTT_CONNECT_EVENT) {
_rpnMQTTSubscribe();
}
if (type == MQTT_MESSAGE_EVENT) {
unsigned char i = 0;
String rpn_topic = getSetting({"rpnTopic", i});
while (rpn_topic.length()) {
if (rpn_topic.equals(topic)) {
String rpn_name = getSetting({"rpnName", i});
if (rpn_name.length()) {
rpn_variable_set(_rpn_ctxt, rpn_name.c_str(), atof(payload));
_rpn_last = millis();
_rpn_run = true;
break;
}
}
rpn_topic = getSetting({"rpnTopic", ++i});
}
}
}
#endif // MQTT_SUPPORT
void _rpnConfigure() {
#if MQTT_SUPPORT
if (mqttConnected()) _rpnMQTTSubscribe();
#endif
_rpn_delay = getSetting("rpnDelay", RPN_DELAY);
}
void _rpnBrokerCallback(const String& topic, unsigned char id, double value, const char*) {
char name[32] = {0};
snprintf(name, sizeof(name), "%s%u", topic.c_str(), id);
rpn_variable_set(_rpn_ctxt, name, value);
_rpn_last = millis();
_rpn_run = true;
}
void _rpnBrokerStatus(const String& topic, unsigned char id, unsigned int value) {
_rpnBrokerCallback(topic, id, double(value), nullptr);
}
#if NTP_SUPPORT
bool _rpnNtpNow(rpn_context & ctxt) {
if (!ntpSynced()) return false;
rpn_stack_push(ctxt, now());
return true;
}
bool _rpnNtpFunc(rpn_context & ctxt, int (*func)(time_t)) {
float timestamp;
rpn_stack_pop(ctxt, timestamp);
rpn_stack_push(ctxt, func(time_t(timestamp)));
return true;
}
#endif
void _rpnDump() {
float value;
DEBUG_MSG_P(PSTR("[RPN] Stack:\n"));
unsigned char num = rpn_stack_size(_rpn_ctxt);
if (0 == num) {
DEBUG_MSG_P(PSTR(" (empty)\n"));
} else {
unsigned char index = num - 1;
while (rpn_stack_get(_rpn_ctxt, index, value)) {
DEBUG_MSG_P(PSTR(" %02d: %s\n"), index--, String(value).c_str());
}
}
}
void _rpnInit() {
// Init context
rpn_init(_rpn_ctxt);
// Time functions need NTP support
// TODO: since 1.15.0, timelib+ntpclientlib are no longer used with latest Cores
// `now` is always in UTC, `utc_...` functions to be used instead to convert time
#if NTP_SUPPORT && !NTP_LEGACY_SUPPORT
rpn_operator_set(_rpn_ctxt, "utc", 0, _rpnNtpNow);
rpn_operator_set(_rpn_ctxt, "now", 0, _rpnNtpNow);
rpn_operator_set(_rpn_ctxt, "utc_month", 1, [](rpn_context & ctxt) {
return _rpnNtpFunc(ctxt, utc_month);
});
rpn_operator_set(_rpn_ctxt, "month", 1, [](rpn_context & ctxt) {
return _rpnNtpFunc(ctxt, month);
});
rpn_operator_set(_rpn_ctxt, "utc_day", 1, [](rpn_context & ctxt) {
return _rpnNtpFunc(ctxt, utc_day);
});
rpn_operator_set(_rpn_ctxt, "day", 1, [](rpn_context & ctxt) {
return _rpnNtpFunc(ctxt, day);
});
rpn_operator_set(_rpn_ctxt, "utc_dow", 1, [](rpn_context & ctxt) {
return _rpnNtpFunc(ctxt, utc_weekday);
});
rpn_operator_set(_rpn_ctxt, "dow", 1, [](rpn_context & ctxt) {
return _rpnNtpFunc(ctxt, weekday);
});
rpn_operator_set(_rpn_ctxt, "utc_hour", 1, [](rpn_context & ctxt) {
return _rpnNtpFunc(ctxt, utc_hour);
});
rpn_operator_set(_rpn_ctxt, "hour", 1, [](rpn_context & ctxt) {
return _rpnNtpFunc(ctxt, hour);
});
rpn_operator_set(_rpn_ctxt, "utc_minute", 1, [](rpn_context & ctxt) {
return _rpnNtpFunc(ctxt, utc_minute);
});
rpn_operator_set(_rpn_ctxt, "minute", 1, [](rpn_context & ctxt) {
return _rpnNtpFunc(ctxt, minute);
});
#endif
// TODO: 1.14.0 weekday(...) conversion seemed to have 0..6 range with Monday as 0
// using classic Sunday as first, but instead of 0 it is 1
// Implementation above also uses 1 for Sunday, staying compatible with TimeLib
#if NTP_SUPPORT && NTP_LEGACY_SUPPORT
rpn_operator_set(_rpn_ctxt, "utc", 0, [](rpn_context & ctxt) {
if (!ntpSynced()) return false;
rpn_stack_push(ctxt, ntpLocal2UTC(now()));
return true;
});
rpn_operator_set(_rpn_ctxt, "now", 0, _rpnNtpNow);
rpn_operator_set(_rpn_ctxt, "month", 1, [](rpn_context & ctxt) {
return _rpnNtpFunc(ctxt, month);
});
rpn_operator_set(_rpn_ctxt, "day", 1, [](rpn_context & ctxt) {
return _rpnNtpFunc(ctxt, day);
});
rpn_operator_set(_rpn_ctxt, "dow", 1, [](rpn_context & ctxt) {
return _rpnNtpFunc(ctxt, weekday);
});
rpn_operator_set(_rpn_ctxt, "hour", 1, [](rpn_context & ctxt) {
return _rpnNtpFunc(ctxt, hour);
});
rpn_operator_set(_rpn_ctxt, "minute", 1, [](rpn_context & ctxt) {
return _rpnNtpFunc(ctxt, minute);
});
#endif
// Dumps RPN stack contents
rpn_operator_set(_rpn_ctxt, "debug", 0, [](rpn_context & ctxt) {
_rpnDump();
return true;
});
// Accept relay number and numeric API status value (0, 1 and 2)
#if RELAY_SUPPORT
rpn_operator_set(_rpn_ctxt, "relay", 2, [](rpn_context & ctxt) {
float status, id;
rpn_stack_pop(ctxt, id);
rpn_stack_pop(ctxt, status);
if (int(status) == 2) {
relayToggle(int(id));
} else {
relayStatus(int(id), int(status) == 1);
}
return true;
});
#endif // RELAY_SUPPORT == 1
// Channel operators
#if RELAY_PROVIDER == RELAY_PROVIDER_LIGHT
rpn_operator_set(_rpn_ctxt, "update", 0, [](rpn_context & ctxt) {
lightUpdate(true, true);
return true;
});
rpn_operator_set(_rpn_ctxt, "black", 0, [](rpn_context & ctxt) {
lightColor((unsigned long) 0);
return true;
});
rpn_operator_set(_rpn_ctxt, "channel", 2, [](rpn_context & ctxt) {
float value, id;
rpn_stack_pop(ctxt, id);
rpn_stack_pop(ctxt, value);
lightChannel(int(id), int(value));
return true;
});
#endif
}
#if TERMINAL_SUPPORT
void _rpnInitCommands() {
terminalRegisterCommand(F("RPN.VARS"), [](const terminal::CommandContext&) {
unsigned char num = rpn_variables_size(_rpn_ctxt);
if (0 == num) {
DEBUG_MSG_P(PSTR("[RPN] No variables\n"));
} else {
DEBUG_MSG_P(PSTR("[RPN] Variables:\n"));
for (unsigned char i=0; i<num; i++) {
char * name = rpn_variable_name(_rpn_ctxt, i);
float value;
rpn_variable_get(_rpn_ctxt, name, value);
DEBUG_MSG_P(PSTR(" %s: %s\n"), name, String(value).c_str());
}
}
terminalOK();
});
terminalRegisterCommand(F("RPN.OPS"), [](const terminal::CommandContext&) {
unsigned char num = _rpn_ctxt.operators.size();
DEBUG_MSG_P(PSTR("[RPN] Operators:\n"));
for (unsigned char i=0; i<num; i++) {
DEBUG_MSG_P(PSTR(" %s (%d)\n"), _rpn_ctxt.operators[i].name, _rpn_ctxt.operators[i].argc);
}
terminalOK();
});
terminalRegisterCommand(F("RPN.TEST"), [](const terminal::CommandContext& ctx) {
if (ctx.argc == 2) {
DEBUG_MSG_P(PSTR("[RPN] Running \"%s\"\n"), ctx.argv[1].c_str());
rpn_process(_rpn_ctxt, ctx.argv[1].c_str(), true);
_rpnDump();
rpn_stack_clear(_rpn_ctxt);
terminalOK();
} else {
terminalError(F("Wrong arguments"));
}
});
}
#endif
void _rpnRun() {
unsigned char i = 0;
String rule = getSetting({"rpnRule", i});
while (rule.length()) {
//DEBUG_MSG_P(PSTR("[RPN] Running \"%s\"\n"), rule.c_str());
rpn_process(_rpn_ctxt, rule.c_str(), true);
//_rpnDump();
rule = getSetting({"rpnRule", ++i});
rpn_stack_clear(_rpn_ctxt);
}
if (!getSetting("rpnSticky", 1 == RPN_STICKY)) {
rpn_variables_clear(_rpn_ctxt);
}
}
void _rpnLoop() {
if (_rpn_run && (millis() - _rpn_last > _rpn_delay)) {
_rpnRun();
_rpn_run = false;
}
}
void rpnSetup() {
// Init context
_rpnInit();
// Load & cache settings
_rpnConfigure();
// Terminal commands
#if TERMINAL_SUPPORT
_rpnInitCommands();
#endif
// Websockets
#if WEB_SUPPORT
wsRegister()
.onVisible([](JsonObject& root) { root["rpnVisible"] = 1; })
.onConnected(_rpnWebSocketOnConnected)
.onKeyCheck(_rpnWebSocketOnKeyCheck);
#endif
// MQTT
#if MQTT_SUPPORT
mqttRegister(_rpnMQTTCallback);
#endif
#if NTP_SUPPORT
NtpBroker::Register([](const NtpTick tick, time_t timestamp, const String& datetime) {
static const String tick_every_hour(F("tick1h"));
static const String tick_every_minute(F("tick1m"));
const char* ptr =
(tick == NtpTick::EveryMinute) ? tick_every_minute.c_str() :
(tick == NtpTick::EveryHour) ? tick_every_hour.c_str() : nullptr;
if (ptr != nullptr) {
rpn_variable_set(_rpn_ctxt, ptr, timestamp);
_rpn_last = millis();
_rpn_run = true;
}
});
#endif
StatusBroker::Register(_rpnBrokerStatus);
#if SENSOR_SUPPORT
SensorReadBroker::Register(_rpnBrokerCallback);
#endif
espurnaRegisterReload(_rpnConfigure);
espurnaRegisterLoop(_rpnLoop);
}
#endif // RPN_RULES_SUPPORT