adafruit-mirror/zephyr
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 8

tests: Bluetooth: Audio: Use ext adv for all connectable adv

Browse source 
Most specs require the use of extended advertising, and most
tests used legacy advertising.

Implement a common function to create and start an extended
advertising set to reduce code duplication.

Signed-off-by: Emil Gydesen <emil.gydesen@nordicsemi.no>
This commit is contained in:
Emil Gydesen 2025-01-09 21:42:30 +01:00 committed by Benjamin Cabé
parent 09d5b9d80f
commit 0e9a3e0e6c
21 changed files with 221 additions and 366 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

40
tests/bsim/bluetooth/audio/src/bap_broadcast_sink_test.c
View file

@ -59,7 +59,6 @@ static uint32_t broadcaster_broadcast_id;
static struct audio_test_stream broadcast_sink_streams[CONFIG_BT_BAP_BROADCAST_SNK_STREAM_COUNT];
static struct bt_bap_stream *streams[ARRAY_SIZE(broadcast_sink_streams)];
static uint32_t requested_bis_sync;
static struct bt_le_ext_adv *ext_adv;
static const struct bt_bap_scan_delegator_recv_state *req_recv_state;
static uint8_t recv_state_broadcast_code[BT_ISO_BROADCAST_CODE_SIZE];
@ -897,39 +896,6 @@ static void test_broadcast_delete_inval(void)
}
}
static void test_start_adv(void)
{
const struct bt_data ad[] = {
BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)),
BT_DATA_BYTES(BT_DATA_UUID16_ALL, BT_UUID_16_ENCODE(BT_UUID_BASS_VAL),
BT_UUID_16_ENCODE(BT_UUID_PACS_VAL)),
BT_DATA_BYTES(BT_DATA_SVC_DATA16, BT_UUID_16_ENCODE(BT_UUID_BASS_VAL)),
};
int err;
/* Create a connectable advertising set */
err = bt_le_ext_adv_create(BT_LE_EXT_ADV_CONN, NULL, &ext_adv);
if (err != 0) {
FAIL("Failed to create advertising set (err %d)\n", err);
return;
}
err = bt_le_ext_adv_set_data(ext_adv, ad, ARRAY_SIZE(ad), NULL, 0);
if (err != 0) {
FAIL("Failed to set advertising data (err %d)\n", err);
return;
}
err = bt_le_ext_adv_start(ext_adv, BT_LE_EXT_ADV_START_DEFAULT);
if (err != 0) {
FAIL("Failed to start advertising set (err %d)\n", err);
return;
}
}
static void test_common(void)
{
int err;
@ -1144,6 +1110,7 @@ static void test_sink_encrypted_incorrect_code(void)
static void broadcast_sink_with_assistant(void)
{
struct bt_le_ext_adv *ext_adv;
int err;
err = init();
@ -1152,7 +1119,7 @@ static void broadcast_sink_with_assistant(void)
return;
}
test_start_adv();
setup_connectable_adv(&ext_adv);
WAIT_FOR_FLAG(flag_connected);
printk("Waiting for PA sync request\n");
@ -1200,6 +1167,7 @@ static void broadcast_sink_with_assistant(void)
static void broadcast_sink_with_assistant_incorrect_code(void)
{
struct bt_le_ext_adv *ext_adv;
int err;
err = init();
@ -1208,7 +1176,7 @@ static void broadcast_sink_with_assistant_incorrect_code(void)
return;
}
test_start_adv();
setup_connectable_adv(&ext_adv);
WAIT_FOR_FLAG(flag_connected);
printk("Waiting for PA sync request\n");

9
tests/bsim/bluetooth/audio/src/bap_scan_delegator_test.c
View file

@ -691,6 +691,7 @@ static void sync_all_broadcasts(void)
static int common_init(void)
{
struct bt_le_ext_adv *ext_adv;
int err;
err = bt_enable(NULL);
@ -709,13 +710,7 @@ static int common_init(void)
bt_le_per_adv_sync_cb_register(&pa_sync_cb);
err = bt_le_adv_start(BT_LE_ADV_CONN_FAST_1, ad, AD_SIZE, NULL, 0);
if (err) {
FAIL("Advertising failed to start (err %d)\n", err);
return err;
}
printk("Advertising successfully started\n");
setup_connectable_adv(&ext_adv);
WAIT_FOR_FLAG(flag_connected);

51
tests/bsim/bluetooth/audio/src/bap_unicast_server_test.c
View file

@ -70,19 +70,6 @@ static struct audio_test_stream
static const struct bt_bap_qos_cfg_pref qos_pref =
BT_BAP_QOS_CFG_PREF(true, BT_GAP_LE_PHY_2M, 0x02, 10, 40000, 40000, 40000, 40000);
static uint8_t unicast_server_addata[] = {
BT_UUID_16_ENCODE(BT_UUID_ASCS_VAL), /* ASCS UUID */
BT_AUDIO_UNICAST_ANNOUNCEMENT_TARGETED, /* Target Announcement */
BT_BYTES_LIST_LE16(PREF_CONTEXT),
BT_BYTES_LIST_LE16(PREF_CONTEXT),
0x00, /* Metadata length */
};
static const struct bt_data unicast_server_ad[] = {
BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)),
BT_DATA_BYTES(BT_DATA_UUID16_ALL, BT_UUID_16_ENCODE(BT_UUID_ASCS_VAL)),
BT_DATA(BT_DATA_SVC_DATA16, unicast_server_addata, ARRAY_SIZE(unicast_server_addata)),
};
static struct bt_le_ext_adv *ext_adv;
CREATE_FLAG(flag_stream_configured);
@ -460,26 +447,7 @@ static void init(void)
&stream_ops);
}
/* Create a connectable advertising set */
err = bt_le_ext_adv_create(BT_LE_EXT_ADV_CONN, NULL, &ext_adv);
if (err != 0) {
FAIL("Failed to create advertising set (err %d)\n", err);
return;
}
err = bt_le_ext_adv_set_data(ext_adv, unicast_server_ad, ARRAY_SIZE(unicast_server_ad),
NULL, 0);
if (err != 0) {
FAIL("Failed to set advertising data (err %d)\n", err);
return;
}
err = bt_le_ext_adv_start(ext_adv, BT_LE_EXT_ADV_START_DEFAULT);
if (err != 0) {
FAIL("Failed to start advertising set (err %d)\n", err);
return;
}
printk("Advertising started\n");
setup_connectable_adv(&ext_adv);
}
static void test_main(void)
@ -540,22 +508,7 @@ static void test_main_acl_disconnect(void)
* bt_conn object is properly unref'ed by the stack
*/
for (size_t i = 0U; i < ARRAY_SIZE(dummy_ext_adv); i++) {
const struct bt_le_adv_param param = BT_LE_ADV_PARAM_INIT(
(BT_LE_ADV_OPT_EXT_ADV | BT_LE_ADV_OPT_CONN), BT_GAP_ADV_SLOW_INT_MAX,
BT_GAP_ADV_SLOW_INT_MAX, NULL);
int err;
err = bt_le_ext_adv_create(&param, NULL, &dummy_ext_adv[i]);
if (err != 0) {
FAIL("Failed to create advertising set[%zu] (err %d)\n", i, err);
return;
}
err = bt_le_ext_adv_start(dummy_ext_adv[i], BT_LE_EXT_ADV_START_DEFAULT);
if (err != 0) {
FAIL("Failed to start advertising set[%zu] (err %d)\n", i, err);
return;
}
setup_connectable_adv(&dummy_ext_adv[i]);
}
bt_conn_cb_register(&conn_callbacks);

