implement ble read

CMakeLists.txt

     src/text.c
     src/image.c
     src/state.c
+    src/volcano.c
 
     ${CMAKE_CURRENT_BINARY_DIR}/fatfs/ff.c
     ${CMAKE_CURRENT_BINARY_DIR}/fatfs/ffunicode.c

include/ble.h

 
 #define BLE_MAX_NAME_LENGTH 32
 #define BLE_MAX_SCAN_RESULTS 32
+#define BLE_MAX_VALUE_LEN 64
 
 enum ble_scan_mode {
     BLE_SCAN_OFF    = 0,
 
 void ble_init(void);
 bool ble_is_ready(void);
+
 void ble_scan(enum ble_scan_mode mode);
-int ble_get_scan_results(struct ble_scan_result *buf, uint len);
+int32_t ble_get_scan_results(struct ble_scan_result *buf, uint16_t len);
+
 void ble_connect(bd_addr_t addr, bd_addr_type_t type);
+bool ble_is_connected(void);
 void ble_disconnect(void);
 
+int32_t ble_read(const uint8_t *uuid, uint8_t *buff, uint16_t buff_len);
+int32_t ble_write(const uint8_t *uuid, uint8_t *buff, uint16_t buff_len);
+
 #endif // __BLE_H__

include/volcano.h

+/*
+ * volcano.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 __VOLCANO_H__
+#define __VOLCANO_H__
+
+// in 1/10th degrees C, or < 0 on error
+int16_t volcano_get_current_temp(void);
+int16_t volcano_get_target_temp(void);
+
+// v in 1/10th degrees C, returns < 0 on error
+int8_t volcano_set_target_temp(uint16_t v);
+
+#endif // __VOLCANO_H__

src/ble.c

     TC_IDLE,
     TC_W4_SCAN,
     TC_W4_CONNECT,
-    TC_READY
+    TC_READY,
+    TC_W4_READ,
+    TC_READ_COMPLETE,
 };
 
 static btstack_packet_callback_registration_t hci_event_callback_registration;
 
 static enum ble_state state = TC_OFF;
 static struct ble_scan_result scans[BLE_MAX_SCAN_RESULTS] = {0};
+static uint16_t read_len = 0;
+static uint8_t read_buff[BLE_MAX_VALUE_LEN] = {0};
 
 static void hci_add_scan_result(bd_addr_t addr, bd_addr_type_t type, int8_t rssi) {
     int unused = -1;
     UNUSED(size);
     UNUSED(channel);
 
+    //debug("type=0x%02X size=%d", packet_type, size);
+    //hexdump(packet, size);
+
     if (packet_type != HCI_EVENT_PACKET) {
         //debug("unexpected packet 0x%02X", packet_type);
         return;
         state = TC_IDLE;
         break;
 
+    case GATT_EVENT_CHARACTERISTIC_VALUE_QUERY_RESULT:
+        if (state != TC_W4_READ) {
+            debug("gatt query result in invalid state %d", state);
+            return;
+        }
+        uint16_t len = gatt_event_characteristic_value_query_result_get_value_length(packet);
+        if ((read_len + len) > BLE_MAX_VALUE_LEN) {
+            debug("not enough space for value (%d + %d > %d)", read_len, len, BLE_MAX_VALUE_LEN);
+            return;
+        }
+        memcpy(read_buff + read_len,
+               gatt_event_characteristic_value_query_result_get_value(packet),
+               len);
+        read_len += len;
+        break;
+
+    case GATT_EVENT_QUERY_COMPLETE:
+        if (state != TC_W4_READ) {
+            debug("gatt query complete in invalid state %d", state);
+            return;
+        }
+        state = TC_READ_COMPLETE;
+        break;
+
     default:
         //debug("unexpected event 0x%02X", hci_event_packet_get_type(packet));
         break;
     cyw43_thread_exit();
 }
 
-int ble_get_scan_results(struct ble_scan_result *buf, uint len) {
+int32_t ble_get_scan_results(struct ble_scan_result *buf, uint16_t len) {
     if (!buf || (len <= 0)) {
         return -1;
     }
         return -1;
     }
 
-    uint pos = 0;
-    for (uint i = 0; i < BLE_MAX_SCAN_RESULTS; i++) {
+    uint16_t pos = 0;
+    for (uint16_t i = 0; i < BLE_MAX_SCAN_RESULTS; i++) {
         if (!scans[i].set) {
             continue;
         }
     cyw43_thread_exit();
 }
 
+bool ble_is_connected(void) {
+    cyw43_thread_enter();
+
+    bool v = (state == TC_READY)
+             || (state == TC_W4_READ)
+             || (state == TC_READ_COMPLETE);
+
+    cyw43_thread_exit();
+    return v;
+}
+
 void ble_disconnect(void) {
     cyw43_thread_enter();
 
 
     cyw43_thread_exit();
 }
+
+int32_t ble_read(const uint8_t *uuid, uint8_t *buff, uint16_t buff_len) {
+    cyw43_thread_enter();
+
+    if (state != TC_READY) {
+        cyw43_thread_exit();
+        debug("invalid state for read (%d)", state);
+        return -1;
+    }
+
+    uint8_t r = gatt_client_read_value_of_characteristics_by_uuid128(hci_event_handler,
+                                                                     connection_handle,
+                                                                     0x0001, 0xFFFF, uuid);
+    if (r != ERROR_CODE_SUCCESS) {
+        cyw43_thread_exit();
+        debug("gatt read failed %d", r);
+        return -2;
+    }
+
+    state = TC_W4_READ;
+    read_len = 0;
+    cyw43_thread_exit();
+
+    while (1) {
+        sleep_ms(1);
+
+        // TODO timeout
+
+        cyw43_thread_enter();
+        enum ble_state state_cached = state;
+        cyw43_thread_exit();
+
+        if (state_cached == TC_READ_COMPLETE) {
+            break;
+        }
+    }
+
+    cyw43_thread_enter();
+
+    state = TC_READY;
+
+    if (read_len > buff_len) {
+        debug("buffer too short (%d < %d)", buff_len, read_len);
+        cyw43_thread_exit();
+        return -3;
+    }
+
+    memcpy(buff, read_buff, read_len);
+
+    cyw43_thread_exit();
+    return read_len;
+}
+
+int32_t ble_write(const uint8_t *uuid, uint8_t *buff, uint16_t buff_len) {
+    UNUSED(uuid);
+    UNUSED(buff);
+    UNUSED(buff_len);
+    return -1;
+}

src/console.c

 #include "text.h"
 #include "lcd.h"
 #include "image.h"
+#include "volcano.h"
 
 #define CNSL_BUFF_SIZE 1024
 #define CNSL_REPEAT_MS 500
         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("");
         println("Press Enter with no input to repeat last command.");
         println("Use repeat to continuously execute last command.");
         println("Stop this by calling repeat again.");
                 volt, lipo_percentage(volt),
                 lipo_charging() ? "charging" : "draining");
     } else if (strcmp(line, "scan") == 0) {
-        ble_scan(2);
+        ble_scan(BLE_SCAN_TOGGLE);
     } else if (strcmp(line, "scanres") == 0) {
         struct ble_scan_result results[BLE_MAX_SCAN_RESULTS] = {0};
         int n = ble_get_scan_results(results, BLE_MAX_SCAN_RESULTS);
         }
     } else if (strcmp(line, "bat") == 0) {
         draw_battery_indicator();
+    } else if (strcmp(line, "vrct") == 0) {
+        int16_t r = volcano_get_current_temp();
+        println("volcano current temp: %.1f", r / 10.0);
+    } else if (strcmp(line, "vrtt") == 0) {
+        int16_t r = volcano_get_target_temp();
+        println("volcano target temp: %.1f", r / 10.0);
     } else {
         println("unknown command \"%s\"", line);
     }

src/main.c

 
     // wait for BLE stack to be ready before using it
     while (!ble_is_ready()) {
-        sleep_ms(10);
+        sleep_ms(1);
     }
 
     debug("starting app");

src/volcano.c

+/*
+ * volcano.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 "util.h"
+#include "ble.h"
+#include "volcano.h"
+
+// Volcano UUIDs are always the same, except for the 4th byte
+
+#define UUID_CURRENT_TEMP 0x01
+#define UUID_TARGET_TEMP  0x03
+#define UUID_HEATER_ON    0x0F
+#define UUID_HEATER_OFF   0x10
+#define UUID_PUMP_ON      0x13
+#define UUID_PUMP_OFF     0x14
+
+// "101100FF-5354-4f52-5a26-4249434b454c"
+static uint8_t uuid_base[16] = {
+    0x10, 0x11, 0x00, 0xFF, 0x53, 0x54, 0x4f, 0x52,
+    0x5a, 0x26, 0x42, 0x49, 0x43, 0x4b, 0x45, 0x4c,
+};
+
+int16_t volcano_get_current_temp(void) {
+    uuid_base[3] = UUID_CURRENT_TEMP;
+
+    uint8_t buff[4];
+    int32_t r = ble_read(uuid_base, buff, 4);
+    if (r != 4) {
+        debug("ble_read unexpected value %ld", r);
+        return -1;
+    }
+
+    uint32_t *v = (uint32_t *)buff;
+    return *v;
+}
+
+int16_t volcano_get_target_temp(void) {
+    uuid_base[3] = UUID_TARGET_TEMP;
+
+    uint8_t buff[4];
+    int32_t r = ble_read(uuid_base, buff, 4);
+    if (r != 4) {
+        debug("ble_read unexpected value %ld", r);
+        return -1;
+    }
+
+    uint32_t *v = (uint32_t *)buff;
+    return *v;
+}
+
+int8_t volcano_set_target_temp(uint16_t value) {
+    uuid_base[3] = UUID_TARGET_TEMP;
+
+    uint8_t buff[4];
+    uint32_t *v = (uint32_t *)buff;
+    *v = value;
+
+    int32_t r = ble_write(uuid_base, buff, 4);
+    if (r != 4) {
+        debug("ble_write unexpected value %ld", r);
+        return -1;
+    }
+    return 0;
+}