can edit settings now

CMakeLists.txt

     src/workflow_default.c
     src/state_settings.c
     src/state_about.c
+    src/state_value.c
 
     ${CMAKE_CURRENT_BINARY_DIR}/fatfs/ff.c
     ${CMAKE_CURRENT_BINARY_DIR}/fatfs/ffunicode.c

include/config.h

 #define MENU_PREFER_VOLCANO
 //#define MENU_PREFER_CRAFTY
 
+#define VOLCANO_AUTO_CONNECT_TIMEOUT_MS 2000
+#define VOLCANO_AUTO_CONNECT_WITHIN_MS 10000
+
 #ifdef NDEBUG
 // Release build
-
 #define AUTO_MOUNT_MASS_STORAGE
 #define AUTO_LOG_ON_MASS_STORAGE
 #define DEBUG_DISK_WRITE_SOURCES
-
-#ifdef MENU_PREFER_VOLCANO
-#define VOLCANO_AUTO_CONNECT_TIMEOUT_MS 2000
-#define VOLCANO_AUTO_CONNECT_WITHIN_MS 10000
-#endif // MENU_PREFER_VOLCANO
-
 #endif // NDEBUG
 
 #define WATCHDOG_PERIOD_MS 1000

include/menu.h

 
 void menu_run(void (*cb)(struct menu_state *), bool centered);
 
-#ifdef VOLCANO_AUTO_CONNECT_TIMEOUT_MS
 extern bool menu_got_input;
-#endif // VOLCANO_AUTO_CONNECT_TIMEOUT_MS
 
 #define ADD_STATIC_ELEMENT(name) {\
     menu->length += 1; \

include/state.h

     STATE_EDIT_WORKFLOW,
     STATE_SETTINGS,
     STATE_ABOUT,
+    STATE_VALUE,
 
     STATE_INVALID,
 };

include/state_value.h

