feat(split): allow central to connect to multiple peripherals

Author: xudongzheng

app/include/zmk/ble.h

@@ -14,8 +14,8 @@
      IS_ENABLED(CONFIG_ZMK_SPLIT_ROLE_CENTRAL))
 
 #if ZMK_BLE_IS_CENTRAL
-#define ZMK_BLE_PROFILE_COUNT (CONFIG_BT_MAX_PAIRED - 1)
-#define ZMK_BLE_SPLIT_PERIPHERAL_COUNT 1
+#define ZMK_BLE_PROFILE_COUNT (CONFIG_BT_MAX_PAIRED - CONFIG_ZMK_SPLIT_BLE_CENTRAL_PERIPHERALS)
+#define ZMK_BLE_SPLIT_PERIPHERAL_COUNT CONFIG_ZMK_SPLIT_BLE_CENTRAL_PERIPHERALS
 #else
 #define ZMK_BLE_PROFILE_COUNT CONFIG_BT_MAX_PAIRED
 #endif
@@ -34,5 +34,5 @@ char *zmk_ble_active_profile_name();
 int zmk_ble_unpair_all();
 
 #if IS_ENABLED(CONFIG_ZMK_SPLIT_ROLE_CENTRAL)
-void zmk_ble_set_peripheral_addr(bt_addr_le_t *addr);
+int zmk_ble_put_peripheral_addr(const bt_addr_le_t *addr);
 #endif /* IS_ENABLED(CONFIG_ZMK_SPLIT_ROLE_CENTRAL) */

app/src/ble.c

@@ -47,12 +47,6 @@ static uint8_t passkey_digit = 0;
 
 #endif /* IS_ENABLED(CONFIG_ZMK_BLE_PASSKEY_ENTRY) */
 
