jeans/openHASP
jeans/openHASP
1
0
Fork 0
mirror of https://github.com/HASwitchPlate/openHASP.git synced 2025-07-28 05:36:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #170 from HASwitchPlate/master

Browse Source 
Merge master into touch-redesign
This commit is contained in:
fvanroie 2021-05-31 18:52:29 +02:00 committed by GitHub
commit 7a42297e36
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 230 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

205
src/hasp/hasp_attribute.cpp
View File

@ -366,8 +366,8 @@ static void hasp_attribute_get_part_state(lv_obj_t* obj, const char* attr_in, ch
* @param update bool: change/set the value if true, dispatch/get value if false
* @note setting a value won't return anything, getting will dispatch the value
*/
static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t attr_hash, const char* payload,
bool update, bool& result)
static hasp_attribute_type_t hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t attr_hash,
const char* payload, bool update, int32_t& val)
{
char attr[32];
uint8_t part = LV_OBJ_PART_MAIN;
@ -383,50 +383,49 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
* when using hasp_out use attr_p for the original attribute name
* *************************************************************** */
result = true; // default return
switch(attr_hash) {
/* 1: Use other blend modes than normal (`LV_BLEND_MODE_...`)*/
#if LV_USE_BLEND_MODES
case ATTR_BG_BLEND_MODE:
return attribute_bg_blend_mode(obj, part, state, update, attr_p, (lv_blend_mode_t)var);
case ATTR_TEXT_BLEND_MODE:
return lv_obj_set_style_local_text_blend_mode(obj, part, state, (lv_blend_mode_t)var);
case ATTR_BORDER_BLEND_MODE:
return lv_obj_set_style_local_border_blend_mode(obj, part, state, (lv_blend_mode_t)var);
case ATTR_OUTLINE_BLEND_MODE:
return lv_obj_set_style_local_outline_blend_mode(obj, part, state, (lv_blend_mode_t)var);
case ATTR_SHADOW_BLEND_MODE:
return lv_obj_set_style_local_shadow_blend_mode(obj, part, state, (lv_blend_mode_t)var);
case ATTR_LINE_BLEND_MODE:
return lv_obj_set_style_local_line_blend_mode(obj, part, state, (lv_blend_mode_t)var);
case ATTR_VALUE_BLEND_MODE:
return lv_obj_set_style_local_value_blend_mode(obj, part, state, (lv_blend_mode_t)var);
case ATTR_PATTERN_BLEND_MODE:
return lv_obj_set_style_local_pattern_blend_mode(obj, part, state, (lv_blend_mode_t)var);
return attribute_bg_blend_mode(obj, part, state, update, (lv_blend_mode_t)var, val);
// case ATTR_TEXT_BLEND_MODE:
// return lv_obj_set_style_local_text_blend_mode(obj, part, state, (lv_blend_mode_t)var);
// case ATTR_BORDER_BLEND_MODE:
// return lv_obj_set_style_local_border_blend_mode(obj, part, state, (lv_blend_mode_t)var);
// case ATTR_OUTLINE_BLEND_MODE:
// return lv_obj_set_style_local_outline_blend_mode(obj, part, state, (lv_blend_mode_t)var);
// case ATTR_SHADOW_BLEND_MODE:
// return lv_obj_set_style_local_shadow_blend_mode(obj, part, state, (lv_blend_mode_t)var);
// case ATTR_LINE_BLEND_MODE:
// return lv_obj_set_style_local_line_blend_mode(obj, part, state, (lv_blend_mode_t)var);
// case ATTR_VALUE_BLEND_MODE:
// return lv_obj_set_style_local_value_blend_mode(obj, part, state, (lv_blend_mode_t)var);
// case ATTR_PATTERN_BLEND_MODE:
// return lv_obj_set_style_local_pattern_blend_mode(obj, part, state, (lv_blend_mode_t)var);
#endif
case ATTR_SIZE:
return attribute_size(obj, part, state, update, attr_p, var);
return attribute_size(obj, part, state, update, var, val);
case ATTR_RADIUS:
return attribute_radius(obj, part, state, update, attr_p, var);
return attribute_radius(obj, part, state, update, var, val);
case ATTR_CLIP_CORNER:
return attribute_clip_corner(obj, part, state, update, attr_p, var);
return attribute_clip_corner(obj, part, state, update, var, val);
case ATTR_OPA_SCALE:
return attribute_opa_scale(obj, part, state, update, attr_p, (lv_opa_t)var);
return attribute_opa_scale(obj, part, state, update, (lv_opa_t)var, val);
case ATTR_TRANSFORM_WIDTH:
return attribute_transform_width(obj, part, state, update, attr_p, (lv_style_int_t)var);
return attribute_transform_width(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_TRANSFORM_HEIGHT:
return attribute_transform_height(obj, part, state, update, attr_p, (lv_style_int_t)var);
return attribute_transform_height(obj, part, state, update, (lv_style_int_t)var, val);
/* Background attributes */
case ATTR_BG_MAIN_STOP:
return attribute_bg_main_stop(obj, part, state, update, attr_p, (lv_style_int_t)var);
return attribute_bg_main_stop(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_BG_GRAD_STOP:
return attribute_bg_grad_stop(obj, part, state, update, attr_p, (lv_style_int_t)var);
return attribute_bg_grad_stop(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_BG_GRAD_DIR:
return attribute_bg_grad_dir(obj, part, state, update, attr_p, (lv_grad_dir_t)var);
return attribute_bg_grad_dir(obj, part, state, update, (lv_grad_dir_t)var, val);
case ATTR_BG_COLOR: {
if(update) {
lv_color32_t c;
@ -435,7 +434,7 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
} else {
attr_out_color(obj, attr, lv_obj_get_style_bg_color(obj, part));
}
return;
return HASP_ATTR_TYPE_METHOD_OK;
}
case ATTR_BG_GRAD_COLOR:
if(update) {
@ -446,33 +445,33 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
} else {
attr_out_color(obj, attr, lv_obj_get_style_bg_grad_color(obj, part));
}
return;
return HASP_ATTR_TYPE_METHOD_OK;
case ATTR_BG_OPA:
return attribute_bg_opa(obj, part, state, update, attr_p, (lv_opa_t)var);
return attribute_bg_opa(obj, part, state, update, (lv_opa_t)var, val);
/* Margin attributes */
case ATTR_MARGIN_TOP:
return attribute_margin_top(obj, part, state, update, attr_p, (lv_style_int_t)var);
return attribute_margin_top(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_MARGIN_BOTTOM:
return attribute_margin_bottom(obj, part, state, update, attr_p, (lv_style_int_t)var);
return attribute_margin_bottom(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_MARGIN_LEFT:
return attribute_margin_left(obj, part, state, update, attr_p, (lv_style_int_t)var);
return attribute_margin_left(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_MARGIN_RIGHT:
return attribute_margin_right(obj, part, state, update, attr_p, (lv_style_int_t)var);
return attribute_margin_right(obj, part, state, update, (lv_style_int_t)var, val);
/* Padding attributes */
case ATTR_PAD_TOP:
return attribute_pad_top(obj, part, state, update, attr_p, (lv_style_int_t)var);
return attribute_pad_top(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_PAD_BOTTOM:
return attribute_pad_bottom(obj, part, state, update, attr_p, (lv_style_int_t)var);
return attribute_pad_bottom(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_PAD_LEFT:
return attribute_pad_left(obj, part, state, update, attr_p, (lv_style_int_t)var);
return attribute_pad_left(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_PAD_RIGHT:
return attribute_pad_right(obj, part, state, update, attr_p, (lv_style_int_t)var);
return attribute_pad_right(obj, part, state, update, (lv_style_int_t)var, val);
#if LVGL_VERSION_MAJOR == 7
case ATTR_PAD_INNER:
return attribute_pad_inner(obj, part, state, update, attr_p, (lv_style_int_t)var);
return attribute_pad_inner(obj, part, state, update, (lv_style_int_t)var, val);
#endif
/* Scale attributes */
@ -485,7 +484,7 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
} else {
attr_out_color(obj, attr, lv_obj_get_style_scale_grad_color(obj, part));
}
return;
return HASP_ATTR_TYPE_METHOD_OK;
}
case ATTR_SCALE_END_COLOR:
if(update) {
@ -496,25 +495,25 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
} else {
attr_out_color(obj, attr, lv_obj_get_style_scale_end_color(obj, part));
}
return;
return HASP_ATTR_TYPE_METHOD_OK;
case ATTR_SCALE_END_LINE_WIDTH:
return attribute_scale_end_line_width(obj, part, state, update, attr_p, (lv_style_int_t)var);
return attribute_scale_end_line_width(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_SCALE_END_BORDER_WIDTH:
return attribute_scale_end_border_width(obj, part, state, update, attr_p, (lv_style_int_t)var);
return attribute_scale_end_border_width(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_SCALE_BORDER_WIDTH:
return attribute_scale_border_width(obj, part, state, update, attr_p, (lv_style_int_t)var);
return attribute_scale_border_width(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_SCALE_WIDTH:
return attribute_scale_width(obj, part, state, update, attr_p, (lv_style_int_t)var);
return attribute_scale_width(obj, part, state, update, (lv_style_int_t)var, val);
/* Text attributes */
case ATTR_TEXT_LETTER_SPACE:
return attribute_text_letter_space(obj, part, state, update, attr_p, (lv_style_int_t)var);
return attribute_text_letter_space(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_TEXT_LINE_SPACE:
return attribute_text_line_space(obj, part, state, update, attr_p, (lv_style_int_t)var);
return attribute_text_line_space(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_TEXT_DECOR:
return attribute_text_decor(obj, part, state, update, attr_p, (lv_text_decor_t)var);
return attribute_text_decor(obj, part, state, update, (lv_text_decor_t)var, val);
case ATTR_TEXT_OPA:
return attribute_text_opa(obj, part, state, update, attr_p, (lv_opa_t)var);
return attribute_text_opa(obj, part, state, update, (lv_opa_t)var, val);
case ATTR_TEXT_COLOR: {
if(update) {
lv_color32_t c;
@ -523,7 +522,7 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
} else {
attr_out_color(obj, attr, lv_obj_get_style_text_color(obj, part));
}
return;
return HASP_ATTR_TYPE_METHOD_OK;
}
case ATTR_TEXT_SEL_COLOR: {
if(update) {
@ -534,7 +533,7 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
} else {
attr_out_color(obj, attr, lv_obj_get_style_text_sel_color(obj, part));
}
return;
return HASP_ATTR_TYPE_METHOD_OK;
}
case ATTR_TEXT_FONT: {
lv_font_t* font = haspPayloadToFont(payload);
@ -555,18 +554,19 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
} else {
LOG_WARNING(TAG_ATTR, F("Unknown Font ID %s"), payload);
}
return;
return HASP_ATTR_TYPE_METHOD_OK;
}
/* Border attributes */
case ATTR_BORDER_WIDTH:
return attribute_border_width(obj, part, state, update, attr_p, (lv_style_int_t)var);
return attribute_border_width(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_BORDER_SIDE:
return attribute_border_side(obj, part, state, update, attr_p, (lv_border_side_t)var);
return attribute_border_side(obj, part, state, update, (lv_border_side_t)var, val);
case ATTR_BORDER_POST:
return attribute_border_post(obj, part, state, update, attr_p, Parser::is_true(payload));
attribute_border_post(obj, part, state, update, Parser::is_true(payload), val);
return HASP_ATTR_TYPE_BOOL;
case ATTR_BORDER_OPA:
return attribute_border_opa(obj, part, state, update, attr_p, (lv_opa_t)var);
return attribute_border_opa(obj, part, state, update, (lv_opa_t)var, val);
case ATTR_BORDER_COLOR: {
if(update) {
lv_color32_t c;
@ -576,16 +576,16 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
} else {
attr_out_color(obj, attr, lv_obj_get_style_border_color(obj, part));
}
return;
return HASP_ATTR_TYPE_METHOD_OK;
}
/* Outline attributes */
case ATTR_OUTLINE_WIDTH:
return attribute_outline_width(obj, part, state, update, attr_p, (lv_style_int_t)var);
return attribute_outline_width(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_OUTLINE_PAD:
return attribute_outline_pad(obj, part, state, update, attr_p, (lv_style_int_t)var);
return attribute_outline_pad(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_OUTLINE_OPA:
return attribute_outline_opa(obj, part, state, update, attr_p, (lv_opa_t)var);
return attribute_outline_opa(obj, part, state, update, (lv_opa_t)var, val);
case ATTR_OUTLINE_COLOR: {
if(update) {
lv_color32_t c;
@ -595,21 +595,21 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
} else {
attr_out_color(obj, attr, lv_obj_get_style_outline_color(obj, part));
}
return;
return HASP_ATTR_TYPE_METHOD_OK;
}
/* Shadow attributes */
#if LV_USE_SHADOW
case ATTR_SHADOW_WIDTH:
return attribute_shadow_width(obj, part, state, update, attr_p, (lv_style_int_t)var);
return attribute_shadow_width(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_SHADOW_OFS_X:
return attribute_shadow_ofs_x(obj, part, state, update, attr_p, (lv_style_int_t)var);
return attribute_shadow_ofs_x(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_SHADOW_OFS_Y:
return attribute_shadow_ofs_y(obj, part, state, update, attr_p, (lv_style_int_t)var);
return attribute_shadow_ofs_y(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_SHADOW_SPREAD:
return attribute_shadow_spread(obj, part, state, update, attr_p, (lv_style_int_t)var);
return attribute_shadow_spread(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_SHADOW_OPA:
return attribute_shadow_opa(obj, part, state, update, attr_p, (lv_opa_t)var);
return attribute_shadow_opa(obj, part, state, update, (lv_opa_t)var, val);
case ATTR_SHADOW_COLOR: {
if(update) {
lv_color32_t c;
@ -619,21 +619,22 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
} else {
attr_out_color(obj, attr, lv_obj_get_style_shadow_color(obj, part));
}
return;
return HASP_ATTR_TYPE_METHOD_OK;
}
#endif
/* Line attributes */
case ATTR_LINE_WIDTH:
return attribute_line_width(obj, part, state, update, attr_p, (lv_style_int_t)var);
return attribute_line_width(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_LINE_DASH_WIDTH:
return attribute_line_dash_width(obj, part, state, update, attr_p, (lv_style_int_t)var);
return attribute_line_dash_width(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_LINE_DASH_GAP:
return attribute_line_dash_gap(obj, part, state, update, attr_p, (lv_style_int_t)var);
return attribute_line_dash_gap(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_LINE_ROUNDED:
return attribute_line_rounded(obj, part, state, update, attr_p, Parser::is_true(payload));
attribute_line_rounded(obj, part, state, update, Parser::is_true(payload), val);
return HASP_ATTR_TYPE_BOOL;
case ATTR_LINE_OPA:
return attribute_line_opa(obj, part, state, update, attr_p, (lv_opa_t)var);
return attribute_line_opa(obj, part, state, update, (lv_opa_t)var, val);
case ATTR_LINE_COLOR: {
if(update) {
lv_color32_t c;
@ -642,29 +643,29 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
} else {
attr_out_color(obj, attr, lv_obj_get_style_line_color(obj, part));
}
return;
return HASP_ATTR_TYPE_METHOD_OK;
}
/* Value attributes */
case ATTR_VALUE_LETTER_SPACE:
return attribute_value_letter_space(obj, part, state, update, attr_p, (lv_style_int_t)var);
return attribute_value_letter_space(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_VALUE_LINE_SPACE:
return attribute_value_line_space(obj, part, state, update, attr_p, (lv_style_int_t)var);
return attribute_value_line_space(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_VALUE_OFS_X:
return attribute_value_ofs_x(obj, part, state, update, attr_p, (lv_style_int_t)var);
return attribute_value_ofs_x(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_VALUE_OFS_Y:
return attribute_value_ofs_y(obj, part, state, update, attr_p, (lv_style_int_t)var);
return attribute_value_ofs_y(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_VALUE_ALIGN:
return attribute_value_align(obj, part, state, update, attr_p, (lv_align_t)var);
return attribute_value_align(obj, part, state, update, (lv_align_t)var, val);
case ATTR_VALUE_OPA:
return attribute_value_opa(obj, part, state, update, attr_p, (lv_opa_t)var);
return attribute_value_opa(obj, part, state, update, (lv_opa_t)var, val);
case ATTR_VALUE_STR: {
if(update) {
my_obj_set_value_str_text(obj, part, state, payload);
} else {
attr_out_str(obj, attr, lv_obj_get_style_value_str(obj, part));
}
return;
return HASP_ATTR_TYPE_METHOD_OK;
}
case ATTR_VALUE_COLOR: {
if(update) {
@ -675,25 +676,26 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
} else {
attr_out_color(obj, attr, lv_obj_get_style_value_color(obj, part));
}
return;
return HASP_ATTR_TYPE_METHOD_OK;
}
case ATTR_VALUE_FONT: {
lv_font_t* font = haspPayloadToFont(payload);
if(font) {
return lv_obj_set_style_local_value_font(obj, part, state, font);
lv_obj_set_style_local_value_font(obj, part, state, font);
} else {
LOG_WARNING(TAG_ATTR, F("Unknown Font ID %s"), attr_p);
return;
}
return HASP_ATTR_TYPE_METHOD_OK;
}
/* Pattern attributes */
case ATTR_PATTERN_REPEAT:
return attribute_pattern_repeat(obj, part, state, update, attr_p, Parser::is_true(payload));
attribute_pattern_repeat(obj, part, state, update, Parser::is_true(payload), val);
return HASP_ATTR_TYPE_BOOL;
case ATTR_PATTERN_OPA:
return attribute_pattern_opa(obj, part, state, update, attr_p, (lv_opa_t)var);
return attribute_pattern_opa(obj, part, state, update, (lv_opa_t)var, val);
case ATTR_PATTERN_RECOLOR_OPA:
return attribute_pattern_recolor_opa(obj, part, state, update, attr_p, (lv_opa_t)var);
return attribute_pattern_recolor_opa(obj, part, state, update, (lv_opa_t)var, val);
case ATTR_PATTERN_RECOLOR: {
if(update) {
lv_color32_t c;
@ -703,7 +705,7 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
} else {
attr_out_color(obj, attr, lv_obj_get_style_pattern_recolor(obj, part));
}
return;
return HASP_ATTR_TYPE_METHOD_OK;
}
case ATTR_PATTERN_IMAGE:
@ -712,9 +714,9 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
/* Image attributes */
case ATTR_IMAGE_RECOLOR_OPA:
return attribute_image_recolor_opa(obj, part, state, update, attr_p, (lv_opa_t)var);
return attribute_image_recolor_opa(obj, part, state, update, (lv_opa_t)var, val);
case ATTR_IMAGE_OPA:
return attribute_image_opa(obj, part, state, update, attr_p, (lv_opa_t)var);
return attribute_image_opa(obj, part, state, update, (lv_opa_t)var, val);
case ATTR_IMAGE_RECOLOR: {
if(update) {
lv_color32_t c;
@ -724,7 +726,7 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
} else {
attr_out_color(obj, attr, lv_obj_get_style_image_recolor(obj, part));
}
return;
return HASP_ATTR_TYPE_METHOD_OK;
}
/* Transition attributes */
@ -734,8 +736,9 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
break;
}
LOG_WARNING(TAG_ATTR, F(D_ATTRIBUTE_UNKNOWN " (%d)"), attr_p, attr_hash);
result = false;
// LOG_WARNING(TAG_ATTR, F(D_ATTRIBUTE_UNKNOWN " (%d)"), attr_p, attr_hash);
// result = false;
return HASP_ATTR_TYPE_NOT_FOUND;
}
static hasp_attribute_type_t hasp_process_arc_attribute(lv_obj_t* obj, uint16_t attr_hash, int32_t& val, bool update)
@ -2011,14 +2014,14 @@ void hasp_process_obj_attribute(lv_obj_t* obj, const char* attribute, const char
}
if(ret == HASP_ATTR_TYPE_NOT_FOUND) {
bool result;
hasp_local_style_attr(obj, attribute, attr_hash, payload, update, result);
if(result) {
ret = HASP_ATTR_TYPE_METHOD_OK;
} else {
ret = HASP_ATTR_TYPE_NOT_FOUND;
}
LOG_VERBOSE(TAG_ATTR, "%s %d ret:%d", __FILE__, __LINE__, ret);
// bool result;
ret = hasp_local_style_attr(obj, attribute, attr_hash, payload, update, val);
// if(result) {
// ret = HASP_ATTR_TYPE_METHOD_OK;
// } else {
// ret = HASP_ATTR_TYPE_NOT_FOUND;
// }
// LOG_VERBOSE(TAG_ATTR, "%s %d ret:%d", __FILE__, __LINE__, ret);
}
// Positive return codes have returned a value, negative are warnings

25
src/hasp/hasp_attribute.h
View File

@ -49,6 +49,20 @@ typedef enum {
HASP_ATTR_TYPE_METHOD_OK,
} hasp_attribute_type_t;
struct hasp_attr_local_opa_t
{
uint16_t hash;
void (*set)(lv_obj_t*, uint8_t, lv_state_t, lv_opa_t);
lv_opa_t (*get)(const lv_obj_t*, uint8_t);
};
struct hasp_attr_local_int_t
{
uint16_t hash;
void (*set)(lv_obj_t*, uint8_t, lv_state_t, lv_style_int_t);
lv_style_int_t (*get)(const lv_obj_t*, uint8_t);
};
struct hasp_attr_update_bool_const_t
{
lv_hasp_obj_type_t obj_type;
@ -129,7 +143,7 @@ struct hasp_attr_update_char_const_t
const char* (*get)(const lv_obj_t*);
};
#define _HASP_ATTRIBUTE(prop_name, func_name, value_type) \
#define _HASP_ATTRIBUTE_OLD(prop_name, func_name, value_type) \
static inline void attribute_##func_name(lv_obj_t* obj, uint8_t part, lv_state_t state, bool update, \
const char* attr, value_type val) \
{ \
@ -142,6 +156,15 @@ struct hasp_attr_update_char_const_t
} \
}
#define _HASP_ATTRIBUTE(prop_name, func_name, value_type) \
static inline hasp_attribute_type_t attribute_##func_name(lv_obj_t* obj, uint8_t part, lv_state_t state, bool update, \
value_type val, int32_t& res) \
{ \
if(update) lv_obj_set_style_local_##func_name(obj, part, state, (value_type)val); \
res = (int32_t)lv_obj_get_style_##func_name(obj, part); \
return HASP_ATTR_TYPE_INT; \
}
_HASP_ATTRIBUTE(RADIUS, radius, lv_style_int_t)
_HASP_ATTRIBUTE(CLIP_CORNER, clip_corner, bool)
_HASP_ATTRIBUTE(SIZE, size, lv_style_int_t)

69
src/hasp/hasp_dispatch.cpp
View File

@ -75,21 +75,38 @@ void dispatch_state_subtopic(const char* subtopic, const char* payload)
#endif
}
// Format filesystem and erase EEPROM
bool dispatch_factory_reset()
void dispatch_state_eventid(const char* topic, hasp_event_t eventid)
{
bool formated = true;
bool erased = true;
char payload[32];
char eventname[8];
#if HASP_USE_SPIFFS > 0 || HASP_USE_LITTLEFS > 0
formated = HASP_FS.format();
#endif
Parser::get_event_name(eventid, eventname, sizeof(eventname));
if(eventid == HASP_EVENT_ON || eventid == HASP_EVENT_OFF) {
snprintf_P(payload, sizeof(payload), PSTR("{\"state\":\"%s\"}"), eventname);
} else {
snprintf_P(payload, sizeof(payload), PSTR("{\"event\":\"%s\"}"), eventname);
}
dispatch_state_subtopic(topic, payload);
}
#if HASP_USE_EEPROM > 0
erased = false;
#endif
void dispatch_state_brightness(const char* topic, hasp_event_t eventid, int32_t val)
{
char payload[64];
char eventname[8];
return formated && erased;
Parser::get_event_name(eventid, eventname, sizeof(eventname));
snprintf_P(payload, sizeof(payload), PSTR("{\"state\":\"%s\",\"brightness\":%d}"), eventname, val);
dispatch_state_subtopic(topic, payload);
}
void dispatch_state_val(const char* topic, hasp_event_t eventid, int32_t val)
{
char payload[64];
char eventname[8];
Parser::get_event_name(eventid, eventname, sizeof(eventname));
snprintf_P(payload, sizeof(payload), PSTR("{\"state\":\"%s\",\"val\":%d}"), eventname, val);
dispatch_state_subtopic(topic, payload);
}
void dispatch_json_error(uint8_t tag, DeserializationError& jsonError)
@ -200,8 +217,9 @@ static void dispatch_output(const char* topic, const char* payload)
return;
}
JsonVariant state = json[F("state")];
JsonVariant value = json[F("val")];
JsonVariant state = json[F("state")];
JsonVariant value = json[F("val")];
JsonVariant brightness = json[F("brightness")];
// Check if the state needs to change
if(!state.isNull() && power_state != state.as<bool>()) {
@ -212,6 +230,9 @@ static void dispatch_output(const char* topic, const char* payload)
if(!value.isNull() && state_value != value.as<int32_t>()) {
state_value = value.as<int32_t>();
updated = true;
} else if(!brightness.isNull() && state_value != brightness.as<int32_t>()) {
state_value = brightness.as<int32_t>();
updated = true;
}
// Set new state
@ -800,11 +821,8 @@ void dispatch_backlight(const char*, const char* payload)
// Return the current state
char topic[10];
char buffer[64];
memcpy_P(topic, PSTR("backlight"), 10);
snprintf_P(buffer, sizeof(buffer), PSTR("{\"state\":\"%s\",\"brightness\":%u}"),
haspDevice.get_backlight_power() ? "on" : "off", haspDevice.get_backlight_level());
dispatch_state_subtopic(topic, buffer);
dispatch_state_brightness(topic, (hasp_event_t)haspDevice.get_backlight_power(), haspDevice.get_backlight_level());
}
void dispatch_web_update(const char*, const char* espOtaUrl)
@ -955,6 +973,23 @@ void dispatch_current_state()
dispatch_send_discovery(NULL, NULL);
}
// Format filesystem and erase EEPROM
bool dispatch_factory_reset()
{
bool formated = true;
bool erased = true;
#if HASP_USE_SPIFFS > 0 || HASP_USE_LITTLEFS > 0
formated = HASP_FS.format();
#endif
#if HASP_USE_EEPROM > 0
erased = false;
#endif
return formated && erased;
}
void dispatch_calibrate(const char*, const char*)
{
guiCalibrate();

5
src/hasp/hasp_dispatch.h
View File

@ -74,11 +74,12 @@ void dispatch_idle(const char*, const char*);
void dispatch_calibrate(const char*, const char*);
void dispatch_wakeup(const char*, const char*);
void dispatch_gpio_input_event(uint8_t pin, uint8_t group, uint8_t eventid);
void dispatch_normalized_group_values(hasp_update_value_t& value);
void dispatch_state_subtopic(const char* subtopic, const char* payload);
void dispatch_state_eventid(const char* topic, hasp_event_t eventid);
void dispatch_state_brightness(const char* topic, hasp_event_t eventid, int32_t val);
void dispatch_state_val(const char* topic, hasp_event_t eventid, int32_t val);
void dispatch_config(const char* topic, const char* payload);

18
src/hasp/hasp_event.cpp
View File

@ -245,24 +245,6 @@ static inline void event_update_group(uint8_t group, lv_obj_t* obj, bool power,
dispatch_normalized_group_values(value);
}
#if HASP_USE_GPIO > 0
void event_gpio_input(uint8_t pin, uint8_t eventid)
{
char payload[32];
char topic[10];
char eventname[8];
snprintf_P(topic, sizeof(topic), PSTR("input%d"), pin);
Parser::get_event_name(eventid, eventname, sizeof(eventname));
if(eventid == HASP_EVENT_ON || eventid == HASP_EVENT_OFF) {
snprintf_P(payload, sizeof(payload), PSTR("{\"state\":\"%s\"}"), eventname);
} else {
snprintf_P(payload, sizeof(payload), PSTR("{\"event\":\"%s\"}"), eventname);
}
dispatch_state_subtopic(topic, payload);
}
#endif
static void log_event(const char* name, lv_event_t event)
{
return;

5
src/hasp/hasp_event.h
View File

@ -26,9 +26,4 @@ void msgbox_event_handler(lv_obj_t* obj, lv_event_t event);
void cpicker_event_handler(lv_obj_t* obj, lv_event_t event);
void calendar_event_handler(lv_obj_t* obj, lv_event_t event);
#if HASP_USE_GPIO > 0
// GPIO event Handler
void event_gpio_input(uint8_t pin, uint8_t eventid);
#endif
#endif // HASP_EVENT_H

2
src/hasp/lv_theme_hasp.c
View File

@ -226,8 +226,6 @@ static lv_style_int_t hasp_dpx(lv_style_int_t n)
static void basic_init(lv_style_int_t border_width, lv_style_int_t outline_width, lv_color_t value_color,
lv_color_t color_scr_text)
{
sizeof(lv_style_t);
// Objects with transparent background, like Checkbox, container
style_init_reset(&styles->transparent);
lv_style_set_bg_opa(&styles->transparent, LV_STATE_DEFAULT, LV_OPA_TRANSP);

62
src/sys/gpio/hasp_gpio.cpp
View File

@ -38,6 +38,8 @@ hasp_gpio_config_t gpioConfig[HASP_NUM_GPIO_CONFIG] = {
};
uint8_t pwm_channel = 1; // Backlight has 0
static inline void gpio_input_event(uint8_t pin, hasp_event_t eventid);
static inline void gpio_update_group(uint8_t group, lv_obj_t* obj, bool power, int32_t val, int32_t min, int32_t max)
{
hasp_update_value_t value = {.obj = obj, .group = group, .min = min, .max = max, .val = val, .power = power};
@ -87,7 +89,7 @@ void gpio_log_serial_dimmer(const char* command)
static void gpio_event_handler(AceButton* button, uint8_t eventType, uint8_t buttonState)
{
uint8_t btnid = button->getId();
uint8_t eventid;
hasp_event_t eventid;
bool state = false;
switch(eventType) {
case AceButton::kEventPressed:
@ -125,7 +127,7 @@ static void gpio_event_handler(AceButton* button, uint8_t eventType, uint8_t but
}
gpioConfig[btnid].power = Parser::get_event_state(eventid);
event_gpio_input(gpioConfig[btnid].pin, eventid);
gpio_input_event(gpioConfig[btnid].pin, eventid);
// update objects and gpios in this group
if(gpioConfig[btnid].group && eventid != HASP_EVENT_LONG) // do not repeat DOWN + LONG
@ -210,27 +212,30 @@ static void gpio_setup_pin(uint8_t index)
break;
}
gpio->power = 1; // on by default, value is set to 0
gpio->power = 0; // off by default, value is set to 0
gpio->max = 255;
switch(gpio->type) {
case hasp_gpio_type_t::SWITCH:
case hasp_gpio_type_t::BATTERY... hasp_gpio_type_t::WINDOW:
if(gpio->btn) delete gpio->btn;
gpio->btn = new AceButton(&switchConfig, gpio->pin, default_state, index);
pinMode(gpio->pin, INPUT_PULLUP);
gpio->btn = new AceButton(&switchConfig, gpio->pin, default_state, index);
gpio->power = gpio->btn->isPressedRaw();
pinMode(gpio->pin, input_mode);
gpio->max = 0;
break;
case hasp_gpio_type_t::BUTTON:
if(gpio->btn) delete gpio->btn;
gpio->btn = new AceButton(&buttonConfig, gpio->pin, default_state, index);
pinMode(gpio->pin, INPUT_PULLUP);
gpio->btn = new AceButton(&buttonConfig, gpio->pin, default_state, index);
gpio->power = gpio->btn->isPressedRaw();
pinMode(gpio->pin, input_mode);
gpio->max = 0;
break;
#if defined(ARDUINO_ARCH_ESP32)
case hasp_gpio_type_t::TOUCH:
if(gpio->btn) delete gpio->btn;
gpio->btn = new AceButton(&touchConfig, gpio->pin, HIGH, index);
gpio->max = 0;
gpio->btn = new AceButton(&touchConfig, gpio->pin, HIGH, index);
gpio->power = gpio->btn->isPressedRaw();
gpio->max = 0;
// touchAttachInterrupt(gpio->pin, gotTouch, 33);
break;
#endif
@ -238,7 +243,9 @@ static void gpio_setup_pin(uint8_t index)
case hasp_gpio_type_t::POWER_RELAY:
case hasp_gpio_type_t::LIGHT_RELAY:
pinMode(gpio->pin, OUTPUT);
gpio->max = 1; // on-off
gpio->power = gpio->inverted; // gpio is off, state is set to reflect the true output state of the gpio
gpio->max = 1; // on-off
gpio->val = gpio->power;
break;
case hasp_gpio_type_t::PWM:
@ -277,11 +284,8 @@ static void gpio_setup_pin(uint8_t index)
Serial1.begin(115200UL, SERIAL_8N1, UART_PIN_NO_CHANGE, gpio->pin,
gpio->type == hasp_gpio_type_t::SERIAL_DIMMER_EU); // true = EU, false = AU
Serial1.flush();
//delay(10);
//Serial1.print(" ");
Serial1.write(0x20);
Serial1.write(0x20);
// delay(10);
Serial1.write((const uint8_t*)command, 8);
#endif
gpio_log_serial_dimmer(command);
@ -353,7 +357,7 @@ void gpioEvery5Seconds(void)
for(uint8_t i = 0; i < HASP_NUM_GPIO_CONFIG; i++) {
if(gpio_is_input(&gpioConfig[i])) {
gpioConfig[i].power = !gpioConfig[i].power;
event_gpio_input(gpioConfig[i].pin, gpioConfig[i].power);
gpio_input_event(gpioConfig[i].pin, (hasp_event_t)gpioConfig[i].power);
}
}
}
@ -372,19 +376,37 @@ bool gpio_get_pin_state(uint8_t pin, bool& power, int32_t& val)
return false;
}
static inline void gpio_input_event(uint8_t pin, hasp_event_t eventid)
{
char topic[10];
snprintf_P(topic, sizeof(topic), PSTR("input%d"), pin);
dispatch_state_eventid(topic, eventid);
}
static inline void gpio_input_state(hasp_gpio_config_t* gpio)
{
event_gpio_input(gpio->pin, gpio->power);
gpio_input_event(gpio->pin, (hasp_event_t)gpio->power);
}
void gpio_output_state(hasp_gpio_config_t* gpio)
{
char payload[32];
char topic[12];
snprintf_P(topic, sizeof(topic), PSTR("output%d"), gpio->pin);
snprintf_P(payload, sizeof(payload), PSTR("{\"state\":%d,\"val\":%d}"), gpio->power, gpio->val);
dispatch_state_subtopic(topic, payload);
switch(gpio->type) {
case LIGHT_RELAY:
case POWER_RELAY:
dispatch_state_eventid(topic, (hasp_event_t)gpio->power);
break;
case LED:
case SERIAL_DIMMER:
case SERIAL_DIMMER_AU:
case SERIAL_DIMMER_EU:
dispatch_state_brightness(topic, (hasp_event_t)gpio->power, gpio->val);
break;
default:
dispatch_state_val(topic, (hasp_event_t)gpio->power, gpio->val);
}
}
bool gpio_input_pin_state(uint8_t pin)
@ -615,8 +637,8 @@ bool gpio_set_pin_state(uint8_t pin, bool power, int32_t val)
return false;
}
if(gpio->max == 1) { // it's a relay
gpio->val = gpio->power; // val and power are equal
if(gpio->max == 1) { // it's a relay
val = power; // val and power are equal
}
if(gpio->group) {

12
src/sys/svc/hasp_http.cpp
View File

@ -1652,7 +1652,7 @@ void webHandleGpioConfig()
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void webHandleGpioOptions()
void webHandleGpioOutput()
{ // http://plate01/config/gpio/options
if(!httpIsAuthenticated(F("config/gpio/options"))) return;
@ -1673,9 +1673,7 @@ void webHandleGpioOptions()
httpMessage += config_id;
httpMessage += F("'>");
httpMessage += F("<p><b>GPIO Options");
httpMessage += config_id;
httpMessage += F(" Options</b></p>");
httpMessage += F("<p><b>GPIO Output</b></p>");
httpMessage += F("<p><b>" D_GPIO_PIN "</b> <select id='pin' name='pin'>");
hasp_gpio_config_t conf = gpioGetPinConfig(config_id);
@ -1782,9 +1780,7 @@ void webHandleGpioInput()
httpMessage += config_id;
httpMessage += F("'>");
httpMessage += F("<p><b>GPIO Options");
httpMessage += config_id;
httpMessage += F(" Options</b></p>");
httpMessage += F("<p><b>GPIO Input</b></p>");
httpMessage += F("<p><b>" D_GPIO_PIN "</b> <select id='pin' name='pin'>");
hasp_gpio_config_t conf = gpioGetPinConfig(config_id);
@ -2343,7 +2339,7 @@ void httpSetup()
#endif
#if HASP_USE_GPIO > 0
webServer.on(F("/config/gpio"), webHandleGpioConfig);
webServer.on(F("/config/gpio/options"), webHandleGpioOptions);
webServer.on(F("/config/gpio/options"), webHandleGpioOutput);
webServer.on(F("/config/gpio/input"), webHandleGpioInput);
#endif
webServer.on(F("/saveConfig"), webHandleSaveConfig);

2
src/sys/svc/hasp_telnet.cpp
View File

@ -318,7 +318,7 @@ IRAM_ATTR void telnetLoop()
if(telnetConsole) {
while(telnetConsole->readKey()) {
if(!telnetConsole) return; // the telnetConsole was destroyed
if(bufferedTelnetClient.peek() < 0) bufferedTelnetClient.flush(); // flush pending updates
if(bufferedTelnetClient.available() <= 0) bufferedTelnetClient.flush(); // flush pending updates
};
} else {