README.md

 # Pi Pico Volcano Remote Control Gadget
 
+Supports:
+
+ * workflows for the Volcano Hybrid
+ * basic status and settings for Crafty+
+
 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).
 
 Adapted from the [tinyusb-cdc-example](https://github.com/hathach/tinyusb/blob/master/examples/device/cdc_msc/src/main.c), [adc example](https://github.com/raspberrypi/pico-examples/tree/master/adc/read_vsys), [standalone client example](https://github.com/raspberrypi/pico-examples/blob/master/pico_w/bt/standalone/client.c) and my [Trackball firmware](https://git.xythobuz.de/thomas/Trackball).
 
+`python-test` contains a similar app to the C version in the top level of the repo, but instead written for MicroPython on the Pico W.
+Unfortunately I had many performance and space problems with this, so I decided to rewrite it.
+`web-app` contains a script to conveniently fetch the original web app JS sources, for "reverse engineering".
+
 ## Quick Start
 
 When compiling for the first time, check out the required git submodules.

include/ble.h

 bool ble_is_connected(void);
 void ble_disconnect(void);
 
+int8_t ble_discover(const uint8_t *service, const uint8_t *characteristic);
+
 int32_t ble_read(const uint8_t *characteristic, uint8_t *buff, uint16_t buff_len);
 int8_t ble_write(const uint8_t *service, const uint8_t *characteristic,
-                 uint8_t *buff, uint16_t buff_len);
+                 const uint8_t *buff, uint16_t buff_len);
+
+int8_t ble_notification_disable(const uint8_t *service, const uint8_t *characteristic);
+int8_t ble_notification_enable(const uint8_t *service, const uint8_t *characteristic);
+bool ble_notification_ready(void);
+uint16_t ble_notification_get(uint8_t *buff, uint16_t buff_len);
 
 #endif // __BLE_H__

include/config.h

 
 #ifdef MENU_PREFER_VOLCANO
 #define VOLCANO_AUTO_CONNECT_TIMEOUT_MS 2000
+#define VOLCANO_AUTO_CONNECT_WITHIN_MS 10000
 #endif // MENU_PREFER_VOLCANO
 
 #endif // NDEBUG

include/lcd.h

 
 #include <stdint.h>
 
+#define LCD_WIDTH 240
+#define LCD_HEIGHT 240
+
 #define RGB_565(r, g, b) ( \
       (((r) >> 3) << 11)   \
     | (((g) >> 2) << 5)    \

include/volcano.h

 #include <stdint.h>
 #include <stdbool.h>
 
+// returns < 0 on error
+int8_t volcano_discover_characteristics(void);
+
 // in 1/10th degrees C, or < 0 on error
 int16_t volcano_get_current_temp(void);
 int16_t volcano_get_target_temp(void);

src/ble.c

 #include "util.h"
 #include "ble.h"
 
-#define BLE_READ_TIMEOUT_MS (2 * 500)
-#define BLE_SRVC_TIMEOUT_MS (2 * 500)
-#define BLE_CHAR_TIMEOUT_MS (2 * 2000)
-#define BLE_WRTE_TIMEOUT_MS (2 * 500)
+#define BLE_READ_TIMEOUT_MS (3 * 500)
+#define BLE_SRVC_TIMEOUT_MS (3 * 500)
+#define BLE_CHAR_TIMEOUT_MS (3 * 2000)
+#define BLE_WRTE_TIMEOUT_MS (3 * 500)
+#define BLE_NOTY_TIMEOUT_MS (3 * 500)
 #define BLE_MAX_SCAN_AGE_MS (10 * 1000)
 #define BLE_MAX_SERVICES 8
 #define BLE_MAX_CHARACTERISTICS 8
     TC_W4_CHARACTERISTIC,
     TC_W4_WRITE,
     TC_WRITE_COMPLETE,
+    TC_W4_NOTIFY_ENABLE,
+    TC_NOTIFY_ENABLED,
 };
 
 struct ble_characteristic {
     bool set;
     gatt_client_characteristic_t c;
+    gatt_client_notification_t n;
 };
 
 struct ble_service {
             state = TC_WRITE_COMPLETE;
             break;
 
+        case TC_W4_NOTIFY_ENABLE:
+            //debug("notify enable complete");
+            state = TC_NOTIFY_ENABLED;
+            break;
+
         default:
             debug("gatt query complete in invalid state %d", state);
             break;
         break;
     }
 