+/*
+ * state_value.h
+ *
+ * Copyright (c) 2023 Thomas Buck (thomas@xythobuz.de)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * See <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __STATE_VALUE_H__
+#define __STATE_VALUE_H__
+
+#include <sys/types.h>
+#include "state.h"
+
+enum value_step_mode {
+    VAL_STEP_INCREMENT = 0,
+    VAL_STEP_SHIFT,
+};
+
+void state_value_set(void *value, size_t length,
+                     ssize_t min, ssize_t max,
+                     enum value_step_mode mode, ssize_t step);
+void state_value_return(enum system_state state);
+
+void state_value_enter(void);
+void state_value_exit(void);
+void state_value_run(void);
+
+#endif // __STATE_VALUE_H__

include/text.h

 #define __TEXT_H__
 
 #include "mcufont.h"
+#include "menu.h"
 
 #define TEXT_BG_NONE -1
+#define TEXT_BOX_HEIGHT(font, space) ((MENU_MAX_LINES * font) + ((MENU_MAX_LINES - 1) * space))
 
 struct text_font {
     const char *fontname;

src/main.c

     usb_run();
     serial_run();
     heartbeat_run();
+
+    if (lcd_get_backlight() != mem_data()->backlight) {
+        lcd_set_backlight(mem_data()->backlight);
+    }
 }
 
 int main(void) {

src/menu.c

 #include "buttons.h"
 #include "text.h"
 #include "lcd.h"
-#include "mem.h"
 #include "menu.h"
 
 static char prev_buff[MENU_MAX_LEN] = {0};
 static void (*down_callback)(int) = NULL;
 static void (*exit_callback)(void) = NULL;
 
-#ifdef VOLCANO_AUTO_CONNECT_TIMEOUT_MS
 bool menu_got_input = false;
-#endif // VOLCANO_AUTO_CONNECT_TIMEOUT_MS
 
 static void menu_buttons(enum buttons btn, bool state) {
-#ifdef VOLCANO_AUTO_CONNECT_TIMEOUT_MS
     menu_got_input = true;
-#endif // VOLCANO_AUTO_CONNECT_TIMEOUT_MS
 
-    if (state && (btn == BTN_LEFT)) {
-        uint16_t backlight_value = lcd_get_backlight();
-        if (backlight_value > 0x00FF) {
-            backlight_value = backlight_value >> 1;
-        }
-        lcd_set_backlight(backlight_value);
-        mem_data()->backlight = backlight_value;
-        return;
-    } else if (state && (btn == BTN_RIGHT)) {
-        uint16_t backlight_value = lcd_get_backlight();
-        if (backlight_value < 0xFF00) {
-            backlight_value = backlight_value << 1;
-        }
-        lcd_set_backlight(backlight_value);
-        mem_data()->backlight = backlight_value;
-        return;
-    } else if (state && ((btn == BTN_ENTER) || (btn == BTN_A))) {
+    if (state && ((btn == BTN_ENTER) || (btn == BTN_A))) {
         if (enter_callback) {
             enter_callback(menu.selection);
         }
 
 void menu_deinit(void) {
     buttons_callback(NULL);
-    mem_write();
 }
 
 void menu_run(void (*draw)(struct menu_state *), bool centered) {
         text_box(menu.buff, centered,
                  "fixed_10x20",
                  0, LCD_WIDTH,
-                 50, (MENU_MAX_LINES * 20) + ((MENU_MAX_LINES - 1) * 2),
+                 50, TEXT_BOX_HEIGHT(20, 2),
                  0);
     }
 }

src/state.c

 #include "state_edit_workflow.h"
 #include "state_settings.h"
 #include "state_about.h"
+#include "state_value.h"
 #include "state.h"
 
 #define stringify(name) # name
         .exit = state_about_exit,
         .run = state_about_run,
     }, {
+        .name = stringify(STATE_VALUE),
+        .enter = state_value_enter,
+        .exit = state_value_exit,
+        .run = state_value_run,
+    }, {
         .name = stringify(STATE_INVALID),
         .enter = NULL,
         .exit = NULL,

src/state_about.c

 ;
 
 static const uint16_t step_size = 10;
-static const uint16_t max_height = (MENU_MAX_LINES * 20) + ((MENU_MAX_LINES - 1) * 2);
+static const uint16_t max_height = TEXT_BOX_HEIGHT(20, 2);
 
 static uint16_t off = 0;
 static bool held_up = false;

src/state_scan.c

 #include "config.h"
 #include "ble.h"
 #include "models.h"
+#include "mem.h"
 #include "menu.h"
 #include "state.h"
 #include "state_workflow.h"
 
 static struct ble_scan_result results[BLE_MAX_SCAN_RESULTS] = {0};
 static int result_count = 0;
-
-#ifdef VOLCANO_AUTO_CONNECT_TIMEOUT_MS
 static uint32_t auto_connect_time = 0;
 static int auto_connect_idx = 0;
-#endif // VOLCANO_AUTO_CONNECT_TIMEOUT_MS
 
 static void enter_cb(int selection) {
     int devs = 0;
     }
 }
 
-static void edit_cb(int selection) {
-    UNUSED(selection);
-
-    state_wf_edit(true);
-    state_switch(STATE_WORKFLOW);
-}
-
 void state_scan_enter(void) {
-    menu_init(enter_cb, edit_cb, NULL, NULL);
+    menu_init(enter_cb, NULL, NULL, NULL);
     ble_scan(BLE_SCAN_ON);
 }
 
             if (dev == DEV_VOLCANO) {
                 menu->selection = devs - 1;
 
-#ifdef VOLCANO_AUTO_CONNECT_TIMEOUT_MS
-#ifdef VOLCANO_AUTO_CONNECT_WITHIN_MS
                 if (to_ms_since_boot(get_absolute_time()) <= VOLCANO_AUTO_CONNECT_WITHIN_MS) {
-#endif // VOLCANO_AUTO_CONNECT_WITHIN_MS
-                    auto_connect_time = to_ms_since_boot(get_absolute_time());
-                    auto_connect_idx = i;
-#ifdef VOLCANO_AUTO_CONNECT_WITHIN_MS
+                    if (mem_data()->wf_auto_connect) {
+                        auto_connect_time = to_ms_since_boot(get_absolute_time());
+                        auto_connect_idx = i;
+                    }
                 }
-#endif // VOLCANO_AUTO_CONNECT_WITHIN_MS
-#endif // VOLCANO_AUTO_CONNECT_TIMEOUT_MS
             }
 #endif // MENU_PREFER_VOLCANO
 #ifdef MENU_PREFER_CRAFTY
 #endif // defined(MENU_PREFER_VOLCANO) || defined(MENU_PREFER_CRAFTY)
 
         if ((devs - 1) == menu->selection) {
-#ifdef VOLCANO_AUTO_CONNECT_TIMEOUT_MS
             if ((auto_connect_time != 0) && (!menu_got_input)) {
                 uint32_t now = to_ms_since_boot(get_absolute_time());
                 uint32_t diff = now - auto_connect_time;
                                 "%ld ",
                                 (VOLCANO_AUTO_CONNECT_TIMEOUT_MS / 1000) - (diff / 1000));
             } else {
-#endif // VOLCANO_AUTO_CONNECT_TIMEOUT_MS
                 pos += snprintf(menu->buff + pos, MENU_MAX_LEN - pos, "> ");
-#ifdef VOLCANO_AUTO_CONNECT_TIMEOUT_MS
             }
-#endif // VOLCANO_AUTO_CONNECT_TIMEOUT_MS
         } else {
             pos += snprintf(menu->buff + pos, MENU_MAX_LEN - pos, "  ");
         }
 void state_scan_run(void) {
     menu_run(draw, false);
 
-#ifdef VOLCANO_AUTO_CONNECT_TIMEOUT_MS
     if ((auto_connect_time != 0) && (!menu_got_input)) {
         uint32_t now = to_ms_since_boot(get_absolute_time());
         if ((now - auto_connect_time) >= VOLCANO_AUTO_CONNECT_TIMEOUT_MS) {
             auto_connect_time = 0;
         }
     }
-#endif // VOLCANO_AUTO_CONNECT_TIMEOUT_MS
 }

src/state_settings.c

 #include "menu.h"
 #include "mem.h"
 #include "state.h"
+#include "state_value.h"
+#include "state_workflow.h"
 #include "state_settings.h"
 
 static void enter_cb(int selection) {
     switch (selection) {
     case 0:
         // Auto Connect
+        state_value_set(&mem_data()->wf_auto_connect,
+                        sizeof(mem_data()->wf_auto_connect),
+                        0, 1, VAL_STEP_INCREMENT, 1);
+        state_value_return(STATE_SETTINGS);
+        state_switch(STATE_VALUE);
         break;
 
     case 1:
         // Brightness
+        state_value_set(&mem_data()->backlight,
+                        sizeof(mem_data()->backlight),
+                        0x00FF, 0xFF00, VAL_STEP_SHIFT, 1);
+        state_value_return(STATE_SETTINGS);
+        state_switch(STATE_VALUE);
         break;
 
     case 2:
         // Workflows
+        state_wf_edit(true);
+        state_switch(STATE_WORKFLOW);
         break;
 
     case 3:
 
 void state_settings_exit(void) {
     menu_deinit();
+    mem_write();
 }
 
 static void draw(struct menu_state *menu) {

src/state_value.c

+/*
+ * state_value.c
+ *
+ * Copyright (c) 2023 Thomas Buck (thomas@xythobuz.de)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * See <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+
+#include "config.h"
+#include "buttons.h"
+#include "log.h"
+#include "lcd.h"
+#include "text.h"
+#include "state_value.h"
+
+static void *val_p = NULL;
+static size_t val_len = 0;
+static ssize_t val_min = 0;
+static ssize_t val_max = 0;
+static ssize_t val_step = 0;
+
+static enum value_step_mode val_mode = VAL_STEP_INCREMENT;
+static enum system_state val_ret_state = STATE_SCAN;
+
+static ssize_t val = 0;
+
+void state_value_set(void *value, size_t length,
+                     ssize_t min, ssize_t max,
+                     enum value_step_mode mode, ssize_t step) {
+    val_p = value;
+    val_len = length;
+    val_min = min;
+    val_max = max;
+    val_mode = mode;
+    val_step = step;
+}
+
+void state_value_return(enum system_state state) {
+    val_ret_state = state;
+}
+
+static void draw(void) {
+    static char buff[100];
+    static size_t pos = 0;
+
+    if ((val_p == NULL) || (val_len <= 0)) {
+        pos += snprintf(buff, sizeof(buff),
+                        "error");
+    } else {
+        pos += snprintf(buff, sizeof(buff),
+                        "%d", val);
+    }
+
+    text_box(buff, false,
+             "fixed_10x20",
+             0, LCD_WIDTH,
+             50, TEXT_BOX_HEIGHT(20, 2),
+             0);
+}
+
+static void write(void) {
+    if ((val_p == NULL) || (val_len <= 0)) {
+        debug("invalid params");
+        return;
+    }
+
+    switch (val_len) {
+    case 1:
+        *((uint8_t *)val_p) = val;
+        break;
+
+    case 2:
+        *((uint16_t *)val_p) = val;
+        break;
+
+    case 4:
+        *((uint32_t *)val_p) = val;
+        break;
+
+    default:
+        debug("invalid len %d", val_len);
+        return;
+    }
+}
+
+static void step(ssize_t v) {
+    if ((val_p == NULL) || (val_len <= 0)) {
+        debug("invalid params");
+        return;
+    }
+
+    if (((v > 0) && (val >= val_max))
+        || ((v < 0) && (val <= val_min))) {
+        debug("val=%d v=%d", val, v);
+        return;
+    }
+
+    switch (val_mode) {
+    case VAL_STEP_INCREMENT:
+        val += v * val_step;
+        break;
+
+    case VAL_STEP_SHIFT:
+        if ((val_step * v) > 0) {
+            val <<= val_step;
+        } else {
+            val >>= val_step;
+        }
+        break;
+    }
+
+    // apply new value while editing
+    write();
+}
+
+static void value_buttons(enum buttons btn, bool state) {
+    if (state && (btn == BTN_Y)) {
+        state_switch(val_ret_state);
+    } else if (state && (btn == BTN_LEFT)) {
+        step(-1);
+        draw();
+    } else if (state && (btn == BTN_RIGHT)) {
+        step(1);
+        draw();
+    }
+}
+
+void state_value_enter(void) {
+    buttons_callback(value_buttons);
+
+    switch (val_len) {
+    case 1:
+        val = *((uint8_t *)val_p);
+        break;
+
+    case 2:
+        val = *((uint16_t *)val_p);
+        break;
+
+    case 4:
+        val = *((uint32_t *)val_p);
+        break;
+
+    default:
+        debug("invalid len %d", val_len);
+        return;
+    }
+
+    draw();
+}
+
+void state_value_exit(void) {
+    buttons_callback(NULL);
+    write();
+}
+
+void state_value_run(void) { }

src/state_workflow.c

 #include "pico/stdlib.h"
 
 #include "config.h"
+#include "mem.h"
 #include "menu.h"
 #include "workflow.h"
 #include "state.h"
 #include "state_workflow.h"
 
 static bool edit_mode = false;
-
-#ifdef VOLCANO_AUTO_CONNECT_TIMEOUT_MS
 static uint32_t auto_connect_time = 0;
-#endif // VOLCANO_AUTO_CONNECT_TIMEOUT_MS
 
 static void enter_cb(int selection) {
     if ((selection >= 0) && (selection < wf_count())) {
 }
 
 static void exit_cb(void) {
-    state_switch(STATE_SCAN);
+    if (edit_mode) {
+        state_switch(STATE_SETTINGS);
+    } else {
+        state_switch(STATE_SCAN);
+    }
 }
 
 void state_wf_edit(bool edit) {
         menu_init(enter_cb, NULL, NULL, exit_cb);
     }
 
-#ifdef VOLCANO_AUTO_CONNECT_TIMEOUT_MS
-    auto_connect_time = to_ms_since_boot(get_absolute_time());
-#endif // VOLCANO_AUTO_CONNECT_TIMEOUT_MS
+    if (mem_data()->wf_auto_connect) {
+        auto_connect_time = to_ms_since_boot(get_absolute_time());
+    }
 }
 
 void state_wf_exit(void) {
         }
 
         if (i == menu->selection) {
-#ifdef VOLCANO_AUTO_CONNECT_TIMEOUT_MS
             if ((auto_connect_time != 0) && (!menu_got_input) && (!edit_mode)) {
                 uint32_t now = to_ms_since_boot(get_absolute_time());
                 uint32_t diff = now - auto_connect_time;
                                 "%ld ",
                                 (VOLCANO_AUTO_CONNECT_TIMEOUT_MS / 1000) - (diff / 1000));
             } else {
-#endif // VOLCANO_AUTO_CONNECT_TIMEOUT_MS
                 pos += snprintf(menu->buff + pos, MENU_MAX_LEN - pos, "> ");
-#ifdef VOLCANO_AUTO_CONNECT_TIMEOUT_MS
             }
-#endif // VOLCANO_AUTO_CONNECT_TIMEOUT_MS
         } else {
             pos += snprintf(menu->buff + pos, MENU_MAX_LEN - pos, "  ");
         }
 void state_wf_run(void) {
     menu_run(draw, false);
 
-#ifdef VOLCANO_AUTO_CONNECT_TIMEOUT_MS
     if ((auto_connect_time != 0) && (!menu_got_input) && (!edit_mode)) {
         uint32_t now = to_ms_since_boot(get_absolute_time());
         if ((now - auto_connect_time) >= VOLCANO_AUTO_CONNECT_TIMEOUT_MS) {
             menu_got_input = true;
         }
     }
-#endif // VOLCANO_AUTO_CONNECT_TIMEOUT_MS
 }