detect known device types and read their serial number

CMakeLists.txt

@@ -63,6 +63,7 @@ target_sources(gadget PUBLIC
     src/volcano.c
     src/serial.c
     src/ring.c
+    src/models.c
 
     ${CMAKE_CURRENT_BINARY_DIR}/fatfs/ff.c
     ${CMAKE_CURRENT_BINARY_DIR}/fatfs/ffunicode.c

include/ble.h

@@ -22,6 +22,7 @@
 #include "btstack.h"
 
 #define BLE_MAX_NAME_LENGTH 32
+#define BLE_MAX_DATA_LENGTH 26
 #define BLE_MAX_SCAN_RESULTS 32
 #define BLE_MAX_VALUE_LEN 64
 
@@ -39,6 +40,8 @@ struct ble_scan_result {
     bd_addr_type_t type;
     int8_t rssi;
     char name[BLE_MAX_NAME_LENGTH + 1];
+    uint8_t data[BLE_MAX_DATA_LENGTH];
+    size_t data_len;
 };
 
 void ble_init(void);

include/models.h

@@ -0,0 +1,33 @@
+/*
+ * models.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 __MODELS_H__
+#define __MODELS_H__
+
+#include <stdint.h>
+
+enum known_devices {
+    DEV_UNKNOWN = 0,
+    DEV_VOLCANO,
+    DEV_CRAFTY,
+};
+
+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);
+
+#endif // __MODELS_H__

src/ble.c

@@ -24,6 +24,7 @@
 
 #include "config.h"
 #include "log.h"
+#include "main.h"
 #include "util.h"
 #include "ble.h"
 
@@ -104,6 +105,7 @@ static void hci_add_scan_result(bd_addr_t addr, bd_addr_type_t type, int8_t rssi
     scans[unused].type = type;
     scans[unused].rssi = rssi;
     scans[unused].name[0] = '\0';
+    scans[unused].data_len = 0;
 }
 
 static void hci_scan_result_add_name(bd_addr_t addr, const uint8_t *data, uint8_t data_size) {
@@ -128,6 +130,28 @@ static void hci_scan_result_add_name(bd_addr_t addr, const uint8_t *data, uint8_
     debug("no matching entry for %s to add name '%.*s' to", bd_addr_to_str(addr), data_size, data);
 }
 
+static void hci_scan_result_add_data(bd_addr_t addr, const uint8_t *data, uint8_t data_size) {
+    for (uint i = 0; i < BLE_MAX_SCAN_RESULTS; i++) {
+        if (!scans[i].set) {
+            continue;
+        }
+        if (memcmp(addr, scans[i].addr, sizeof(bd_addr_t)) != 0) {
+            continue;
+        }
+
+        uint8_t len = data_size;
+        if (len > BLE_MAX_DATA_LENGTH) {
+            len = BLE_MAX_DATA_LENGTH;
+        }
+        memcpy(scans[i].data, data, len);
+        scans[i].data_len = len;
+        scans[i].time = to_ms_since_boot(get_absolute_time());
+        return;
+    }
+
+    debug("no matching entry for %s to add data to", bd_addr_to_str(addr));
+}
+
 static void hci_event_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size) {
     UNUSED(size);
     UNUSED(channel);
@@ -189,6 +213,18 @@ static void hci_event_handler(uint8_t packet_type, uint16_t channel, uint8_t *pa
                 hci_scan_result_add_name(addr, data, data_size);
                 break;
 
+            case BLUETOOTH_DATA_TYPE_SERVICE_DATA:
+            case BLUETOOTH_DATA_TYPE_MANUFACTURER_SPECIFIC_DATA:
+                // TODO ugly
+                if (data_size == 12) {
+                    // Crafty+
+                    hci_scan_result_add_data(addr, data, data_size);
+                } else if (data_size == 26) {
+                    // Volcano
+                    hci_scan_result_add_data(addr, data, data_size);
+                }
+                break;
+
             default:
                 //debug("Unexpected advertisement type 0x%02X from %s", data_type, bd_addr_to_str(addr));
                 //hexdump(data, data_size);
@@ -399,10 +435,13 @@ int32_t ble_get_scan_results(struct ble_scan_result *buf, uint16_t len) {
             continue;
         }
 
-        uint32_t diff = to_ms_since_boot(get_absolute_time()) - scans[i].time;
-        if (diff >= BLE_MAX_SCAN_AGE_MS) {
-            //debug("removing %s due to age", bd_addr_to_str(scans[i].addr));
-            scans[i].set = false;
+        // only age out entries while scanning, otherwise keep results cached
+        if (state == TC_W4_SCAN) {
+            uint32_t diff = to_ms_since_boot(get_absolute_time()) - scans[i].time;
+            if (diff >= BLE_MAX_SCAN_AGE_MS) {
+                //debug("removing %s due to age", bd_addr_to_str(scans[i].addr));
+                scans[i].set = false;
+            }
         }
 
         memcpy(buf + pos, scans + i, sizeof(struct ble_scan_result));
@@ -497,15 +536,13 @@ int32_t ble_read(const uint8_t *characteristic, uint8_t *buff, uint16_t buff_len
     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_READ_TIMEOUT_MS) {
             debug("timeout waiting for read");
             return -3;
         }
-#if BLE_READ_TIMEOUT_MS >= (WATCHDOG_PERIOD_MS / 2)
-        watchdog_update();
-#endif
 
         cyw43_thread_enter();
         enum ble_state state_cached = state;
@@ -585,15 +622,13 @@ int8_t ble_write(const uint8_t *service, const uint8_t *characteristic,
         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_SRVC_TIMEOUT_MS) {
                 debug("timeout waiting for service");
                 return -3;
             }
-#if BLE_SRVC_TIMEOUT_MS >= (WATCHDOG_PERIOD_MS / 2)
-            watchdog_update();
-#endif
 
             cyw43_thread_enter();
             enum ble_state state_cached = state;
@@ -604,9 +639,6 @@ int8_t ble_write(const uint8_t *service, const uint8_t *characteristic,
             }
         }
 
-        // allow some time for service discovery
-        watchdog_update();
-
         cyw43_thread_enter();
     }
 
@@ -654,15 +686,13 @@ int8_t ble_write(const uint8_t *service, const uint8_t *characteristic,
         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_CHAR_TIMEOUT_MS) {
                 debug("timeout waiting for characteristic");
                 return -5;
             }
-#if BLE_CHAR_TIMEOUT_MS >= (WATCHDOG_PERIOD_MS / 2)
-            watchdog_update();
-#endif
 
             cyw43_thread_enter();
             enum ble_state state_cached = state;
@@ -673,9 +703,6 @@ int8_t ble_write(const uint8_t *service, const uint8_t *characteristic,
             }
         }
 
-        // allow some time for characteristic discovery
-        watchdog_update();
-
         cyw43_thread_enter();
     }
 
@@ -700,15 +727,13 @@ int8_t ble_write(const uint8_t *service, const uint8_t *characteristic,
     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_WRTE_TIMEOUT_MS) {
             debug("timeout waiting for write");
             return -7;
         }
-#if BLE_WRTE_TIMEOUT_MS >= (WATCHDOG_PERIOD_MS / 2)
-        watchdog_update();
-#endif
 
         cyw43_thread_enter();
         enum ble_state state_cached = state;

src/console.c

@@ -30,7 +30,6 @@
 #include "usb_cdc.h"
 #include "usb_msc.h"
 #include "debug_disk.h"
-#include "console.h"
 #include "lipo.h"
 #include "ble.h"
 #include "text.h"
@@ -39,6 +38,8 @@
 #include "volcano.h"
 #include "serial.h"
 #include "main.h"
+#include "models.h"
+#include "console.h"
 
 #define CNSL_BUFF_SIZE 64
 #define CNSL_REPEAT_MS 500
@@ -141,11 +142,17 @@ static void cnsl_interpret(const char *line) {
         } else {
             println("%d results", n);
             for (int i = 0; i < n; i++) {
+                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,
+                                      info, sizeof(info));
+                }
                 uint32_t age = to_ms_since_boot(get_absolute_time()) - results[i].time;
-                println("addr=%s type=%d rssi=%d age=%.1fs name='%s'",
+                println("addr=%s type=%d rssi=%d age=%.1fs name='%s' info='%s'",
                         bd_addr_to_str(results[i].addr),
                         results[i].type, results[i].rssi,
-                        age / 1000.0, results[i].name);
+                        age / 1000.0, results[i].name, info);
             }
         }
     } else if (str_startswith(line, "con ")) {

src/models.c

@@ -0,0 +1,53 @@
+/*
+ * models.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 <stddef.h>
+#include <string.h>
+
+#include "config.h"
+#include "log.h"
+#include "util.h"
+#include "models.h"
+
+enum known_devices models_filter_name(const char *name) {
+    if (name == NULL) {
+        return DEV_UNKNOWN;
+    } else if (strcmp(name, "S&B VOLCANO H") == 0) {
+        return DEV_VOLCANO;
+    } else if (strcmp(name, "STORZ&BICKEL") == 0) {
+        return DEV_VOLCANO;
+    } 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)) {
+        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))) {
+        return -2;
+    }
+    memcpy(buff, data + serial_off, serial_len);
+    buff[serial_len] = '\0';
+
+    return 0;
+}

src/state.c

@@ -90,6 +90,9 @@ void state_run(void) {
     };
 
     switch (state) {
+    case STATE_INIT:
+        break;
+
     case STATE_SCAN: {
         struct ble_scan_result results[BLE_MAX_SCAN_RESULTS] = {0};
         int n = ble_get_scan_results(results, BLE_MAX_SCAN_RESULTS);