51
tests/bsim/bluetooth/audio/src/cap_acceptor_test.c
View file

@ -53,11 +53,6 @@
extern enum bst_result_t bst_result;
#define SINK_CONTEXT \
(BT_AUDIO_CONTEXT_TYPE_UNSPECIFIED | BT_AUDIO_CONTEXT_TYPE_MEDIA | \
BT_AUDIO_CONTEXT_TYPE_CONVERSATIONAL)
#define SOURCE_CONTEXT (BT_AUDIO_CONTEXT_TYPE_UNSPECIFIED | BT_AUDIO_CONTEXT_TYPE_NOTIFICATIONS)
CREATE_FLAG(flag_broadcaster_found);
CREATE_FLAG(flag_broadcast_code);
CREATE_FLAG(flag_base_received);
@ -415,27 +410,6 @@ static struct bt_bap_scan_delegator_cb scan_delegator_cbs = {
.broadcast_code = broadcast_code_cb,
};
/* TODO: Expand with CAP service data */
static const struct bt_data cap_acceptor_ad[] = {
BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)),
BT_DATA(BT_DATA_NAME_COMPLETE, CONFIG_BT_DEVICE_NAME, sizeof(CONFIG_BT_DEVICE_NAME) - 1),
BT_DATA_BYTES(BT_DATA_UUID16_SOME, BT_UUID_16_ENCODE(BT_UUID_ASCS_VAL),
BT_UUID_16_ENCODE(BT_UUID_CAS_VAL)),
BT_DATA_BYTES(BT_DATA_SVC_DATA16, BT_UUID_16_ENCODE(BT_UUID_CAS_VAL),
BT_AUDIO_UNICAST_ANNOUNCEMENT_TARGETED),
IF_ENABLED(CONFIG_BT_BAP_UNICAST_SERVER,
(BT_DATA_BYTES(BT_DATA_SVC_DATA16,
BT_UUID_16_ENCODE(BT_UUID_ASCS_VAL),
BT_AUDIO_UNICAST_ANNOUNCEMENT_TARGETED,
BT_BYTES_LIST_LE16(SINK_CONTEXT),
BT_BYTES_LIST_LE16(SOURCE_CONTEXT),
0x00, /* Metadata length */),
))
IF_ENABLED(CONFIG_BT_BAP_SCAN_DELEGATOR,
(BT_DATA_BYTES(BT_DATA_SVC_DATA16, BT_UUID_16_ENCODE(BT_UUID_BASS_VAL)),
))
};
static struct bt_csip_set_member_svc_inst *csip_set_member;
static struct bt_bap_stream *unicast_stream_alloc(void)
@ -636,32 +610,9 @@ static int set_supported_contexts(void)
void test_start_adv(void)
{
int err;
struct bt_le_ext_adv *ext_adv;
/* Create a connectable non-scannable advertising set */
err = bt_le_ext_adv_create(BT_LE_EXT_ADV_CONN_CUSTOM, NULL, &ext_adv);
if (err != 0) {
FAIL("Failed to create advertising set (err %d)\n", err);
return;
}
/* Add cap acceptor advertising data */
err = bt_le_ext_adv_set_data(ext_adv, cap_acceptor_ad, ARRAY_SIZE(cap_acceptor_ad), NULL,
0);
if (err != 0) {
FAIL("Failed to set advertising data (err %d)\n", err);
return;
}
err = bt_le_ext_adv_start(ext_adv, BT_LE_EXT_ADV_START_DEFAULT);
if (err != 0) {
FAIL("Failed to start advertising set (err %d)\n", err);
return;
}
setup_connectable_adv(&ext_adv);
}
static void set_available_contexts(void)

