can also edit workflow steps

include/state_value.h

 
 void state_value_set(void *value, size_t length,
                      ssize_t min, ssize_t max,
-                     enum value_step_mode mode, ssize_t step);
+                     enum value_step_mode mode, ssize_t step,
+                     const char *name);
 void state_value_return(enum system_state state);
 
 void state_value_enter(void);

include/workflow.h

 
     uint16_t index;
     uint16_t count;
-    struct wf_step step;
+    struct wf_step *step;
     uint16_t start_val, curr_val;
 };
 
 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_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);

src/state_edit_workflow.c

 #include <string.h>
 
 #include "config.h"
+#include "mem.h"
 #include "menu.h"
 #include "workflow.h"
 #include "state.h"
+#include "state_value.h"
 #include "state_edit_workflow.h"
 
 static uint16_t wf_index = 0;
 
 static void enter_cb(int selection) {
+    static char buff[20];
+
     if ((selection >= 0) && (selection < wf_steps(wf_index))) {
-        // TODO edit value
+        struct wf_step *step = wf_get_step(wf_index, selection);
+        switch (step->op) {
+        case OP_SET_TEMPERATURE:
+        case OP_WAIT_TEMPERATURE:
+            snprintf(buff, sizeof(buff),
+                     "%s Temp.",
+                     step->op == OP_WAIT_TEMPERATURE ? "Wait" : "Set");
+            state_value_set(&step->val,
+                            sizeof(step->val),
+                            400, 2300, VAL_STEP_INCREMENT, 10,
+                            buff);
+            break;
+
+        case OP_WAIT_TIME:
+        case OP_PUMP_TIME:
+            snprintf(buff, sizeof(buff),
+                     "%s Time",
+                     step->op == OP_WAIT_TIME ? "Wait" : "Pump");
+            state_value_set(&step->val,
+                            sizeof(step->val),
+                            0, 60000, VAL_STEP_INCREMENT, 1000,
+                            buff);
+            break;
+        }
+
+        state_value_return(STATE_EDIT_WORKFLOW);
+        state_switch(STATE_VALUE);
     }
 }
 
             pos += snprintf(menu->buff + pos, MENU_MAX_LEN - pos, "  ");
         }
 
-        struct wf_step step = wf_get_step(wf_index, i);
+        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));
     }

src/state_settings.c

         // Auto Connect
         state_value_set(&mem_data()->wf_auto_connect,
                         sizeof(mem_data()->wf_auto_connect),
-                        0, 1, VAL_STEP_INCREMENT, 1);
+                        0, 1, VAL_STEP_INCREMENT, 1,
+                        "Auto Connect");
         state_value_return(STATE_SETTINGS);
         state_switch(STATE_VALUE);
         break;
         // Brightness
         state_value_set(&mem_data()->backlight,
                         sizeof(mem_data()->backlight),
-                        0x00FF, 0xFF00, VAL_STEP_SHIFT, 1);
+                        0x00FF, 0xFF00, VAL_STEP_SHIFT, 1,
+                        "Brightness");
         state_value_return(STATE_SETTINGS);
         state_switch(STATE_VALUE);
         break;

src/state_value.c

 static ssize_t val_min = 0;
 static ssize_t val_max = 0;
 static ssize_t val_step = 0;
+static const char *val_name = NULL;
 
 static enum value_step_mode val_mode = VAL_STEP_INCREMENT;
 static enum system_state val_ret_state = STATE_SCAN;
 
 void state_value_set(void *value, size_t length,
                      ssize_t min, ssize_t max,
-                     enum value_step_mode mode, ssize_t step) {
+                     enum value_step_mode mode, ssize_t step,
+                     const char *name) {
     val_p = value;
     val_len = length;
     val_min = min;
     val_max = max;
     val_mode = mode;
     val_step = step;
+    val_name = name;
 }
 
 void state_value_return(enum system_state state) {
     static char buff[100];
     static size_t pos = 0;
 
-    if ((val_p == NULL) || (val_len <= 0)) {
+    if ((val_p == NULL) || (val_len <= 0) || (val_name == NULL)) {
         pos += snprintf(buff, sizeof(buff),
                         "error");
     } else {
-        pos += snprintf(buff, sizeof(buff),
-                        "%d", val);
+        if (val_mode == VAL_STEP_INCREMENT) {
+            pos += snprintf(buff, sizeof(buff),
+                            "%s:\n%d -> %d -> %d",
+                            val_name, val_min / val_step, val / val_step, val_max / val_step);
+        } else {
+            pos += snprintf(buff, sizeof(buff),
+                            "%s:\n%04X -> %04X -> %04X",
+                            val_name, val_min, val, val_max);
+        }
     }
 
-    text_box(buff, false,
+    text_box(buff, true,
              "fixed_10x20",
              0, LCD_WIDTH,
              50, TEXT_BOX_HEIGHT(20, 2),
 
     if (((v > 0) && (val >= val_max))
         || ((v < 0) && (val <= val_min))) {
-        debug("val=%d v=%d", val, v);
         return;
     }
 

src/state_volcano_run.c

     pos += snprintf(menu->buff + pos, MENU_MAX_LEN - pos,
                     "step %d / %d\n", state.index, state.count);
 
-    switch (state.step.op) {
+    switch (state.step->op) {
     case OP_SET_TEMPERATURE:
         pos += snprintf(menu->buff + pos, MENU_MAX_LEN - pos,
                         "\n%s", wf_step_str(state.step));
                         "%.1f -> %.1f -> %.1f",
                         state.start_val / 10.0f,
                         state.curr_val / 10.0f,
-                        state.step.val / 10.0f);
+                        state.step->val / 10.0f);
         break;
 
     case OP_WAIT_TIME:
                         "%.0f -> %.0f -> %.0f",
                         state.start_val / 1000.0f,
                         state.curr_val / 1000.0f,
-                        state.step.val / 1000.0f);
+                        state.step->val / 1000.0f);
         break;
     }
 

src/workflow.c

     mem_data()->wf[index].steps[step] = tmp;
 }
 
-struct wf_step wf_get_step(uint16_t index, uint16_t step) {
+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 NULL;
     }
-    return mem_data()->wf[index].steps[step];
+    return &mem_data()->wf[index].steps[step];
 }
 
-const char *wf_step_str(struct wf_step step) {
+const char *wf_step_str(struct wf_step *step) {
     static char buff[20];
 
-    switch (step.op) {
+    switch (step->op) {
     case OP_SET_TEMPERATURE:
         snprintf(buff, sizeof(buff),
-                 "set temp %.1f C", step.val / 10.0f);
+                 "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);
+                 "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);
+                 (step->op == OP_WAIT_TIME) ? "wait" : "pump",
+                 step->val / 1000.0f);
         break;
     }
 
         .status = status,
         .index = step,
         .count = mem_data()->wf[wf_i].count,
-        .step = mem_data()->wf[wf_i].steps[step],
+        .step = &mem_data()->wf[wf_i].steps[step],
         .start_val = start_val,
         .curr_val = curr_val,
     };