rename state_volcano_workflow to state_workflow

CMakeLists.txt

     src/state_scan.c
     src/workflow.c
     src/menu.c
-    src/state_volcano_workflow.c
+    src/state_workflow.c
     src/state_volcano_run.c
     src/crafty.c
     src/state_crafty.c

include/models.h

     DEV_CRAFTY,
 };
 
+enum unit {
+    UNIT_C = 0,
+    UNIT_F,
+    UNIT_INVALID,
+};
+
 enum known_devices models_filter_name(const char *name);
 int8_t models_get_serial(const uint8_t *data, size_t data_len, char *buff, size_t buff_len);
 

include/state.h

 enum system_state {
     STATE_INIT = 0,
     STATE_SCAN,
-    STATE_VOLCANO_WORKFLOW,
+    STATE_WORKFLOW,
     STATE_VOLCANO_RUN,
     STATE_CRAFTY,
     STATE_EDIT_WORKFLOW,

include/state_volcano_workflow.h → include/state_workflow.h

 /*
- * state_volcano_workflow.h
+ * state_workflow.h
  *
  * Copyright (c) 2023 Thomas Buck (thomas@xythobuz.de)
  *
  * See <http://www.gnu.org/licenses/>.
  */
 
-#ifndef __STATE_VOLCANO_WORKFLOW_H__
-#define __STATE_VOLCANO_WORKFLOW_H__
+#ifndef __STATE_WORKFLOW_H__
+#define __STATE_WORKFLOW_H__
 
 #include <stdbool.h>
 
-void state_volcano_wf_edit(bool edit);
+void state_wf_edit(bool edit);
 
-void state_volcano_wf_enter(void);
-void state_volcano_wf_exit(void);
-void state_volcano_wf_run(void);
+void state_wf_enter(void);
+void state_wf_exit(void);
+void state_wf_run(void);
 
-#endif // __STATE_VOLCANO_WORKFLOW_H__
+#endif // __STATE_WORKFLOW_H__

include/volcano.h

 #include <stdint.h>
 #include <stdbool.h>
 
+#include "models.h"
+
+enum volcano_state {
+    VOLCANO_STATE_HEATER = (1 << 0),
+    VOLCANO_STATE_PUMP = (1 << 1),
+};
+
 // returns < 0 on error
 int8_t volcano_discover_characteristics(void);
 
 int8_t volcano_set_heater_state(bool value);
 int8_t volcano_set_pump_state(bool value);
 
+enum unit volcano_get_unit(void);
+enum volcano_state volcano_get_state(void);
+
 #endif // __VOLCANO_H__

src/state.c

 #include "config.h"
 #include "log.h"
 #include "state_scan.h"
-#include "state_volcano_workflow.h"
+#include "state_workflow.h"
 #include "state_volcano_run.h"
 #include "state_crafty.h"
 #include "state_edit_workflow.h"
         .exit = state_scan_exit,
         .run = state_scan_run,
     }, {
-        .name = stringify(STATE_VOLCANO_WORKFLOW),
-        .enter = state_volcano_wf_enter,
-        .exit = state_volcano_wf_exit,
-        .run = state_volcano_wf_run,
+        .name = stringify(STATE_WORKFLOW),
+        .enter = state_wf_enter,
+        .exit = state_wf_exit,
+        .run = state_wf_run,
     }, {
         .name = stringify(STATE_VOLCANO_RUN),
         .enter = state_volcano_run_enter,

src/state_scan.c

 #include "models.h"
 #include "menu.h"
 #include "state.h"
-#include "state_volcano_workflow.h"
+#include "state_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);
+                state_wf_edit(false);
+                state_switch(STATE_WORKFLOW);
             } else if (dev == DEV_CRAFTY) {
                 state_crafty_target(results[i].addr, results[i].type);
                 state_switch(STATE_CRAFTY);
 static void edit_cb(int selection) {
     UNUSED(selection);
 
-    state_volcano_wf_edit(true);
-    state_switch(STATE_VOLCANO_WORKFLOW);
+    state_wf_edit(true);
+    state_switch(STATE_WORKFLOW);
 }
 
 void state_scan_enter(void) {
         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);
+            state_wf_edit(false);
+            state_switch(STATE_WORKFLOW);
 
             auto_connect_time = 0;
         }

src/state_settings.c

 #include "config.h"
 #include "log.h"
 #include "menu.h"
