microchip-application-bmd380-bmd380_central/le_scan.c

#include <stdbool.h>
#include <stdint.h>

#ifdef __cplusplus
extern "C"
{
#endif

#include "app_config.h"
#include "apply_old_config.h"
#include "sdk_config.h"

#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"

#include "nrf_delay.h"
#include "nrf_gpio.h"

#include "nrf_sdh.h"
#include "nrf_sdh_ble.h"
#include "nrf_sdh_freertos.h"

#include "ble_advdata.h"
#include "ble_gap.h"
#include "nrf_ble_scan.h"

#ifdef __cplusplus
}
#endif

#define MAX_DEV_NAME_LEN ((BLE_GAP_ADV_SET_DATA_SIZE_MAX + 1) - AD_DATA_OFFSET)

static void on_adv_report(ble_gap_evt_adv_report_t const *p_adv_report)
{
    // Initialize advertisement report for parsing.
    ret_code_t err_code;
    uint16_t offset        = 0;
    void *p_manu_spec_data = NULL;
    char dev_name[MAX_DEV_NAME_LEN];
    memset(dev_name, 0x00, MAX_DEV_NAME_LEN);

    // Search for advertising names.
    uint32_t device_name_len = ble_advdata_search(p_adv_report->data.p_data,
                                                  p_adv_report->data.len,
                                                  &offset,
                                                  BLE_GAP_AD_TYPE_COMPLETE_LOCAL_NAME);
    if (device_name_len)
    {
        uint8_t *p = (uint8_t *)p_adv_report->data.p_data;
        memcpy(dev_name, &p[offset], device_name_len);
    }

    // Search for advertising manufacturer spec data
    offset = 0;
    uint32_t manu_spec_data_len =
        ble_advdata_search(p_adv_report->data.p_data, p_adv_report->data.len, &offset, BLE_GAP_AD_TYPE_MANUFACTURER_SPECIFIC_DATA);

    if (manu_spec_data_len)
    {
        p_manu_spec_data = &p_adv_report->data.p_data[offset];
    }

    extern void host_scan_filter_match_cb(
        void *p_manu_spec_data,
        uint32_t manu_spec_data_len,
        char *p_device_name,
        uint32_t device_name_len,
        ble_gap_addr_t const *peer_addr,
        int16_t rssi);

    host_scan_filter_match_cb(
        p_manu_spec_data,
        manu_spec_data_len,
        dev_name,
        device_name_len,
        &p_adv_report->peer_addr,
        p_adv_report->rssi);
}

static uint8_t scan_buffer[BLE_GAP_SCAN_BUFFER_MAX];
static ble_data_t const adv_report_buffer = { .p_data = scan_buffer,
                                              .len    = BLE_GAP_SCAN_BUFFER_MAX };
static ble_uuid_t const filter_uuid       = { .type = BLE_UUID_TYPE_BLE, .uuid = 0xFFF0 };
static uint64_t mac                       = 0;
static uint32_t peer_addr_idx             = 0;
static ble_gap_addr_t peer_addr_list[16];

void le_scan_handler(ble_evt_t const *p_ble_evt, void *p_context)
{
    ret_code_t err_code;
    ble_gap_evt_adv_report_t const *p_adv_report = &p_ble_evt->evt.gap_evt.params.adv_report;
    uint16_t data_len                            = p_ble_evt->evt.gap_evt.params.adv_report.data.len;
    ble_gap_addr_t const *peer_addr              = &p_ble_evt->evt.gap_evt.params.adv_report.peer_addr;
    uint64_t u64_peer_addr                       = 0;
    memcpy(&u64_peer_addr, peer_addr, sizeof(peer_addr->addr));

    if (ble_advdata_uuid_find(p_adv_report->data.p_data, data_len, &filter_uuid))
    {
        mac = u64_peer_addr;

        if (peer_addr)
        {
            char peer_addr_str[(2 + 1) * BLE_GAP_ADDR_LEN + 1]        = { 0 };
            peer_addr_list[peer_addr_idx++ % COUNTOF(peer_addr_list)] = *peer_addr;
            sprintf(peer_addr_str, "%02X:%02X:%02X:%02X:%02X:%02X", peer_addr->addr[5], peer_addr->addr[4], peer_addr->addr[3], peer_addr->addr[2], peer_addr->addr[1], peer_addr->addr[0]);
            NRF_LOG_INFO("%s", peer_addr_str);
        }
    }
    else if (mac == u64_peer_addr)
    {
        on_adv_report(p_adv_report);
    }

    sd_ble_gap_scan_start(NULL, &adv_report_buffer);
}

void le_scan_get_peer_addr(ble_gap_addr_t *p_peer_addr)
{
    for (uint32_t i = 0; i < COUNTOF(peer_addr_list); i++)
    {
        if (memcmp(peer_addr_list[i].addr, p_peer_addr->addr, BLE_GAP_ADDR_LEN) == 0)
        {
            p_peer_addr->addr_type = peer_addr_list[i].addr_type;
            break;
        }
    }
}

static ble_gap_scan_params_t scan_params = {
    .active                 = 1,
    .interval               = NRF_BLE_SCAN_SCAN_INTERVAL,
    .window                 = NRF_BLE_SCAN_SCAN_WINDOW,
    .filter_policy          = BLE_GAP_SCAN_FP_ACCEPT_ALL,
    .scan_phys              = BLE_GAP_PHY_1MBPS,
    .timeout                = BLE_GAP_SCAN_TIMEOUT_UNLIMITED,
    .channel_mask           = {0, 0, 0, 0, 0},
    .report_incomplete_evts = 0,
    .extended               = 0,
};

void le_scan_init(void)
{
    // TODO...
}

bool is_scanning = false;

void le_scan_start(void)
{
    if (is_scanning != true)
    {
        NRF_LOG_INFO("Start scanning for UUID service 0x%04X.",
                     BLE_UUID_CUSTOM_SERVICE);
        is_scanning   = true;
        peer_addr_idx = 0;
        memset(peer_addr_list, 0x00, sizeof(peer_addr_list));
        sd_ble_gap_scan_start(&scan_params, &adv_report_buffer);
    }
}

void le_scan_stop(void)
{
    NRF_LOG_INFO("Stop scanning.");
    sd_ble_gap_scan_stop();
    is_scanning = false;
}

ble_gap_scan_params_t *le_scan_params(void)
{
    return &scan_params;
}