78
tests/bsim/bluetooth/audio/src/common.c
View file

@ -1,6 +1,6 @@
/*
* Copyright (c) 2019 Bose Corporation
* Copyright (c) 2020-2021 Nordic Semiconductor ASA
* Copyright (c) 2020-2025 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: Apache-2.0
*/
@ -9,17 +9,24 @@
#include <stddef.h>
#include <stdint.h>
#include <zephyr/autoconf.h>
#include <zephyr/bluetooth/addr.h>
#include <zephyr/bluetooth/audio/audio.h>
#include <zephyr/bluetooth/audio/bap.h>
#include <zephyr/bluetooth/audio/csip.h>
#include <zephyr/bluetooth/audio/tmap.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/byteorder.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/gap.h>
#include <zephyr/bluetooth/uuid.h>
#include <zephyr/kernel.h>
#include <zephyr/net_buf.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/atomic_types.h>
#include <zephyr/sys/printk.h>
#include <zephyr/sys/util.h>
#include <zephyr/sys/util_macro.h>
#include "bs_cmd_line.h"
#include "bs_dynargs.h"
@ -37,9 +44,37 @@ atomic_t flag_disconnected;
atomic_t flag_conn_updated;
atomic_t flag_audio_received;
volatile bt_security_t security_level;
#if defined(CONFIG_BT_CSIP_SET_MEMBER)
uint8_t csip_rsi[BT_CSIP_RSI_SIZE];
#endif /* CONFIG_BT_CSIP_SET_MEMBER */
const struct bt_data ad[AD_SIZE] = {
BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR))
static const struct bt_data connectable_ad[] = {
BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)),
BT_DATA(BT_DATA_NAME_COMPLETE, CONFIG_BT_DEVICE_NAME, sizeof(CONFIG_BT_DEVICE_NAME) - 1),
BT_DATA_BYTES(BT_DATA_UUID16_SOME, BT_UUID_16_ENCODE(BT_UUID_ASCS_VAL),
BT_UUID_16_ENCODE(BT_UUID_CAS_VAL)),
BT_DATA_BYTES(BT_DATA_UUID16_ALL, BT_UUID_16_ENCODE(BT_UUID_BASS_VAL),
BT_UUID_16_ENCODE(BT_UUID_PACS_VAL)),
#if defined(CONFIG_BT_CAP_ACCEPTOR)
BT_DATA_BYTES(BT_DATA_SVC_DATA16, BT_UUID_16_ENCODE(BT_UUID_CAS_VAL),
BT_AUDIO_UNICAST_ANNOUNCEMENT_TARGETED),
#endif /* CONFIG_BT_CAP_ACCEPTOR */
#if defined(CONFIG_BT_BAP_UNICAST_SERVER)
BT_DATA_BYTES(BT_DATA_SVC_DATA16, BT_UUID_16_ENCODE(BT_UUID_ASCS_VAL),
BT_AUDIO_UNICAST_ANNOUNCEMENT_TARGETED, BT_BYTES_LIST_LE16(SINK_CONTEXT),
BT_BYTES_LIST_LE16(SOURCE_CONTEXT), 0x00,
/* Metadata length */),
#endif /* CONFIG_BT_BAP_UNICAST_SERVER */
#if defined(CONFIG_BT_BAP_SCAN_DELEGATOR)
BT_DATA_BYTES(BT_DATA_SVC_DATA16, BT_UUID_16_ENCODE(BT_UUID_BASS_VAL)),
#endif /* CONFIG_BT_BAP_SCAN_DELEGATOR */
#if defined(CONFIG_BT_CSIP_SET_MEMBER)
BT_DATA(BT_DATA_CSIS_RSI, csip_rsi, BT_CSIP_RSI_SIZE),
#endif /* CONFIG_BT_CSIP_SET_MEMBER */
#if defined(CONFIG_BT_TMAP)
BT_DATA_BYTES(BT_DATA_SVC_DATA16, BT_UUID_16_ENCODE(BT_UUID_TMAS_VAL),
BT_UUID_16_ENCODE(TMAP_ROLE_SUPPORTED)),
#endif /* CONFIG_BT_TMAP */
};
static void device_found(const struct bt_le_scan_recv_info *info, struct net_buf_simple *ad_buf)
@ -51,8 +86,9 @@ static void device_found(const struct bt_le_scan_recv_info *info, struct net_buf
return;
}
/* We're only interested in connectable events */
if ((info->adv_props & BT_GAP_ADV_PROP_CONNECTABLE) == 0) {
/* We're only interested in extended advertising connectable events */
if (((info->adv_props & BT_GAP_ADV_PROP_EXT_ADV) == 0U ||
(info->adv_props & BT_GAP_ADV_PROP_CONNECTABLE) == 0U)) {
return;
}
@ -150,6 +186,38 @@ BT_CONN_CB_DEFINE(conn_callbacks) = {
.security_changed = security_changed_cb,
};
void setup_connectable_adv(struct bt_le_ext_adv **ext_adv)
{
int err;
/* Create a non-connectable advertising set */
err = bt_le_ext_adv_create(BT_LE_EXT_ADV_CONN, NULL, ext_adv);
if (err != 0) {
FAIL("Unable to create extended advertising set: %d\n", err);
return;
}
err = bt_le_ext_adv_set_data(*ext_adv, connectable_ad, ARRAY_SIZE(connectable_ad), NULL, 0);
if (err != 0) {
FAIL("Unable to set extended advertising data: %d\n", err);
bt_le_ext_adv_delete(*ext_adv);
return;
}
err = bt_le_ext_adv_start(*ext_adv, BT_LE_EXT_ADV_START_DEFAULT);
if (err != 0) {
FAIL("Failed to start advertising set (err %d)\n", err);
bt_le_ext_adv_delete(*ext_adv);
return;
}
printk("Advertising started\n");
}
void test_tick(bs_time_t HW_device_time)
{
if (bst_result != Passed) {

22
tests/bsim/bluetooth/audio/src/common.h
View file

@ -17,6 +17,7 @@
#include <zephyr/bluetooth/audio/audio.h>
#include <zephyr/bluetooth/audio/bap.h>
#include <zephyr/bluetooth/audio/cap.h>
#include <zephyr/bluetooth/audio/csip.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/conn.h>
@ -26,6 +27,7 @@
#include <zephyr/kernel.h>
#include <zephyr/sys/atomic_types.h>
#include <zephyr/sys/util.h>
#include <zephyr/sys/util_macro.h>
#include <zephyr/sys_clock.h>
#include <zephyr/types.h>
@ -102,23 +104,37 @@ extern enum bst_result_t bst_result;
bs_trace_info_time(1, "PASSED: " __VA_ARGS__); \
} while (0)
#define AD_SIZE 1
#define PA_SYNC_INTERVAL_TO_TIMEOUT_RATIO 20 /* Set the timeout relative to interval */
#define PA_SYNC_SKIP 5
#define PBP_STREAMS_TO_SEND 2
#define SINK_CONTEXT \
(BT_AUDIO_CONTEXT_TYPE_UNSPECIFIED | BT_AUDIO_CONTEXT_TYPE_MEDIA | \
BT_AUDIO_CONTEXT_TYPE_CONVERSATIONAL)
#define SOURCE_CONTEXT \
(BT_AUDIO_CONTEXT_TYPE_UNSPECIFIED | BT_AUDIO_CONTEXT_TYPE_CONVERSATIONAL | \
BT_AUDIO_CONTEXT_TYPE_NOTIFICATIONS)
#define TMAP_ROLE_SUPPORTED \
((IS_ENABLED(CONFIG_BT_TMAP_CG_SUPPORTED) ? BT_TMAP_ROLE_CG : 0U) | \
(IS_ENABLED(CONFIG_BT_TMAP_CT_SUPPORTED) ? BT_TMAP_ROLE_CT : 0U) | \
(IS_ENABLED(CONFIG_BT_TMAP_UMS_SUPPORTED) ? BT_TMAP_ROLE_UMS : 0U) | \
(IS_ENABLED(CONFIG_BT_TMAP_UMR_SUPPORTED) ? BT_TMAP_ROLE_UMR : 0U) | \
(IS_ENABLED(CONFIG_BT_TMAP_BMS_SUPPORTED) ? BT_TMAP_ROLE_BMS : 0U) | \
(IS_ENABLED(CONFIG_BT_TMAP_BMR_SUPPORTED) ? BT_TMAP_ROLE_BMR : 0U))
extern struct bt_le_scan_cb common_scan_cb;
extern const struct bt_data ad[AD_SIZE];
extern struct bt_conn *default_conn;
extern atomic_t flag_connected;
extern atomic_t flag_disconnected;
extern atomic_t flag_conn_updated;
extern atomic_t flag_audio_received;
extern volatile bt_security_t security_level;
extern uint8_t csip_rsi[BT_CSIP_RSI_SIZE];
void disconnected(struct bt_conn *conn, uint8_t reason);
void setup_connectable_adv(struct bt_le_ext_adv **ext_adv);
void test_tick(bs_time_t HW_device_time);
void test_init(void);
uint16_t get_dev_cnt(void);

28
tests/bsim/bluetooth/audio/src/csip_notify_server_test.c
View file

@ -52,15 +52,13 @@ static struct bt_csip_set_member_cb csip_cb = {
static void test_main(void)
{
int err;
const struct bt_data ad[] = {
BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)),
};
struct bt_csip_set_member_register_param csip_params = {
.set_size = 1,
.rank = 1,
.lockable = true,
.cb = &csip_cb,
.cb = &csip_cb,
};
struct bt_le_ext_adv *ext_adv;
printk("Enabling Bluetooth\n");
err = bt_enable(NULL);
@ -77,12 +75,7 @@ static void test_main(void)
return;
}
printk("Start Advertising\n");
err = bt_le_adv_start(BT_LE_ADV_CONN_FAST_1, ad, ARRAY_SIZE(ad), NULL, 0);
if (err != 0) {
FAIL("Advertising failed to start (err %d)\n", err);
return;
}
setup_connectable_adv(&ext_adv);
printk("Waiting to be connected\n");
WAIT_FOR_FLAG(flag_connected);
@ -100,17 +93,11 @@ static void test_main(void)
return;
}
/* Now wait for client to disconnect, then stop adv so it does not reconnect */
/* Now wait for client to disconnect */
printk("Wait for client disconnect\n");
WAIT_FOR_UNSET_FLAG(flag_connected);
printk("Client disconnected\n");
err = bt_le_adv_stop();
if (err != 0) {
FAIL("Advertising failed to stop (err %d)\n", err);
return;
}
/* Trigger changes while device is disconnected */
err = bt_csip_set_member_lock(svc_inst, false, false);
if (err != 0) {
@ -119,9 +106,12 @@ static void test_main(void)
}
printk("Start Advertising\n");
err = bt_le_adv_start(BT_LE_ADV_CONN_FAST_1, ad, ARRAY_SIZE(ad), NULL, 0);
err = bt_le_ext_adv_start(ext_adv, BT_LE_EXT_ADV_START_DEFAULT);
if (err != 0) {
FAIL("Advertising failed to start (err %d)\n", err);
FAIL("Failed to start advertising set (err %d)\n", err);
bt_le_ext_adv_delete(ext_adv);
return;
}

