jeans/openHASP
jeans/openHASP
1
0
Fork 0
mirror of https://github.com/HASwitchPlate/openHASP.git synced 2025-07-28 13:46:36 +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 * @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 * @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, static hasp_attribute_type_t hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t attr_hash,
bool update, bool& result) const char* payload, bool update, int32_t& val)
{ {
char attr[32]; char attr[32];
uint8_t part = LV_OBJ_PART_MAIN; 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 * when using hasp_out use attr_p for the original attribute name
* *************************************************************** */ * *************************************************************** */
result = true; // default return
switch(attr_hash) { switch(attr_hash) {
/* 1: Use other blend modes than normal (`LV_BLEND_MODE_...`)*/ /* 1: Use other blend modes than normal (`LV_BLEND_MODE_...`)*/
#if LV_USE_BLEND_MODES #if LV_USE_BLEND_MODES
case ATTR_BG_BLEND_MODE: case ATTR_BG_BLEND_MODE:
return attribute_bg_blend_mode(obj, part, state, update, attr_p, (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: // case ATTR_TEXT_BLEND_MODE:
return lv_obj_set_style_local_text_blend_mode(obj, part, state, (lv_blend_mode_t)var); // return lv_obj_set_style_local_text_blend_mode(obj, part, state, (lv_blend_mode_t)var);
case ATTR_BORDER_BLEND_MODE: // case ATTR_BORDER_BLEND_MODE:
return lv_obj_set_style_local_border_blend_mode(obj, part, state, (lv_blend_mode_t)var); // return lv_obj_set_style_local_border_blend_mode(obj, part, state, (lv_blend_mode_t)var);
case ATTR_OUTLINE_BLEND_MODE: // case ATTR_OUTLINE_BLEND_MODE:
return lv_obj_set_style_local_outline_blend_mode(obj, part, state, (lv_blend_mode_t)var); // return lv_obj_set_style_local_outline_blend_mode(obj, part, state, (lv_blend_mode_t)var);
case ATTR_SHADOW_BLEND_MODE: // case ATTR_SHADOW_BLEND_MODE:
return lv_obj_set_style_local_shadow_blend_mode(obj, part, state, (lv_blend_mode_t)var); // return lv_obj_set_style_local_shadow_blend_mode(obj, part, state, (lv_blend_mode_t)var);
case ATTR_LINE_BLEND_MODE: // case ATTR_LINE_BLEND_MODE:
return lv_obj_set_style_local_line_blend_mode(obj, part, state, (lv_blend_mode_t)var); // return lv_obj_set_style_local_line_blend_mode(obj, part, state, (lv_blend_mode_t)var);
case ATTR_VALUE_BLEND_MODE: // case ATTR_VALUE_BLEND_MODE:
return lv_obj_set_style_local_value_blend_mode(obj, part, state, (lv_blend_mode_t)var); // return lv_obj_set_style_local_value_blend_mode(obj, part, state, (lv_blend_mode_t)var);
case ATTR_PATTERN_BLEND_MODE: // case ATTR_PATTERN_BLEND_MODE:
return lv_obj_set_style_local_pattern_blend_mode(obj, part, state, (lv_blend_mode_t)var); // return lv_obj_set_style_local_pattern_blend_mode(obj, part, state, (lv_blend_mode_t)var);
#endif #endif
case ATTR_SIZE: 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: 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: 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: 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: 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: 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 */ /* Background attributes */
case ATTR_BG_MAIN_STOP: 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: 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: 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: { case ATTR_BG_COLOR: {
if(update) { if(update) {
lv_color32_t c; 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 { } else {
attr_out_color(obj, attr, lv_obj_get_style_bg_color(obj, part)); 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: case ATTR_BG_GRAD_COLOR:
if(update) { if(update) {
@ -446,33 +445,33 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
} else { } else {
attr_out_color(obj, attr, lv_obj_get_style_bg_grad_color(obj, part)); 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: 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 */ /* Margin attributes */
case ATTR_MARGIN_TOP: 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: 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: 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: 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 */ /* Padding attributes */
case ATTR_PAD_TOP: 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: 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: 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: 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 #if LVGL_VERSION_MAJOR == 7
case ATTR_PAD_INNER: 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 #endif
/* Scale attributes */ /* Scale attributes */
@ -485,7 +484,7 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
} else { } else {
attr_out_color(obj, attr, lv_obj_get_style_scale_grad_color(obj, part)); 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: case ATTR_SCALE_END_COLOR:
if(update) { if(update) {
@ -496,25 +495,25 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
} else { } else {
attr_out_color(obj, attr, lv_obj_get_style_scale_end_color(obj, part)); 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: 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: 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: 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: 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 */ /* Text attributes */
case ATTR_TEXT_LETTER_SPACE: 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: 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: 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: 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: { case ATTR_TEXT_COLOR: {
if(update) { if(update) {
lv_color32_t c; 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 { } else {
attr_out_color(obj, attr, lv_obj_get_style_text_color(obj, part)); 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: { case ATTR_TEXT_SEL_COLOR: {
if(update) { if(update) {
@ -534,7 +533,7 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
} else { } else {
attr_out_color(obj, attr, lv_obj_get_style_text_sel_color(obj, part)); 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: { case ATTR_TEXT_FONT: {
lv_font_t* font = haspPayloadToFont(payload); 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 { } else {
LOG_WARNING(TAG_ATTR, F("Unknown Font ID %s"), payload); LOG_WARNING(TAG_ATTR, F("Unknown Font ID %s"), payload);
} }
return; return HASP_ATTR_TYPE_METHOD_OK;
} }
/* Border attributes */ /* Border attributes */
case ATTR_BORDER_WIDTH: 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: 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: 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: 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: { case ATTR_BORDER_COLOR: {
if(update) { if(update) {
lv_color32_t c; 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 { } else {
attr_out_color(obj, attr, lv_obj_get_style_border_color(obj, part)); attr_out_color(obj, attr, lv_obj_get_style_border_color(obj, part));
} }
return; return HASP_ATTR_TYPE_METHOD_OK;
} }
/* Outline attributes */ /* Outline attributes */
case ATTR_OUTLINE_WIDTH: 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: 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: 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: { case ATTR_OUTLINE_COLOR: {
if(update) { if(update) {
lv_color32_t c; 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 { } else {
attr_out_color(obj, attr, lv_obj_get_style_outline_color(obj, part)); attr_out_color(obj, attr, lv_obj_get_style_outline_color(obj, part));
} }
return; return HASP_ATTR_TYPE_METHOD_OK;
} }
/* Shadow attributes */ /* Shadow attributes */
#if LV_USE_SHADOW #if LV_USE_SHADOW
case ATTR_SHADOW_WIDTH: 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: 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: 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: 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: 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: { case ATTR_SHADOW_COLOR: {
if(update) { if(update) {
lv_color32_t c; 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 { } else {
attr_out_color(obj, attr, lv_obj_get_style_shadow_color(obj, part)); attr_out_color(obj, attr, lv_obj_get_style_shadow_color(obj, part));
} }
return; return HASP_ATTR_TYPE_METHOD_OK;
} }
#endif #endif
/* Line attributes */ /* Line attributes */
case ATTR_LINE_WIDTH: 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: 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: 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: 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: 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: { case ATTR_LINE_COLOR: {
if(update) { if(update) {
lv_color32_t c; 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 { } else {
attr_out_color(obj, attr, lv_obj_get_style_line_color(obj, part)); attr_out_color(obj, attr, lv_obj_get_style_line_color(obj, part));
} }
return; return HASP_ATTR_TYPE_METHOD_OK;
} }
/* Value attributes */ /* Value attributes */
case ATTR_VALUE_LETTER_SPACE: 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: 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: 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: 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: 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: 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: { case ATTR_VALUE_STR: {
if(update) { if(update) {
my_obj_set_value_str_text(obj, part, state, payload); my_obj_set_value_str_text(obj, part, state, payload);
} else { } else {
attr_out_str(obj, attr, lv_obj_get_style_value_str(obj, part)); attr_out_str(obj, attr, lv_obj_get_style_value_str(obj, part));
} }
return; return HASP_ATTR_TYPE_METHOD_OK;
} }
case ATTR_VALUE_COLOR: { case ATTR_VALUE_COLOR: {
if(update) { if(update) {
@ -675,25 +676,26 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
} else { } else {
attr_out_color(obj, attr, lv_obj_get_style_value_color(obj, part)); attr_out_color(obj, attr, lv_obj_get_style_value_color(obj, part));
} }
return; return HASP_ATTR_TYPE_METHOD_OK;
} }
case ATTR_VALUE_FONT: { case ATTR_VALUE_FONT: {
lv_font_t* font = haspPayloadToFont(payload); lv_font_t* font = haspPayloadToFont(payload);
if(font) { 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 { } else {
LOG_WARNING(TAG_ATTR, F("Unknown Font ID %s"), attr_p); LOG_WARNING(TAG_ATTR, F("Unknown Font ID %s"), attr_p);
return;
} }
return HASP_ATTR_TYPE_METHOD_OK;
} }
/* Pattern attributes */ /* Pattern attributes */
case ATTR_PATTERN_REPEAT: 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: 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: 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: { case ATTR_PATTERN_RECOLOR: {
if(update) { if(update) {
lv_color32_t c; 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 { } else {
attr_out_color(obj, attr, lv_obj_get_style_pattern_recolor(obj, part)); attr_out_color(obj, attr, lv_obj_get_style_pattern_recolor(obj, part));
} }
return; return HASP_ATTR_TYPE_METHOD_OK;
} }
case ATTR_PATTERN_IMAGE: 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 */ /* Image attributes */
case ATTR_IMAGE_RECOLOR_OPA: 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: 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: { case ATTR_IMAGE_RECOLOR: {
if(update) { if(update) {
lv_color32_t c; 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 { } else {
attr_out_color(obj, attr, lv_obj_get_style_image_recolor(obj, part)); attr_out_color(obj, attr, lv_obj_get_style_image_recolor(obj, part));
} }
return; return HASP_ATTR_TYPE_METHOD_OK;
} }
/* Transition attributes */ /* Transition attributes */
@ -734,8 +736,9 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
break; break;
} }
LOG_WARNING(TAG_ATTR, F(D_ATTRIBUTE_UNKNOWN " (%d)"), attr_p, attr_hash); // LOG_WARNING(TAG_ATTR, F(D_ATTRIBUTE_UNKNOWN " (%d)"), attr_p, attr_hash);
result = false; // 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) 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) { if(ret == HASP_ATTR_TYPE_NOT_FOUND) {
bool result; // bool result;
hasp_local_style_attr(obj, attribute, attr_hash, payload, update, result); ret = hasp_local_style_attr(obj, attribute, attr_hash, payload, update, val);
if(result) { // if(result) {
ret = HASP_ATTR_TYPE_METHOD_OK; // ret = HASP_ATTR_TYPE_METHOD_OK;
} else { // } else {
ret = HASP_ATTR_TYPE_NOT_FOUND; // ret = HASP_ATTR_TYPE_NOT_FOUND;
} // }
LOG_VERBOSE(TAG_ATTR, "%s %d ret:%d", __FILE__, __LINE__, ret); // LOG_VERBOSE(TAG_ATTR, "%s %d ret:%d", __FILE__, __LINE__, ret);
} }
// Positive return codes have returned a value, negative are warnings // 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_ATTR_TYPE_METHOD_OK,
} hasp_attribute_type_t; } 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 struct hasp_attr_update_bool_const_t
{ {
lv_hasp_obj_type_t obj_type; 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*); 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, \ 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) \ 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(RADIUS, radius, lv_style_int_t)
_HASP_ATTRIBUTE(CLIP_CORNER, clip_corner, bool) _HASP_ATTRIBUTE(CLIP_CORNER, clip_corner, bool)
_HASP_ATTRIBUTE(SIZE, size, lv_style_int_t) _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 #endif
} }
// Format filesystem and erase EEPROM void dispatch_state_eventid(const char* topic, hasp_event_t eventid)
bool dispatch_factory_reset()
{ {
bool formated = true; char payload[32];
bool erased = true; char eventname[8];
#if HASP_USE_SPIFFS > 0 || HASP_USE_LITTLEFS > 0 Parser::get_event_name(eventid, eventname, sizeof(eventname));
formated = HASP_FS.format(); if(eventid == HASP_EVENT_ON || eventid == HASP_EVENT_OFF) {
#endif 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 void dispatch_state_brightness(const char* topic, hasp_event_t eventid, int32_t val)
erased = false; {
#endif 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) void dispatch_json_error(uint8_t tag, DeserializationError& jsonError)
@ -200,8 +217,9 @@ static void dispatch_output(const char* topic, const char* payload)
return; return;
} }
JsonVariant state = json[F("state")]; JsonVariant state = json[F("state")];
JsonVariant value = json[F("val")]; JsonVariant value = json[F("val")];
JsonVariant brightness = json[F("brightness")];
// Check if the state needs to change // Check if the state needs to change
if(!state.isNull() && power_state != state.as<bool>()) { 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>()) { if(!value.isNull() && state_value != value.as<int32_t>()) {
state_value = value.as<int32_t>(); state_value = value.as<int32_t>();
updated = true; updated = true;
} else if(!brightness.isNull() && state_value != brightness.as<int32_t>()) {
state_value = brightness.as<int32_t>();
updated = true;
} }
// Set new state // Set new state
@ -800,11 +821,8 @@ void dispatch_backlight(const char*, const char* payload)
// Return the current state // Return the current state
char topic[10]; char topic[10];
char buffer[64];
memcpy_P(topic, PSTR("backlight"), 10); memcpy_P(topic, PSTR("backlight"), 10);
snprintf_P(buffer, sizeof(buffer), PSTR("{\"state\":\"%s\",\"brightness\":%u}"), dispatch_state_brightness(topic, (hasp_event_t)haspDevice.get_backlight_power(), haspDevice.get_backlight_level());
haspDevice.get_backlight_power() ? "on" : "off", haspDevice.get_backlight_level());
dispatch_state_subtopic(topic, buffer);
} }
void dispatch_web_update(const char*, const char* espOtaUrl) void dispatch_web_update(const char*, const char* espOtaUrl)
@ -955,6 +973,23 @@ void dispatch_current_state()
dispatch_send_discovery(NULL, NULL); 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*) void dispatch_calibrate(const char*, const char*)
{ {
guiCalibrate(); 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_calibrate(const char*, const char*);
void dispatch_wakeup(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_normalized_group_values(hasp_update_value_t& value);
void dispatch_state_subtopic(const char* subtopic, const char* payload); 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); 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); 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) static void log_event(const char* name, lv_event_t event)
{ {
return; 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 cpicker_event_handler(lv_obj_t* obj, lv_event_t event);
void calendar_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 #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, 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) lv_color_t color_scr_text)
{ {
sizeof(lv_style_t);
// Objects with transparent background, like Checkbox, container // Objects with transparent background, like Checkbox, container
style_init_reset(&styles->transparent); style_init_reset(&styles->transparent);
lv_style_set_bg_opa(&styles->transparent, LV_STATE_DEFAULT, LV_OPA_TRANSP); 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 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) 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}; 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) static void gpio_event_handler(AceButton* button, uint8_t eventType, uint8_t buttonState)
{ {
uint8_t btnid = button->getId(); uint8_t btnid = button->getId();
uint8_t eventid; hasp_event_t eventid;
bool state = false; bool state = false;
switch(eventType) { switch(eventType) {
case AceButton::kEventPressed: 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); 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 // update objects and gpios in this group
if(gpioConfig[btnid].group && eventid != HASP_EVENT_LONG) // do not repeat DOWN + LONG 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; 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; gpio->max = 255;
switch(gpio->type) { switch(gpio->type) {
case hasp_gpio_type_t::SWITCH: case hasp_gpio_type_t::SWITCH:
case hasp_gpio_type_t::BATTERY... hasp_gpio_type_t::WINDOW: case hasp_gpio_type_t::BATTERY... hasp_gpio_type_t::WINDOW:
if(gpio->btn) delete gpio->btn; if(gpio->btn) delete gpio->btn;
gpio->btn = new AceButton(&switchConfig, gpio->pin, default_state, index); gpio->btn = new AceButton(&switchConfig, gpio->pin, default_state, index);
pinMode(gpio->pin, INPUT_PULLUP); gpio->power = gpio->btn->isPressedRaw();
pinMode(gpio->pin, input_mode);
gpio->max = 0; gpio->max = 0;
break; break;
case hasp_gpio_type_t::BUTTON: case hasp_gpio_type_t::BUTTON:
if(gpio->btn) delete gpio->btn; if(gpio->btn) delete gpio->btn;
gpio->btn = new AceButton(&buttonConfig, gpio->pin, default_state, index); gpio->btn = new AceButton(&buttonConfig, gpio->pin, default_state, index);
pinMode(gpio->pin, INPUT_PULLUP); gpio->power = gpio->btn->isPressedRaw();
pinMode(gpio->pin, input_mode);
gpio->max = 0; gpio->max = 0;
break; break;
#if defined(ARDUINO_ARCH_ESP32) #if defined(ARDUINO_ARCH_ESP32)
case hasp_gpio_type_t::TOUCH: case hasp_gpio_type_t::TOUCH:
if(gpio->btn) delete gpio->btn; if(gpio->btn) delete gpio->btn;
gpio->btn = new AceButton(&touchConfig, gpio->pin, HIGH, index); gpio->btn = new AceButton(&touchConfig, gpio->pin, HIGH, index);
gpio->max = 0; gpio->power = gpio->btn->isPressedRaw();
gpio->max = 0;
// touchAttachInterrupt(gpio->pin, gotTouch, 33); // touchAttachInterrupt(gpio->pin, gotTouch, 33);
break; break;
#endif #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::POWER_RELAY:
case hasp_gpio_type_t::LIGHT_RELAY: case hasp_gpio_type_t::LIGHT_RELAY:
pinMode(gpio->pin, OUTPUT); 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; break;
case hasp_gpio_type_t::PWM: 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, Serial1.begin(115200UL, SERIAL_8N1, UART_PIN_NO_CHANGE, gpio->pin,
gpio->type == hasp_gpio_type_t::SERIAL_DIMMER_EU); // true = EU, false = AU gpio->type == hasp_gpio_type_t::SERIAL_DIMMER_EU); // true = EU, false = AU
Serial1.flush(); Serial1.flush();
//delay(10);
//Serial1.print(" ");
Serial1.write(0x20); Serial1.write(0x20);
Serial1.write(0x20); Serial1.write(0x20);
// delay(10);
Serial1.write((const uint8_t*)command, 8); Serial1.write((const uint8_t*)command, 8);
#endif #endif
gpio_log_serial_dimmer(command); gpio_log_serial_dimmer(command);
@ -353,7 +357,7 @@ void gpioEvery5Seconds(void)
for(uint8_t i = 0; i < HASP_NUM_GPIO_CONFIG; i++) { for(uint8_t i = 0; i < HASP_NUM_GPIO_CONFIG; i++) {
if(gpio_is_input(&gpioConfig[i])) { if(gpio_is_input(&gpioConfig[i])) {
gpioConfig[i].power = !gpioConfig[i].power; 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; 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) 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) void gpio_output_state(hasp_gpio_config_t* gpio)
{ {
char payload[32];
char topic[12]; char topic[12];
snprintf_P(topic, sizeof(topic), PSTR("output%d"), gpio->pin); 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) 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; return false;
} }
if(gpio->max == 1) { // it's a relay if(gpio->max == 1) { // it's a relay
gpio->val = gpio->power; // val and power are equal val = power; // val and power are equal
} }
if(gpio->group) { 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 { // http://plate01/config/gpio/options
if(!httpIsAuthenticated(F("config/gpio/options"))) return; if(!httpIsAuthenticated(F("config/gpio/options"))) return;
@ -1673,9 +1673,7 @@ void webHandleGpioOptions()
httpMessage += config_id; httpMessage += config_id;
httpMessage += F("'>"); httpMessage += F("'>");
httpMessage += F("<p><b>GPIO Options"); httpMessage += F("<p><b>GPIO Output</b></p>");
httpMessage += config_id;
httpMessage += F(" Options</b></p>");
httpMessage += F("<p><b>" D_GPIO_PIN "</b> <select id='pin' name='pin'>"); httpMessage += F("<p><b>" D_GPIO_PIN "</b> <select id='pin' name='pin'>");
hasp_gpio_config_t conf = gpioGetPinConfig(config_id); hasp_gpio_config_t conf = gpioGetPinConfig(config_id);
@ -1782,9 +1780,7 @@ void webHandleGpioInput()
httpMessage += config_id; httpMessage += config_id;
httpMessage += F("'>"); httpMessage += F("'>");
httpMessage += F("<p><b>GPIO Options"); httpMessage += F("<p><b>GPIO Input</b></p>");
httpMessage += config_id;
httpMessage += F(" Options</b></p>");
httpMessage += F("<p><b>" D_GPIO_PIN "</b> <select id='pin' name='pin'>"); httpMessage += F("<p><b>" D_GPIO_PIN "</b> <select id='pin' name='pin'>");
hasp_gpio_config_t conf = gpioGetPinConfig(config_id); hasp_gpio_config_t conf = gpioGetPinConfig(config_id);
@ -2343,7 +2339,7 @@ void httpSetup()
#endif #endif
#if HASP_USE_GPIO > 0 #if HASP_USE_GPIO > 0
webServer.on(F("/config/gpio"), webHandleGpioConfig); 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); webServer.on(F("/config/gpio/input"), webHandleGpioInput);
#endif #endif
webServer.on(F("/saveConfig"), webHandleSaveConfig); webServer.on(F("/saveConfig"), webHandleSaveConfig);

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

@ -318,7 +318,7 @@ IRAM_ATTR void telnetLoop()
if(telnetConsole) { if(telnetConsole) {
while(telnetConsole->readKey()) { while(telnetConsole->readKey()) {
if(!telnetConsole) return; // the telnetConsole was destroyed 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 { } else {