add more volcano config options

CMakeLists.txt

     src/state_about.c
     src/state_value.c
     src/textbox.c
+    src/state_volcano_conf.c
 
     ${CMAKE_CURRENT_BINARY_DIR}/fatfs/ff.c
     ${CMAKE_CURRENT_BINARY_DIR}/fatfs/ffunicode.c

include/state.h

     STATE_SETTINGS,
     STATE_ABOUT,
     STATE_VALUE,
+    STATE_VOLCANO_CONF,
 
     STATE_INVALID,
 };

include/state_volcano_conf.h

+/*
+ * state_volcano_conf.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_CONF_H__
+#define __STATE_VOLCANO_CONF_H__
+
+#include <ble.h>
+
+void state_volcano_conf_target(bd_addr_t addr, bd_addr_type_t type);
+
+void state_volcano_conf_enter(void);
+void state_volcano_conf_exit(void);
+void state_volcano_conf_run(void);
+
+#endif // __STATE_VOLCANO_CONF_H__

include/volcano.h

 #include "models.h"
 
 enum volcano_state {
+    VOLCANO_STATE_NONE = 0,
     VOLCANO_STATE_HEATER = (1 << 0),
     VOLCANO_STATE_PUMP = (1 << 1),
+    VOLCANO_STATE_INVALID = 0xFF,
 };
 
 // returns < 0 on error
 // returns < 0 on error
 int8_t volcano_set_heater_state(bool value);
 int8_t volcano_set_pump_state(bool value);
+int8_t volcano_set_unit(enum unit unit);
+int8_t volcano_set_vibration(bool value);
+int8_t volcano_set_display_cooling(bool value);
 
 enum unit volcano_get_unit(void);
 enum volcano_state volcano_get_state(void);
 
+// returns bool, or < 0 on error
+int8_t volcano_get_vibration(void);
+int8_t volcano_get_display_cooling(void);
+
 #endif // __VOLCANO_H__

src/console.c

         println("   text - draw text on screen");
         println("    bat - draw battery indicator");
         println("");
-        println("   vrct - Volcano read current temperature");
-        println("   vrtt - Volcano read target temperature");
+        println("     vr - Volcano read values");
         println(" vwtt X - Volcano write target temperature");
         println("  vwh X - Set heater to 1 or 0");
         println("  vwp X - Set pump to 1 or 0");
+        println("  vwu X - Set unit to C or F");
+        println("  vwv X - Set vibration to 1 or 0");
+        println(" vwdc X - Set display cooling to 1 or 0");
         println("");
         println("    wfl - List available workflows");
         println("   wf X - Run workflow");
         }
     } else if (strcmp(line, "bat") == 0) {
         draw_battery_indicator();
-    } else if (strcmp(line, "vrct") == 0) {
+    } else if (strcmp(line, "vr") == 0) {
 #ifdef TEST_VOLCANO_AUTO_CONNECT
         DEV_AUTO_CONNECT(TEST_VOLCANO_AUTO_CONNECT);
 #endif // TEST_VOLCANO_AUTO_CONNECT
 
-        int16_t r = volcano_get_current_temp();
-        println("volcano current temp: %.1f", r / 10.0);
+        int16_t temp = volcano_get_current_temp();
+        println("volcano current temp: %.1f", temp / 10.0);
 
-#ifdef TEST_VOLCANO_AUTO_CONNECT
-        ble_disconnect();
-#endif // TEST_VOLCANO_AUTO_CONNECT
-    } else if (strcmp(line, "vrtt") == 0) {
-#ifdef TEST_VOLCANO_AUTO_CONNECT
-        DEV_AUTO_CONNECT(TEST_VOLCANO_AUTO_CONNECT);
-#endif // TEST_VOLCANO_AUTO_CONNECT
+        temp = volcano_get_target_temp();
+        println("volcano target temp: %.1f", temp / 10.0);
+
+        enum unit unit = volcano_get_unit();
+        println("volcano unit: %s", (unit == UNIT_C) ? "C" : "F");
+
+        enum volcano_state state = volcano_get_state();
+        println("volcano state: 0x%02X", state);
 
-        int16_t r = volcano_get_target_temp();
-        println("volcano target temp: %.1f", r / 10.0);
+        int8_t r = volcano_get_vibration();
+        println("volcano vibration: %d", r);
+
+        r = volcano_get_display_cooling();
+        println("volcano display cooling: %d", r);
 
 #ifdef TEST_VOLCANO_AUTO_CONNECT
         ble_disconnect();
                 println("success");
             }
         }
+    } else if (str_startswith(line, "vwu ")) {
+        char val;
+        int r = sscanf(line, "vwu %c", &val);
+        if ((r != 1) || ((val != 'C') && (val != 'F'))) {
+            println("invalid input (%d %c)", r, val);
+        } else {
+#ifdef TEST_VOLCANO_AUTO_CONNECT
+            DEV_AUTO_CONNECT(TEST_VOLCANO_AUTO_CONNECT);
+#endif // TEST_VOLCANO_AUTO_CONNECT
+
+            int8_t r = volcano_set_unit((val == 'C') ? UNIT_C : UNIT_F);
+
+#ifdef TEST_VOLCANO_AUTO_CONNECT
+            ble_disconnect();
+#endif // TEST_VOLCANO_AUTO_CONNECT
+
+            if (r < 0) {
+                println("error writing value %d", r);
+            } else {
+                println("success");
+            }
+        }
+    } else if (str_startswith(line, "vwv ")) {
+        int val;
+        int r = sscanf(line, "vwv %d", &val);
+        if ((r != 1) || ((val != 0) && (val != 1))) {
+            println("invalid input (%d %d)", r, val);
+        } else {
+#ifdef TEST_VOLCANO_AUTO_CONNECT
+            DEV_AUTO_CONNECT(TEST_VOLCANO_AUTO_CONNECT);
+#endif // TEST_VOLCANO_AUTO_CONNECT
+
+            int8_t r = volcano_set_vibration(val == 1);
+
+#ifdef TEST_VOLCANO_AUTO_CONNECT
+            ble_disconnect();
+#endif // TEST_VOLCANO_AUTO_CONNECT
+
+            if (r < 0) {
+                println("error writing value %d", r);
+            } else {
+                println("success");
+            }
+        }
+    } else if (str_startswith(line, "vwdc ")) {
+        int val;
+        int r = sscanf(line, "vwdc %d", &val);
+        if ((r != 1) || ((val != 0) && (val != 1))) {
+            println("invalid input (%d %d)", r, val);
+        } else {
+#ifdef TEST_VOLCANO_AUTO_CONNECT
+            DEV_AUTO_CONNECT(TEST_VOLCANO_AUTO_CONNECT);
+#endif // TEST_VOLCANO_AUTO_CONNECT
+
+            int8_t r = volcano_set_display_cooling(val == 1);
+
+#ifdef TEST_VOLCANO_AUTO_CONNECT
+            ble_disconnect();
+#endif // TEST_VOLCANO_AUTO_CONNECT
+
+            if (r < 0) {
+                println("error writing value %d", r);
+            } else {
+                println("success");
+            }
+        }
     } else if (strcmp(line, "wfl") == 0) {
         println("%d workflows", wf_count());
         for (int i = 0; i < wf_count(); i++) {

src/state.c

 #include "state_settings.h"
 #include "state_about.h"
 #include "state_value.h"
+#include "state_volcano_conf.h"
 #include "state.h"
 
 #define stringify(name) # name
         .exit = state_value_exit,
         .run = state_value_run,
     }, {
+        .name = stringify(STATE_VOLCANO_CONF),
+        .enter = state_volcano_conf_enter,
+        .exit = state_volcano_conf_exit,
+        .run = state_volcano_conf_run,
+    }, {
         .name = stringify(STATE_INVALID),
         .enter = NULL,
         .exit = NULL,

src/state_scan.c

 #include "state.h"
 #include "state_workflow.h"
 #include "state_volcano_run.h"
+#include "state_volcano_conf.h"
 #include "state_crafty.h"
 #include "state_scan.h"
 
     }
 }
 
+static void edit_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 (devs++ == selection) {
+            if (dev == DEV_VOLCANO) {
+                state_volcano_conf_target(results[i].addr, results[i].type);
+                state_switch(STATE_VOLCANO_CONF);
+            } else if (dev == DEV_CRAFTY) {
+                state_crafty_target(results[i].addr, results[i].type);
+                state_switch(STATE_CRAFTY);
+            }
+            return;
+        }
+    }
+
+    if (selection == devs) {
+        state_switch(STATE_SETTINGS);
+    } else if (selection == (devs + 1)) {
+        state_switch(STATE_ABOUT);
+    }
+}
+
 void state_scan_enter(void) {
-    menu_init(enter_cb, NULL, NULL, NULL);
+    menu_init(enter_cb, edit_cb, NULL, NULL);
     ble_scan(BLE_SCAN_ON);
 }
 

src/state_volcano_conf.c

+/*
+ * state_volcano_conf.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 "config.h"
+#include "log.h"
+#include "menu.h"
+#include "volcano.h"
+#include "state.h"
+#include "state_value.h"
+#include "state_volcano_conf.h"
+
+static bd_addr_t ble_addr = {0};
+static bd_addr_type_t ble_type = 0;
+static bool wait_for_connect = false;
+static bool wait_for_disconnect = false;
+static bool connected = false;
+
+static bool val_celsius = false;
+static bool val_vibrate = false;
+static bool val_disp_cool = false;
+
+void state_volcano_conf_target(bd_addr_t addr, bd_addr_type_t type) {
+    debug("%s %d", bd_addr_to_str(addr), type);
+    memcpy(ble_addr, addr, sizeof(bd_addr_t));
+    ble_type = type;
+
+    connected = false;
+}
+
+static void enter_cb(int selection) {
+    switch (selection) {
+    case 0:
+        // Celsius
+        state_value_set(&val_celsius,
+                        sizeof(val_celsius),
+                        0, 1, VAL_STEP_INCREMENT, 1,
+                        "Celsius");
+        state_value_return(STATE_VOLCANO_CONF);
+        state_switch(STATE_VALUE);
+        break;
+
+    case 1:
+        // Vibrate
+        state_value_set(&val_vibrate,
+                        sizeof(val_vibrate),
+                        0, 1, VAL_STEP_INCREMENT, 1,
+                        "Vibrate");
+        state_value_return(STATE_VOLCANO_CONF);
+        state_switch(STATE_VALUE);
+        break;
+
+    case 2:
+        // Disp. Cool
+        state_value_set(&val_disp_cool,
+                        sizeof(val_disp_cool),
+                        0, 1, VAL_STEP_INCREMENT, 1,
+                        "Disp. Cool");
+        state_value_return(STATE_VOLCANO_CONF);
+        state_switch(STATE_VALUE);
+        break;
+    }
+}
+
+static void send_values(void) {
+    volcano_set_unit(val_celsius ? UNIT_C : UNIT_F);
+    sleep_ms(100);
+    volcano_set_vibration(val_vibrate);
+    sleep_ms(100);
+    volcano_set_display_cooling(val_disp_cool);
+}
+
+static void fetch_values(void) {
+    enum unit unit = volcano_get_unit();
+    val_celsius = (unit == UNIT_C);
+
+    int8_t r = volcano_get_vibration();
+    val_vibrate = (r == 1);
+
+    r = volcano_get_display_cooling();
+    val_disp_cool = (r == 1);
+}
+
+static void exit_cb(void) {
+    debug("volcano disconnect");
+    ble_disconnect();
+    wait_for_disconnect = true;
+}
+
+void state_volcano_conf_enter(void) {
+    menu_init(enter_cb, NULL, NULL, exit_cb);
+
+    if (!connected) {
+        debug("volcano connect");
+        ble_connect(ble_addr, ble_type);
+        wait_for_connect = true;
+    } else {
+        debug("volcano write");
+        send_values();
+    }
+}
+
+void state_volcano_conf_exit(void) {
+    menu_deinit();
+}
+
+static void draw(struct menu_state *menu) {
+    if (wait_for_connect) {
+        snprintf(menu->buff, MENU_MAX_LEN,
+                 "Connecting\nand\nDiscovering");
+        return;
+    } else if (wait_for_disconnect) {
+        snprintf(menu->buff, MENU_MAX_LEN,
+                 "\nDisconnecting");
+        return;
+    }
+
+    int pos = 0;
+    menu->length = 0;
+
+    ADD_STATIC_ELEMENT("Celsius");
+    ADD_STATIC_ELEMENT("Vibrate");
+    ADD_STATIC_ELEMENT("Disp. Cool");
+
+    if (menu->selection < 0) {
+        menu->selection = 0;
+    }
+}
+
+void state_volcano_conf_run(void) {
+    if (wait_for_connect && ble_is_connected()) {
+        wait_for_connect = false;
+        connected = true;
+        debug("volcano start");
+        fetch_values();
+    }
+
+    menu_run(draw, true);
+
+    // back to main menu when disconnected
+    if (wait_for_disconnect && !ble_is_connected()) {
+        wait_for_disconnect = false;
+        connected = false;
+        debug("volcano done");
+        state_switch(STATE_SCAN);
+    }
+}

src/volcano.c

 #include "volcano.h"
 
 #define UUID_SRVC_1       0x10
-#define UUID_GET_STATE    0x0C
-#define UUID_GET_UNIT     0x0D
+#define UUID_PRJSTAT1     0x0C
+#define UUID_PRJSTAT2     0x0D
+#define UUID_PRJSTAT3     0x0E
 
 #define UUID_SRVC_2       0x11
 #define UUID_WRITE_SRVC   0x00
 #define UUID_PUMP_ON      0x13
 #define UUID_PUMP_OFF     0x14
 
+#define MASK_PRJSTAT1_HEIZUNG_ENA        0x0020
+#define MASK_PRJSTAT1_AUTOBLESHUTDOWN    0x0200
+#define MASK_PRJSTAT1_PUMPE_FET_ENABLE   0x2000
+
+#define MASK_PRJSTAT2_FAHRENHEIT_ENA     0x0200
+#define MASK_PRJSTAT2_DISPLAY_ON_COOLING 0x1000
+
+#define MASK_PRJSTAT3_VIBRATION          0x0400
+
 // "10xx00xx-5354-4f52-5a26-4249434b454c"
 static uint8_t uuid_base[16] = {
     0x10, 0xFF, 0x00, 0xFF, 0x53, 0x54, 0x4f, 0x52,
 
 enum unit volcano_get_unit(void) {
     uuid_base[1] = UUID_SRVC_1;
-    uuid_base[3] = UUID_GET_UNIT;
+    uuid_base[3] = UUID_PRJSTAT2;
 
     uint8_t buff[4];
     int32_t r = ble_read(uuid_base, buff, sizeof(buff));
     }
 
     uint32_t *v = (uint32_t *)buff;
-    return (*v & 0x200) ? UNIT_F : UNIT_C;
+    return (*v & MASK_PRJSTAT2_FAHRENHEIT_ENA) ? UNIT_F : UNIT_C;
 }
 
 enum volcano_state volcano_get_state(void) {
     uuid_base[1] = UUID_SRVC_1;
-    uuid_base[3] = UUID_GET_STATE;
+    uuid_base[3] = UUID_PRJSTAT1;
 
     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;
+        return VOLCANO_STATE_INVALID;
     }
 
     uint32_t *v = (uint32_t *)buff;
-    uint32_t heater = (*v & 0x0020);
-    uint32_t pump = (*v & 0x2000);
+    uint32_t heater = (*v & MASK_PRJSTAT1_HEIZUNG_ENA);
+    uint32_t pump = (*v & MASK_PRJSTAT1_PUMPE_FET_ENABLE);
     return (heater ? VOLCANO_STATE_HEATER : 0) | (pump ? VOLCANO_STATE_PUMP : 0);
 }
+
+int8_t volcano_set_unit(enum unit unit) {
+    uuid_base[1] = UUID_SRVC_1;
+    uuid_base2[1] = UUID_SRVC_1;
+    uuid_base[3] = UUID_WRITE_SRVC;
+    uuid_base2[3] = UUID_PRJSTAT2;
+
+    uint32_t v = MASK_PRJSTAT2_FAHRENHEIT_ENA;
+    if (unit == UNIT_F) {
+        v |= 0x10000;
+    }
+
+    int8_t r = ble_write(uuid_base, uuid_base2, (uint8_t *)&v, sizeof(v));
+    if (r != 0) {
+        debug("ble_write unexpected value %d", r);
+    }
+    return r;
+}
+
+int8_t volcano_set_vibration(bool value) {
+    uuid_base[1] = UUID_SRVC_1;
+    uuid_base2[1] = UUID_SRVC_1;
+    uuid_base[3] = UUID_WRITE_SRVC;
+    uuid_base2[3] = UUID_PRJSTAT3;
+
+    uint32_t v = MASK_PRJSTAT3_VIBRATION;
+    if (!value) {
+        v |= 0x10000;
+    }
+
+    int8_t r = ble_write(uuid_base, uuid_base2, (uint8_t *)&v, sizeof(v));
+    if (r != 0) {
+        debug("ble_write unexpected value %d", r);
+    }
+    return r;
+}
+
+int8_t volcano_get_vibration(void) {
+    uuid_base[1] = UUID_SRVC_1;
+    uuid_base[3] = UUID_PRJSTAT3;
+
+    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 -1;
+    }
+
+    uint32_t *v = (uint32_t *)buff;
+    return (*v & MASK_PRJSTAT3_VIBRATION) ? 0 : 1;
+}
+
+int8_t volcano_set_display_cooling(bool value) {
+    uuid_base[1] = UUID_SRVC_1;
+    uuid_base2[1] = UUID_SRVC_1;
+    uuid_base[3] = UUID_WRITE_SRVC;
+    uuid_base2[3] = UUID_PRJSTAT2;
+
+    uint32_t v = MASK_PRJSTAT2_DISPLAY_ON_COOLING;
+    if (!value) {
+        v |= 0x10000;
+    }
+
+    int8_t r = ble_write(uuid_base, uuid_base2, (uint8_t *)&v, sizeof(v));
+    if (r != 0) {
+        debug("ble_write unexpected value %d", r);
+    }
+    return r;
+
+}
+
+int8_t volcano_get_display_cooling(void) {
+    uuid_base[1] = UUID_SRVC_1;
+    uuid_base[3] = UUID_PRJSTAT2;
+
+    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 -1;
+    }
+
+    uint32_t *v = (uint32_t *)buff;
+    return (*v & MASK_PRJSTAT2_DISPLAY_ON_COOLING) ? 0 : 1;
+}