-#if IS_ENABLED(CONFIG_ZMK_SPLIT_ROLE_CENTRAL)
-#define PROFILE_COUNT (CONFIG_BT_MAX_PAIRED - 1)
-#else
-#define PROFILE_COUNT CONFIG_BT_MAX_PAIRED
-#endif
-
 enum advertising_type {
     ZMK_ADV_NONE,
     ZMK_ADV_DIR,
@@ -84,7 +78,7 @@ static const struct bt_data zmk_ble_ad[] = {
 
 #if IS_ENABLED(CONFIG_ZMK_SPLIT_ROLE_CENTRAL)
 
-static bt_addr_le_t peripheral_addr;
+static bt_addr_le_t peripheral_addrs[ZMK_BLE_SPLIT_PERIPHERAL_COUNT];
 
 #endif /* IS_ENABLED(CONFIG_ZMK_SPLIT_ROLE_CENTRAL) */
 
@@ -280,9 +274,34 @@ char *zmk_ble_active_profile_name() { return profiles[active_profile].name; }
 
 #if IS_ENABLED(CONFIG_ZMK_SPLIT_ROLE_CENTRAL)
 
-void zmk_ble_set_peripheral_addr(bt_addr_le_t *addr) {
-    memcpy(&peripheral_addr, addr, sizeof(bt_addr_le_t));
-    settings_save_one("ble/peripheral_address", addr, sizeof(bt_addr_le_t));
+int zmk_ble_put_peripheral_addr(const bt_addr_le_t *addr) {
+    for (int i = 0; i < ZMK_BLE_SPLIT_PERIPHERAL_COUNT; i++) {
+        // If the address is recognized and already stored in settings, return
+        // index and no additional action is necessary.
+        if (!bt_addr_le_cmp(&peripheral_addrs[i], addr)) {
+            return i;
+        }
+
+        // If the peripheral address slot is open, store new peripheral in the
+        // slot and return index. This compares against BT_ADDR_LE_ANY as that
+        // is the zero value.
+        if (!bt_addr_le_cmp(&peripheral_addrs[i], BT_ADDR_LE_ANY)) {
+            char addr_str[BT_ADDR_LE_STR_LEN];
+            bt_addr_le_to_str(addr, addr_str, sizeof(addr_str));
+            LOG_DBG("Storing peripheral %s in slot %d", log_strdup(addr_str), i);
+            bt_addr_le_copy(&peripheral_addrs[i], addr);
+
+            char setting_name[32];
+            sprintf(setting_name, "ble/peripheral_addresses/%d", i);
+            settings_save_one(setting_name, addr, sizeof(bt_addr_le_t));
+
+            return i;
+        }
+    }
+
+    // The peripheral does not match a known peripheral and there is no
+    // available slot.
+    return -ENOMEM;
 }
 
 #endif /* IS_ENABLED(CONFIG_ZMK_SPLIT_ROLE_CENTRAL) */
@@ -337,15 +356,20 @@ static int ble_profiles_handle_set(const char *name, size_t len, settings_read_c
         }
     }
 #if IS_ENABLED(CONFIG_ZMK_SPLIT_ROLE_CENTRAL)
-    else if (settings_name_steq(name, "peripheral_address", &next) && !next) {
+    else if (settings_name_steq(name, "peripheral_addresses", &next) && next) {
         if (len != sizeof(bt_addr_le_t)) {
             return -EINVAL;
         }
 
-        int err = read_cb(cb_arg, &peripheral_addr, sizeof(bt_addr_le_t));
-        if (err <= 0) {
-            LOG_ERR("Failed to handle peripheral address from settings (err %d)", err);
-            return err;
+        int i = atoi(next);
+        if (i >= ZMK_BLE_SPLIT_PERIPHERAL_COUNT) {
+            LOG_ERR("Failed to store peripheral address in memory");
+        } else {
+            int err = read_cb(cb_arg, &peripheral_addrs[i], sizeof(bt_addr_le_t));
+            if (err <= 0) {
+                LOG_ERR("Failed to handle peripheral address from settings (err %d)", err);
+                return err;
+            }
         }
     }
 #endif

app/src/split/bluetooth/Kconfig

@@ -17,6 +17,10 @@ config ZMK_SPLIT_ROLE_CENTRAL
 
 if ZMK_SPLIT_ROLE_CENTRAL
 
+config ZMK_SPLIT_BLE_CENTRAL_PERIPHERALS
+	int "Number of peripherals that will connect to the central."
+	default 1
+
 config ZMK_SPLIT_BLE_CENTRAL_POSITION_QUEUE_SIZE
 	int "Max number of key position state events to queue when received from peripherals"
 	default 5

app/src/split/bluetooth/central.c

@@ -49,6 +49,8 @@ struct peripheral_slot {
 
 static struct peripheral_slot peripherals[ZMK_BLE_SPLIT_PERIPHERAL_COUNT];
 
+static bool is_scanning = false;
+
 static const struct bt_uuid_128 split_service_uuid = BT_UUID_INIT_128(ZMK_SPLIT_BT_SERVICE_UUID);
 
 K_MSGQ_DEFINE(peripheral_event_msgq, sizeof(struct zmk_position_state_changed),
@@ -130,8 +132,9 @@ int release_peripheral_slot(int index) {
     return 0;
 }
 
-int reserve_peripheral_slot() {
-    for (int i = 0; i < ZMK_BLE_SPLIT_PERIPHERAL_COUNT; i++) {
+int reserve_peripheral_slot(const bt_addr_le_t *addr) {
+    int i = zmk_ble_put_peripheral_addr(addr);
+    if (i >= 0) {
         if (peripherals[i].state == PERIPHERAL_SLOT_STATE_OPEN) {
             // Be sure the slot is fully reinitialized.
             release_peripheral_slot(i);
@@ -344,9 +347,56 @@ static void split_central_process_connection(struct bt_conn *conn) {
 
     LOG_DBG("New connection params: Interval: %d, Latency: %d, PHY: %d", info.le.interval,
             info.le.latency, info.le.phy->rx_phy);
+
+    // Restart scanning if necessary.
+    start_scan();
 }
 
-static bool split_central_eir_found(struct bt_data *data, void *user_data) {
+static bool split_central_eir_found(const bt_addr_le_t *addr) {
+    LOG_DBG("Found the split service");
+
+    int slot_idx = reserve_peripheral_slot(addr);
+    if (slot_idx < 0) {
+        LOG_ERR("Failed to reserve peripheral slot (err %d)", slot_idx);
+        return false;
+    }
+
+    // Stop scanning so we can connect to the peripheral device.
+    LOG_DBG("Stopping peripheral scanning");
+    is_scanning = false;
+    int err = bt_le_scan_stop();
+    if (err) {
+        LOG_ERR("Stop LE scan failed (err %d)", err);
+        return false;
+    }
+
+    struct peripheral_slot *slot = &peripherals[slot_idx];
+
+    slot->conn = bt_conn_lookup_addr_le(BT_ID_DEFAULT, addr);
+    if (slot->conn) {
+        LOG_DBG("Found existing connection");
+        split_central_process_connection(slot->conn);
+        err = bt_conn_le_phy_update(slot->conn, BT_CONN_LE_PHY_PARAM_2M);
+        if (err) {
+            LOG_ERR("Update phy conn failed (err %d)", err);
+        }
+    } else {
+        struct bt_le_conn_param *param = BT_LE_CONN_PARAM(0x0006, 0x0006, 30, 400);
+
+        LOG_DBG("Initiating new connnection");
+
+        err = bt_conn_le_create(addr, BT_CONN_LE_CREATE_CONN, param, &slot->conn);
+        if (err) {
+            LOG_ERR("Create conn failed (err %d) (create conn? 0x%04x)", err,
+                    BT_HCI_OP_LE_CREATE_CONN);
+            start_scan();
+        }
+    }
+
+    return false;
+}
+
+static bool split_central_eir_parse(struct bt_data *data, void *user_data) {
     bt_addr_le_t *addr = user_data;
     int i;
 
@@ -361,9 +411,7 @@ static bool split_central_eir_found(struct bt_data *data, void *user_data) {
         }
 
         for (i = 0; i < data->data_len; i += 16) {
-            struct bt_le_conn_param *param;
             struct bt_uuid_128 uuid;
-            int err;
 
             if (!bt_uuid_create(&uuid.uuid, &data->data[i], 16)) {
                 LOG_ERR("Unable to load UUID");
@@ -382,46 +430,7 @@ static bool split_central_eir_found(struct bt_data *data, void *user_data) {
                 continue;
             }
 
-            LOG_DBG("Found the split service");
-
-            zmk_ble_set_peripheral_addr(addr);
-
-            err = bt_le_scan_stop();
-            if (err) {
-                LOG_ERR("Stop LE scan failed (err %d)", err);
-                continue;
-            }
-
-            uint8_t slot_idx = reserve_peripheral_slot();
-            if (slot_idx < 0) {
-                LOG_ERR("Faild to reserve peripheral slot (err %d)", slot_idx);
-                continue;
-            }
-
-            struct peripheral_slot *slot = &peripherals[slot_idx];
-
-            slot->conn = bt_conn_lookup_addr_le(BT_ID_DEFAULT, addr);
-            if (slot->conn) {
-                LOG_DBG("Found existing connection");
-                split_central_process_connection(slot->conn);
-                err = bt_conn_le_phy_update(slot->conn, BT_CONN_LE_PHY_PARAM_2M);
-                if (err) {
-                    LOG_ERR("Update phy conn failed (err %d)", err);
-                }
-            } else {
-                param = BT_LE_CONN_PARAM(0x0006, 0x0006, 30, 400);
-
-                LOG_DBG("Initiating new connnection");
-
-                err = bt_conn_le_create(addr, BT_CONN_LE_CREATE_CONN, param, &slot->conn);
-                if (err) {
-                    LOG_ERR("Create conn failed (err %d) (create conn? 0x%04x)", err,
-                            BT_HCI_OP_LE_CREATE_CONN);
-                    start_scan();
-                }
-            }
-
-            return false;
+            return split_central_eir_found(addr);
         }
     }
 
@@ -438,14 +447,33 @@ static void split_central_device_found(const bt_addr_le_t *addr, int8_t rssi, ui
 
     /* We're only interested in connectable events */
     if (type == BT_GAP_ADV_TYPE_ADV_IND || type == BT_GAP_ADV_TYPE_ADV_DIRECT_IND) {
-        bt_data_parse(ad, split_central_eir_found, (void *)addr);
+        bt_data_parse(ad, split_central_eir_parse, (void *)addr);
     }
 }
 
 static int start_scan(void) {
-    int err;
+    // No action is necessary if central is already scanning.
+    if (is_scanning) {
+        LOG_DBG("Scanning already running");
+        return 0;
+    }
+
+    // If all the devices are connected, there is no need to scan.
+    bool has_unconnected = false;
+    for (int i = 0; i < CONFIG_ZMK_SPLIT_BLE_CENTRAL_PERIPHERALS; i++) {
+        if (peripherals[i].conn == NULL) {
+            has_unconnected = true;
+            break;
+        }
+    }
+    if (!has_unconnected) {
+        LOG_DBG("All devices are connected, scanning is unnecessary");
+        return 0;
+    }
 
-    err = bt_le_scan_start(BT_LE_SCAN_PASSIVE, split_central_device_found);
+    // Start scanning otherwise.
+    is_scanning = true;
+    int err = bt_le_scan_start(BT_LE_SCAN_PASSIVE, split_central_device_found);
     if (err) {
         LOG_ERR("Scanning failed to start (err %d)", err);
         return err;