18
tests/bsim/bluetooth/audio/src/csip_set_coordinator_test.c
View file

@ -185,7 +185,8 @@ static bool is_discovered(const bt_addr_le_t *addr)
static bool csip_found(struct bt_data *data, void *user_data)
{
if (bt_csip_set_coordinator_is_set_member(primary_inst->info.sirk, data)) {
if (primary_inst == NULL ||
bt_csip_set_coordinator_is_set_member(primary_inst->info.sirk, data)) {
const bt_addr_le_t *addr = user_data;
char addr_str[BT_ADDR_LE_STR_LEN];
@ -200,7 +201,7 @@ static bool csip_found(struct bt_data *data, void *user_data)
bt_addr_le_copy(&addr_found[members_found++], addr);
if (primary_inst->info.set_size == 0) {
if (primary_inst == NULL || primary_inst->info.set_size == 0) {
printk("Found member %u\n", members_found);
} else {
printk("Found member (%u / %u)\n", members_found,
@ -218,16 +219,9 @@ static void csip_set_coordinator_scan_recv(const struct bt_le_scan_recv_info *in
struct net_buf_simple *ad)
{
/* We're only interested in connectable events */
if (info->adv_props & BT_GAP_ADV_PROP_CONNECTABLE) {
if (primary_inst == NULL) {
/* Scanning for the first device */
if (members_found == 0) {
bt_addr_le_copy(&addr_found[members_found++],
info->addr);
}
} else { /* Scanning for set members */
bt_data_parse(ad, csip_found, (void *)info->addr);
}
if ((info->adv_props & BT_GAP_ADV_PROP_EXT_ADV) != 0U &&
(info->adv_props & BT_GAP_ADV_PROP_CONNECTABLE) != 0U) {
bt_data_parse(ad, csip_found, (void *)info->addr);
}
}

13
tests/bsim/bluetooth/audio/src/csip_set_member_test.c
View file

@ -53,11 +53,7 @@ static struct bt_csip_set_member_cb csip_cbs = {
static void bt_ready(int err)
{
uint8_t rsi[BT_CSIP_RSI_SIZE];
struct bt_data ad[] = {
BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)),
BT_CSIP_DATA_RSI(rsi),
};
struct bt_le_ext_adv *ext_adv;
if (err != 0) {
FAIL("Bluetooth init failed (err %d)\n", err);
@ -74,16 +70,13 @@ static void bt_ready(int err)
return;
}
err = bt_csip_set_member_generate_rsi(svc_inst, rsi);
err = bt_csip_set_member_generate_rsi(svc_inst, csip_rsi);
if (err != 0) {
FAIL("Failed to generate RSI (err %d)\n", err);
return;
}
err = bt_le_adv_start(BT_LE_ADV_CONN_FAST_1, ad, ARRAY_SIZE(ad), NULL, 0);
if (err != 0) {
FAIL("Advertising failed to start (err %d)\n", err);
}
setup_connectable_adv(&ext_adv);
}
static void test_sirk(void)

97
tests/bsim/bluetooth/audio/src/gmap_ugg_test.c
View file

@ -21,6 +21,7 @@
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/byteorder.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/crypto.h>
#include <zephyr/bluetooth/gap.h>
#include <zephyr/bluetooth/gatt.h>
#include <zephyr/bluetooth/hci_types.h>
@ -424,6 +425,49 @@ static const struct bt_gmap_cb gmap_cb = {
.discover = gmap_discover_cb,
};
static void scan_recv_cb(const struct bt_le_scan_recv_info *info, struct net_buf_simple *buf)
{
char addr_str[BT_ADDR_LE_STR_LEN];
struct bt_conn *conn;
int err;
/* Check for connectable, extended advertising */
if (((info->adv_props & BT_GAP_ADV_PROP_EXT_ADV) == 0) ||
((info->adv_props & BT_GAP_ADV_PROP_CONNECTABLE)) == 0) {
/* We're only interested in connectable extended advertising */
}
conn = bt_conn_lookup_addr_le(BT_ID_DEFAULT, info->addr);
if (conn != NULL) {
/* Already connected to this device */
bt_conn_unref(conn);
return;
}
bt_addr_le_to_str(info->addr, addr_str, sizeof(addr_str));
printk("Device found: %s (RSSI %d)\n", addr_str, info->rssi);
/* connect only to devices in close proximity */
if (info->rssi < -70) {
FAIL("RSSI too low");
return;
}
printk("Stopping scan\n");
if (bt_le_scan_stop()) {
FAIL("Could not stop scan");
return;
}
err = bt_conn_le_create(info->addr, BT_CONN_LE_CREATE_CONN,
BT_LE_CONN_PARAM(BT_GAP_INIT_CONN_INT_MIN, BT_GAP_INIT_CONN_INT_MIN,
0, BT_GAP_MS_TO_CONN_TIMEOUT(4000)),
&connected_conns[connected_conn_cnt]);
if (err != 0) {
FAIL("Could not connect to peer: %d", err);
}
}
static void init(void)
{
const struct bt_gmap_feat features = {
@ -431,6 +475,9 @@ static void init(void)
BT_GMAP_UGG_FEAT_MULTISINK),
};
const enum bt_gmap_role role = BT_GMAP_ROLE_UGG;
static struct bt_le_scan_cb scan_cb = {
.recv = scan_recv_cb,
};
int err;
err = bt_enable(NULL);
@ -443,6 +490,11 @@ static void init(void)
bap_stream_tx_init();
bt_gatt_cb_register(&gatt_callbacks);
err = bt_le_scan_cb_register(&scan_cb);
if (err != 0) {
FAIL("Failed to register scan callbacks (err %d)\n", err);
return;
}
err = bt_bap_unicast_client_register_cb(&unicast_client_cbs);
if (err != 0) {
@ -480,56 +532,13 @@ static void init(void)
}
}
static void gmap_device_found(const bt_addr_le_t *addr, int8_t rssi, uint8_t type,
struct net_buf_simple *ad)
{
char addr_str[BT_ADDR_LE_STR_LEN];
struct bt_conn *conn;
int err;
/* We're only interested in connectable events */
if (type != BT_HCI_ADV_IND && type != BT_HCI_ADV_DIRECT_IND) {
return;
}
conn = bt_conn_lookup_addr_le(BT_ID_DEFAULT, addr);
if (conn != NULL) {
/* Already connected to this device */
bt_conn_unref(conn);
return;
}
bt_addr_le_to_str(addr, addr_str, sizeof(addr_str));
printk("Device found: %s (RSSI %d)\n", addr_str, rssi);
/* connect only to devices in close proximity */
if (rssi < -70) {
FAIL("RSSI too low");
return;
}
printk("Stopping scan\n");
if (bt_le_scan_stop()) {
FAIL("Could not stop scan");
return;
}
err = bt_conn_le_create(addr, BT_CONN_LE_CREATE_CONN,
BT_LE_CONN_PARAM(BT_GAP_INIT_CONN_INT_MIN, BT_GAP_INIT_CONN_INT_MIN,
0, BT_GAP_MS_TO_CONN_TIMEOUT(4000)),
&connected_conns[connected_conn_cnt]);
if (err) {
FAIL("Could not connect to peer: %d", err);
}
}
static void scan_and_connect(void)
{
int err;
UNSET_FLAG(flag_connected);
err = bt_le_scan_start(BT_LE_SCAN_PASSIVE, gmap_device_found);
err = bt_le_scan_start(BT_LE_SCAN_PASSIVE, NULL);
if (err != 0) {
FAIL("Scanning failed to start (err %d)\n", err);
return;

14
tests/bsim/bluetooth/audio/src/gmap_ugt_test.c
View file

@ -88,12 +88,6 @@ static struct bt_bap_stream_ops unicast_stream_ops = {
.started = unicast_stream_started_cb,
};
/* TODO: Expand with GMAP service data */
static const struct bt_data gmap_acceptor_ad[] = {
BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)),
BT_DATA_BYTES(BT_DATA_UUID16_ALL, BT_UUID_16_ENCODE(BT_UUID_CAS_VAL)),
};
static struct bt_csip_set_member_svc_inst *csip_set_member;
static struct bt_bap_stream *unicast_stream_alloc(void)
@ -368,6 +362,7 @@ static void test_main(void)
static struct bt_pacs_cap unicast_cap = {
.codec_cap = &codec_cap,
};
struct bt_le_ext_adv *ext_adv;
int err;
err = bt_enable(NULL);
@ -445,12 +440,7 @@ static void test_main(void)
return;
}
err = bt_le_adv_start(BT_LE_ADV_CONN_FAST_1, gmap_acceptor_ad, ARRAY_SIZE(gmap_acceptor_ad),
NULL, 0);
if (err != 0) {
FAIL("Advertising failed to start (err %d)\n", err);
return;
}
setup_connectable_adv(&ext_adv);
WAIT_FOR_FLAG(flag_connected);

10
tests/bsim/bluetooth/audio/src/has_test.c
View file

@ -41,15 +41,9 @@ static const struct bt_has_preset_ops preset_ops = {
static void start_adv(void)
{
int err;
struct bt_le_ext_adv *ext_adv;
err = bt_le_adv_start(BT_LE_ADV_CONN_FAST_1, ad, AD_SIZE, NULL, 0);
if (err) {
FAIL("Advertising failed to start (err %d)\n", err);
return;
}
LOG_DBG("Advertising successfully started");
setup_connectable_adv(&ext_adv);
}
static void test_common(void)

9
tests/bsim/bluetooth/audio/src/ias_test.c
View file

@ -50,6 +50,7 @@ BT_IAS_CB_DEFINE(ias_callbacks) = {
static void test_main(void)
{
struct bt_le_ext_adv *ext_adv;
int err;
err = bt_enable(NULL);
@ -58,13 +59,7 @@ static void test_main(void)
return;
}
err = bt_le_adv_start(BT_LE_ADV_CONN_FAST_1, ad, AD_SIZE, NULL, 0);
if (err) {
FAIL("Advertising failed to start (err %d)\n", err);
return;
}
printk("Advertising successfully started\n");
setup_connectable_adv(&ext_adv);
WAIT_FOR_FLAG(flag_connected);

26
tests/bsim/bluetooth/audio/src/mcs_test.c
View file

@ -16,21 +16,9 @@
#ifdef CONFIG_BT_MCS
extern enum bst_result_t bst_result;
static void start_adv(void)
{
int err;
err = bt_le_adv_start(BT_LE_ADV_CONN_FAST_1, ad, AD_SIZE, NULL, 0);
if (err) {
FAIL("Advertising failed to start (err %d)\n", err);
return;
}
printk("Advertising successfully started\n");
}
static void test_main(void)
{
struct bt_le_ext_adv *ext_adv;
int err;
printk("Media Control Server test application. Board: %s\n", CONFIG_BOARD);
@ -50,12 +38,22 @@ static void test_main(void)
}
printk("Bluetooth initialized\n");
setup_connectable_adv(&ext_adv);
PASS("MCS passed\n");
while (1) {
start_adv();
WAIT_FOR_FLAG(flag_connected);
WAIT_FOR_UNSET_FLAG(flag_connected);
err = bt_le_ext_adv_start(ext_adv, BT_LE_EXT_ADV_START_DEFAULT);
if (err != 0) {
FAIL("Failed to start advertising set (err %d)\n", err);
bt_le_ext_adv_delete(ext_adv);
return;
}
}
}

8
tests/bsim/bluetooth/audio/src/media_controller_test.c
View file

@ -1649,16 +1649,14 @@ void test_media_controller_local_player(void)
/* BabbleSim entry point for remote player test */
void test_media_controller_remote_player(void)
{
int err;
struct bt_le_ext_adv *ext_adv;
printk("Media Control remote player test application. Board: %s\n", CONFIG_BOARD);
initialize_bluetooth();
initialize_media();
err = bt_le_adv_start(BT_LE_ADV_CONN_FAST_1, ad, AD_SIZE, NULL, 0);
if (err) {
FAIL("Advertising failed to start (err %d)\n", err);
}
setup_connectable_adv(&ext_adv);
WAIT_FOR_FLAG(flag_connected);

10
tests/bsim/bluetooth/audio/src/micp_mic_dev_test.c
View file

@ -385,6 +385,7 @@ static void test_main(void)
{
int err;
struct bt_micp_mic_dev_register_param micp_param;
struct bt_le_ext_adv *ext_adv;
err = bt_enable(NULL);
if (err != 0) {
@ -431,14 +432,7 @@ static void test_main(void)
}
printk("MICP initialized\n");
err = bt_le_adv_start(BT_LE_ADV_CONN_FAST_1, ad, AD_SIZE, NULL, 0);
if (err != 0) {
FAIL("Advertising failed to start (err %d)\n", err);
return;
}
printk("Advertising successfully started\n");
setup_connectable_adv(&ext_adv);
WAIT_FOR_FLAG(flag_connected);

51
tests/bsim/bluetooth/audio/src/pacs_notify_server_test.c
View file

@ -158,9 +158,7 @@ static void test_main(void)
{
int err;
enum bt_audio_context available, available_for_conn;
const struct bt_data ad[] = {
BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)),
};
struct bt_le_ext_adv *ext_adv;
LOG_DBG("Enabling Bluetooth");
err = bt_enable(NULL);
@ -191,11 +189,7 @@ static void test_main(void)
}
LOG_DBG("Start Advertising");
err = bt_le_adv_start(BT_LE_ADV_CONN_FAST_1, ad, ARRAY_SIZE(ad), NULL, 0);
if (err != 0) {
FAIL("Advertising failed to start (err %d)", err);
return;
}
setup_connectable_adv(&ext_adv);
LOG_DBG("Waiting to be connected");
WAIT_FOR_FLAG(flag_connected);
@ -210,24 +204,21 @@ static void test_main(void)
LOG_INF("Trigger changes while device is connected");
trigger_notifications();
/* Now wait for client to disconnect, then stop adv so it does not reconnect */
/* Now wait for client to disconnect */
LOG_DBG("Wait for client disconnect");
WAIT_FOR_UNSET_FLAG(flag_connected);
LOG_DBG("Client disconnected");
err = bt_le_adv_stop();
if (err != 0) {
FAIL("Advertising failed to stop (err %d)", err);
return;
}
LOG_INF("Trigger changes while device is disconnected");
trigger_notifications();
LOG_DBG("Start Advertising");
err = bt_le_adv_start(BT_LE_ADV_CONN_FAST_1, ad, ARRAY_SIZE(ad), NULL, 0);
err = bt_le_ext_adv_start(ext_adv, BT_LE_EXT_ADV_START_DEFAULT);
if (err != 0) {
FAIL("Advertising failed to start (err %d)", err);
FAIL("Failed to start advertising set (err %d)\n", err);
bt_le_ext_adv_delete(ext_adv);
return;
}
@ -235,16 +226,13 @@ static void test_main(void)
WAIT_FOR_UNSET_FLAG(flag_connected);
LOG_DBG("Client disconnected");
err = bt_le_adv_stop();
if (err != 0) {
FAIL("Advertising failed to stop (err %d)", err);
return;
}
LOG_DBG("Start Advertising");
err = bt_le_adv_start(BT_LE_ADV_CONN_FAST_1, ad, ARRAY_SIZE(ad), NULL, 0);
err = bt_le_ext_adv_start(ext_adv, BT_LE_EXT_ADV_START_DEFAULT);
if (err != 0) {
FAIL("Advertising failed to start (err %d)", err);
FAIL("Failed to start advertising set (err %d)\n", err);
bt_le_ext_adv_delete(ext_adv);
return;
}
@ -269,16 +257,13 @@ static void test_main(void)
WAIT_FOR_UNSET_FLAG(flag_connected);
LOG_DBG("Client disconnected");
err = bt_le_adv_stop();
if (err != 0) {
FAIL("Advertising failed to stop (err %d)", err);
return;
}
LOG_DBG("Start Advertising");
err = bt_le_adv_start(BT_LE_ADV_CONN_FAST_1, ad, ARRAY_SIZE(ad), NULL, 0);
err = bt_le_ext_adv_start(ext_adv, BT_LE_EXT_ADV_START_DEFAULT);
if (err != 0) {
FAIL("Advertising failed to start (err %d)", err);
FAIL("Failed to start advertising set (err %d)\n", err);
bt_le_ext_adv_delete(ext_adv);
return;
}

7
tests/bsim/bluetooth/audio/src/tbs_client_test.c
View file

@ -481,6 +481,7 @@ static void discover_tbs(void)
static void test_main(void)
{
struct bt_le_ext_adv *ext_adv;
int err;
int index = 0;
@ -503,11 +504,7 @@ static void test_main(void)
printk("Audio Server: Bluetooth discovered\n");
err = bt_le_adv_start(BT_LE_ADV_CONN_FAST_1, ad, AD_SIZE, NULL, 0);
if (err != 0) {
FAIL("Advertising failed to start (err %d)\n", err);
return;
}
setup_connectable_adv(&ext_adv);
printk("Advertising successfully started\n");

1
tests/bsim/bluetooth/audio/src/tmap_client_test.c
View file

@ -1,5 +1,6 @@
/*
* Copyright 2023 NXP
* Copyright (c) 2025 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: Apache-2.0
*/

35
tests/bsim/bluetooth/audio/src/tmap_server_test.c
View file

@ -24,21 +24,10 @@
#ifdef CONFIG_BT_TMAP
extern enum bst_result_t bst_result;
static uint8_t tmap_addata[] = {
BT_UUID_16_ENCODE(BT_UUID_TMAS_VAL), /* TMAS UUID */
(BT_TMAP_ROLE_UMR | BT_TMAP_ROLE_CT), 0x00, /* TMAP Role */
};
static const struct bt_data ad_tmas[] = {
BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)),
BT_DATA_BYTES(BT_DATA_GAP_APPEARANCE, 0x09, 0x41), /* Appearance - Earbud */
BT_DATA(BT_DATA_SVC_DATA16, tmap_addata, ARRAY_SIZE(tmap_addata)),
};
static void test_main(void)
{
int err;
struct bt_le_ext_adv *adv;
struct bt_le_ext_adv *ext_adv;
err = bt_enable(NULL);
if (err != 0) {
@ -48,32 +37,14 @@ static void test_main(void)
printk("Bluetooth initialized\n");
/* Initialize TMAP */
err = bt_tmap_register(BT_TMAP_ROLE_CT | BT_TMAP_ROLE_UMR);
err = bt_tmap_register(TMAP_ROLE_SUPPORTED);
if (err != 0) {
FAIL("Failed to register TMAP (err %d)\n", err);
return;
}
printk("TMAP initialized. Start advertising...\n");
/* Create a connectable extended advertising set */
err = bt_le_ext_adv_create(BT_LE_EXT_ADV_CONN, NULL, &adv);
if (err) {
printk("Failed to create advertising set (err %d)\n", err);
return;
}
setup_connectable_adv(&ext_adv);
err = bt_le_ext_adv_set_data(adv, ad_tmas, ARRAY_SIZE(ad_tmas), NULL, 0);
if (err) {
printk("Failed to set advertising data (err %d)\n", err);
return;
}
err = bt_le_ext_adv_start(adv, BT_LE_EXT_ADV_START_DEFAULT);
if (err) {
printk("Failed to start advertising set (err %d)\n", err);
return;
}
printk("Advertising successfully started\n");
WAIT_FOR_FLAG(flag_connected);
printk("Connected!\n");

9
tests/bsim/bluetooth/audio/src/vcp_vol_rend_test.c
View file

@ -1029,6 +1029,7 @@ static void test_standalone(void)
static void test_main(void)
{
struct bt_le_ext_adv *ext_adv;
int err;
err = bt_enable(NULL);
@ -1044,13 +1045,7 @@ static void test_main(void)
printk("VCP initialized\n");
err = bt_le_adv_start(BT_LE_ADV_CONN_FAST_1, ad, AD_SIZE, NULL, 0);
if (err != 0) {
FAIL("Advertising failed to start (err %d)\n", err);
return;
}
printk("Advertising successfully started\n");
setup_connectable_adv(&ext_adv);
WAIT_FOR_FLAG(flag_connected);