edit menu to reorder workflows and steps

CMakeLists.txt

     src/crafty.c
     src/state_crafty.c
     src/mem.c
+    src/state_edit_workflow.c
+    src/workflow_default.c
 
     ${CMAKE_CURRENT_BINARY_DIR}/fatfs/ff.c
     ${CMAKE_CURRENT_BINARY_DIR}/fatfs/ffunicode.c

include/mem.h

 #define __MEM_H__
 
 #include <stdint.h>
+#include "workflow.h"
 
-#define MEM_VERSION 0x01
+#define MEM_VERSION 0x02
 
 struct mem_data {
     uint16_t backlight;
+    uint16_t wf_count;
+    struct workflow wf[WF_MAX_FLOWS];
 } __attribute__((packed));
 
-#define MEM_DATA_INIT {         \
-    .backlight = (0xFF00 >> 1), \
+
+// wf and wf_count are assigned in mem_init()
+#define MEM_DATA_INIT {           \
+    .backlight = (0xFF00 >> 1),   \
 }
 
 void mem_init(void);

include/menu.h

     char *buff;
 };
 
-void menu_init(void (*enter)(int), void (*exit)(void));
+void menu_init(void (*enter)(int),
+               void (*up)(int),
+               void (*down)(int),
+               void (*exit)(void));
 void menu_deinit(void);
 
 void menu_run(void (*cb)(struct menu_state *), bool centered);

include/state.h

     STATE_VOLCANO_WORKFLOW,
     STATE_VOLCANO_RUN,
     STATE_CRAFTY,
+    STATE_EDIT_WORKFLOW,
 
     STATE_INVALID,
 };

include/state_edit_workflow.h

