add volcano auto connect

include/config.h

 #define MENU_PREFER_VOLCANO
 //#define MENU_PREFER_CRAFTY
 
+#ifdef MENU_PREFER_VOLCANO
+#define VOLCANO_AUTO_CONNECT_TIMEOUT_MS 2000
+#endif // MENU_PREFER_VOLCANO
+
 #ifdef NDEBUG
 // Release build
 #define AUTO_MOUNT_MASS_STORAGE

include/mem.h

 
 struct mem_data {
     uint16_t backlight;
+
     uint16_t wf_count;
     struct workflow wf[WF_MAX_FLOWS];
 } __attribute__((packed));
 
-
 // wf and wf_count are assigned in mem_init()
 #define MEM_DATA_INIT {           \
     .backlight = (0xFF00 >> 1),   \
 void mem_init(void);
 void mem_write(void);
 struct mem_data *mem_data(void);
+void mem_load_defaults(void);
 
 #endif // __MEM_H__

include/menu.h

     int off;
     int selection;
     int length;
-    char *buff;
+    char buff[MENU_MAX_LEN];
 };
 
 void menu_init(void (*enter)(int),
 
 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
+
 #endif // __MENU_H__

src/buttons.c

 #include "pico/stdlib.h"
 
 #include "config.h"
+#include "log.h"
 #include "buttons.h"
 
 static const uint gpio_num[NUM_BTNS] = {
         if ((now - buttons[i].last_time) > DEBOUNCE_DELAY_MS) {
             if (state != buttons[i].current_state) {
                 buttons[i].current_state = state;
+                debug("btn %d now %s", i, state ? "pressed" : "released");
                 if (callback) {
                     callback(i, state);
                 }

src/console.c

 #include "main.h"
 #include "models.h"
 #include "workflow.h"
-#include "console.h"
 #include "crafty.h"
+#include "mem.h"
+#include "console.h"
 
 #define CNSL_BUFF_SIZE 64
 #define CNSL_REPEAT_MS 500
         println("   help - print this message");
         println("  mount - make mass storage medium (un)available");
         println("  power - show Lipo battery status");
+        println("   memr - reset flash memory config");
         println("");
         println("   scan - start or stop BLE scan");
         println("scanres - print list of found BLE devices");
         println("Battery: %.2fV = %.1f%% @ %s",
                 volt, lipo_percentage(volt),
                 lipo_charging() ? "charging" : "draining");
+    } else if (strcmp(line, "memr") == 0) {
+        mem_load_defaults();
+        mem_write();
     } else if (strcmp(line, "scan") == 0) {
         ble_scan(BLE_SCAN_TOGGLE);
     } else if (strcmp(line, "scanres") == 0) {

src/log.c

 static uint8_t log_buff[4096] = {0};
 static struct ring_buffer log = RB_INIT(log_buff, sizeof(log_buff));
 
-static uint8_t line_buff[128] = {0};
+static uint8_t line_buff[256] = {0};
 static volatile bool got_input = false;
 static FIL log_file_fat;
 

src/mem.c

     return ~c;
 }
 
-void mem_init(void) {
+void mem_load_defaults(void) {
     data_ram.data.wf_count = wf_default_count;
+    debug("preparing %d default workflows", data_ram.data.wf_count);
     for (uint16_t i = 0; i < wf_default_count; i++) {
         data_ram.data.wf[i] = wf_default_data[i];
+        debug("\"%s\" by \"%s\"", data_ram.data.wf[i].name, data_ram.data.wf[i].author);
     }
+}
+
+void mem_init(void) {
+    mem_load_defaults();
 
     if (!flash_safe_execute_core_init()) {
         debug("error calling flash_safe_execute_core_init");
         if (checksum != flash_ptr->checksum) {
             debug("invalid checksum (0x%08lX != 0x%08lX)", flash_ptr->checksum, checksum);
         } else {
+            debug("loading from flash (0x%08lX)", checksum);
             data_ram = *flash_ptr;
         }
     } else {
         debug("invalid config (0x%02X != 0x%02X)", flash_ptr->version, MEM_VERSION);
     }
+
+    debug("found %d workflows", data_ram.data.wf_count);
+    for (uint16_t i = 0; i < data_ram.data.wf_count; i++) {
+        debug("\"%s\" by \"%s\"", data_ram.data.wf[i].name, data_ram.data.wf[i].author);
+    }
 }
 
 static void mem_write_flash(void *param) {
 
     data_ram.checksum = calc_checksum(&data_ram);
 
-    debug("writing new data");
+    debug("writing new data (0x%08lX)", data_ram.checksum);
     int r = flash_safe_execute(mem_write_flash, &data_ram, FLASH_LOCK_TIMEOUT_MS);
     if (r != PICO_OK) {
         debug("error calling mem_write_flash: %d", r);

src/menu.c

 #include "menu.h"
 
 static char prev_buff[MENU_MAX_LEN] = {0};
-static char buff[MENU_MAX_LEN] = {0};
-static struct menu_state menu = { .off = 0, .selection = -1, .length = 0, .buff = buff };
+static struct menu_state menu = { .off = 0, .selection = -1, .length = 0, .buff = {0} };
 static void (*enter_callback)(int) = NULL;
 static void (*up_callback)(int) = NULL;
 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) {
         draw(&menu);
     }
 
-    if (strncmp(buff, prev_buff, MENU_MAX_LEN) != 0) {
-        strncpy(prev_buff, buff, MENU_MAX_LEN);
-        text_box(buff, centered);
+    if (strncmp(menu.buff, prev_buff, MENU_MAX_LEN) != 0) {
+        strncpy(prev_buff, menu.buff, MENU_MAX_LEN);
+        text_box(menu.buff, centered);
     }
 }

src/state_scan.c

 #include <stdio.h>
 #include <string.h>
 
+#include "pico/stdlib.h"
+
 #include "config.h"
 #include "ble.h"
 #include "models.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;
     for (int i = 0; i < result_count; i++) {
 #ifdef MENU_PREFER_VOLCANO
             if (dev == DEV_VOLCANO) {
                 menu->selection = devs - 1;
+#ifdef VOLCANO_AUTO_CONNECT_TIMEOUT_MS
+                auto_connect_time = to_ms_since_boot(get_absolute_time());
+                auto_connect_idx = i;
+#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) {
-            pos += snprintf(menu->buff + pos, MENU_MAX_LEN - pos, "> ");
+#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;
+                pos += snprintf(menu->buff + pos, MENU_MAX_LEN - pos,
+                                "%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) {
+            state_volcano_run_target(results[auto_connect_idx].addr,
+                                     results[auto_connect_idx].type);
+            state_volcano_wf_edit(false);
+            state_switch(STATE_VOLCANO_WORKFLOW);
+
+            auto_connect_time = 0;
+        }
+    }
+#endif // VOLCANO_AUTO_CONNECT_TIMEOUT_MS
 }

src/state_volcano_run.c

 }
 
 void state_volcano_run_target(bd_addr_t addr, bd_addr_type_t type) {
+    debug("%s %d", bd_addr_to_str(addr), type);
     memcpy(ble_addr, addr, sizeof(bd_addr_t));
     ble_type = type;
 }

src/state_volcano_workflow.c

 #include <stdio.h>
 #include <string.h>
 
+#include "pico/stdlib.h"
+
 #include "config.h"
 #include "menu.h"
 #include "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())) {
         if (edit_mode) {
     } else {
         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
 }
 
 void state_volcano_wf_exit(void) {
         }
 
         if (i == menu->selection) {
-            pos += snprintf(menu->buff + pos, MENU_MAX_LEN - pos, "> ");
+#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;
+                pos += snprintf(menu->buff + pos, MENU_MAX_LEN - pos,
+                                "%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_volcano_wf_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) {
+            state_volcano_run_index(0);
+            state_switch(STATE_VOLCANO_RUN);
+
+            auto_connect_time = 0;
+            menu_got_input = true;
+        }
+    }
+#endif // VOLCANO_AUTO_CONNECT_TIMEOUT_MS
 }

src/text.c

         return;
     }
 
+    debug("searching for \"%s\"", tf->fontname);
+
     const struct mf_font_s *font = mf_find_font(tf->fontname);
     if (!font) {
         debug("No such font: %s", tf->fontname);