detect known device types and read their serial number

CMakeLists.txt

     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

 #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
 
     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

+/*
+ * 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

 
 #include "config.h"
 #include "log.h"
+#include "main.h"
 #include "util.h"
 #include "ble.h"
 
     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) {
     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);
                 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);
             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));
     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;
         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;
             }
         }
 
-        // allow some time for service discovery
-        watchdog_update();
-
         cyw43_thread_enter();
     }
 
         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;
             }
         }
 
-        // allow some time for characteristic discovery
-        watchdog_update();
-
         cyw43_thread_enter();
     }
 
     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

 #include "usb_cdc.h"
 #include "usb_msc.h"
 #include "debug_disk.h"
-#include "console.h"
 #include "lipo.h"
 #include "ble.h"
 #include "text.h"
 #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
         } 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

+/*
+ * 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

     };
 
     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);