+    case GATT_EVENT_NOTIFICATION: {
+        if ((state != TC_READY) && (state != TC_WRITE_COMPLETE)) {
+            debug("gatt notification in invalid state %d", state);
+            return;
+        }
+
+        uint16_t value_length = gatt_event_notification_get_value_length(packet);
+        const uint8_t *value = gatt_event_notification_get_value(packet);
+        if ((read_len + value_length) <= BLE_MAX_VALUE_LEN) {
+            memcpy(data_buff + read_len, value, value_length);
+            read_len += value_length;
+        }
+
+        break;
+    }
+
     default:
         //debug("unexpected event 0x%02X", hci_event_packet_get_type(packet));
         break;
 
     memcpy(buff, data_buff, read_len);
 
+    uint16_t tmp = read_len;
+    read_len = 0;
+
     cyw43_thread_exit();
-    return read_len;
+    return tmp;
 }
 
-int8_t ble_write(const uint8_t *service, const uint8_t *characteristic,
-                  uint8_t *buff, uint16_t buff_len) {
-    cyw43_thread_enter();
-
-    if (state != TC_READY) {
-        cyw43_thread_exit();
-        debug("invalid state for write (%d)", state);
-        return -1;
-    }
-
+static int discover_service(const uint8_t *service) {
     // check if service has already been discovered
     int srvc = -1, free_srvc = -1;
     for (int i = 0; i < BLE_MAX_SERVICES; i++) {
         cyw43_thread_enter();
     }
 
+    return srvc;
+}
+
+static int discover_characteristic(int srvc, const uint8_t *characteristic) {
     // check if characteristic has already been discovered
     int ch = -1, free_ch = -1;
     for (int i = 0; i < BLE_MAX_CHARACTERISTICS; i++) {
         cyw43_thread_enter();
     }
 
+    return ch;
+}
+
+int8_t ble_write(const uint8_t *service, const uint8_t *characteristic,
+                 const uint8_t *buff, uint16_t buff_len) {
+    cyw43_thread_enter();
+
+    if (state != TC_READY) {
+        cyw43_thread_exit();
+        debug("invalid state for write (%d)", state);
+        return -1;
+    }
+
+    int srvc = discover_service(service);
+    if (srvc < 0) {
+        debug("error discovering service (%d)", srvc);
+        return srvc;
+    }
+
+    int ch = discover_characteristic(srvc, characteristic);
+    if (ch < 0) {
+        debug("error discovering characteristic (%d)", ch);
+        return ch;
+    }
+
     if (buff_len > BLE_MAX_VALUE_LEN) {
         buff_len = BLE_MAX_VALUE_LEN;
     }
     cyw43_thread_exit();
     return ret;
 }
+
+int8_t ble_discover(const uint8_t *service, const uint8_t *characteristic) {
+    cyw43_thread_enter();
+
+    if (state != TC_READY) {
+        cyw43_thread_exit();
+        debug("invalid state for discovery (%d)", state);
+        return -1;
+    }
+
+    int srvc = discover_service(service);
+    if (srvc < 0) {
+        debug("error discovering service (%d)", srvc);
+        return srvc;
+    }
+
+    int ch = discover_characteristic(srvc, characteristic);
+    if (ch < 0) {
+        debug("error discovering characteristic (%d)", ch);
+        return ch;
+    }
+
+    cyw43_thread_exit();
+    return 0;
+}
+
+int8_t ble_notification_disable(const uint8_t *service, const uint8_t *characteristic) {
+    cyw43_thread_enter();
+
+    if (state != TC_READY) {
+        cyw43_thread_exit();
+        debug("invalid state for notify (%d)", state);
+        return -1;
+    }
+
+    int srvc = discover_service(service);
+    if (srvc < 0) {
+        debug("error discovering service (%d)", srvc);
+        return srvc;
+    }
+
+    int ch = discover_characteristic(srvc, characteristic);
+    if (ch < 0) {
+        debug("error discovering characteristic (%d)", ch);
+        return ch;
+    }
+
+    gatt_client_stop_listening_for_characteristic_value_updates(&services[srvc].chars[ch].n);
+
+    cyw43_thread_exit();
+    return 0;
+}
+
+int8_t ble_notification_enable(const uint8_t *service, const uint8_t *characteristic) {
+    cyw43_thread_enter();
+
+    if (state != TC_READY) {
+        cyw43_thread_exit();
+        debug("invalid state for notify (%d)", state);
+        return -1;
+    }
+
+    int srvc = discover_service(service);
+    if (srvc < 0) {
+        debug("error discovering service (%d)", srvc);
+        return srvc;
+    }
+
+    int ch = discover_characteristic(srvc, characteristic);
+    if (ch < 0) {
+        debug("error discovering characteristic (%d)", ch);
+        return ch;
+    }
+
+    gatt_client_listen_for_characteristic_value_updates(&services[srvc].chars[ch].n,
+                                                        hci_event_handler,
+                                                        connection_handle,
+                                                        &services[srvc].chars[ch].c);
+
+    gatt_client_write_client_characteristic_configuration(hci_event_handler,
+                                                          connection_handle,
+                                                          &services[srvc].chars[ch].c,
+                                                          GATT_CLIENT_CHARACTERISTICS_CONFIGURATION_NOTIFICATION);
+
+    state = TC_W4_NOTIFY_ENABLE;
+    cyw43_thread_exit();
+
+    uint32_t start_time = to_ms_since_boot(get_absolute_time());
+    while (1) {
+        sleep_ms(1);
+        main_loop_hw();
+
+        uint32_t now = to_ms_since_boot(get_absolute_time());
+        if ((now - start_time) >= BLE_NOTY_TIMEOUT_MS) {
+            debug("timeout waiting for notify enable");
+            cyw43_thread_enter();
+            state = TC_READY;
+            cyw43_thread_exit();
+            return -6;
+        }
+
+        cyw43_thread_enter();
+        enum ble_state state_cached = state;
+        cyw43_thread_exit();
+
+        if ((state_cached == TC_NOTIFY_ENABLED) || (state_cached == TC_READY)) {
+            break;
+        }
+    }
+
+    cyw43_thread_enter();
+
+    int8_t ret = (state == TC_NOTIFY_ENABLED) ? 0 : -7;
+    state = TC_READY;
+
+    cyw43_thread_exit();
+    return ret;
+}
+
+bool ble_notification_ready(void) {
+    cyw43_thread_enter();
+
+    if (state != TC_READY) {
+        cyw43_thread_exit();
+        debug("invalid state for notify (%d)", state);
+        return -1;
+    }
+
+    uint16_t tmp = read_len;
+
+    cyw43_thread_exit();
+    return (tmp > 0);
+
+}
+
+uint16_t ble_notification_get(uint8_t *buff, uint16_t buff_len) {
+    cyw43_thread_enter();
+
+    if (state != TC_READY) {
+        cyw43_thread_exit();
+        debug("invalid state for notify (%d)", state);
+        return -1;
+    }
+
+    if (read_len > buff_len) {
+        debug("buffer too short (%d < %d)", buff_len, read_len);
+        cyw43_thread_exit();
+        return -2;
+    }
+
+    memcpy(buff, data_buff, read_len);
+
+    uint16_t tmp = read_len;
+    read_len = 0;
+
+    cyw43_thread_exit();
+    return tmp;
+}

src/buttons.c

 
         if ((now - buttons[i].last_time) > DEBOUNCE_DELAY_MS) {
             if (state != buttons[i].current_state) {
+                //debug("btn %d now %s", i, state ? "pressed" : "released");
+
                 buttons[i].current_state = state;
-                debug("btn %d now %s", i, state ? "pressed" : "released");
                 if (callback) {
                     callback(i, state);
                 }

src/console.c

                         bd_addr_to_str(results[i].addr),
                         results[i].type, results[i].rssi,
                         age / 1000.0, results[i].name, info);
+
+                if (results[i].data_len > 0) {
+                    hexdump(results[i].data, results[i].data_len);
+                }
+
+                if (i < (n - 1)) {
+                    println();
+                }
             }
         }
     } else if (str_startswith(line, "con ")) {

src/lcd.c

 #define LCD_PIN_RST 12
 #define LCD_PIN_BL 13
 
-#define ST7789_PICO_COLUMN                             240
-#define ST7789_PICO_ROW                                ST7789_PICO_COLUMN
+#define ST7789_PICO_COLUMN                             LCD_HEIGHT
+#define ST7789_PICO_ROW                                LCD_WIDTH
 
 #define ST7789_PICO_ACCESS                            (ST7789_ORDER_PAGE_TOP_TO_BOTTOM | \
                                                        ST7789_ORDER_COLUMN_LEFT_TO_RIGHT | \

src/mem.c

 
 void mem_load_defaults(void) {
     data_ram.data.wf_count = wf_default_count;
-    debug("preparing %d default workflows", data_ram.data.wf_count);
     for (uint16_t i = 0; i < wf_default_count; i++) {
         data_ram.data.wf[i] = wf_default_data[i];
-        debug("\"%s\" by \"%s\"", data_ram.data.wf[i].name, data_ram.data.wf[i].author);
     }
 }
 
     } else {
         debug("invalid config (0x%02X != 0x%02X)", flash_ptr->version, MEM_VERSION);
     }
