add workflow logic

CMakeLists.txt

@@ -65,6 +65,7 @@ target_sources(gadget PUBLIC
     src/ring.c
     src/models.c
     src/state_scan.c
+    src/workflow.c
 
     ${CMAKE_CURRENT_BINARY_DIR}/fatfs/ff.c
     ${CMAKE_CURRENT_BINARY_DIR}/fatfs/ffunicode.c

include/workflow.h

@@ -0,0 +1,35 @@
+/*
+ * 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 __WORKFLOW_H__
+#define __WORKFLOW_H__
+
+enum wf_status {
+    WF_IDLE = 0,
+    WF_RUNNING,
+};
+
+uint16_t wf_count(void);
+const char *wf_name(uint16_t index);
+
+enum wf_status wf_status(void);
+void wf_start(uint16_t index);
+
+void wf_run(void);
+
+#endif // __WORKFLOW_H__

src/console.c

@@ -39,6 +39,7 @@
 #include "serial.h"
 #include "main.h"
 #include "models.h"
+#include "workflow.h"
 #include "console.h"
 
 #define CNSL_BUFF_SIZE 64
@@ -114,7 +115,9 @@ static void cnsl_interpret(const char *line) {
         println(" vwtt X - Volcano write target temperature");
         println("  vwh X - Set heater to 1 or 0");
         println("  vwp X - Set heater to 1 or 0");
-        println("     vt - Run a hard-coded test workflow");
+        println("");
+        println("    wfl - List available workflows");
+        println("   wf X - Run workflow");
         println("");
         println("Press Enter with no input to repeat last command.");
         println("Use repeat to continuously execute last command.");
@@ -315,94 +318,45 @@ static void cnsl_interpret(const char *line) {
                 println("success");
             }
         }
-    } else if (strcmp(line, "vt") == 0) {
-#ifdef TEST_VOLCANO_AUTO_CONNECT
-        VOLCANO_AUTO_CONNECT
-#endif // TEST_VOLCANO_AUTO_CONNECT
-
-        println("init workflow test");
-        volcano_set_pump_state(false);
-        volcano_set_heater_state(false);
-        volcano_set_target_temp(1850);
-        volcano_set_heater_state(true);
-
-        println("wait for 185");
-        while (volcano_get_current_temp() < 1840) {
-            main_loop_hw();
-        }
-
-        println("wait for 10s");
-        uint32_t start = to_ms_since_boot(get_absolute_time());
-        while ((to_ms_since_boot(get_absolute_time()) - start) < (10 * 1000)) {
-            main_loop_hw();
+    } 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("pumping");
-        volcano_set_pump_state(true);
-
-        println("wait for 10s");
-        start = to_ms_since_boot(get_absolute_time());
-        while ((to_ms_since_boot(get_absolute_time()) - start) < (10 * 1000)) {
-            main_loop_hw();
-        }
-
-        println("step done");
-        volcano_set_pump_state(false);
-        volcano_set_target_temp(1950);
-
-        println("wait for 195");
-        while (volcano_get_current_temp() < 1940) {
-            main_loop_hw();
-        }
-
-        println("wait for 5s");
-        start = to_ms_since_boot(get_absolute_time());
-        while ((to_ms_since_boot(get_absolute_time()) - start) < (5 * 1000)) {
-            main_loop_hw();
-        }
-
-        println("pumping");
-        volcano_set_pump_state(true);
-
-        println("wait for 20s");
-        start = to_ms_since_boot(get_absolute_time());
-        while ((to_ms_since_boot(get_absolute_time()) - start) < (20 * 1000)) {
-            main_loop_hw();
-        }
-
-        println("step done");
-        volcano_set_pump_state(false);
-        volcano_set_target_temp(2050);
-
-        println("wait for 205");
-        while (volcano_get_current_temp() < 2040) {
-            main_loop_hw();
-        }
-
-        println("wait for 5s");
-        start = to_ms_since_boot(get_absolute_time());
-        while ((to_ms_since_boot(get_absolute_time()) - start) < (5 * 1000)) {
-            main_loop_hw();
+    } else if (str_startswith(line, "wf ")) {
+        int wf = -1;
+        for (int i = 0; i < wf_count(); i++) {
+            if (strcmp(wf_name(i), line + 3) == 0) {
+                wf = i;
+                break;
+            }
         }
 
-        println("pumping");
-        volcano_set_pump_state(true);
+        if (wf < 0) {
+            println("unknown workflow");
+        } else {
+            if (wf_status() != WF_IDLE) {
+                println("workflow in progress");
+            } else {
+#ifdef TEST_VOLCANO_AUTO_CONNECT
+                VOLCANO_AUTO_CONNECT
+#endif // TEST_VOLCANO_AUTO_CONNECT
 
-        println("wait for 20s");
-        start = to_ms_since_boot(get_absolute_time());
-        while ((to_ms_since_boot(get_absolute_time()) - start) < (20 * 1000)) {
-            main_loop_hw();
-        }
+                println("starting workflow");
+                wf_start(wf);
 
-        println("turning off");
-        volcano_set_pump_state(false);
-        volcano_set_heater_state(false);
+                while (wf_status() != WF_IDLE) {
+                    main_loop_hw();
+                    wf_run();
+                }
 
-        println("done");
+                println("done");
 
 #ifdef TEST_VOLCANO_AUTO_CONNECT
-        ble_disconnect();
+                ble_disconnect();
 #endif // TEST_VOLCANO_AUTO_CONNECT
+            }
+        }
     } else {
         println("unknown command \"%s\"", line);
     }

src/main.c

@@ -35,6 +35,7 @@
 #include "image.h"
 #include "state.h"
 #include "serial.h"
+#include "workflow.h"
 
 void main_loop_hw(void) {
     watchdog_update();
@@ -104,6 +105,7 @@ int main(void) {
         cnsl_run();
         battery_run();
         state_run();
+        wf_run();
     }
 
     return 0;

src/workflow.c

@@ -0,0 +1,261 @@
+/*
+ * 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 "config.h"
+#include "log.h"
+#include "volcano.h"
+#include "workflow.h"
+
+#define WF_MAX_STEPS 32
+#define WF_MAX_FLOWS 5
+
+enum wf_op {
+    OP_SET_TEMPERATURE = 0,
+    OP_WAIT_TEMPERATURE,
+    OP_WAIT_TIME,
+    OP_PUMP_TIME,
+};
+
+struct wf_step {
+    enum wf_op op;
+    uint16_t val;
+};
+
+struct workflow {
+    const char *name;
+    struct wf_step steps[WF_MAX_STEPS];
+    uint16_t count;
+};
+
+static const struct workflow wf[WF_MAX_FLOWS] = {
+    {
+        .name = "Default",
+        .steps = {
+            { .op = OP_WAIT_TEMPERATURE, .val = 1850 },
+            { .op = OP_WAIT_TIME, .val = 15000 },
+            { .op = OP_PUMP_TIME, .val = 5000 },
+
+            { .op = OP_WAIT_TEMPERATURE, .val = 1950 },
+            { .op = OP_WAIT_TIME, .val = 10000 },
+            { .op = OP_PUMP_TIME, .val = 20000 },
+
+            { .op = OP_WAIT_TEMPERATURE, .val = 2050 },
+            { .op = OP_WAIT_TIME, .val = 10000 },
+            { .op = OP_PUMP_TIME, .val = 20000 },
+
+            { .op = OP_PUMP_TIME, .val = 1000 },
+            { .op = OP_WAIT_TIME, .val = 1000 },
+
+            { .op = OP_PUMP_TIME, .val = 1000 },
+            { .op = OP_WAIT_TIME, .val = 1000 },
+
+            { .op = OP_PUMP_TIME, .val = 1000 },
+            { .op = OP_WAIT_TIME, .val = 1000 },
+
+            { .op = OP_PUMP_TIME, .val = 1000 },
+            { .op = OP_WAIT_TIME, .val = 1000 },
+
+            { .op = OP_SET_TEMPERATURE, .val = 1900 },
+        },
+        .count = 18,
+    }, {
+        .name = "Relaxo",
+        .steps = {
+            { .op = OP_WAIT_TEMPERATURE, .val = 1750 },
+            { .op = OP_WAIT_TIME, .val = 15000 },
+            { .op = OP_PUMP_TIME, .val = 5000 },
+
+            { .op = OP_WAIT_TEMPERATURE, .val = 1850 },
+            { .op = OP_WAIT_TIME, .val = 10000 },
+            { .op = OP_PUMP_TIME, .val = 20000 },
+
+            { .op = OP_WAIT_TEMPERATURE, .val = 1950 },
+            { .op = OP_WAIT_TIME, .val = 10000 },
+            { .op = OP_PUMP_TIME, .val = 20000 },
+
+            { .op = OP_PUMP_TIME, .val = 1000 },
+            { .op = OP_WAIT_TIME, .val = 1000 },
+
+            { .op = OP_PUMP_TIME, .val = 1000 },
+            { .op = OP_WAIT_TIME, .val = 1000 },
+
+            { .op = OP_PUMP_TIME, .val = 1000 },
+            { .op = OP_WAIT_TIME, .val = 1000 },
+
+            { .op = OP_PUMP_TIME, .val = 1000 },
+            { .op = OP_WAIT_TIME, .val = 1000 },
+
+            { .op = OP_SET_TEMPERATURE, .val = 1900 },
+        },
+        .count = 18,
+    }, {
+        .name = "Hardcore",
+        .steps = {
+            { .op = OP_WAIT_TEMPERATURE, .val = 1900 },
+            { .op = OP_WAIT_TIME, .val = 15000 },
+            { .op = OP_PUMP_TIME, .val = 5000 },
+
+            { .op = OP_WAIT_TEMPERATURE, .val = 2050 },
+            { .op = OP_WAIT_TIME, .val = 10000 },
+            { .op = OP_PUMP_TIME, .val = 20000 },
+
+            { .op = OP_WAIT_TEMPERATURE, .val = 2200 },
+            { .op = OP_WAIT_TIME, .val = 10000 },
+            { .op = OP_PUMP_TIME, .val = 20000 },
+
+            { .op = OP_PUMP_TIME, .val = 1000 },
+            { .op = OP_WAIT_TIME, .val = 1000 },
+
+            { .op = OP_PUMP_TIME, .val = 1000 },
+            { .op = OP_WAIT_TIME, .val = 1000 },
+
+            { .op = OP_PUMP_TIME, .val = 1000 },
+            { .op = OP_WAIT_TIME, .val = 1000 },
+
+            { .op = OP_PUMP_TIME, .val = 1000 },
+            { .op = OP_WAIT_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,
+    },
+};
+
+static const uint16_t count = 4;
+
+static enum wf_status status = WF_IDLE;
+static uint16_t wf_i = 0;
+static uint16_t step = 0;
+static uint32_t start_t = 0;
+
+static void do_step(void) {
+    switch (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);
+        volcano_set_target_temp(wf[wf_i].steps[step].val);
+        break;
+
+    case OP_PUMP_TIME:
+        volcano_set_pump_state(true);
+        __attribute__((fallthrough));
+
+    case OP_WAIT_TIME:
+        start_t = to_ms_since_boot(get_absolute_time());
+        debug("workflow time %.3f s", wf[wf_i].steps[step].val / 1000.0);
+        break;
+    }
+}
+
+uint16_t wf_count(void) {
+    return count;
+}
+
+const char *wf_name(uint16_t index) {
+    if (index >= count) {
+        debug("invalid index %d", index);
+        return NULL;
+    }
+    return wf[index].name;
+}
+
+enum wf_status wf_status(void) {
+    return status;
+}
+
+void wf_start(uint16_t index) {
+    if (status != WF_IDLE) {
+        debug("workflow already running");
+        return;
+    }
+    if (index >= count) {
+        debug("invalid index %d", index);
+        return;
+    }
+
+    status = WF_RUNNING;
+    wf_i = index;
+    step = 0;
+
+    // discover characteristics
+    volcano_set_pump_state(false);
+    volcano_set_heater_state(false);
+    volcano_set_target_temp(1850);
+
+    volcano_set_heater_state(true);
+
+    do_step();
+}
+
+void wf_run(void) {
+    if (status == WF_IDLE) {
+        return;
+    }
+
+    bool done = false;
+
+    switch (wf[wf_i].steps[step].op) {
+    case OP_SET_TEMPERATURE:
+        done = true;
+        break;
+
+    case OP_WAIT_TEMPERATURE:
+        done = (volcano_get_current_temp() >= (wf[wf_i].steps[step].val - 5));
+        break;
+
+    case OP_PUMP_TIME:
+    case OP_WAIT_TIME:
+        done = ((to_ms_since_boot(get_absolute_time()) - start_t) >= wf[wf_i].steps[step].val);
+        break;
+    }
+
+    if (done) {
+        if (wf[wf_i].steps[step].op == OP_PUMP_TIME) {
+            volcano_set_pump_state(false);
+        }
+
+        step++;
+        if (step >= wf[wf_i].count) {
+            status = WF_IDLE;
+            volcano_set_heater_state(false);
+            debug("workflow finished");
+        } else {
+            do_step();
+        }
+    }
+}