+#include "mem.h"
 #include "state.h"
 #include "state_settings.h"
 
     switch (selection) {
     case 0:
         // Auto Connect
+        break;
 
+    case 1:
+        // Brightness
+        break;
+
+    case 2:
+        // Workflows
+        break;
+
+    case 3:
+        // Reset
+        mem_load_defaults();
+        break;
     }
 }
 
     ADD_STATIC_ELEMENT("Auto Connect");
     ADD_STATIC_ELEMENT("Brightness");
     ADD_STATIC_ELEMENT("Workflows");
+    ADD_STATIC_ELEMENT("Reset");
 
     if (menu->selection < 0) {
         menu->selection = 0;

src/state_volcano_workflow.c → src/state_workflow.c

 /*
- * state_volcano_workflow.c
+ * state_workflow.c
  *
  * Copyright (c) 2023 Thomas Buck (thomas@xythobuz.de)
  *
 #include "state.h"
 #include "state_volcano_run.h"
 #include "state_edit_workflow.h"
-#include "state_volcano_workflow.h"
+#include "state_workflow.h"
 
 static bool edit_mode = false;
 
     state_switch(STATE_SCAN);
 }
 
-void state_volcano_wf_edit(bool edit) {
+void state_wf_edit(bool edit) {
     edit_mode = edit;
 }
 
-void state_volcano_wf_enter(void) {
+void state_wf_enter(void) {
     if (edit_mode) {
         menu_init(enter_cb, lower_cb, upper_cb, exit_cb);
     } else {
 #endif // VOLCANO_AUTO_CONNECT_TIMEOUT_MS
 }
 
-void state_volcano_wf_exit(void) {
+void state_wf_exit(void) {
     menu_deinit();
 }
 
 
         if (i == menu->selection) {
 #ifdef VOLCANO_AUTO_CONNECT_TIMEOUT_MS
-            if ((auto_connect_time != 0) && (!menu_got_input)) {
+            if ((auto_connect_time != 0) && (!menu_got_input) && (!edit_mode)) {
                 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,
     }
 }
 
-void state_volcano_wf_run(void) {
+void state_wf_run(void) {
     menu_run(draw, false);
 
 #ifdef VOLCANO_AUTO_CONNECT_TIMEOUT_MS
-    if ((auto_connect_time != 0) && (!menu_got_input)) {
+    if ((auto_connect_time != 0) && (!menu_got_input) && (!edit_mode)) {
         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);

src/volcano.c

 #include "ble.h"
 #include "volcano.h"
 
-// Volcano UUIDs are always the same, except for the 4th byte
+#define UUID_SRVC_1       0x10
+#define UUID_GET_STATE    0x0C
+#define UUID_GET_UNIT     0x0D
+
+#define UUID_SRVC_2       0x11
 #define UUID_WRITE_SRVC   0x00
 #define UUID_CURRENT_TEMP 0x01
 #define UUID_TARGET_TEMP  0x03
 #define UUID_PUMP_ON      0x13
 #define UUID_PUMP_OFF     0x14
 
-// "101100xx-5354-4f52-5a26-4249434b454c"
+// "10xx00xx-5354-4f52-5a26-4249434b454c"
 static uint8_t uuid_base[16] = {
-    0x10, 0x11, 0x00, 0xFF, 0x53, 0x54, 0x4f, 0x52,
+    0x10, 0xFF, 0x00, 0xFF, 0x53, 0x54, 0x4f, 0x52,
     0x5a, 0x26, 0x42, 0x49, 0x43, 0x4b, 0x45, 0x4c,
 };
 static uint8_t uuid_base2[16] = {
-    0x10, 0x11, 0x00, 0xFF, 0x53, 0x54, 0x4f, 0x52,
+    0x10, 0xFF, 0x00, 0xFF, 0x53, 0x54, 0x4f, 0x52,
     0x5a, 0x26, 0x42, 0x49, 0x43, 0x4b, 0x45, 0x4c,
 };
 
 int8_t volcano_discover_characteristics(void) {
+    uuid_base[1] = UUID_SRVC_2;
+    uuid_base2[1] = UUID_SRVC_2;
+
     uuid_base[3] = UUID_WRITE_SRVC;
     int8_t r;
 
 }
 
 int16_t volcano_get_current_temp(void) {
+    uuid_base[1] = UUID_SRVC_2;
     uuid_base[3] = UUID_CURRENT_TEMP;
 
     uint8_t buff[4];
 }
 
 int8_t volcano_set_target_temp(uint16_t value) {
+    uuid_base[1] = UUID_SRVC_2;
+    uuid_base2[1] = UUID_SRVC_2;
     uuid_base[3] = UUID_WRITE_SRVC;
     uuid_base2[3] = UUID_TARGET_TEMP;
 
 }
 
 int8_t volcano_set_heater_state(bool value) {
+    uuid_base[1] = UUID_SRVC_2;
+    uuid_base2[1] = UUID_SRVC_2;
     uuid_base[3] = UUID_WRITE_SRVC;
 
     if (value) {
 }
 
 int8_t volcano_set_pump_state(bool value) {
+    uuid_base[1] = UUID_SRVC_2;
+    uuid_base2[1] = UUID_SRVC_2;
     uuid_base[3] = UUID_WRITE_SRVC;
 
     if (value) {
     }
     return r;
 }
+
+enum unit volcano_get_unit(void) {
+    uuid_base[1] = UUID_SRVC_1;
+    uuid_base[3] = UUID_GET_UNIT;
+
+    uint8_t buff[4];
+    int32_t r = ble_read(uuid_base, buff, sizeof(buff));
+    if (r != sizeof(buff)) {
+        debug("ble_read unexpected value %ld", r);
+        return UNIT_INVALID;
+    }
+
+    uint32_t *v = (uint32_t *)buff;
+    return (*v & 0x200) ? UNIT_F : UNIT_C;
+}
+
+enum volcano_state volcano_get_state(void) {
+    uuid_base[1] = UUID_SRVC_1;
+    uuid_base[3] = UUID_GET_STATE;
+
+    uint8_t buff[4];
+    int32_t r = ble_read(uuid_base, buff, sizeof(buff));
+    if (r != sizeof(buff)) {
+        debug("ble_read unexpected value %ld", r);
+        return 0xFF;
+    }
+
+    uint32_t *v = (uint32_t *)buff;
+    uint32_t heater = (*v & 0x0020);
+    uint32_t pump = (*v & 0x2000);
+    return (heater ? VOLCANO_STATE_HEATER : 0) | (pump ? VOLCANO_STATE_PUMP : 0);
+}

src/workflow.c

  * See <http://www.gnu.org/licenses/>.
  */
 
+#define WF_CONFIRM_WRITES
+
 #include <stdio.h>
 
 #include "config.h"
 #include "volcano.h"
 #include "workflow.h"
 
+#ifdef WF_CONFIRM_WRITES
+#define DO_WHILE(x, y) \
+    do {               \
+        x;             \
+    } while (y)
+#else // WF_CONFIRM_WRITES
+#define DO_WHILE(x, y) x
+#endif // WF_CONFIRM_WRITES
+
 static enum wf_status status = WF_IDLE;
 static uint16_t wf_i = 0;
 static uint16_t step = 0;
     case OP_WAIT_TEMPERATURE:
         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(mem_data()->wf[wf_i].steps[step].val);
-        } while (volcano_get_target_temp() != mem_data()->wf[wf_i].steps[step].val);
+        DO_WHILE(volcano_set_target_temp(mem_data()->wf[wf_i].steps[step].val),
+                 volcano_get_target_temp() != mem_data()->wf[wf_i].steps[step].val);
         break;
 
     case OP_PUMP_TIME:
