add simple volcano_run state

CMakeLists.txt

     src/workflow.c
     src/menu.c
     src/state_volcano_workflow.c
+    src/state_volcano_run.c
 
     ${CMAKE_CURRENT_BINARY_DIR}/fatfs/ff.c
     ${CMAKE_CURRENT_BINARY_DIR}/fatfs/ffunicode.c

include/menu.h

 };
 
 void menu_init(void (*cb)(int));
+void menu_deinit(void);
+
 void menu_run(void (*cb)(struct menu_state *));
 
 #endif // __MENU_H__

include/state.h

     STATE_INIT = 0,
     STATE_SCAN,
     STATE_VOLCANO_WORKFLOW,
+    STATE_VOLCANO_RUN,
 };
 
 void state_switch(enum system_state next);

include/state_volcano_run.h

+/*
+ * state_volcano_run.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_VOLCANO_RUN_H__
+#define __STATE_VOLCANO_RUN_H__
+
+#include <ble.h>
+
+void state_volcano_run_index(uint16_t index);
+void state_volcano_run_target(bd_addr_t addr, bd_addr_type_t type);
+
+void state_volcano_run_enter(void);
+void state_volcano_run_exit(void);
+void state_volcano_run_run(void);
+
+#endif // __STATE_VOLCANO_RUN_H__

include/workflow.h

 struct wf_state wf_status(void);
 void wf_start(uint16_t index);
 
+void wf_reset(void);
 void wf_run(void);
 
 #endif // __WORKFLOW_H__

src/menu.c

     buttons_callback(menu_buttons);
 }
 
+void menu_deinit(void) {
+    buttons_callback(NULL);
+}
+
 void menu_run(void (*draw)(struct menu_state *)) {
     if (draw) {
         draw(&menu);

src/state.c

 #include "log.h"
 #include "state_scan.h"
 #include "state_volcano_workflow.h"
+#include "state_volcano_run.h"
 #include "state.h"
 
 static enum system_state state = STATE_INIT;
         state_volcano_wf_exit();
         break;
 
+    case STATE_VOLCANO_RUN:
+        debug("leaving STATE_VOLCANO_RUN");
+        state_volcano_run_exit();
+        break;
+
     default:
         break;
     }
         state_volcano_wf_enter();
         break;
 
+    case STATE_VOLCANO_RUN:
+        debug("entering STATE_VOLCANO_RUN");
+        state_volcano_run_enter();
+        break;
+
     default:
         break;
     }
         state_volcano_wf_run();
         break;
 
+    case STATE_VOLCANO_RUN:
+        state_volcano_run_run();
+        break;
+
     default:
         debug("invalid main state %d", state);
         state_switch(STATE_SCAN);

src/state_scan.c

 #include "models.h"
 #include "menu.h"
 #include "state.h"
+#include "state_volcano_run.h"
 #include "state_scan.h"
 
 static struct ble_scan_result results[BLE_MAX_SCAN_RESULTS] = {0};
 
         if (devs++ == selection) {
             if (dev == DEV_VOLCANO) {
+                state_volcano_run_target(results[i].addr, results[i].type);
                 state_switch(STATE_VOLCANO_WORKFLOW);
             }
             return;
 }
 
 void state_scan_exit(void) {
+    menu_deinit();
     ble_scan(BLE_SCAN_OFF);
 }
 

src/state_volcano_run.c

+/*
+ * state_volcano_run.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 <string.h>
+
+#include "config.h"
+#include "workflow.h"
+#include "state.h"
+#include "state_volcano_run.h"
+
+#include "menu.h"
+
+static uint16_t wf_index;
+static bd_addr_t ble_addr;
+static bd_addr_type_t ble_type;
+static bool wait_for_connect = false;
+
+void state_volcano_run_index(uint16_t index) {
+    wf_index = index;
+}
+
+void state_volcano_run_target(bd_addr_t addr, bd_addr_type_t type) {
+    memcpy(ble_addr, addr, sizeof(bd_addr_t));
+    ble_type = type;
+}
+
+void state_volcano_run_enter(void) {
+    ble_connect(ble_addr, ble_type);
+    wait_for_connect = true;
+}
+
+void state_volcano_run_exit(void) {
+    wf_reset();
+    ble_disconnect();
+}
+
+static void draw(struct menu_state *menu) {
+    struct wf_state state = wf_status();
+    snprintf(menu->buff, MENU_MAX_LEN, "%d / %d", state.step, state.count);
+}
+
+void state_volcano_run_run(void) {
+    if (wait_for_connect && ble_is_connected()) {
+        wait_for_connect = false;
+        wf_start(wf_index);
+    }
+
+    menu_run(draw);
+
+    struct wf_state state = wf_status();
+    if (state.status == WF_IDLE) {
+        state_switch(STATE_SCAN);
+    }
+}

src/state_volcano_workflow.c

 #include "config.h"
 #include "menu.h"
 #include "workflow.h"
+#include "state.h"
+#include "state_volcano_run.h"
 #include "state_volcano_workflow.h"
 
 static void enter_cb(int selection) {
-    (void)(selection); // TODO
+    if ((selection >= 0) && (selection < wf_count())) {
+        state_volcano_run_index(selection);
+        state_switch(STATE_VOLCANO_RUN);
+    }
 }
 
 void state_volcano_wf_enter(void) {
 }
 
 void state_volcano_wf_exit(void) {
-    // nothing to do
+    menu_deinit();
 }
 
 static void draw(struct menu_state *menu) {

src/workflow.c

     do_step();
 }
 
+void wf_reset(void) {
+    status = WF_IDLE;
+}
+
 void wf_run(void) {
     if (status == WF_IDLE) {
         return;