+/*
+ * state_edit_workflow.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_EDIT_WORKFLOW_H__
+#define __STATE_EDIT_WORKFLOW_H__
+
+#include <stdint.h>
+
+void state_edit_wf_index(uint16_t index);
+
+void state_edit_wf_enter(void);
+void state_edit_wf_exit(void);
+void state_edit_wf_run(void);
+
+#endif // __STATE_EDIT_WORKFLOW_H__

include/state_volcano_workflow.h

 #ifndef __STATE_VOLCANO_WORKFLOW_H__
 #define __STATE_VOLCANO_WORKFLOW_H__
 
+#include <stdbool.h>
+
+void state_volcano_wf_edit(bool edit);
+
 void state_volcano_wf_enter(void);
 void state_volcano_wf_exit(void);
 void state_volcano_wf_run(void);

include/workflow.h

 
 #include <stdint.h>
 
+#define WF_MAX_STEPS 42
+#define WF_MAX_FLOWS 6
+
 enum wf_op {
     OP_SET_TEMPERATURE = 0,
     OP_WAIT_TEMPERATURE,
     uint16_t val;
 };
 
+struct workflow {
+    const char *name;
+    const char *author;
+    struct wf_step steps[WF_MAX_STEPS];
+    uint16_t count;
+};
+
 enum wf_status {
     WF_IDLE = 0,
     WF_RUNNING,
 };
 
 uint16_t wf_count(void);
+
+void wf_move_down(uint16_t index);
+void wf_move_up(uint16_t index);
+
 const char *wf_name(uint16_t index);
 const char *wf_author(uint16_t index);
 
+uint16_t wf_steps(uint16_t index);
+
+void wf_move_step_down(uint16_t index, uint16_t step);
+void wf_move_step_up(uint16_t index, uint16_t step);
+
+struct wf_step wf_get_step(uint16_t index, uint16_t step);
+const char *wf_step_str(struct wf_step step);
+
 struct wf_state wf_status(void);
 void wf_start(uint16_t index);
 
 void wf_reset(void);
 void wf_run(void);
 
+extern const uint16_t wf_default_count;
+extern const struct workflow wf_default_data[];
+
 #endif // __WORKFLOW_H__

src/mem.c

 }
 
 void mem_init(void) {
+    data_ram.data.wf_count = wf_default_count;
+    for (uint16_t i = 0; i < wf_default_count; i++) {
+        data_ram.data.wf[i] = wf_default_data[i];
+    }
+
     if (!flash_safe_execute_core_init()) {
         debug("error calling flash_safe_execute_core_init");
     }

src/menu.c

 static char buff[MENU_MAX_LEN] = {0};
 static struct menu_state menu = { .off = 0, .selection = -1, .length = 0, .buff = buff };
 static void (*enter_callback)(int) = NULL;
+static void (*up_callback)(int) = NULL;
+static void (*down_callback)(int) = NULL;
 static void (*exit_callback)(void) = NULL;
 
 static void menu_buttons(enum buttons btn, bool state) {
             enter_callback(menu.selection);
         }
         return;
+    } else if (state && (btn == BTN_B)) {
+        if (up_callback) {
+            up_callback(menu.selection);
+        }
+        return;
+    } else if (state && (btn == BTN_X)) {
+        if (down_callback) {
+            down_callback(menu.selection);
+        }
+        return;
     } else if (state && (btn == BTN_Y)) {
         if (exit_callback) {
             exit_callback();
     }
 }
 
-void menu_init(void (*enter)(int), void (*exit)(void)) {
+void menu_init(void (*enter)(int),
+               void (*up)(int),
+               void (*down)(int),
+               void (*exit)(void)) {
     menu.off = 0;
     menu.selection = -1;
     menu.length = 0;
 
     enter_callback = enter;
+    up_callback = up;
+    down_callback = down;
     exit_callback = exit;
     buttons_callback(menu_buttons);
 }

src/state.c

 #include "state_volcano_workflow.h"
 #include "state_volcano_run.h"
 #include "state_crafty.h"
+#include "state_edit_workflow.h"
 #include "state.h"
 
 #define stringify(name) # name
         .exit = state_crafty_exit,
         .run = state_crafty_run,
     }, {
+        .name = stringify(STATE_EDIT_WORKFLOW),
+        .enter = state_edit_wf_enter,
+        .exit = state_edit_wf_exit,
+        .run = state_edit_wf_run,
+    }, {
         .name = stringify(STATE_INVALID),
         .enter = NULL,
         .exit = NULL,

src/state_edit_workflow.c

+/*
+ * state_edit_workflow.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 "menu.h"
+#include "workflow.h"
+#include "state.h"
+#include "state_edit_workflow.h"
+
+static uint16_t wf_index = 0;
+
+static void enter_cb(int selection) {
+    if ((selection >= 0) && (selection < wf_steps(wf_index))) {
+        // TODO edit value
+    }
+}
+
+static void lower_cb(int selection) {
+    if ((selection > 0) && (selection < wf_steps(wf_index))) {
+        wf_move_step_down(wf_index, selection);
+    }
+}
+
+static void upper_cb(int selection) {
+    if ((selection >= 0) && (selection < (wf_steps(wf_index) - 1))) {
+        wf_move_step_up(wf_index, selection);
+    }
+}
+
+static void exit_cb(void) {
+    state_switch(STATE_SCAN);
+}
+
+void state_edit_wf_index(uint16_t index) {
+    wf_index = index;
+}
+
+void state_edit_wf_enter(void) {
+    menu_init(enter_cb, lower_cb, upper_cb, exit_cb);
+}
+
+void state_edit_wf_exit(void) {
+    menu_deinit();
+}
+
+static void draw(struct menu_state *menu) {
+    menu->length = wf_steps(wf_index);
+
+    int pos = 0;
+    for (uint16_t i = 0; i < menu->length; i++) {
+        if ((i < menu->off)
+            || ((i - menu->off) >= MENU_MAX_LINES)) {
+            continue;
+        }
+
+        if (i == menu->selection) {
+            pos += snprintf(menu->buff + pos, MENU_MAX_LEN - pos, "> ");
+        } else {
+            pos += snprintf(menu->buff + pos, MENU_MAX_LEN - pos, "  ");
+        }
+
+        struct wf_step step = wf_get_step(wf_index, i);
+        pos += snprintf(menu->buff + pos, MENU_MAX_LEN - pos,
+                        "% 2d: %s\n", i, wf_step_str(step));
+    }
+
+    if (menu->selection < 0) {
+        menu->selection = 0;
+    }
+}
+
+void state_edit_wf_run(void) {
+    menu_run(draw, false);
+}

src/state_scan.c

 #include "models.h"
 #include "menu.h"
 #include "state.h"
+#include "state_volcano_workflow.h"
 #include "state_volcano_run.h"
 #include "state_crafty.h"
 #include "state_scan.h"
         if (devs++ == selection) {
             if (dev == DEV_VOLCANO) {
                 state_volcano_run_target(results[i].addr, results[i].type);
+                state_volcano_wf_edit(false);
                 state_switch(STATE_VOLCANO_WORKFLOW);
             } else if (dev == DEV_CRAFTY) {
                 state_crafty_target(results[i].addr, results[i].type);
     }
 }
 
+static void edit_cb(int selection) {
+    UNUSED(selection);
+
+    state_volcano_wf_edit(true);
+    state_switch(STATE_VOLCANO_WORKFLOW);
+}
+
 void state_scan_enter(void) {
-    menu_init(enter_cb, NULL);
+    menu_init(enter_cb, edit_cb, NULL, NULL);
     ble_scan(BLE_SCAN_ON);
 }
 

src/state_volcano_run.c

 }
 
 void state_volcano_run_enter(void) {
-    menu_init(NULL, NULL);
+    menu_init(NULL, NULL, NULL, NULL);
     buttons_callback(volcano_buttons);
 
     debug("workflow connect");
     switch (state.step.op) {
     case OP_SET_TEMPERATURE:
         pos += snprintf(menu->buff + pos, MENU_MAX_LEN - pos,
-                        "\nset temp %.1f C", state.step.val / 10.0f);
+                        "\n%s", wf_step_str(state.step));
         break;
 
     case OP_WAIT_TEMPERATURE:
         pos += snprintf(menu->buff + pos, MENU_MAX_LEN - pos,
-                        "wait temp %.1f C\n", state.step.val / 10.0f);
+                        "%s\n", wf_step_str(state.step));
         pos += snprintf(menu->buff + pos, MENU_MAX_LEN - pos,
                         "%.1f -> %.1f -> %.1f",
                         state.start_val / 10.0f,
     case OP_WAIT_TIME:
     case OP_PUMP_TIME:
         pos += snprintf(menu->buff + pos, MENU_MAX_LEN - pos,
-                        "%s time %.1f s\n",
-                        (state.step.op == OP_WAIT_TIME) ? "wait" : "pump",
-                        state.step.val / 1000.0f);
+                        "%s\n", wf_step_str(state.step));
         pos += snprintf(menu->buff + pos, MENU_MAX_LEN - pos,
                         "%.0f -> %.0f -> %.0f",
                         state.start_val / 1000.0f,

src/state_volcano_workflow.c

 #include "workflow.h"
 #include "state.h"
 #include "state_volcano_run.h"
+#include "state_edit_workflow.h"
 #include "state_volcano_workflow.h"
 
+static bool edit_mode = false;
+
 static void enter_cb(int selection) {
     if ((selection >= 0) && (selection < wf_count())) {
-        state_volcano_run_index(selection);
-        state_switch(STATE_VOLCANO_RUN);
+        if (edit_mode) {
+            state_edit_wf_index(selection);
+            state_switch(STATE_EDIT_WORKFLOW);
+        } else {
+            state_volcano_run_index(selection);
+            state_switch(STATE_VOLCANO_RUN);
+        }
+    }
+}
+
+static void lower_cb(int selection) {
+    if (!edit_mode) {
+        return;
+    }
+
+    if ((selection > 0) && (selection < wf_count())) {
+        wf_move_down(selection);
+    }
+}
+
+static void upper_cb(int selection) {
+    if (!edit_mode) {
+        return;
+    }
+
+    if ((selection >= 0) && (selection < (wf_count() - 1))) {
+        wf_move_up(selection);
     }
 }
 
     state_switch(STATE_SCAN);
 }
 
+void state_volcano_wf_edit(bool edit) {
+    edit_mode = edit;
+}
+
 void state_volcano_wf_enter(void) {
-    menu_init(enter_cb, exit_cb);
+    if (edit_mode) {
+        menu_init(enter_cb, lower_cb, upper_cb, exit_cb);
+    } else {
+        menu_init(enter_cb, NULL, NULL, exit_cb);
+    }
 }
 
 void state_volcano_wf_exit(void) {
             pos += snprintf(menu->buff + pos, MENU_MAX_LEN - pos, "  ");
         }
 
-        pos += snprintf(menu->buff + pos, MENU_MAX_LEN - pos, "'%s' by %s\n", wf_name(i), wf_author(i));
+        pos += snprintf(menu->buff + pos, MENU_MAX_LEN - pos,
+                        "'%s' by %s\n", wf_name(i), wf_author(i));
     }
 
     if ((menu->selection < 0) && (menu->length > 0)) {

src/workflow.c

  * See <http://www.gnu.org/licenses/>.
  */
 