-
-    debug("found %d workflows", data_ram.data.wf_count);
-    for (uint16_t i = 0; i < data_ram.data.wf_count; i++) {
-        debug("\"%s\" by \"%s\"", data_ram.data.wf[i].name, data_ram.data.wf[i].author);
-    }
 }
 
 static void mem_write_flash(void *param) {

src/state_crafty.c

 
 #include "menu.h"
 
-#define CRAFTY_UPDATE_TIME_MS 1000
+#define CRAFTY_UPDATE_TIME_MS 3000
 
 static bd_addr_t ble_addr = {0};
 static bd_addr_type_t ble_type = 0;
     static uint32_t last = 0;
     uint32_t now = to_ms_since_boot(get_absolute_time());
     if (((now - last) >= CRAFTY_UPDATE_TIME_MS) || (last == 0)) {
-        last = now;
         menu_run(draw, true);
+        last = to_ms_since_boot(get_absolute_time());
     }
 
     if (wait_for_disconnect && !ble_is_connected()) {

src/state_scan.c

 #ifdef MENU_PREFER_VOLCANO
             if (dev == DEV_VOLCANO) {
                 menu->selection = devs - 1;
+
 #ifdef VOLCANO_AUTO_CONNECT_TIMEOUT_MS
-                auto_connect_time = to_ms_since_boot(get_absolute_time());
-                auto_connect_idx = i;
+#ifdef VOLCANO_AUTO_CONNECT_WITHIN_MS
+                if (to_ms_since_boot(get_absolute_time()) <= VOLCANO_AUTO_CONNECT_WITHIN_MS) {
+#endif // VOLCANO_AUTO_CONNECT_WITHIN_MS
+                    auto_connect_time = to_ms_since_boot(get_absolute_time());
+                    auto_connect_idx = i;
+#ifdef VOLCANO_AUTO_CONNECT_WITHIN_MS
+                }
+#endif // VOLCANO_AUTO_CONNECT_WITHIN_MS
 #endif // VOLCANO_AUTO_CONNECT_TIMEOUT_MS
             }
 #endif // MENU_PREFER_VOLCANO

src/text.c

         text_prepare_font(&font);
     }
 
-    int x = 0;
-    int width = 240;
+    int x_off = 0;
+    int width = LCD_WIDTH;
 
-    int y = 50;
-    int height = MENU_MAX_LINES * (20 + 2);
+    int y_off = 50;
+    int height = (MENU_MAX_LINES * 20) + ((MENU_MAX_LINES - 1) * 2);
 
     struct text_conf text = {
         .text = "",
-        .x = x,
-        .y = y,
+        .x = x_off,
+        .y = y_off,
         .justify = false,
         .alignment = centered ? MF_ALIGN_CENTER : MF_ALIGN_LEFT,
         .width = width,
         .font = &font,
     };
 
-    lcd_write_rect(x,
-                   y,
-                   x + width - 1,
-                   y + height - 1,
+    lcd_write_rect(x_off, y_off,
+                   x_off + width - 1,
+                   y_off + height - 1,
                    RGB_565(0x00, 0x00, 0x00));
 
     text.text = s;

src/volcano.c

     0x5a, 0x26, 0x42, 0x49, 0x43, 0x4b, 0x45, 0x4c,
 };
 
+int8_t volcano_discover_characteristics(void) {
+    uuid_base[3] = UUID_WRITE_SRVC;
+    int8_t r;
+
+    uuid_base2[3] = UUID_TARGET_TEMP;
+    r = ble_discover(uuid_base, uuid_base2);
+    if (r < 0) {
+        return r;
+    }
+
+    uuid_base2[3] = UUID_HEATER_ON;
+    r = ble_discover(uuid_base, uuid_base2);
+    if (r < 0) {
+        return r;
+    }
+
+    uuid_base2[3] = UUID_HEATER_OFF;
+    r = ble_discover(uuid_base, uuid_base2);
+    if (r < 0) {
+        return r;
+    }
+
+    uuid_base2[3] = UUID_PUMP_ON;
+    r = ble_discover(uuid_base, uuid_base2);
+    if (r < 0) {
+        return r;
+    }
+
+    uuid_base2[3] = UUID_PUMP_OFF;
+    r = ble_discover(uuid_base, uuid_base2);
+    if (r < 0) {
+        return r;
+    }
+
+    return 0;
+}
+
 int16_t volcano_get_current_temp(void) {
     uuid_base[3] = UUID_CURRENT_TEMP;
 

src/workflow.c

     wf_i = index;
     step = 0;
 
-    // discover characteristics
-    volcano_set_pump_state(false);
-    volcano_set_heater_state(false);
-    volcano_set_target_temp(1850);
-
+    /*
+     * first turn on heater, then do discovery, to save some time.
+     * this means we heat for some seconds before changing the setpoint.
+     * should not be a problem in practice.
+     */
     volcano_set_heater_state(true);
+    volcano_discover_characteristics();
 
     do_step();
 }