help
This select can make the allocation of memory will become more flexible
+config BLE_SCAN_DUPLICATE
+ bool "BLE Scan Duplicate Options "
+ depends on BLUEDROID_ENABLED
+ default y
+ help
+ This select enables parameters setting of BLE scan duplicate.
+
+config DUPLICATE_SCAN_CACHE_SIZE
+ int "Maximum number of devices in scan duplicate filter"
+ depends on BLE_SCAN_DUPLICATE
+ range 10 200
+ default 20
+ help
+ Maximum number of devices which can be recorded in scan duplicate filter.
+ When the maximum amount of device in the filter is reached, the cache will be refreshed.
+
+config BLE_MESH_SCAN_DUPLICATE_EN
+ bool "Special duplicate scan mechanism for BLE Mesh scan"
+ depends on BLE_SCAN_DUPLICATE
+ default n
+ help
+ This enables the BLE scan duplicate for special BLE Mesh scan.
+
+config MESH_DUPLICATE_SCAN_CACHE_SIZE
+ int "Maximum number of Mesh adv packets in scan duplicate filter"
+ depends on BLE_MESH_SCAN_DUPLICATE_EN
+ range 10 200
+ default 50
+ help
+ Maximum number of adv packets which can be recorded in duplicate scan cache for BLE Mesh.
+ When the maximum amount of device in the filter is reached, the cache will be refreshed.
+
config SMP_ENABLE
bool
depends on BLUEDROID_ENABLED
3. directed advertising packets addressed to this device.*/
} esp_ble_scan_filter_t;
+/// Ble scan duplicate type
+typedef enum {
+ BLE_SCAN_DUPLICATE_DISABLE = 0x0, /*!< the Link Layer should generate advertising reports to the host for each packet received */
+ BLE_SCAN_DUPLICATE_ENABLE = 0x1, /*!< the Link Layer should filter out duplicate advertising reports to the Host */
+ BLE_SCAN_DUPLICATE_MAX = 0x2, /*!< 0x02 – 0xFF, Reserved for future use */
+} esp_ble_scan_duplicate_t;
+
/// Ble scan parameters
typedef struct {
esp_ble_scan_type_t scan_type; /*!< Scan type */
Range: 0x0004 to 0x4000 Default: 0x0010 (10 ms)
Time = N * 0.625 msec
Time Range: 2.5 msec to 10240 msec */
+ esp_ble_scan_duplicate_t scan_duplicate; /*!< The Scan_Duplicates parameter controls whether the Link Layer should filter out
+ duplicate advertising reports (BLE_SCAN_DUPLICATE_ENABLE) to the Host, or if the Link Layer should generate
+ advertising reports for each packet received */
} esp_ble_scan_params_t;
/// Connection update parameters
p_data->ble_set_scan_fil_params.scan_window,
p_data->ble_set_scan_fil_params.scan_mode,
p_data->ble_set_scan_fil_params.addr_type_own,
+ p_data->ble_set_scan_fil_params.scan_duplicate_filter,
p_data->ble_set_scan_fil_params.scan_filter_policy,
p_data->ble_set_scan_fil_params.scan_param_setup_cback);
}
** scan_interval - scan interval
** scan_window - scan window
** scan_mode - scan mode
+** scan_duplicate_filter - scan duplicate filter
** scan_param_setup_status_cback - Set scan param status callback
**
** Returns void
*******************************************************************************/
void BTA_DmSetBleScanFilterParams(tGATT_IF client_if, UINT32 scan_interval,
UINT32 scan_window, tBLE_SCAN_MODE scan_mode, UINT8 scan_fil_poilcy,
- UINT8 addr_type_own, tBLE_SCAN_PARAM_SETUP_CBACK scan_param_setup_cback)
+ UINT8 addr_type_own, UINT8 scan_duplicate_filter, tBLE_SCAN_PARAM_SETUP_CBACK scan_param_setup_cback)
{
tBTA_DM_API_BLE_SCAN_FILTER_PARAMS *p_msg;
p_msg->scan_window = scan_window;
p_msg->scan_mode = scan_mode;
p_msg->addr_type_own = addr_type_own;
+ p_msg->scan_duplicate_filter = scan_duplicate_filter;
p_msg->scan_filter_policy = scan_fil_poilcy;
p_msg->scan_param_setup_cback = scan_param_setup_cback;
UINT32 scan_window;
tBLE_SCAN_MODE scan_mode;
UINT8 addr_type_own;
+ UINT8 scan_duplicate_filter;
UINT8 scan_filter_policy;
tBLE_SCAN_PARAM_SETUP_CBACK scan_param_setup_cback;
} tBTA_DM_API_BLE_SCAN_FILTER_PARAMS;
** scan_interval - scan interval
** scan_window - scan window
** scan_mode - scan mode
+** scan_duplicate_filter - scan duplicate filter
** scan_param_setup_status_cback - Set scan param status callback
**
** Returns void
*******************************************************************************/
extern void BTA_DmSetBleScanFilterParams(tGATT_IF client_if, UINT32 scan_interval,
UINT32 scan_window, tBLE_SCAN_MODE scan_mode, UINT8 scan_fil_poilcy,
- UINT8 addr_type_own, tBLE_SCAN_PARAM_SETUP_CBACK scan_param_setup_cback);
+ UINT8 addr_type_own, UINT8 scan_duplicate_filter, tBLE_SCAN_PARAM_SETUP_CBACK scan_param_setup_cback);
/*******************************************************************************
BLE_ISVALID_PARAM(scan_params->scan_window, BTM_BLE_SCAN_WIN_MIN, BTM_BLE_SCAN_WIN_MAX) &&
BLE_ISVALID_PARAM(scan_params->own_addr_type, BLE_ADDR_TYPE_PUBLIC, BLE_ADDR_TYPE_RPA_RANDOM) &&
BLE_ISVALID_PARAM(scan_params->scan_filter_policy, BLE_SCAN_FILTER_ALLOW_ALL, BLE_SCAN_FILTER_ALLOW_WLIST_PRA_DIR) &&
+ BLE_ISVALID_PARAM(scan_params->scan_duplicate, BLE_SCAN_DUPLICATE_DISABLE, BLE_SCAN_DUPLICATE_MAX -1) &&
(scan_params->scan_type == BTM_BLE_SCAN_MODE_ACTI || scan_params->scan_type == BTM_BLE_SCAN_MODE_PASS)) {
BTA_DmSetBleScanFilterParams(ESP_DEFAULT_GATT_IF, /*client_if*/
scan_params->scan_interval,
scan_params->scan_type,
scan_params->scan_filter_policy,
scan_params->own_addr_type,
+ scan_params->scan_duplicate,
scan_param_setup_cback);
} else {
btc_scan_params_callback(ESP_DEFAULT_GATT_IF, BTM_ILLEGAL_VALUE);
BTM_BLE_DEFAULT_SFP);
}
- p_inq->scan_duplicate_filter = BTM_BLE_DUPLICATE_DISABLE;
status = btm_ble_start_scan();
}
tBTM_STATUS BTM_BleScan(BOOLEAN start, UINT32 duration,
tBTM_INQ_RESULTS_CB *p_results_cb, tBTM_CMPL_CB *p_cmpl_cb)
{
- tBTM_BLE_INQ_CB *p_inq = &btm_cb.ble_ctr_cb.inq_var;
tBTM_STATUS status = BTM_WRONG_MODE;
if (!controller_get_interface()->supports_ble()) {
/* enable resolving list */
btm_ble_enable_resolving_list_for_platform(BTM_BLE_RL_SCAN);
#endif
- p_inq->scan_duplicate_filter = BTM_BLE_DUPLICATE_DISABLE;
status = btm_ble_start_scan();
}
}
void BTM_BleSetScanFilterParams(tGATT_IF client_if, UINT32 scan_interval, UINT32 scan_window,
- tBLE_SCAN_MODE scan_mode, UINT8 addr_type_own, tBTM_BLE_SFP scan_filter_policy,
+ tBLE_SCAN_MODE scan_mode, UINT8 addr_type_own, UINT8 scan_duplicate_filter, tBTM_BLE_SFP scan_filter_policy,
tBLE_SCAN_PARAM_SETUP_CBACK scan_setup_status_cback)
{
tBTM_BLE_INQ_CB *p_cb = &btm_cb.ble_ctr_cb.inq_var;
p_cb->scan_window = scan_window;
p_cb->sfp = scan_filter_policy;
p_cb->scan_params_set = TRUE;
+ p_cb->scan_duplicate_filter = scan_duplicate_filter;
+
btsnd_hcic_ble_set_scan_params(p_cb->scan_type, (UINT16)scan_interval,
(UINT16)scan_window,
/* enable IRK list */
btm_ble_enable_resolving_list_for_platform(BTM_BLE_RL_SCAN);
#endif
- p_ble_cb->inq_var.scan_duplicate_filter = BTM_BLE_DUPLICATE_DISABLE;
status = btm_ble_start_scan();
} else if ((p_ble_cb->inq_var.scan_interval != BTM_BLE_LOW_LATENCY_SCAN_INT) ||
(p_ble_cb->inq_var.scan_window != BTM_BLE_LOW_LATENCY_SCAN_WIN)) {
tBTM_STATUS status = BTM_CMD_STARTED;
// recoverly the scan parameters to the controller before start scan
btm_ble_recover_scan_params();
+ if(p_inq->scan_duplicate_filter > BTM_BLE_DUPLICATE_MAX) {
+ p_inq->scan_duplicate_filter = BTM_BLE_DUPLICATE_DISABLE;
+ }
/* start scan, disable duplicate filtering */
if (!btsnd_hcic_ble_set_scan_enable (BTM_BLE_SCAN_ENABLE, p_inq->scan_duplicate_filter)) {
status = BTM_NO_RESOURCES;
#define BTM_BLE_ENC_MASK 0x03
-#define BTM_BLE_DUPLICATE_ENABLE 1
#define BTM_BLE_DUPLICATE_DISABLE 0
+#define BTM_BLE_DUPLICATE_ENABLE 1
+#define BTM_BLE_DUPLICATE_MAX BTM_BLE_DUPLICATE_ENABLE
#define BTM_BLE_GAP_DISC_SCAN_INT 18 /* Interval(scan_int) = 11.25 ms= 0x0010 * 0.625 ms */
#define BTM_BLE_GAP_DISC_SCAN_WIN 18 /* scan_window = 11.25 ms= 0x0010 * 0.625 ms */
case HCI_BLE_CLEAR_WHITE_LIST:
btm_ble_clear_white_list_complete(p, evt_len);
break;
-
+ case HCI_BLE_WRITE_ADV_PARAMS: {
+ uint8_t status;
+ STREAM_TO_UINT8 (status, p);
+ if(status != HCI_SUCCESS) {
+ HCI_TRACE_ERROR("hci write adv params error 0x%x", status);
+ }
+ break;
+ }
+ case HCI_BLE_RC_PARAM_REQ_REPLY: {
+ uint8_t status;
+ STREAM_TO_UINT8 (status, p);
+ if(status != HCI_SUCCESS) {
+ HCI_TRACE_ERROR("hci connection params reply command error 0x%x", status);
+ }
+ break;
+ }
+ case HCI_BLE_RC_PARAM_REQ_NEG_REPLY: {
+ uint8_t status;
+ STREAM_TO_UINT8 (status, p);
+ if(status != HCI_SUCCESS) {
+ HCI_TRACE_ERROR("hci connection params neg reply command error %x", status);
+ }
+ break;
+ }
case HCI_BLE_REMOVE_WHITE_LIST:
btm_ble_remove_from_white_list_complete(p, evt_len);
break;
#endif
#endif /* (BLE_INCLUDED == TRUE) */
- default:
+ default: {
if ((opcode & HCI_GRP_VENDOR_SPECIFIC) == HCI_GRP_VENDOR_SPECIFIC) {
btm_vsc_complete (p, opcode, evt_len, (tBTM_CMPL_CB *)p_cplt_cback);
}
+ uint8_t status;
+ STREAM_TO_UINT8 (status, p);
+ if(status != HCI_SUCCESS) {
+ HCI_TRACE_ERROR("%s opcode 0x%x status 0x%x", __func__, opcode, status);
+ }
break;
}
+ }
}
/*******************************************************************************
** scan_window - Scan window
** scan_type - Scan type
** addr_type_own - owner address type
+** scan_duplicate_filter - scan duplicate filter
** scan_filter_policy - scan filter policy
** scan_setup_status_cback - Scan setup status callback
**
**
*******************************************************************************/
void BTM_BleSetScanFilterParams(tGATT_IF client_if, UINT32 scan_interval, UINT32 scan_window,
- tBLE_SCAN_MODE scan_mode, UINT8 addr_type_own, tBTM_BLE_SFP scan_filter_policy,
+ tBLE_SCAN_MODE scan_mode, UINT8 addr_type_own, UINT8 scan_duplicate_filter, tBTM_BLE_SFP scan_filter_policy,
tBLE_SCAN_PARAM_SETUP_CBACK scan_setup_status_cback);
#define BTDM_CFG_BT_DATA_RELEASE (1<<0)
#define BTDM_CFG_HCI_UART (1<<1)
#define BTDM_CFG_CONTROLLER_RUN_APP_CPU (1<<2)
+#define BTDM_CFG_SCAN_DUPLICATE_OPTIONS (1<<3)
+#define BTDM_CFG_SEND_ADV_RESERVED_SIZE (1<<4)
/* Other reserved for future */
/* not for user call, so don't put to include file */
#if CONFIG_BTDM_CONTROLLER_PINNED_TO_CORE == 1
mask |= BTDM_CFG_CONTROLLER_RUN_APP_CPU;
#endif
+ mask |= BTDM_CFG_SCAN_DUPLICATE_OPTIONS;
+
+ mask |= BTDM_CFG_SEND_ADV_RESERVED_SIZE;
+
return mask;
}
uint8_t controller_task_prio; /*!< Bluetooth controller task priority */
uint8_t hci_uart_no; /*!< If use UART1/2 as HCI IO interface, indicate UART number */
uint32_t hci_uart_baudrate; /*!< If use UART1/2 as HCI IO interface, indicate UART baudrate */
+ uint8_t scan_duplicate_mode; /*!< If use UART1/2 as HCI IO interface, indicate UART baudrate */
+ uint16_t normal_adv_size; /*!< Normal adv size for scan duplicate */
+ uint16_t mesh_adv_size; /*!< Mesh adv size for scan duplicate */
+ uint16_t send_adv_reserved_size; /*!< Controller minimum memory value */
+ uint32_t controller_debug_flag; /*!< Controller debug log flag */
} esp_bt_controller_config_t;
#ifdef CONFIG_BT_ENABLED
+/* While scanning, if the free memory value in controller is less than SCAN_SEND_ADV_RESERVED_SIZE,
+the adv packet will be discarded until the memory is restored. */
+#define SCAN_SEND_ADV_RESERVED_SIZE 1000
+/* open controller log debug when adv lost */
+#define CONTROLLER_ADV_LOST_DEBUG_BIT (0<<0)
#ifdef CONFIG_BT_HCI_UART_NO
#define BT_HCI_UART_NO_DEFAULT CONFIG_BT_HCI_UART_NO
#define BT_HCI_UART_BAUDRATE_DEFAULT 921600
#endif /* BT_HCI_UART_BAUDRATE_DEFAULT */
+/* normal adv cache size */
+#ifdef CONFIG_DUPLICATE_SCAN_CACHE_SIZE
+#define NORMAL_SCAN_DUPLICATE_CACHE_SIZE CONFIG_DUPLICATE_SCAN_CACHE_SIZE
+#else
+#define NORMAL_SCAN_DUPLICATE_CACHE_SIZE 20
+#endif
+
+#ifndef CONFIG_BLE_MESH_SCAN_DUPLICATE_EN
+#define CONFIG_BLE_MESH_SCAN_DUPLICATE_EN FALSE
+#endif
+
+#define SCAN_DUPLICATE_MODE_NORMAL_ADV_ONLY 0
+#define SCAN_DUPLICATE_MODE_NORMAL_ADV_MESH_ADV 1
+
+#if CONFIG_BLE_MESH_SCAN_DUPLICATE_EN
+ #define SCAN_DUPLICATE_MODE SCAN_DUPLICATE_MODE_NORMAL_ADV_MESH_ADV
+ #ifdef CONFIG_MESH_DUPLICATE_SCAN_CACHE_SIZE
+ #define MESH_DUPLICATE_SCAN_CACHE_SIZE CONFIG_MESH_DUPLICATE_SCAN_CACHE_SIZE
+ #else
+ #define MESH_DUPLICATE_SCAN_CACHE_SIZE 50
+ #endif
+#else
+ #define SCAN_DUPLICATE_MODE SCAN_DUPLICATE_MODE_NORMAL_ADV_ONLY
+ #define MESH_DUPLICATE_SCAN_CACHE_SIZE 0
+#endif
+
#define BT_CONTROLLER_INIT_CONFIG_DEFAULT() { \
.controller_task_stack_size = ESP_TASK_BT_CONTROLLER_STACK, \
.controller_task_prio = ESP_TASK_BT_CONTROLLER_PRIO, \
.hci_uart_no = BT_HCI_UART_NO_DEFAULT, \
.hci_uart_baudrate = BT_HCI_UART_BAUDRATE_DEFAULT, \
+ .scan_duplicate_mode = SCAN_DUPLICATE_MODE, \
+ .normal_adv_size = NORMAL_SCAN_DUPLICATE_CACHE_SIZE, \
+ .mesh_adv_size = MESH_DUPLICATE_SCAN_CACHE_SIZE, \
+ .send_adv_reserved_size = SCAN_SEND_ADV_RESERVED_SIZE, \
+ .controller_debug_flag = CONTROLLER_ADV_LOST_DEBUG_BIT, \
};
+
#else
#define BT_CONTROLLER_INIT_CONFIG_DEFAULT() {0}; _Static_assert(0, "please enable bluetooth in menuconfig to use bt.h");
#endif
-Subproject commit 16516d7009f1c31c21939047447a95238194de40
+Subproject commit 7c55331605beefea4882efc4343c23b28eb38d83
- ["R SSC1 C +BLEADV:SetAdv,OK"]
- *open_capture_nic
- *dut1_stop_adv
- - - LOOP 2 2 "['0x20-0x40','0xA0-0xB0']" "['NPDU','PDU']"
+ - - LOOP 2 2 "['0x20-0x40','0xA0-0xB0']" "['PDU','PDU']"
- [""]
- - "SSC SSC1 bleadv -D -z start -t 2 -i {%s}"
- ["R SSC1 C +BLEADV:OK"]
- ["R SSC1 C +BLEADV:SetAdv,OK"]
- *open_capture_nic
- *dut1_stop_adv
- - - LOOP 2 2 "['0x20-0x40','0xA0-0xB0']" "['NPDU','PDU']"
+ - - LOOP 2 2 "['0x20-0x40','0xA0-0xB0']" "['PDU','PDU']"
- [""]
- - "SSC SSC1 bleadv -D -z start -t 3 -i {%s}"
- ["R SSC1 C +BLEADV:OK"]
.own_addr_type = BLE_ADDR_TYPE_PUBLIC,
.scan_filter_policy = BLE_SCAN_FILTER_ALLOW_ALL,
.scan_interval = 0x50,
- .scan_window = 0x30
+ .scan_window = 0x30,
+ .scan_duplicate = BLE_SCAN_DUPLICATE_DISABLE
};
static void esp_eddystone_show_inform(const esp_eddystone_result_t* res)
.own_addr_type = BLE_ADDR_TYPE_PUBLIC,
.scan_filter_policy = BLE_SCAN_FILTER_ALLOW_ALL,
.scan_interval = 0x50,
- .scan_window = 0x30
+ .scan_window = 0x30,
+ .scan_duplicate = BLE_SCAN_DUPLICATE_DISABLE
};
#elif (IBEACON_MODE == IBEACON_SENDER)
.own_addr_type = BLE_ADDR_TYPE_PUBLIC,
.scan_filter_policy = BLE_SCAN_FILTER_ALLOW_ALL,
.scan_interval = 0x50,
- .scan_window = 0x30
+ .scan_window = 0x30,
+ .scan_duplicate = BLE_SCAN_DUPLICATE_DISABLE
};
static const char device_name[] = "ESP_SPP_SERVER";
.own_addr_type = BLE_ADDR_TYPE_PUBLIC,
.scan_filter_policy = BLE_SCAN_FILTER_ALLOW_ALL,
.scan_interval = 0x50,
- .scan_window = 0x30
+ .scan_window = 0x30,
+ .scan_duplicate = BLE_SCAN_DUPLICATE_DISABLE
};
struct gattc_profile_inst {
.own_addr_type = BLE_ADDR_TYPE_PUBLIC,
.scan_filter_policy = BLE_SCAN_FILTER_ALLOW_ALL,
.scan_interval = 0x50,
- .scan_window = 0x30
+ .scan_window = 0x30,
+ .scan_duplicate = BLE_SCAN_DUPLICATE_DISABLE
};
struct gattc_profile_inst {
.own_addr_type = BLE_ADDR_TYPE_RANDOM,
.scan_filter_policy = BLE_SCAN_FILTER_ALLOW_ALL,
.scan_interval = 0x50,
- .scan_window = 0x30
+ .scan_window = 0x30,
+ .scan_duplicate = BLE_SCAN_DUPLICATE_DISABLE
};
.own_addr_type = BLE_ADDR_TYPE_PUBLIC,
.scan_filter_policy = BLE_SCAN_FILTER_ALLOW_ALL,
.scan_interval = 0x50,
- .scan_window = 0x30
+ .scan_window = 0x30,
+ .scan_duplicate = BLE_SCAN_DUPLICATE_DISABLE
};
struct gattc_profile_inst {