-        volcano_set_pump_state(true);
+        DO_WHILE(volcano_set_pump_state(true),
+                 !(volcano_get_state() & VOLCANO_STATE_PUMP));
         start_t = to_ms_since_boot(get_absolute_time());
         start_val = 0;
         debug("workflow pump %.3f s", mem_data()->wf[wf_i].steps[step].val / 1000.0);
      * this means we heat for some seconds before changing the setpoint.
      * should not be a problem in practice.
      */
-    volcano_set_heater_state(true);
+    DO_WHILE(volcano_set_heater_state(true),
+             !(volcano_get_state() & VOLCANO_STATE_HEATER));
     volcano_discover_characteristics();
 
     do_step();
 
     if (done) {
         if (mem_data()->wf[wf_i].steps[step].op == OP_PUMP_TIME) {
-            volcano_set_pump_state(false);
+            DO_WHILE(volcano_set_pump_state(false),
+                     volcano_get_state() & VOLCANO_STATE_PUMP);
         }
 
         step++;
         if (step >= mem_data()->wf[wf_i].count) {
             status = WF_IDLE;
-            volcano_set_heater_state(false);
+            DO_WHILE(volcano_set_heater_state(false),
+                     volcano_get_state() & VOLCANO_STATE_HEATER);
             debug("workflow finished");
         } else {
             do_step();

src/workflow_default.c

     { .op = OP_WAIT_TIME, .val = 1000 }, \
     { .op = OP_PUMP_TIME, .val = 1000 }
 
+#define NOTIFICATIONS NOTIFY, NOTIFY
+#define NOTIFICATIONS_LENGTH (2 * 2)
+
 const uint16_t wf_default_count = 5;
 
 const struct workflow wf_default_data[] = {
     {
-        .name = "XXL",
+        .name = "Default",
         .author = "xythobuz",
         .steps = {
             { .op = OP_WAIT_TEMPERATURE, .val = 1850 },
             { .op = OP_WAIT_TIME, .val = 10000 },
-            { .op = OP_PUMP_TIME, .val = 8000 },
+            { .op = OP_PUMP_TIME, .val = 5000 },
 
             { .op = OP_WAIT_TEMPERATURE, .val = 1950 },
             { .op = OP_WAIT_TIME, .val = 5000 },
-            { .op = OP_PUMP_TIME, .val = 25000 },
+            { .op = OP_PUMP_TIME, .val = 20000 },
 
             { .op = OP_WAIT_TEMPERATURE, .val = 2050 },
             { .op = OP_WAIT_TIME, .val = 5000 },
-            { .op = OP_PUMP_TIME, .val = 25000 },
+            { .op = OP_PUMP_TIME, .val = 20000 },
 
-            NOTIFY, NOTIFY, NOTIFY, NOTIFY,
+            NOTIFICATIONS,
 
             { .op = OP_SET_TEMPERATURE, .val = 1900 },
         },
-        .count = 18,
+        .count = 10 + NOTIFICATIONS_LENGTH,
     }, {
-        .name = "Default",
+        .name = "XXL",
         .author = "xythobuz",
         .steps = {
             { .op = OP_WAIT_TEMPERATURE, .val = 1850 },
             { .op = OP_WAIT_TIME, .val = 10000 },
-            { .op = OP_PUMP_TIME, .val = 5000 },
+            { .op = OP_PUMP_TIME, .val = 8000 },
 
             { .op = OP_WAIT_TEMPERATURE, .val = 1950 },
             { .op = OP_WAIT_TIME, .val = 5000 },
-            { .op = OP_PUMP_TIME, .val = 20000 },
+            { .op = OP_PUMP_TIME, .val = 25000 },
 
             { .op = OP_WAIT_TEMPERATURE, .val = 2050 },
             { .op = OP_WAIT_TIME, .val = 5000 },
-            { .op = OP_PUMP_TIME, .val = 20000 },
+            { .op = OP_PUMP_TIME, .val = 25000 },
 
-            NOTIFY, NOTIFY, NOTIFY, NOTIFY,
+            NOTIFICATIONS,
 
             { .op = OP_SET_TEMPERATURE, .val = 1900 },
         },
-        .count = 18,
+        .count = 10 + NOTIFICATIONS_LENGTH,
     }, {
         .name = "Vorbi",
         .author = "Rinor",
             { .op = OP_WAIT_TIME, .val = 5000 },
             { .op = OP_PUMP_TIME, .val = 20000 },
 
-            NOTIFY, NOTIFY, NOTIFY, NOTIFY,
+            NOTIFICATIONS,
 
             { .op = OP_SET_TEMPERATURE, .val = 1900 },
         },
-        .count = 18,
+        .count = 10 + NOTIFICATIONS_LENGTH,
     }, {
         .name = "Hotty",
         .author = "xythobuz",
             { .op = OP_WAIT_TIME, .val = 5000 },
             { .op = OP_PUMP_TIME, .val = 20000 },
 
-            NOTIFY, NOTIFY, NOTIFY, NOTIFY,
+            NOTIFICATIONS,
 
             { .op = OP_SET_TEMPERATURE, .val = 1900 },
         },
-        .count = 18,
+        .count = 10 + NOTIFICATIONS_LENGTH,
     },
 };