jeans/openHASP
jeans/openHASP
1
0
Fork 0
mirror of https://github.com/HASwitchPlate/openHASP.git synced 2025-07-27 21:26:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

Revert changes unrelated to PC build

Browse Source
This commit is contained in:
Kuba Szczodrzyński 2024-02-12 18:24:43 +01:00
parent b0969892fd
commit 55f39f02d0
No known key found for this signature in database
GPG Key ID: 43037AC62A600562
12 changed files with 45 additions and 222 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/hasp_conf.h
View File

@ -181,10 +181,6 @@
#define HASP_NUM_GPIO_CONFIG 8
#endif
#ifndef HASP_USE_EVENT_DATA_SUBST
#define HASP_USE_EVENT_DATA_SUBST 0
#endif
// #ifndef HASP_USE_CUSTOM
// #define HASP_USE_CUSTOM 0
// #endif

115
src/hasp/hasp_dispatch.cpp
View File

@ -37,8 +37,6 @@
#endif
#endif
#include <map>
dispatch_conf_t dispatch_setings = {.teleperiod = 300};
uint16_t dispatchSecondsToNextTeleperiod = 0;
@ -50,8 +48,6 @@ haspCommand_t commands[28];
moodlight_t moodlight = {.brightness = 255};
uint8_t saved_jsonl_page = 0;
static std::map<int, lv_task_t*> scheduled_tasks;
/* Sends the payload out on the state/subtopic
*/
void dispatch_state_subtopic(const char* subtopic, const char* payload)
@ -614,17 +610,11 @@ void dispatch_screenshot(const char*, const char* filename, uint8_t source)
}
bool dispatch_json_variant(JsonVariant& json, uint8_t& savedPage, uint8_t source)
{
JsonObject dummy;
return dispatch_json_variant_with_data(json, savedPage, source, dummy);
}
bool dispatch_json_variant_with_data(JsonVariant& json, uint8_t& savedPage, uint8_t source, JsonObject& data)
{
if(json.is<JsonArray>()) { // handle json as an array of commands
LOG_DEBUG(TAG_MSGR, "Json ARRAY");
for(JsonVariant command : json.as<JsonArray>()) {
dispatch_json_variant_with_data(command, savedPage, source, data);
dispatch_json_variant(command, savedPage, source);
}
} else if(json.is<JsonObject>()) { // handle json as a jsonl
@ -632,23 +622,13 @@ bool dispatch_json_variant_with_data(JsonVariant& json, uint8_t& savedPage, uint
hasp_new_object(json.as<JsonObject>(), savedPage);
} else if(json.is<std::string>()) { // handle json as a single command
std::string command = json.as<std::string>();
LOG_DEBUG(TAG_MSGR, "Json text = %s", json.as<std::string>().c_str());
dispatch_simple_text_command(json.as<std::string>().c_str(), source);
#if HASP_USE_EVENT_DATA_SUBST
if(command.find('%') != std::string::npos) {
// '%' found in command, run variable substitution
for(JsonPair kv : data) {
std::string find = "%" + std::string(kv.key().c_str()) + "%";
std::string replace = kv.value().as<std::string>();
size_t pos = command.find(find);
if(pos == std::string::npos) continue;
command.replace(pos, find.length(), replace);
}
}
#endif
} else if(json.is<const char*>()) { // handle json as a single command
LOG_DEBUG(TAG_MSGR, "Json text = %s", json.as<const char*>());
dispatch_simple_text_command(json.as<const char*>(), source);
LOG_DEBUG(TAG_MSGR, "Json text = %s", command.c_str());
dispatch_simple_text_command(command.c_str(), source);
} else if(json.isNull()) { // event handler not found
// nothing to do
@ -1425,88 +1405,6 @@ void dispatch_sleep(const char*, const char*, uint8_t source)
hasp_set_wakeup_touch(false);
}
static void dispatch_schedule_runner(lv_task_t* task)
{
dispatch_text_line((const char*)task->user_data, TAG_MSGR);
}
void dispatch_schedule(const char*, const char* payload, uint8_t source)
{
// duplicate the string for modification
char* argline = strdup(payload);
// split argline into argv by whitespace; limit to 4 parts
char* argv[4];
int argn = 0;
argv[argn++] = argline;
while(*argline) {
if(*argline == ' ') {
*argline = '\0';
argv[argn++] = argline + 1;
}
argline++;
if(argn == 4) break;
}
const char* action = argv[0];
uint32_t id = atoi(argv[1]);
if(strcasecmp(action, "set") == 0) {
if(argn != 4) {
LOG_ERROR(TAG_MSGR, F("Usage: schedule set <id> <period(ms)> <cmd...>"));
goto end;
}
uint32_t period = atoi(argv[2]);
const char* command = strdup(argv[3]);
if(scheduled_tasks.find(id) != scheduled_tasks.end()) {
// update an existing task
lv_task_t* task = scheduled_tasks[id];
free(task->user_data);
task->period = period;
task->user_data = (void*)command;
} else {
// create a new task
lv_task_t* task = lv_task_create(dispatch_schedule_runner, period, LV_TASK_PRIO_MID, (void*)command);
scheduled_tasks[id] = task;
}
LOG_INFO(TAG_MSGR, F("Scheduled command ID %u, every %u ms: %s"), id, period, command);
goto end;
}
if(argn != 2) {
LOG_ERROR(TAG_MSGR, F("Usage: schedule <set/del/start/stop> <id>"));
goto end;
}
if(scheduled_tasks.find(id) == scheduled_tasks.end()) {
LOG_ERROR(TAG_MSGR, F("Task by ID %u does not exist"), id);
goto end;
}
{
lv_task_t* task = scheduled_tasks[id];
if(strcasecmp(action, "del") == 0) {
free(task->user_data);
lv_task_del(task);
scheduled_tasks.erase(id);
goto end;
}
if(strcasecmp(action, "start") == 0) {
lv_task_set_prio(task, LV_TASK_PRIO_MID);
goto end;
}
if(strcasecmp(action, "stop") == 0) {
lv_task_set_prio(task, LV_TASK_PRIO_OFF);
goto end;
}
}
end:
// release the duplicated argline
free(argv[0]);
}
void dispatch_idle_state(uint8_t state)
{
char topic[8];
@ -1640,7 +1538,6 @@ void dispatchSetup()
dispatch_add_command(PSTR("moodlight"), dispatch_moodlight);
dispatch_add_command(PSTR("idle"), dispatch_idle);
dispatch_add_command(PSTR("sleep"), dispatch_sleep);
dispatch_add_command(PSTR("schedule"), dispatch_schedule);
dispatch_add_command(PSTR("statusupdate"), dispatch_statusupdate);
dispatch_add_command(PSTR("clearpage"), dispatch_clear_page);
dispatch_add_command(PSTR("clearfont"), dispatch_clear_font);

3
src/hasp/hasp_dispatch.h
View File

@ -55,7 +55,6 @@ void dispatch_parse_jsonl(Stream& stream, uint8_t& saved_page_id);
void dispatch_parse_jsonl(std::istream& stream, uint8_t& saved_page_id);
#endif
bool dispatch_json_variant(JsonVariant& json, uint8_t& savedPage, uint8_t source);
bool dispatch_json_variant_with_data(JsonVariant& json, uint8_t& savedPage, uint8_t source, JsonObject& data);
void dispatch_clear_page(const char* page);
void dispatch_json_error(uint8_t tag, DeserializationError& jsonError);
@ -102,4 +101,4 @@ struct haspCommand_t
void (*func)(const char*, const char*, uint8_t);
};
#endif
#endif

93
src/hasp/hasp_event.cpp
View File

@ -42,51 +42,23 @@ void event_reset_last_value_sent()
last_value_sent = INT16_MIN;
}
static bool script_event_handler(const char* eventname, const char* action, const char* data)
void script_event_handler(const char* eventname, const char* json)
{
if(action == NULL) {
LOG_DEBUG(TAG_EVENT, F("Skipping event: name=%s, data=%s"), eventname, data);
return false;
}
StaticJsonDocument<256> doc;
StaticJsonDocument<64> filter;
filter[eventname] = true;
filter["pub"] = true;
DeserializationError jsonError = deserializeJson(doc, action, DeserializationOption::Filter(filter));
DeserializationError jsonError = deserializeJson(doc, json, DeserializationOption::Filter(filter));
if(!jsonError) {
JsonVariant json = doc[eventname].as<JsonVariant>();
if(json.isNull()) {
LOG_DEBUG(TAG_EVENT, F("Skipping event: name=%s, data=%s"), eventname, data);
goto end;
} else {
LOG_DEBUG(TAG_EVENT, F("Handling event: name=%s, data=%s"), eventname, data);
}
JsonObject dataJson;
#if HASP_USE_EVENT_DATA_SUBST
if(data != NULL) {
StaticJsonDocument<256> jsonDoc;
if(deserializeJson(jsonDoc, data) != DeserializationError::Ok) {
LOG_ERROR(TAG_EVENT, F("Deserialization failed"));
} else {
dataJson = jsonDoc.as<JsonObject>();
}
}
#endif
JsonVariant json = doc[eventname].as<JsonVariant>();
uint8_t savedPage = haspPages.get();
if(!dispatch_json_variant_with_data(json, savedPage, TAG_EVENT, dataJson)) {
if(!dispatch_json_variant(json, savedPage, TAG_EVENT)) {
LOG_WARNING(TAG_EVENT, F(D_DISPATCH_COMMAND_NOT_FOUND), eventname);
}
} else {
dispatch_json_error(TAG_EVENT, jsonError);
}
end:
if(doc["pub"].is<bool>()) return !doc["pub"].as<bool>();
return true;
}
/**
@ -282,16 +254,11 @@ static bool translate_event(lv_obj_t* obj, lv_event_t event, uint8_t& eventid)
// ##################### Value Senders ########################################################
static void event_send_object_data(lv_obj_t* obj, const char* eventname, const char* data)
static void event_send_object_data(lv_obj_t* obj, const char* data)
{
uint8_t pageid;
uint8_t objid;
// handle object "action", abort sending if handled
if(script_event_handler(eventname, my_obj_get_action(obj), data)) {
return;
}
if(hasp_find_id_from_obj(obj, &pageid, &objid)) {
if(!data) return;
object_dispatch_state(pageid, objid, data);
@ -304,23 +271,23 @@ static void event_send_object_data(lv_obj_t* obj, const char* eventname, const c
static void event_object_val_event(lv_obj_t* obj, uint8_t eventid, int16_t val)
{
char data[512];
char eventname[8];
{
char eventname[8];
Parser::get_event_name(eventid, eventname, sizeof(eventname));
if(const char* tag = my_obj_get_tag(obj))
snprintf_P(data, sizeof(data), PSTR("{\"event\":\"%s\",\"val\":%d,\"tag\":%s}"), eventname, val, tag);
else
snprintf_P(data, sizeof(data), PSTR("{\"event\":\"%s\",\"val\":%d}"), eventname, val);
}
event_send_object_data(obj, eventname, data);
event_send_object_data(obj, data);
}
// Send out events with a val and text attribute
static void event_object_selection_changed(lv_obj_t* obj, uint8_t eventid, int16_t val, const char* text)
{
char data[512];
char eventname[8];
{
char eventname[8];
Parser::get_event_name(eventid, eventname, sizeof(eventname));
if(const char* tag = my_obj_get_tag(obj))
@ -329,7 +296,7 @@ static void event_object_selection_changed(lv_obj_t* obj, uint8_t eventid, int16
else
snprintf_P(data, sizeof(data), PSTR("{\"event\":\"%s\",\"val\":%d,\"text\":\"%s\"}"), eventname, val, text);
}
event_send_object_data(obj, eventname, data);
event_send_object_data(obj, data);
}
// ##################### Event Handlers ########################################################
@ -435,16 +402,16 @@ void swipe_event_handler(lv_obj_t* obj, lv_event_t event)
lv_gesture_dir_t dir = lv_indev_get_gesture_dir(lv_indev_get_act());
switch(dir) {
case LV_GESTURE_DIR_LEFT:
script_event_handler("left", swipe, NULL);
script_event_handler("left", swipe);
break;
case LV_GESTURE_DIR_RIGHT:
script_event_handler("right", swipe, NULL);
script_event_handler("right", swipe);
break;
case LV_GESTURE_DIR_BOTTOM:
script_event_handler("down", swipe, NULL);
script_event_handler("down", swipe);
break;
default:
script_event_handler("up", swipe, NULL);
script_event_handler("up", swipe);
}
}
}
@ -465,8 +432,8 @@ void textarea_event_handler(lv_obj_t* obj, lv_event_t event)
if(!translate_event(obj, event, hasp_event_id)) return;
char data[1024];
char eventname[8];
{
char eventname[8];
Parser::get_event_name(hasp_event_id, eventname, sizeof(eventname));
if(const char* tag = my_obj_get_tag(obj))
@ -477,7 +444,7 @@ void textarea_event_handler(lv_obj_t* obj, lv_event_t event)
lv_textarea_get_text(obj));
}
event_send_object_data(obj, eventname, data);
event_send_object_data(obj, data);
} else if(event == LV_EVENT_FOCUSED) {
lv_textarea_set_cursor_hidden(obj, false);
} else if(event == LV_EVENT_DEFOCUSED) {
@ -551,17 +518,23 @@ void generic_event_handler(lv_obj_t* obj, lv_event_t event)
if(last_value_sent == HASP_EVENT_LOST) return;
char data[512];
char eventname[8];
{
if(const char* action = my_obj_get_action(obj)) {
char eventname[8];
Parser::get_event_name(last_value_sent, eventname, sizeof(eventname));
script_event_handler(eventname, action);
} else {
char data[512];
{
char eventname[8];
Parser::get_event_name(last_value_sent, eventname, sizeof(eventname));
if(const char* tag = my_obj_get_tag(obj))
snprintf_P(data, sizeof(data), PSTR("{\"event\":\"%s\",\"tag\":%s}"), eventname, tag);
else
snprintf_P(data, sizeof(data), PSTR("{\"event\":\"%s\"}"), eventname);
if(const char* tag = my_obj_get_tag(obj))
snprintf_P(data, sizeof(data), PSTR("{\"event\":\"%s\",\"tag\":%s}"), eventname, tag);
else
snprintf_P(data, sizeof(data), PSTR("{\"event\":\"%s\"}"), eventname);
}
event_send_object_data(obj, data);
}
event_send_object_data(obj, eventname, data);
// Update group objects and gpios on release
if(last_value_sent != LV_EVENT_LONG_PRESSED && last_value_sent != LV_EVENT_LONG_PRESSED_REPEAT) {
@ -868,8 +841,8 @@ void cpicker_event_handler(lv_obj_t* obj, lv_event_t event)
if(hasp_event_id == HASP_EVENT_CHANGED && last_color_sent.full == color.full) return; // same value as before
char data[512];
char eventname[8];
{
char eventname[8];
Parser::get_event_name(hasp_event_id, eventname, sizeof(eventname));
lv_color32_t c32;
@ -891,7 +864,7 @@ void cpicker_event_handler(lv_obj_t* obj, lv_event_t event)
eventname, c32.ch.red, c32.ch.green, c32.ch.blue, c32.ch.red, c32.ch.green, c32.ch.blue, hsv.h,
hsv.s, hsv.v);
}
event_send_object_data(obj, eventname, data);
event_send_object_data(obj, data);
// event_update_group(obj->user_data.groupid, obj, val, min, max);
}
@ -918,8 +891,8 @@ void calendar_event_handler(lv_obj_t* obj, lv_event_t event)
return; // same object and value as before
char data[512];
char eventname[8];
{
char eventname[8];
Parser::get_event_name(hasp_event_id, eventname, sizeof(eventname));
last_value_sent = val;
@ -934,7 +907,7 @@ void calendar_event_handler(lv_obj_t* obj, lv_event_t event)
PSTR("{\"event\":\"%s\",\"val\":\"%d\",\"text\":\"%04d-%02d-%02dT00:00:00Z\"}"), eventname,
date->day, date->year, date->month, date->day);
}
event_send_object_data(obj, eventname, data);
event_send_object_data(obj, data);
// event_update_group(obj->user_data.groupid, obj, val, min, max);
}

1
src/hasp_config.h
View File

@ -90,7 +90,6 @@ const char FP_GUI_BACKLIGHTINVERT[] PROGMEM = "bcklinv";
const char FP_GUI_POINTER[] PROGMEM = "cursor";
const char FP_GUI_LONG_TIME[] PROGMEM = "long";
const char FP_GUI_REPEAT_TIME[] PROGMEM = "repeat";
const char FP_GUI_FPS[] PROGMEM = "fps";
const char FP_DEBUG_TELEPERIOD[] PROGMEM = "tele";
const char FP_DEBUG_ANSI[] PROGMEM = "ansi";
const char FP_GPIO_CONFIG[] PROGMEM = "config";

35
src/hasp_gui.cpp
View File

@ -57,8 +57,6 @@ uint32_t screenshotEtag = 0;
void (*drv_display_flush_cb)(struct _disp_drv_t* disp_drv, const lv_area_t* area, lv_color_t* color_p);
static lv_disp_buf_t disp_buf;
static bool gui_initialized = false;
static uint32_t anim_fps_deferred = 0;
static inline void gui_init_lvgl()
{
@ -102,27 +100,6 @@ void gui_hide_pointer(bool hidden)
if(cursor) lv_obj_set_hidden(cursor, hidden || !gui_settings.show_pointer);
}
bool gui_set_fps(uint32_t fps)
{
if(!gui_initialized) {
LOG_ERROR(TAG_GUI, F("GUI not initialized, deferring FPS setting"));
anim_fps_deferred = fps;
return false;
}
bool changed = false;
uint32_t period = 1000 / fps;
// find animation task by its period
lv_task_t* task = NULL;
while(task = lv_task_get_next(task)) {
if(!(task->period == LV_DISP_DEF_REFR_PERIOD)) continue;
changed |= (task->period != period);
LOG_INFO(TAG_GUI, F("Changing animation period: %u -> %u (%u FPS)"), task->period, period, fps);
task->period = period;
}
return changed;
}
IRAM_ATTR void gui_flush_cb(lv_disp_drv_t* disp, const lv_area_t* area, lv_color_t* color_p)
{
haspTft.flush_pixels(disp, area, color_p);
@ -396,13 +373,6 @@ void guiSetup()
}
#endif // ESP32 && HASP_USE_ESP_MQTT
// apply deferred FPS setting
gui_initialized = true;
if(anim_fps_deferred != 0) {
gui_set_fps(anim_fps_deferred);
anim_fps_deferred = 0;
}
LOG_INFO(TAG_LVGL, F(D_SERVICE_STARTED));
}
@ -642,11 +612,6 @@ bool guiSetConfig(const JsonObject& settings)
changed |= status;
}
if(!settings[FPSTR(FP_GUI_FPS)].isNull()) {
uint32_t fps = settings[FPSTR(FP_GUI_FPS)].as<uint32_t>();
changed |= gui_set_fps(fps);
}
return changed;
}
#endif // HASP_USE_CONFIG

1
src/hasp_gui.h
View File

@ -48,7 +48,6 @@ void guiEverySecond(void);
void guiStart(void);
void guiStop(void);
void gui_hide_pointer(bool hidden);
bool gui_set_fps(uint32_t fps);
/* ===== Special Event Processors ===== */
void guiCalibrate(void);

3
user_setups/darwin_sdl/darwin_sdl_64bits.ini
View File

@ -34,8 +34,7 @@ build_flags =
-D HASP_USE_GIFDECODE=0
-D HASP_USE_JPGDECODE=0
-D HASP_USE_MQTT=1
-D HASP_USE_EVENT_DATA_SUBST=1
-D MQTT_MAX_PACKET_SIZE=32768
-D MQTT_MAX_PACKET_SIZE=2048
-D HASP_ATTRIBUTE_FAST_MEM=
-D IRAM_ATTR= ; No IRAM_ATTR available
-D PROGMEM= ; No PROGMEM available

3
user_setups/linux_sdl/linux_fbdev_64bits.ini
View File

@ -31,8 +31,7 @@ build_flags =
-D HASP_USE_JPGDECODE=0
-D HASP_USE_MQTT=1
-D HASP_USE_LVGL_TASK=1
-D HASP_USE_EVENT_DATA_SUBST=1
-D MQTT_MAX_PACKET_SIZE=32768
-D MQTT_MAX_PACKET_SIZE=2048
-D HASP_ATTRIBUTE_FAST_MEM=
-D IRAM_ATTR= ; No IRAM_ATTR available
-D PROGMEM= ; No PROGMEM available

3
user_setups/linux_sdl/linux_sdl_64bits.ini
View File

@ -34,8 +34,7 @@ build_flags =
-D HASP_USE_GIFDECODE=0
-D HASP_USE_JPGDECODE=0
-D HASP_USE_MQTT=1
-D HASP_USE_EVENT_DATA_SUBST=1
-D MQTT_MAX_PACKET_SIZE=32768
-D MQTT_MAX_PACKET_SIZE=2048
-D HASP_ATTRIBUTE_FAST_MEM=
-D IRAM_ATTR= ; No IRAM_ATTR available
-D PROGMEM= ; No PROGMEM available

3
user_setups/win32/windows_gdi_64bits.ini
View File

@ -30,8 +30,7 @@ build_flags =
-D HASP_USE_MQTT=1
-D HASP_USE_SYSLOG=0
-D HASP_USE_LVGL_TASK=1
-D HASP_USE_EVENT_DATA_SUBST=1
-D MQTT_MAX_PACKET_SIZE=32768
-D MQTT_MAX_PACKET_SIZE=2048
-D HASP_ATTRIBUTE_FAST_MEM=
-D IRAM_ATTR= ; No IRAM_ATTR available
-D PROGMEM= ; No PROGMEM available

3
user_setups/win32/windows_sdl_64bits.ini
View File

@ -34,8 +34,7 @@ build_flags =
-D HASP_USE_JPGDECODE=0
-D HASP_USE_MQTT=1
-D HASP_USE_SYSLOG=0
-D HASP_USE_EVENT_DATA_SUBST=1
-D MQTT_MAX_PACKET_SIZE=32768
-D MQTT_MAX_PACKET_SIZE=2048
-D HASP_ATTRIBUTE_FAST_MEM=
-D IRAM_ATTR= ; No IRAM_ATTR available
-D PROGMEM= ; No PROGMEM available