+#include <stdio.h>
+
 #include "config.h"
 #include "log.h"
+#include "mem.h"
 #include "volcano.h"
 #include "workflow.h"
 
-#define WF_MAX_STEPS 42
-#define WF_MAX_FLOWS 6
-
-struct workflow {
-    const char *name;
-    const char *author;
-    struct wf_step steps[WF_MAX_STEPS];
-    uint16_t count;
-};
-
-#define NOTIFY \
-    { .op = OP_WAIT_TIME, .val = 1000 }, \
-    { .op = OP_PUMP_TIME, .val = 1000 }
-
-static const struct workflow wf[WF_MAX_FLOWS] = {
-    {
-        .name = "XXL",
-        .author = "xythobuz",
-        .steps = {
-            { .op = OP_WAIT_TEMPERATURE, .val = 1850 },
-            { .op = OP_WAIT_TIME, .val = 10000 },
-            { .op = OP_PUMP_TIME, .val = 8000 },
-
-            { .op = OP_WAIT_TEMPERATURE, .val = 1950 },
-            { .op = OP_WAIT_TIME, .val = 5000 },
-            { .op = OP_PUMP_TIME, .val = 25000 },
-
-            { .op = OP_WAIT_TEMPERATURE, .val = 2050 },
-            { .op = OP_WAIT_TIME, .val = 5000 },
-            { .op = OP_PUMP_TIME, .val = 25000 },
-
-            NOTIFY, NOTIFY, NOTIFY, NOTIFY,
-
-            { .op = OP_SET_TEMPERATURE, .val = 1900 },
-        },
-        .count = 18,
-    }, {
-        .name = "Default",
-        .author = "xythobuz",
-        .steps = {
-            { .op = OP_WAIT_TEMPERATURE, .val = 1850 },
-            { .op = OP_WAIT_TIME, .val = 10000 },
-            { .op = OP_PUMP_TIME, .val = 5000 },
-
-            { .op = OP_WAIT_TEMPERATURE, .val = 1950 },
-            { .op = OP_WAIT_TIME, .val = 5000 },
-            { .op = OP_PUMP_TIME, .val = 20000 },
-
-            { .op = OP_WAIT_TEMPERATURE, .val = 2050 },
-            { .op = OP_WAIT_TIME, .val = 5000 },
-            { .op = OP_PUMP_TIME, .val = 20000 },
-
-            NOTIFY, NOTIFY, NOTIFY, NOTIFY,
-
-            { .op = OP_SET_TEMPERATURE, .val = 1900 },
-        },
-        .count = 18,
-    }, {
-        .name = "Vorbi",
-        .author = "Rinor",
-        .steps = {
-            { .op = OP_WAIT_TEMPERATURE, .val = 1760 },
-            { .op = OP_WAIT_TIME, .val = 10000 },
-            { .op = OP_PUMP_TIME, .val = 6000 },
-
-            { .op = OP_WAIT_TEMPERATURE, .val = 1870 },
-            { .op = OP_WAIT_TIME, .val = 5000 },
-            { .op = OP_PUMP_TIME, .val = 10000 },
-
-            { .op = OP_WAIT_TEMPERATURE, .val = 2040 },
-            { .op = OP_WAIT_TIME, .val = 3000 },
-            { .op = OP_PUMP_TIME, .val = 10000 },
-
-            { .op = OP_WAIT_TEMPERATURE, .val = 2170 },
-            { .op = OP_WAIT_TIME, .val = 5000 },
-            { .op = OP_PUMP_TIME, .val = 10000 },
-        },
-        .count = 12,
-    }, {
-        .name = "Relaxo",
-        .author = "xythobuz",
-        .steps = {
-            { .op = OP_WAIT_TEMPERATURE, .val = 1750 },
-            { .op = OP_WAIT_TIME, .val = 10000 },
-            { .op = OP_PUMP_TIME, .val = 5000 },
-
-            { .op = OP_WAIT_TEMPERATURE, .val = 1850 },
-            { .op = OP_WAIT_TIME, .val = 5000 },
-            { .op = OP_PUMP_TIME, .val = 20000 },
-
-            { .op = OP_WAIT_TEMPERATURE, .val = 1950 },
-            { .op = OP_WAIT_TIME, .val = 5000 },
-            { .op = OP_PUMP_TIME, .val = 20000 },
-
-            NOTIFY, NOTIFY, NOTIFY, NOTIFY,
-
-            { .op = OP_SET_TEMPERATURE, .val = 1900 },
-        },
-        .count = 18,
-    }, {
-        .name = "Hotty",
-        .author = "xythobuz",
-        .steps = {
-            { .op = OP_WAIT_TEMPERATURE, .val = 1900 },
-            { .op = OP_WAIT_TIME, .val = 10000 },
-            { .op = OP_PUMP_TIME, .val = 5000 },
-
-            { .op = OP_WAIT_TEMPERATURE, .val = 2050 },
-            { .op = OP_WAIT_TIME, .val = 5000 },
-            { .op = OP_PUMP_TIME, .val = 20000 },
-
-            { .op = OP_WAIT_TEMPERATURE, .val = 2200 },
-            { .op = OP_WAIT_TIME, .val = 5000 },
-            { .op = OP_PUMP_TIME, .val = 20000 },
-
-            NOTIFY, NOTIFY, NOTIFY, NOTIFY,
-
-            { .op = OP_SET_TEMPERATURE, .val = 1900 },
-        },
-        .count = 18,
-    },
-};
-
-static const uint16_t count = 5;
-
 static enum wf_status status = WF_IDLE;
 static uint16_t wf_i = 0;
 static uint16_t step = 0;
 static uint16_t curr_val = 0;
 
 static void do_step(void) {
-    switch (wf[wf_i].steps[step].op) {
+    switch (mem_data()->wf[wf_i].steps[step].op) {
     case OP_SET_TEMPERATURE:
     case OP_WAIT_TEMPERATURE:
-        debug("workflow temp %.1f C", wf[wf_i].steps[step].val / 10.0);
+        debug("workflow temp %.1f C", mem_data()->wf[wf_i].steps[step].val / 10.0);
         start_val = volcano_get_current_temp();
         do {
-            volcano_set_target_temp(wf[wf_i].steps[step].val);
-        } while (volcano_get_target_temp() != wf[wf_i].steps[step].val);
+            volcano_set_target_temp(mem_data()->wf[wf_i].steps[step].val);
+        } while (volcano_get_target_temp() != mem_data()->wf[wf_i].steps[step].val);
         break;
 
     case OP_PUMP_TIME:
         volcano_set_pump_state(true);
         start_t = to_ms_since_boot(get_absolute_time());
         start_val = 0;
-        debug("workflow pump %.3f s", wf[wf_i].steps[step].val / 1000.0);
+        debug("workflow pump %.3f s", mem_data()->wf[wf_i].steps[step].val / 1000.0);
         break;
 
     case OP_WAIT_TIME:
         start_t = to_ms_since_boot(get_absolute_time());
         start_val = 0;
-        debug("workflow time %.3f s", wf[wf_i].steps[step].val / 1000.0);
+        debug("workflow time %.3f s", mem_data()->wf[wf_i].steps[step].val / 1000.0);
         break;
     }
 
 }
 
 uint16_t wf_count(void) {
-    return count;
+    return mem_data()->wf_count;
+}
+
+void wf_move_down(uint16_t index) {
+    if ((index < 1) || (index >= mem_data()->wf_count)) {
+        debug("invalid index %d", index);
+        return;
+    }
+
+    struct workflow tmp = mem_data()->wf[index - 1];
+    mem_data()->wf[index - 1] = mem_data()->wf[index];
+    mem_data()->wf[index] = tmp;
+}
+
+void wf_move_up(uint16_t index) {
+    if (index >= (mem_data()->wf_count - 1)) {
+        debug("invalid index %d", index);
+        return;
+    }
+
+    struct workflow tmp = mem_data()->wf[index + 1];
+    mem_data()->wf[index + 1] = mem_data()->wf[index];
+    mem_data()->wf[index] = tmp;
+}
+
+uint16_t wf_steps(uint16_t index) {
+    if (index >= mem_data()->wf_count) {
+        debug("invalid index %d", index);
+        return 0;
+    }
+    return mem_data()->wf[index].count;
+}
+
+void wf_move_step_down(uint16_t index, uint16_t step) {
+    if (index >= mem_data()->wf_count) {
+        debug("invalid index %d", index);
+        return;
+    }
+    if ((step < 1) || (step >= mem_data()->wf[index].count)) {
+        debug("invalid step %d", step);
+        return;
+    }
+
+    struct wf_step tmp = mem_data()->wf[index].steps[step - 1];
+    mem_data()->wf[index].steps[step - 1] = mem_data()->wf[index].steps[step];
+    mem_data()->wf[index].steps[step] = tmp;
+}
+
+void wf_move_step_up(uint16_t index, uint16_t step) {
+    if (index >= mem_data()->wf_count) {
+        debug("invalid index %d", index);
+        return;
+    }
+    if (step >= (mem_data()->wf[index].count - 1)) {
+        debug("invalid step %d", step);
+        return;
+    }
+
+    struct wf_step tmp = mem_data()->wf[index].steps[step + 1];
+    mem_data()->wf[index].steps[step + 1] = mem_data()->wf[index].steps[step];
+    mem_data()->wf[index].steps[step] = tmp;
+}
+
+struct wf_step wf_get_step(uint16_t index, uint16_t step) {
+    if (index >= mem_data()->wf_count) {
+        debug("invalid index %d", index);
+        return mem_data()->wf[0].steps[0];
+    }
+    return mem_data()->wf[index].steps[step];
+}
+
+const char *wf_step_str(struct wf_step step) {
+    static char buff[20];
+
+    switch (step.op) {
+    case OP_SET_TEMPERATURE:
+        snprintf(buff, sizeof(buff),
+                 "set temp %.1f C", step.val / 10.0f);
+        break;
+
+    case OP_WAIT_TEMPERATURE:
+        snprintf(buff, sizeof(buff),
+                 "wait temp %.1f C", step.val / 10.0f);
+        break;
+
+    case OP_WAIT_TIME:
+    case OP_PUMP_TIME:
+        snprintf(buff, sizeof(buff),
+                 "%s time %.1f s",
+                 (step.op == OP_WAIT_TIME) ? "wait" : "pump",
+                 step.val / 1000.0f);
+        break;
+    }
+
+    return buff;
 }
 
 const char *wf_name(uint16_t index) {
-    if (index >= count) {
+    if (index >= mem_data()->wf_count) {
         debug("invalid index %d", index);
         return NULL;
     }
-    return wf[index].name;
+    return mem_data()->wf[index].name;
 }
 
 const char *wf_author(uint16_t index) {
-    if (index >= count) {
+    if (index >= mem_data()->wf_count) {
         debug("invalid index %d", index);
         return NULL;
     }
-    return wf[index].author;
+    return mem_data()->wf[index].author;
 }
 
 struct wf_state wf_status(void) {
     struct wf_state s = {
         .status = status,
         .index = step,
-        .count = wf[wf_i].count,
-        .step = wf[wf_i].steps[step],
+        .count = mem_data()->wf[wf_i].count,
+        .step = mem_data()->wf[wf_i].steps[step],
         .start_val = start_val,
         .curr_val = curr_val,
     };
         debug("workflow already running");
         return;
     }
-    if (index >= count) {
+    if (index >= mem_data()->wf_count) {
         debug("invalid index %d", index);
         return;
     }
 
     bool done = false;
 
-    switch (wf[wf_i].steps[step].op) {
+    switch (mem_data()->wf[wf_i].steps[step].op) {
     case OP_SET_TEMPERATURE:
         done = true;
         break;
         }
 
         curr_val = temp;
-        done = (temp >= (wf[wf_i].steps[step].val - 5));
+        done = (temp >= (mem_data()->wf[wf_i].steps[step].val - 5));
         break;
     }
 
         uint32_t now = to_ms_since_boot(get_absolute_time());
         uint32_t diff = now - start_t;
         curr_val = diff;
-        done = (diff >= wf[wf_i].steps[step].val);
+        done = (diff >= mem_data()->wf[wf_i].steps[step].val);
         break;
     }
     }
 
     if (done) {
-        if (wf[wf_i].steps[step].op == OP_PUMP_TIME) {
+        if (mem_data()->wf[wf_i].steps[step].op == OP_PUMP_TIME) {
             volcano_set_pump_state(false);
         }
 
         step++;
-        if (step >= wf[wf_i].count) {
+        if (step >= mem_data()->wf[wf_i].count) {
             status = WF_IDLE;
             volcano_set_heater_state(false);
             debug("workflow finished");

src/workflow_default.c

+/*
+ * workflow_default.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 "config.h"
+#include "workflow.h"
+
+#define NOTIFY \
+    { .op = OP_WAIT_TIME, .val = 1000 }, \
+    { .op = OP_PUMP_TIME, .val = 1000 }
+
+const uint16_t wf_default_count = 5;
+
+const struct workflow wf_default_data[] = {
+    {
+        .name = "XXL",
+        .author = "xythobuz",
+        .steps = {
+            { .op = OP_WAIT_TEMPERATURE, .val = 1850 },
+            { .op = OP_WAIT_TIME, .val = 10000 },
+            { .op = OP_PUMP_TIME, .val = 8000 },
+
+            { .op = OP_WAIT_TEMPERATURE, .val = 1950 },
+            { .op = OP_WAIT_TIME, .val = 5000 },
+            { .op = OP_PUMP_TIME, .val = 25000 },
+
+            { .op = OP_WAIT_TEMPERATURE, .val = 2050 },
+            { .op = OP_WAIT_TIME, .val = 5000 },
+            { .op = OP_PUMP_TIME, .val = 25000 },
+
+            NOTIFY, NOTIFY, NOTIFY, NOTIFY,
+
+            { .op = OP_SET_TEMPERATURE, .val = 1900 },
+        },
+        .count = 18,
+    }, {
+        .name = "Default",
+        .author = "xythobuz",
+        .steps = {
+            { .op = OP_WAIT_TEMPERATURE, .val = 1850 },
+            { .op = OP_WAIT_TIME, .val = 10000 },
+            { .op = OP_PUMP_TIME, .val = 5000 },
+
+            { .op = OP_WAIT_TEMPERATURE, .val = 1950 },
+            { .op = OP_WAIT_TIME, .val = 5000 },
+            { .op = OP_PUMP_TIME, .val = 20000 },
+
+            { .op = OP_WAIT_TEMPERATURE, .val = 2050 },
+            { .op = OP_WAIT_TIME, .val = 5000 },
+            { .op = OP_PUMP_TIME, .val = 20000 },
+
+            NOTIFY, NOTIFY, NOTIFY, NOTIFY,
+
+            { .op = OP_SET_TEMPERATURE, .val = 1900 },
+        },
+        .count = 18,
+    }, {
+        .name = "Vorbi",
+        .author = "Rinor",
+        .steps = {
+            { .op = OP_WAIT_TEMPERATURE, .val = 1760 },
+            { .op = OP_WAIT_TIME, .val = 10000 },
+            { .op = OP_PUMP_TIME, .val = 6000 },
+
+            { .op = OP_WAIT_TEMPERATURE, .val = 1870 },
+            { .op = OP_WAIT_TIME, .val = 5000 },
+            { .op = OP_PUMP_TIME, .val = 10000 },
+
+            { .op = OP_WAIT_TEMPERATURE, .val = 2040 },
+            { .op = OP_WAIT_TIME, .val = 3000 },
+            { .op = OP_PUMP_TIME, .val = 10000 },
+
+            { .op = OP_WAIT_TEMPERATURE, .val = 2170 },
+            { .op = OP_WAIT_TIME, .val = 5000 },
+            { .op = OP_PUMP_TIME, .val = 10000 },
+        },
+        .count = 12,
+    }, {
+        .name = "Relaxo",
+        .author = "xythobuz",
+        .steps = {
+            { .op = OP_WAIT_TEMPERATURE, .val = 1750 },
+            { .op = OP_WAIT_TIME, .val = 10000 },
+            { .op = OP_PUMP_TIME, .val = 5000 },
+
+            { .op = OP_WAIT_TEMPERATURE, .val = 1850 },
+            { .op = OP_WAIT_TIME, .val = 5000 },
+            { .op = OP_PUMP_TIME, .val = 20000 },
+
+            { .op = OP_WAIT_TEMPERATURE, .val = 1950 },
+            { .op = OP_WAIT_TIME, .val = 5000 },
+            { .op = OP_PUMP_TIME, .val = 20000 },
+
+            NOTIFY, NOTIFY, NOTIFY, NOTIFY,
+
+            { .op = OP_SET_TEMPERATURE, .val = 1900 },
+        },
+        .count = 18,
+    }, {
+        .name = "Hotty",
+        .author = "xythobuz",
+        .steps = {
+            { .op = OP_WAIT_TEMPERATURE, .val = 1900 },
+            { .op = OP_WAIT_TIME, .val = 10000 },
+            { .op = OP_PUMP_TIME, .val = 5000 },
+
+            { .op = OP_WAIT_TEMPERATURE, .val = 2050 },
+            { .op = OP_WAIT_TIME, .val = 5000 },
+            { .op = OP_PUMP_TIME, .val = 20000 },
+
+            { .op = OP_WAIT_TEMPERATURE, .val = 2200 },
+            { .op = OP_WAIT_TIME, .val = 5000 },
+            { .op = OP_PUMP_TIME, .val = 20000 },
+
+            NOTIFY, NOTIFY, NOTIFY, NOTIFY,
+
+            { .op = OP_SET_TEMPERATURE, .val = 1900 },
+        },
+        .count = 18,
+    },
+};