ble_scan.h

/*
 * Copyright (c) 2018 - 2025 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
 */
 
#ifndef BLE_SCAN_H__
#define BLE_SCAN_H__
 
#include <stdint.h>
#include <stdbool.h>
#include <string.h>
#include <ble.h>
#include <ble_gap.h>
#include <bm/softdevice_handler/nrf_sdh_ble.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define BLE_SCAN_DEF(_name)                                                                        \
        static struct ble_scan _name;                                                              \
        NRF_SDH_BLE_OBSERVER(_name##_obs, ble_scan_on_ble_evt, &_name, HIGH)
 
enum ble_scan_evt_type {
        BLE_SCAN_EVT_FILTER_MATCH,
        BLE_SCAN_EVT_ALLOW_LIST_REQUEST,
        BLE_SCAN_EVT_ALLOW_LIST_ADV_REPORT,
        BLE_SCAN_EVT_NOT_FOUND,
        BLE_SCAN_EVT_SCAN_TIMEOUT,
        BLE_SCAN_EVT_CONNECTING_ERROR,
        BLE_SCAN_EVT_CONNECTED,
        BLE_SCAN_EVT_ERROR,
};
 
 #define BLE_SCAN_NAME_FILTER (0x01)
#define BLE_SCAN_ADDR_FILTER (0x02)
#define BLE_SCAN_UUID_FILTER (0x04)
#define BLE_SCAN_APPEARANCE_FILTER (0x08)
#define BLE_SCAN_SHORT_NAME_FILTER (0x10)
#define BLE_SCAN_MANUFACTURER_DATA_FILTER (0x20)
struct ble_scan_filter_data {
        union {
                struct {
                        const char *name;
                } name_filter;
                struct {
                        const uint8_t *addr;
                } addr_filter;
                struct {
                        ble_uuid_t uuid;
                } uuid_filter;
                struct {
                        uint16_t appearance;
                } appearance_filter;
                struct {
                        const char *short_name;
                        uint8_t short_name_min_len;
                } short_name_filter;
                struct {
                        const uint8_t *data;
                        uint8_t data_len;
                } manufacturer_data_filter;
        };
};
 
struct ble_scan_filter_match {
        uint8_t name_filter_match: 1;
        uint8_t address_filter_match: 1;
        uint8_t uuid_filter_match: 1;
        uint8_t appearance_filter_match: 1;
        uint8_t short_name_filter_match: 1;
        uint8_t manufacturer_data_filter_match: 1;
};
 
struct ble_scan_evt {
        enum ble_scan_evt_type evt_type;
        const ble_gap_scan_params_t *scan_params;
        union {
                struct {
                        const ble_gap_evt_adv_report_t *adv_report;
                        struct ble_scan_filter_match filter_match;
                } filter_match;
                ble_gap_evt_timeout_t timeout;
                struct {
                        const ble_gap_evt_adv_report_t *adv_report;
                } allow_list_adv_report;
                struct {
                        const ble_gap_evt_adv_report_t *adv_report;
                } not_found;
                struct {
                        const ble_gap_evt_connected_t *connected;
                        uint16_t conn_handle;
                } connected;
                struct {
                        int reason;
                } connecting_err;
                struct {
                        uint32_t reason;
                } error;
        };
};
 
typedef void (*ble_scan_evt_handler_t)(const struct ble_scan_evt *scan_evt);
 
struct ble_scan_name_filter {
        char target_name[CONFIG_BLE_SCAN_NAME_COUNT][CONFIG_BLE_SCAN_NAME_MAX_LEN];
        uint8_t name_cnt;
        bool name_filter_enabled;
};
 
struct ble_scan_short_name_filter {
        struct {
                char short_target_name[CONFIG_BLE_SCAN_SHORT_NAME_MAX_LEN];
                uint8_t short_name_min_len;
        } short_name[CONFIG_BLE_SCAN_SHORT_NAME_COUNT];
        uint8_t name_cnt;
        bool short_name_filter_enabled;
};
 
struct ble_scan_addr_filter {
        ble_gap_addr_t target_addr[CONFIG_BLE_SCAN_ADDRESS_COUNT];
        uint8_t addr_cnt;
        bool addr_filter_enabled;
};
 
struct ble_scan_uuid_filter {
        ble_uuid_t uuid[CONFIG_BLE_SCAN_UUID_COUNT];
        uint8_t uuid_cnt;
        bool uuid_filter_enabled;
};
 
struct ble_scan_appearance_filter {
        uint16_t appearance[CONFIG_BLE_SCAN_APPEARANCE_COUNT];
        uint8_t appearance_cnt;
        bool appearance_filter_enabled;
};
 
struct ble_scan_manufacturer_data_filter {
        struct {
                uint8_t data[CONFIG_BLE_SCAN_MANUFACTURER_DATA_MAX_LEN];
                uint8_t data_len;
        } manufacturer_data[CONFIG_BLE_SCAN_MANUFACTURER_DATA_COUNT];
        uint8_t manufacturer_data_cnt;
        bool manufacturer_data_filter_enabled;
};
 
struct ble_scan_filters {
#if CONFIG_BLE_SCAN_NAME_COUNT > 0
        struct ble_scan_name_filter name_filter;
#endif
#if CONFIG_BLE_SCAN_SHORT_NAME_COUNT > 0
        struct ble_scan_short_name_filter short_name_filter;
#endif
#if CONFIG_BLE_SCAN_ADDRESS_COUNT > 0
        struct ble_scan_addr_filter addr_filter;
#endif
#if CONFIG_BLE_SCAN_UUID_COUNT > 0
        struct ble_scan_uuid_filter uuid_filter;
#endif
#if CONFIG_BLE_SCAN_APPEARANCE_COUNT > 0
        struct ble_scan_appearance_filter appearance_filter;
#endif
#if CONFIG_BLE_SCAN_MANUFACTURER_DATA_COUNT > 0
        struct ble_scan_manufacturer_data_filter manufacturer_data_filter;
#endif
        bool all_filters_mode;
};
 
#define BLE_SCAN_SCAN_PARAMS_DEFAULT                                                               \
{                                                                                                  \
        .active = 1,                                                                               \
        .interval = CONFIG_BLE_SCAN_INTERVAL,                                                      \
        .window = CONFIG_BLE_SCAN_WINDOW,                                                          \
        .timeout = CONFIG_BLE_SCAN_DURATION,                                                       \
        .filter_policy = BLE_GAP_SCAN_FP_ACCEPT_ALL,                                               \
        .scan_phys = BLE_GAP_PHY_1MBPS,                                                            \
}
 
#define BLE_SCAN_CONN_PARAMS_DEFAULT                                                               \
{                                                                                                  \
        .conn_sup_timeout = BLE_GAP_CP_CONN_SUP_TIMEOUT_MIN,                                       \
        .min_conn_interval = CONFIG_BLE_SCAN_MIN_CONNECTION_INTERVAL,                              \
        .max_conn_interval = CONFIG_BLE_SCAN_MAX_CONNECTION_INTERVAL,                              \
        .slave_latency = (uint16_t)CONFIG_BLE_SCAN_PERIPHERAL_LATENCY,                             \
}
 
struct ble_scan_config {
        ble_gap_scan_params_t scan_params;
        bool connect_if_match;
        ble_gap_conn_params_t conn_params;
        uint8_t conn_cfg_tag;
        ble_scan_evt_handler_t evt_handler;
};
 
struct ble_scan {
#if defined(CONFIG_BLE_SCAN_FILTER)
        struct ble_scan_filters scan_filters;
#endif
        bool connect_if_match;
        ble_gap_conn_params_t conn_params;
        uint8_t conn_cfg_tag;
        ble_gap_scan_params_t scan_params;
        ble_scan_evt_handler_t evt_handler;
        uint8_t scan_buffer_data[2][CONFIG_BLE_SCAN_BUFFER_SIZE];
        ble_data_t scan_buffer;
};
 
bool ble_scan_is_allow_list_used(const struct ble_scan *scan);
 
uint32_t ble_scan_init(struct ble_scan *scan, struct ble_scan_config *config);
 
uint32_t ble_scan_start(const struct ble_scan *scan);
 
void ble_scan_stop(const struct ble_scan *scan);
 
uint32_t ble_scan_filters_enable(struct ble_scan *scan, uint8_t mode, bool match_all);
 
uint32_t ble_scan_filters_disable(struct ble_scan *scan);
 
uint32_t ble_scan_filter_get(const struct ble_scan *scan, struct ble_scan_filters *status);
 
uint32_t ble_scan_filter_add(struct ble_scan *scan, uint8_t type,
                             const struct ble_scan_filter_data *data);
 
uint32_t ble_scan_all_filter_remove(struct ble_scan *scan);
 
uint32_t ble_scan_params_set(struct ble_scan *scan, const ble_gap_scan_params_t *scan_params);
 
void ble_scan_on_ble_evt(const ble_evt_t *ble_evt, void *ble_scan);
 
uint32_t ble_scan_copy_addr_to_sd_gap_addr(ble_gap_addr_t *gap_addr,
                                           const uint8_t addr[BLE_GAP_ADDR_LEN]);
 
#ifdef __cplusplus
}
#endif
 
#endif /* BLE_SCAN_H__ */