untested venty handler

CMakeLists.txt

@@ -95,6 +95,8 @@ target_sources(gadget PUBLIC
     src/state_value.c
     src/textbox.c
     src/state_volcano_conf.c
+    src/venty.c
+    src/state_venty.c
 
     ${CMAKE_CURRENT_BINARY_DIR}/fatfs/ff.c
     ${CMAKE_CURRENT_BINARY_DIR}/fatfs/ffunicode.c

README.md

@@ -4,6 +4,7 @@ Supports:
 
  * workflows for the Volcano Hybrid
  * basic status and settings for Crafty+
+ * some settings for Venty (untested)
 
 For use with Raspberry Pi Pico W boards with the [Waveshare Pico LCD 1.3](https://www.waveshare.com/wiki/Pico-LCD-1.3) and the [Pimoroni Pico Lipo Shim](https://shop.pimoroni.com/products/pico-lipo-shim).
 

include/models.h

@@ -25,6 +25,7 @@ enum known_devices {
     DEV_UNKNOWN = 0,
     DEV_VOLCANO,
     DEV_CRAFTY,
+    DEV_VENTY,
 };
 
 enum unit {
@@ -34,6 +35,9 @@ enum unit {
 };
 
 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);
+
+int8_t models_get_serial(enum known_devices dev, const char *name,
+                         const uint8_t *data, size_t data_len,
+                         char *buff, size_t buff_len);
 
 #endif // __MODELS_H__

include/state.h

@@ -30,6 +30,7 @@ enum system_state {
     STATE_ABOUT,
     STATE_VALUE,
     STATE_VOLCANO_CONF,
+    STATE_VENTY,
 
     STATE_INVALID,
 };

include/state_venty.h

@@ -0,0 +1,30 @@
+/*
+ * state_venty.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_VENTY_H__
+#define __STATE_VENTY_H__
+
+#include <ble.h>
+
+void state_venty_target(bd_addr_t addr, bd_addr_type_t type);
+
+void state_venty_enter(void);
+void state_venty_exit(void);
+void state_venty_run(void);
+
+#endif // __STATE_VENTY_H__

include/venty.h

@@ -0,0 +1,43 @@
+/*
+ * venty.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 __VENTY_H__
+#define __VENTY_H__
+
+#include <stdint.h>
+#include <stdbool.h>
+
+// in 1/10th degrees C, or < 0 on error
+int16_t venty_get_target_temp(void);
+
+// v in 1/10th degrees C, returns < 0 on error
+int8_t venty_set_target_temp(uint16_t value);
+
+// returns < 0 on error
+int8_t venty_set_heater_state(bool value);
+int8_t venty_set_eco_current(bool value);
+int8_t venty_set_eco_voltage(bool value);
+
+// in percent, or < 0 on error
+int8_t venty_get_battery_state(void);
+
+// bool, or < 0 on error
+int8_t venty_get_eco_current(void);
+int8_t venty_get_eco_voltage(void);
+
+#endif // __VENTY_H__

picowota

@@ -0,0 +1 @@
+Subproject commit ac8960b274f0f76013364a9b83325036cb52f030

src/console.c

@@ -165,7 +165,8 @@ static void cnsl_interpret(const char *line) {
                 char info[32] = "";
                 enum known_devices dev = models_filter_name(results[i].name);
                 if (dev != DEV_UNKNOWN) {
-                    models_get_serial(results[i].data, results[i].data_len,
+                    models_get_serial(dev, results[i].name,
+                                      results[i].data, results[i].data_len,
                                       info, sizeof(info));
                 }
                 uint32_t age = to_ms_since_boot(get_absolute_time()) - results[i].time;

src/models.c

@@ -31,22 +31,49 @@ enum known_devices models_filter_name(const char *name) {
         return DEV_VOLCANO;
     } else if (strcmp(name, "STORZ&BICKEL") == 0) {
         return DEV_CRAFTY;
+    } else if (str_startswith(name, "S&B VY")) {
+        return DEV_VENTY;
     } else {
         return DEV_UNKNOWN;
     }
 }
 
-int8_t models_get_serial(const uint8_t *data, size_t data_len, char *buff, size_t buff_len) {
-    if ((data == NULL) || (data_len <= 0) || (buff == NULL) || (buff_len <= 0)) {
+int8_t models_get_serial(enum known_devices dev, const char *name,
+                         const uint8_t *data, size_t data_len,
+                         char *buff, size_t buff_len) {
+    if ((name == NULL) || (data == NULL)
+        || (buff == NULL) || (buff_len <= 0)) {
         return -1;
     }
 
-    const size_t serial_len = 8;
-    const size_t serial_off = 2;
-    if ((data_len < (serial_len + serial_off)) || (buff_len < (serial_len + 1))) {
+    size_t serial_len, serial_off, src_len;
+    const uint8_t *src;
+
+    switch (dev) {
+    case DEV_VOLCANO:
+    case DEV_CRAFTY:
+        serial_len = 8;
+        serial_off = 2;
+        src = data;
+        src_len = data_len;
+        break;
+
+    case DEV_VENTY:
+        serial_len = 8;
+        serial_off = 4;
+        src = (const uint8_t *)name;
+        src_len = strlen(name);
+        break;
+
+    default:
         return -2;
     }
-    memcpy(buff, data + serial_off, serial_len);
+
+    if ((src_len < (serial_len + serial_off)) || (buff_len < (serial_len + 1))) {
+        return -3;
+    }
+
+    memcpy(buff, src + serial_off, serial_len);
     buff[serial_len] = '\0';
 
     return 0;

src/state.c

@@ -27,6 +27,7 @@
 #include "state_about.h"
 #include "state_value.h"
 #include "state_volcano_conf.h"
+#include "state_venty.h"
 #include "state.h"
 
 #define stringify(name) # name
@@ -90,6 +91,11 @@ static const struct state states[STATE_INVALID + 1] = {
         .exit = state_volcano_conf_exit,
         .run = state_volcano_conf_run,
     }, {
+        .name = stringify(STATE_VENTY),
+        .enter = state_venty_enter,
+        .exit = state_venty_exit,
+        .run = state_venty_run,
+    }, {
         .name = stringify(STATE_INVALID),
         .enter = NULL,
         .exit = NULL,

src/state_scan.c

@@ -31,6 +31,7 @@
 #include "state_volcano_run.h"
 #include "state_volcano_conf.h"
 #include "state_crafty.h"
+#include "state_venty.h"
 #include "state_scan.h"
 
 static struct ble_scan_result results[BLE_MAX_SCAN_RESULTS] = {0};
@@ -54,6 +55,9 @@ static void enter_cb(int selection) {
             } else if (dev == DEV_CRAFTY) {
                 state_crafty_target(results[i].addr, results[i].type);
                 state_switch(STATE_CRAFTY);
+            } else if (dev == DEV_VENTY) {
+                state_venty_target(results[i].addr, results[i].type);
+                state_switch(STATE_VENTY);
             }
             return;
         }
@@ -81,6 +85,9 @@ static void edit_cb(int selection) {
             } else if (dev == DEV_CRAFTY) {
                 state_crafty_target(results[i].addr, results[i].type);
                 state_switch(STATE_CRAFTY);
+            } else if (dev == DEV_VENTY) {
+                state_venty_target(results[i].addr, results[i].type);
+                state_switch(STATE_VENTY);
             }
             return;
         }
@@ -160,10 +167,13 @@ static void draw(struct menu_state *menu) {
             pos += snprintf(menu->buff + pos, MENU_MAX_LEN - pos, "Volcano ");
         } else if (dev == DEV_CRAFTY) {
             pos += snprintf(menu->buff + pos, MENU_MAX_LEN - pos, "Crafty+ ");
+        } else if (dev == DEV_VENTY) {
+            pos += snprintf(menu->buff + pos, MENU_MAX_LEN - pos, "Venty ");
         }
 
         char info[32] = "";
-        if (models_get_serial(results[i].data, results[i].data_len,
+        if (models_get_serial(dev, results[i].name,
+                              results[i].data, results[i].data_len,
                               info, sizeof(info)) < 0) {
             strcpy(info, "-error-");
         }

src/state_venty.c

@@ -0,0 +1,178 @@
+/*
+ * state_venty.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 "venty.h"
+#include "log.h"
+#include "state.h"
+#include "state_value.h"
+#include "state_venty.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 heater_state = false;
+static int16_t target_temp = 0;
+static int8_t battery = 0;
+static int8_t eco_current = 0;
+static int8_t eco_voltage = 0;
+
+void state_venty_target(bd_addr_t addr, bd_addr_type_t type) {
+    memcpy(ble_addr, addr, sizeof(bd_addr_t));
+    ble_type = type;
+
+    connected = false;
+}
+
+static void enter_cb(int selection) {
+    switch (selection) {
+    case 0:
+        // Target
+        state_value_set(&target_temp,
+                        sizeof(target_temp),
+                        400, 2100, VAL_STEP_INCREMENT, 10,
+                        "Target");
+        state_value_return(STATE_VENTY);
+        state_switch(STATE_VALUE);
+        break;
+
+    case 1:
+        // Heater
+        state_value_set(&heater_state,
+                        sizeof(heater_state),
+                        0, 1, VAL_STEP_INCREMENT, 1,
+                        "Heater");
+        state_value_return(STATE_VENTY);
+        state_switch(STATE_VALUE);
+        break;
+
+    case 2:
+        // Eco Current
+        state_value_set(&eco_current,
+                        sizeof(eco_current),
+                        0, 1, VAL_STEP_INCREMENT, 1,
+                        "Eco Amps");
+        state_value_return(STATE_VENTY);
+        state_switch(STATE_VALUE);
+        break;
+
+    case 3:
+        // Eco Voltage
+        state_value_set(&eco_voltage,
+                        sizeof(eco_voltage),
+                        0, 1, VAL_STEP_INCREMENT, 1,
+                        "Eco Volt");
+        state_value_return(STATE_VENTY);
+        state_switch(STATE_VALUE);
+        break;
+    }
+}
+
+static void send_values(void) {
+    venty_set_heater_state(heater_state);
+    sleep_ms(250);
+    venty_set_target_temp(target_temp);
+    sleep_ms(250);
+    venty_set_eco_current(eco_current);
+    sleep_ms(250);
+    venty_set_eco_voltage(eco_voltage);
+}
+
+
+static void fetch_values(void) {
+    venty_set_heater_state(false);
+    heater_state = false;
+
+    target_temp = venty_get_target_temp();
+    battery = venty_get_battery_state();
+    eco_current = venty_get_eco_current();
+    eco_voltage = venty_get_eco_voltage();
+}
+
+static void exit_cb(void) {
+    debug("venty disconnect");
+    ble_disconnect();
+    wait_for_disconnect = true;
+}
+
+void state_venty_enter(void) {
+    menu_init(enter_cb, NULL, NULL, exit_cb);
+
+    if (!connected) {
+        debug("venty connect");
+        ble_connect(ble_addr, ble_type);
+        wait_for_connect = true;
+    } else {
+        debug("venty write");
+        send_values();
+    }
+}
+
+void state_venty_exit(void) {
+    menu_deinit();
+}
+
+static void draw(struct menu_state *menu) {
+    if (wait_for_connect) {
+        snprintf(menu->buff, MENU_MAX_LEN,
+                 "\nConnecting");
+        return;
+    } else if (wait_for_disconnect) {
+        snprintf(menu->buff, MENU_MAX_LEN,
+                 "\nDisconnecting");
+        return;
+    }
+
+    int pos = 0;
+    menu->length = 0;
+
+    ADD_STATIC_ELEMENT("Target (%d C)", target_temp / 10);
+    ADD_STATIC_ELEMENT("Heater (%d)", heater_state);
+    ADD_STATIC_ELEMENT("Eco Amps (%d)", eco_current);
+    ADD_STATIC_ELEMENT("Eco Volt (%d)", eco_voltage);
+    ADD_STATIC_ELEMENT("Battery: %d %%", battery);
+
+    if (menu->selection < 0) {
+        menu->selection = 0;
+    }
+}
+
+void state_venty_run(void) {
+    if (wait_for_connect && ble_is_connected()) {
+        wait_for_connect = false;
+        connected = true;
+        debug("venty start");
+        fetch_values();
+    }
+
+    menu_run(draw, true);
+
+    if (wait_for_disconnect && !ble_is_connected()) {
+        wait_for_disconnect = false;
+        connected = false;
+        debug("venty done");
+        state_switch(STATE_SCAN);
+    }
+}

src/venty.c

@@ -0,0 +1,209 @@
+/*
+ * venty.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 "ble.h"
+#include "main.h"
+#include "venty.h"
+
+#define VENTY_READ_TIMEOUT_MS 500
+
+enum venty_values {
+    MASK_SET_TEMPERATURE = 1 << 1,
+    MASK_SET_BOOST       = 1 << 2,
+    MASK_SET_SUPERBOOST  = 1 << 3,
+    MASK_HEATER          = 1 << 5,
+    MASK_SETTINGS        = 1 << 7,
+};
+
+enum venty_settings {
+    SETTING_UNIT                = 1 << 0,
+    SETTING_SETPOINT_REACHED    = 1 << 1,
+    SETTING_FACTORY_RESET       = 1 << 2,
+    SETTING_ECOMODE_CHARGE      = 1 << 3,
+    SETTING_BUTTON_CHANGED      = 1 << 4,
+    SETTING_ECOMODE_VOLTAGE     = 1 << 5,
+    SETTING_BOOST_VISUALIZATION = 1 << 6,
+};
+
+// "00000000-5354-4f52-5a26-4249434b454c"
+static uint8_t uuid_service[16] = {
+    0x00, 0x00, 0x00, 0x00, 0x53, 0x54, 0x4f, 0x52,
+    0x5a, 0x26, 0x42, 0x49, 0x43, 0x4b, 0x45, 0x4c,
+};
+
+// "00000001-5354-4f52-5a26-4249434b454c"
+static uint8_t uuid_characteristic[16] = {
+    0x00, 0x00, 0x00, 0x01, 0x53, 0x54, 0x4f, 0x52,
+    0x5a, 0x26, 0x42, 0x49, 0x43, 0x4b, 0x45, 0x4c,
+};
+
+static int8_t venty_cmd(uint8_t *rx, size_t rx_len,
+                        const uint8_t *tx, size_t tx_len) {
+    int8_t r = ble_notification_enable(uuid_service, uuid_characteristic);
+    if (r < 0) {
+        debug("ble_notification_enable failed: %d", r);
+        ble_notification_disable(uuid_service, uuid_characteristic);
+        return r;
+    }
+
+    r = ble_write(uuid_service, uuid_characteristic,
+                         tx, tx_len);
+    if (r < 0) {
+        debug("ble_write failed: %d", r);
+        ble_notification_disable(uuid_service, uuid_characteristic);
+        return r;
+    }
+
+    uint32_t start_time = to_ms_since_boot(get_absolute_time());
+    while (!ble_notification_ready()) {
+        sleep_ms(1);
+        main_loop_hw();
+
+        uint32_t now = to_ms_since_boot(get_absolute_time());
+        if ((now - start_time) >= VENTY_READ_TIMEOUT_MS) {
+            debug("timeout waiting for notification");
+            ble_notification_disable(uuid_service, uuid_characteristic);
+            return -1;
+        }
+    }
+
+    uint8_t uuid[16] = {0};
+    uint16_t len = ble_notification_get(rx, rx_len, uuid);
+
+    if (memcmp(uuid, uuid_characteristic, 16) != 0) {
+        debug("got notification for unexpected uuid");
+        len = 0;
+    }
+
+    ble_notification_disable(uuid_service, uuid_characteristic);
+    return (len <= 0) ? -1 : 0;
+}
+
+int16_t venty_get_target_temp(void) {
+    uint8_t cmd[20] = {0};
+    uint8_t buff[20] = {0};
+
+    cmd[0] = 1;
+
+    int8_t r = venty_cmd(buff, sizeof(buff), cmd, sizeof(cmd));
+    if (r < 0) {
+        return r;
+    }
+
+    int16_t *val = (int16_t *)(buff + 4);
+    return *val;
+}
+
+int8_t venty_set_target_temp(uint16_t value) {
+    uint8_t cmd[20] = {0};
+    uint8_t buff[20] = {0};
+
+    cmd[0] = 1;
+    cmd[1] = MASK_SET_TEMPERATURE;
+    uint16_t *val = (uint16_t *)(cmd + 4);
+    *val = value;
+
+    int8_t r = venty_cmd(buff, sizeof(buff), cmd, sizeof(cmd));
+    return r;
+}
+
+int8_t venty_set_heater_state(bool value) {
+    uint8_t cmd[20] = {0};
+    uint8_t buff[20] = {0};
+
+    cmd[0] = 1;
+    cmd[1] = MASK_HEATER;
+    cmd[11] = value ? 1 : 0;
+
+    int8_t r = venty_cmd(buff, sizeof(buff), cmd, sizeof(cmd));
+    return r;
+}
+
+int8_t venty_get_battery_state(void) {
+    uint8_t cmd[20] = {0};
+    uint8_t buff[20] = {0};
+
+    cmd[0] = 1;
+
+    int8_t r = venty_cmd(buff, sizeof(buff), cmd, sizeof(cmd));
+    if (r < 0) {
+        return r;
+    }
+
+    int8_t *val = (int8_t *)(buff + 8);
+    return *val;
+}
+
+int8_t venty_get_eco_current(void) {
+    uint8_t cmd[20] = {0};
+    uint8_t buff[20] = {0};
+
+    cmd[0] = 1;
+
+    int8_t r = venty_cmd(buff, sizeof(buff), cmd, sizeof(cmd));
+    if (r < 0) {
+        return r;
+    }
+
+    int8_t *val = (int8_t *)(buff + 14);
+    return (*val & SETTING_ECOMODE_CHARGE) ? 1 : 0;
+
+}
+
+int8_t venty_get_eco_voltage(void) {
+    uint8_t cmd[20] = {0};
+    uint8_t buff[20] = {0};
+
+    cmd[0] = 1;
+
+    int8_t r = venty_cmd(buff, sizeof(buff), cmd, sizeof(cmd));
+    if (r < 0) {
+        return r;
+    }
+
+    int8_t *val = (int8_t *)(buff + 14);
+    return (*val & SETTING_ECOMODE_VOLTAGE) ? 1 : 0;
+}
+
+int8_t venty_set_eco_current(bool value) {
+    uint8_t cmd[20] = {0};
+    uint8_t buff[20] = {0};
+
+    cmd[0] = 1;
+    cmd[1] = MASK_SETTINGS;
+    cmd[14] = value ? SETTING_ECOMODE_CHARGE : 0;
+    cmd[15] = SETTING_ECOMODE_CHARGE;
+
+    int8_t r = venty_cmd(buff, sizeof(buff), cmd, sizeof(cmd));
+    return r;
+}
+
+int8_t venty_set_eco_voltage(bool value) {
+    uint8_t cmd[20] = {0};
+    uint8_t buff[20] = {0};
+
+    cmd[0] = 1;
+    cmd[1] = MASK_SETTINGS;
+    cmd[14] = value ? SETTING_ECOMODE_VOLTAGE : 0;
+    cmd[15] = SETTING_ECOMODE_VOLTAGE;
+
+    int8_t r = venty_cmd(buff, sizeof(buff), cmd, sizeof(cmd));
+    return r;
+}