generalize menu infrastructure to also use it for workflow selection

CMakeLists.txt

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

include/buttons.h

 #ifndef __BUTTONS_H__
 #define __BUTTONS_H__
 
+#include <stdbool.h>
+
 enum buttons {
     BTN_A = 0,
     BTN_B,

include/menu.h

+/*
+ * menu.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 __MENU_H__
+#define __MENU_H__
+
+#define MENU_MAX_LINES 5
+#define MENU_MAX_LEN (MENU_MAX_LINES * 32)
+
+struct menu_state {
+    int off;
+    int selection;
+    int length;
+    char *buff;
+};
+
+void menu_init(void (*cb)(int));
+void menu_run(void (*cb)(struct menu_state *));
+
+#endif // __MENU_H__

include/state.h

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

include/state_volcano_workflow.h

+/*
+ * state_volcano_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_VOLCANO_WORKFLOW_H__
+#define __STATE_VOLCANO_WORKFLOW_H__
+
+void state_volcano_wf_enter(void);
+void state_volcano_wf_exit(void);
+void state_volcano_wf_run(void);
+
+#endif // __STATE_VOLCANO_WORKFLOW_H__

include/text.h

 void text_prepare_font(struct text_font *tf);
 void text_draw(struct text_conf *tc);
 
+void text_box(const char *s);
+
 #endif // __TEXT_H__

include/workflow.h

 #ifndef __WORKFLOW_H__
 #define __WORKFLOW_H__
 
+#include <stdint.h>
+
 enum wf_status {
     WF_IDLE = 0,
     WF_RUNNING,
 };
 
+struct wf_state {
+    enum wf_status status;
+
+    uint16_t step;
+    uint16_t count;
+};
+
 uint16_t wf_count(void);
 const char *wf_name(uint16_t index);
+const char *wf_author(uint16_t index);
 
-enum wf_status wf_status(void);
+struct wf_state wf_status(void);
 void wf_start(uint16_t index);
 
 void wf_run(void);

src/console.c

     } else if (strcmp(line, "wfl") == 0) {
         println("%d workflows", wf_count());
         for (int i = 0; i < wf_count(); i++) {
-            println("  %s", wf_name(i));
+            println("  '%s' by %s", wf_name(i), wf_author(i));
         }
     } else if (str_startswith(line, "wf ")) {
         int wf = -1;
         if (wf < 0) {
             println("unknown workflow");
         } else {
-            if (wf_status() != WF_IDLE) {
+            struct wf_state s = wf_status();
+            if (s.status != WF_IDLE) {
                 println("workflow in progress");
             } else {
 #ifdef TEST_VOLCANO_AUTO_CONNECT
                 println("starting workflow");
                 wf_start(wf);
 
-                while (wf_status() != WF_IDLE) {
+                s = wf_status();
+                while (s.status != WF_IDLE) {
                     main_loop_hw();
                     wf_run();
+                    s = wf_status();
                 }
 
                 println("done");

src/menu.c

+/*
+ * menu.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 <string.h>
+
+#include "config.h"
+#include "buttons.h"
+#include "text.h"
+#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 void (*enter_callback)(int) = NULL;
+
+static void menu_buttons(enum buttons btn, bool state) {
+    if (state && (btn == BTN_LEFT)) {
+        // TODO brightness down
+        return;
+    } else if (state && (btn == BTN_RIGHT)) {
+        // TODO brightness up
+        return;
+    } else if (state && ((btn == BTN_ENTER) || (btn == BTN_A))) {
+        if (enter_callback) {
+            enter_callback(menu.selection);
+        }
+        return;
+    } else if ((!state) || ((btn != BTN_UP) && (btn != BTN_DOWN))) {
+        return;
+    }
+
+    if (state && (btn == BTN_UP)) {
+        if (menu.selection < 0) {
+            menu.selection = menu.length - 1;
+        } else {
+            menu.selection -= 1;
+        }
+    } else if (state && (btn == BTN_DOWN)) {
+        if (menu.selection < 0) {
+            menu.selection = 0;
+        } else {
+            menu.selection += 1;
+        }
+    }
+
+    if (menu.selection < 0) {
+        menu.selection += menu.length;
+    }
+    if (menu.selection >= menu.length) {
+        menu.selection -= menu.length;
+    }
+    if (menu.selection >= 0) {
+        while (menu.selection < menu.off) {
+            menu.off -= 1;
+        }
+        while (menu.selection >= (menu.off + MENU_MAX_LINES)) {
+            menu.off += 1;
+        }
+    }
+}
+
+void menu_init(void (*cb)(int)) {
+    menu.off = 0;
+    menu.selection = -1;
+    menu.length = 0;
+
+    enter_callback = cb;
+    buttons_callback(menu_buttons);
+}
+
+void menu_run(void (*draw)(struct menu_state *)) {
+    if (draw) {
+        draw(&menu);
+    }
+
+    if (strncmp(buff, prev_buff, MENU_MAX_LEN) != 0) {
+        strncpy(prev_buff, buff, MENU_MAX_LEN);
+        text_box(buff);
+    }
+}

src/state.c

 #include "config.h"
 #include "log.h"
 #include "state_scan.h"
+#include "state_volcano_workflow.h"
 #include "state.h"
 
 static enum system_state state = STATE_INIT;
         state_scan_exit();
         break;
 
+    case STATE_VOLCANO_WORKFLOW:
+        debug("leaving STATE_VOLCANO_WORKFLOW");
+        state_volcano_wf_exit();
+        break;
+
     default:
         break;
     }
         state_scan_enter();
         break;
 
+    case STATE_VOLCANO_WORKFLOW:
+        debug("entering STATE_VOLCANO_WORKFLOW");
+        state_volcano_wf_enter();
+        break;
+
     default:
         break;
     }
     case STATE_INIT:
         break;
 
-    case STATE_SCAN: {
+    case STATE_SCAN:
         state_scan_run();
         break;
-    }
+
+    case STATE_VOLCANO_WORKFLOW:
+        state_volcano_wf_run();
+        break;
 
     default:
         debug("invalid main state %d", state);

src/state_scan.c

  */
 
 #include <stdio.h>
+#include <string.h>
 
 #include "config.h"
-#include "log.h"
-#include "buttons.h"
 #include "ble.h"
-#include "lcd.h"
-#include "text.h"
 #include "models.h"
+#include "menu.h"
 #include "state.h"
+#include "state_scan.h"
 
-static const int max_lines = 5;
+static struct ble_scan_result results[BLE_MAX_SCAN_RESULTS] = {0};
+static int result_count = 0;
 
-static int menu_off = 0;
-static int menu_selection = -1;
-static int menu_length = 0;
-
-static void text_box(const char *s) {
-    static struct text_font font = {
-        .fontname = "fixed_10x20",
-        .font = NULL,
-    };
-    if (font.font == NULL) {
-        text_prepare_font(&font);
-    }
-
-    struct text_conf text = {
-        .text = "",
-        .x = 0,
-        .y = 50,
-        .justify = false,
-        .alignment = MF_ALIGN_CENTER,
-        .width = 240,
-        .height = 240 - 80,
-        .margin = 2,
-        .fg = RGB_565(0xFF, 0xFF, 0xFF),
-        .bg = RGB_565(0x00, 0x00, 0x00),
-        .font = &font,
-    };
-
-    // TODO clear background?!
-
-    text.text = s;
-    text_draw(&text);
-}
-
-static void state_scan_buttons(enum buttons btn, bool state) {
-    if (state && (btn == BTN_LEFT)) {
-        // TODO brightness down
-        return;
-    } else if (state && (btn == BTN_RIGHT)) {
-        // TODO brightness up
-        return;
-    } else if (state && ((btn == BTN_ENTER) || (btn == BTN_A))) {
-        // TODO menu_selection
-        return;
-    } else if ((!state) || ((btn != BTN_UP) && (btn != BTN_DOWN))) {
-        return;
-    }
-
-    if (state && (btn == BTN_UP)) {
-        if (menu_selection < 0) {
-            menu_selection = menu_length - 1;
-        } else {
-            menu_selection -= 1;
-        }
-    } else if (state && (btn == BTN_DOWN)) {
-        if (menu_selection < 0) {
-            menu_selection = 0;
-        } else {
-            menu_selection += 1;
+static void enter_cb(int selection) {
+    int devs = 0;
+    for (int i = 0; i < result_count; i++) {
+        enum known_devices dev = models_filter_name(results[i].name);
+        if (dev == DEV_UNKNOWN) {
+            continue;
         }
-    }
 
-    if (menu_selection < 0) {
-        menu_selection += menu_length;
-    }
-    if (menu_selection >= menu_length) {
-        menu_selection -= menu_length;
-    }
-    if (menu_selection >= 0) {
-        while (menu_selection < menu_off) {
-            menu_off -= 1;
-        }
-        while (menu_selection >= (menu_off + max_lines)) {
-            menu_off += 1;
+        if (devs++ == selection) {
+            if (dev == DEV_VOLCANO) {
+                state_switch(STATE_VOLCANO_WORKFLOW);
+            }
+            return;
         }
     }
 }
 
 void state_scan_enter(void) {
-    buttons_callback(state_scan_buttons);
+    menu_init(enter_cb);
     ble_scan(BLE_SCAN_ON);
 }
 
 void state_scan_exit(void) {
-    buttons_callback(NULL);
     ble_scan(BLE_SCAN_OFF);
 }
 
-void state_scan_run(void) {
-    static char prev_buff[512] = {0};
-    char buff[512] = {0};
-
-    struct ble_scan_result results[BLE_MAX_SCAN_RESULTS] = {0};
-    int n = ble_get_scan_results(results, BLE_MAX_SCAN_RESULTS);
+static void draw(struct menu_state *menu) {
+    result_count = ble_get_scan_results(results, BLE_MAX_SCAN_RESULTS);
 
     int pos = 0, devs = 0;
-    for (int i = 0; i < n; i++) {
+    for (int i = 0; i < result_count; i++) {
         enum known_devices dev = models_filter_name(results[i].name);
         if (dev == DEV_UNKNOWN) {
             continue;
 
         devs++;
 
-        if (((devs - 1) < menu_off)
-            || ((devs - 1 - menu_off) >= max_lines)) {
+        if (((devs - 1) < menu->off)
+            || ((devs - 1 - menu->off) >= MENU_MAX_LINES)) {
             continue;
         }
 
 #if defined(MENU_PREFER_VOLCANO) || defined(MENU_PREFER_CRAFTY)
-        if (menu_selection < 0) {
+        if (menu->selection < 0) {
 #ifdef MENU_PREFER_VOLCANO
             if (dev == DEV_VOLCANO) {
-                menu_selection = devs - 1;
+                menu->selection = devs - 1;
             }
 #endif // MENU_PREFER_VOLCANO
 #ifdef MENU_PREFER_CRAFTY
             if (dev == DEV_CRAFTY) {
-                menu_selection = devs - 1;
+                menu->selection = devs - 1;
             }
 #endif // MENU_PREFER_CRAFTY
         }
 #endif // defined(MENU_PREFER_VOLCANO) || defined(MENU_PREFER_CRAFTY)
 
-        if ((devs - 1) == menu_selection) {
-            pos += snprintf(buff + pos, sizeof(buff) - pos, "> ");
+        if ((devs - 1) == menu->selection) {
+            pos += snprintf(menu->buff + pos, MENU_MAX_LEN - pos, "> ");
         } else {
-            pos += snprintf(buff + pos, sizeof(buff) - pos, "  ");
+            pos += snprintf(menu->buff + pos, MENU_MAX_LEN - pos, "  ");
         }
 
         if (dev == DEV_VOLCANO) {
-            pos += snprintf(buff + pos, sizeof(buff) - pos, "Volcano ");
+            pos += snprintf(menu->buff + pos, MENU_MAX_LEN - pos, "Volcano ");
         } else if (dev == DEV_CRAFTY) {
-            pos += snprintf(buff + pos, sizeof(buff) - pos, "Crafty+ ");
+            pos += snprintf(menu->buff + pos, MENU_MAX_LEN - pos, "Crafty+ ");
         }
 
         char info[32] = "";
                               info, sizeof(info)) < 0) {
             strcpy(info, "-error-");
         }
-        pos += snprintf(buff + pos, sizeof(buff) - pos, "%s\n", info);
+        pos += snprintf(menu->buff + pos, MENU_MAX_LEN - pos, "%s\n", info);
     }
 
-    menu_length = devs;
+    menu->length = devs;
 
 #if !defined(MENU_PREFER_VOLCANO) && !defined(MENU_PREFER_CRAFTY)
-    if ((menu_selection < 0) && (menu_length > 0)) {
-        menu_selection = 0;
+    if ((menu->selection < 0) && (menu->length > 0)) {
+        menu->selection = 0;
     }
 #endif // !defined(MENU_PREFER_VOLCANO) && !defined(MENU_PREFER_CRAFTY)
 
-    if (menu_length == 0) {
-        strncpy(buff, "NONE", sizeof(buff));
+    if (menu->length == 0) {
+        strncpy(menu->buff, "NONE", MENU_MAX_LEN);
     }
+}
 
-    if (strncmp(buff, prev_buff, sizeof(buff)) != 0) {
-        strncpy(prev_buff, buff, sizeof(prev_buff));
-        text_box(buff);
-    }
+void state_scan_run(void) {
+    menu_run(draw);
 }

src/state_volcano_workflow.c

+/*
+ * state_volcano_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_volcano_workflow.h"
+
+static void enter_cb(int selection) {
+    (void)(selection); // TODO
+}
+
+void state_volcano_wf_enter(void) {
+    menu_init(enter_cb);
+}
+
+void state_volcano_wf_exit(void) {
+    // nothing to do
+}
+
+static void draw(struct menu_state *menu) {
+    menu->length = wf_count();
+
+    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, "  ");
+        }
+
+        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)) {
+        menu->selection = 0;
+    }
+
+    if (menu->length == 0) {
+        strncpy(menu->buff, "NONE", MENU_MAX_LEN);
+    }
+}
+
+void state_volcano_wf_run(void) {
+    menu_run(draw);
+}

src/text.c

     mf_wordwrap(tc->font->font, tc->width - 2 * tc->margin,
                 tc->text, line_callback, &state);
 }
+
+void text_box(const char *s) {
+    static struct text_font font = {
+        .fontname = "fixed_10x20",
+        .font = NULL,
+    };
+    if (font.font == NULL) {
+        text_prepare_font(&font);
+    }
+
+    struct text_conf text = {
+        .text = "",
+        .x = 0,
+        .y = 50,
+        .justify = false,
+        .alignment = MF_ALIGN_CENTER,
+        .width = 240,
+        .height = 240 - 80,
+        .margin = 2,
+        .fg = RGB_565(0xFF, 0xFF, 0xFF),
+        .bg = RGB_565(0x00, 0x00, 0x00),
+        .font = &font,
+    };
+
+    // TODO clear background?!
+
+    text.text = s;
+    text_draw(&text);
+}

src/workflow.c

 #include "volcano.h"
 #include "workflow.h"
 
-#define WF_MAX_STEPS 32
-#define WF_MAX_FLOWS 5
+#define WF_MAX_STEPS 42
+#define WF_MAX_FLOWS 6
 
 enum wf_op {
     OP_SET_TEMPERATURE = 0,
 
 struct workflow {
     const char *name;
+    const char *author;
     struct wf_step steps[WF_MAX_STEPS];
     uint16_t count;
 };
 static const struct workflow wf[WF_MAX_FLOWS] = {
     {
         .name = "Default",
+        .author = "xythobuz",
         .steps = {
             { .op = OP_WAIT_TEMPERATURE, .val = 1850 },
-            { .op = OP_WAIT_TIME, .val = 15000 },
+            { .op = OP_WAIT_TIME, .val = 10000 },
             { .op = OP_PUMP_TIME, .val = 5000 },
 
             { .op = OP_WAIT_TEMPERATURE, .val = 1950 },
-            { .op = OP_WAIT_TIME, .val = 10000 },
+            { .op = OP_WAIT_TIME, .val = 5000 },
             { .op = OP_PUMP_TIME, .val = 20000 },
 
             { .op = OP_WAIT_TEMPERATURE, .val = 2050 },
-            { .op = OP_WAIT_TIME, .val = 10000 },
+            { .op = OP_WAIT_TIME, .val = 5000 },
             { .op = OP_PUMP_TIME, .val = 20000 },
 
             { .op = OP_PUMP_TIME, .val = 1000 },
         },
         .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 = 15000 },
+            { .op = OP_WAIT_TIME, .val = 10000 },
             { .op = OP_PUMP_TIME, .val = 5000 },
 
             { .op = OP_WAIT_TEMPERATURE, .val = 1850 },
-            { .op = OP_WAIT_TIME, .val = 10000 },
+            { .op = OP_WAIT_TIME, .val = 5000 },
             { .op = OP_PUMP_TIME, .val = 20000 },
 
             { .op = OP_WAIT_TEMPERATURE, .val = 1950 },
-            { .op = OP_WAIT_TIME, .val = 10000 },
+            { .op = OP_WAIT_TIME, .val = 5000 },
             { .op = OP_PUMP_TIME, .val = 20000 },
 
             { .op = OP_PUMP_TIME, .val = 1000 },
         .count = 18,
     }, {
         .name = "Hardcore",
+        .author = "xythobuz",
         .steps = {
             { .op = OP_WAIT_TEMPERATURE, .val = 1900 },
-            { .op = OP_WAIT_TIME, .val = 15000 },
+            { .op = OP_WAIT_TIME, .val = 10000 },
             { .op = OP_PUMP_TIME, .val = 5000 },
 
             { .op = OP_WAIT_TEMPERATURE, .val = 2050 },
-            { .op = OP_WAIT_TIME, .val = 10000 },
+            { .op = OP_WAIT_TIME, .val = 5000 },
             { .op = OP_PUMP_TIME, .val = 20000 },
 
             { .op = OP_WAIT_TEMPERATURE, .val = 2200 },
-            { .op = OP_WAIT_TIME, .val = 10000 },
+            { .op = OP_WAIT_TIME, .val = 5000 },
             { .op = OP_PUMP_TIME, .val = 20000 },
 
             { .op = OP_PUMP_TIME, .val = 1000 },
             { .op = OP_SET_TEMPERATURE, .val = 1900 },
         },
         .count = 18,
-    }, {
-        .name = "Vorbi",
-        .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,
     },
 };
 
     return wf[index].name;
 }
 
-enum wf_status wf_status(void) {
-    return status;
+const char *wf_author(uint16_t index) {
+    if (index >= count) {
+        debug("invalid index %d", index);
+        return NULL;
+    }
+    return wf[index].author;
+}
+
+struct wf_state wf_status(void) {
+    struct wf_state s = {
+        .status = status,
+        .step = step,
+        .count = wf[wf_i].count,
+    };
+    return s;
 }
 
 void wf_start(uint16_t index) {