Whitelisting

[Nabil]

Hello,

I'm working on nRF52832-DK with SDK11 on linux.

Is there an example to use whitelisting ? I'm trying to use HIDS_Mouse but it's not working.

How can I write manually a specifical MAC adress to add on the list ?

Thank you.

For now I have try in " on_adv_evt " :

#include <stdint.h>
#include <string.h>
#include <stdbool.h>
#include "nordic_common.h"
#include "nrf.h"
#include "app_error.h"
#include "ble.h"
#include "ble_hci.h"
#include "ble_srv_common.h"
#include "ble_advdata.h"
#include "ble_advertising.h"
#include "ble_conn_params.h"
#include "boards.h"
#include "softdevice_handler.h"
#include "app_timer.h"
#include "device_manager.h"
#include "pstorage.h"
#include "bsp.h"
#include "bsp_btn_ble.h"
#include "our_service.h"
#include "nrf_drv_gpiote.h"
#include "nrf_delay.h"

#include "nrf_drv_timer.h"
#include "app_util_platform.h"



#define IS_SRVC_CHANGED_CHARACT_PRESENT  1                                          
#define CENTRAL_LINK_COUNT               0                                          
#define PERIPHERAL_LINK_COUNT            1                                        
#define DEVICE_NAME                      "OurApp"                        
#define MANUFACTURER_NAME                "Mine"                      
#define APP_ADV_INTERVAL                 300                                      
#define APP_ADV_TIMEOUT_IN_SECONDS       20                                        
#define APP_TIMER_PRESCALER              0                                         
#define APP_RTC_PRESCALER                22                                          
#define APP_TIMER_OP_QUEUE_SIZE          4                                         
#define MIN_CONN_INTERVAL                MSEC_TO_UNITS(100, UNIT_1_25_MS)          
#define MAX_CONN_INTERVAL                MSEC_TO_UNITS(200, UNIT_1_25_MS)           
#define SLAVE_LATENCY                    0                                         
#define CONN_SUP_TIMEOUT                 MSEC_TO_UNITS(4000, UNIT_10_MS)          
#define FIRST_CONN_PARAMS_UPDATE_DELAY   APP_TIMER_TICKS(5000, APP_TIMER_PRESCALER) 
#define NEXT_CONN_PARAMS_UPDATE_DELAY    APP_TIMER_TICKS(30000, APP_TIMER_PRESCALER)
#define MAX_CONN_PARAMS_UPDATE_COUNT     3                                          
#define SEC_PARAM_BOND                   1                                          
#define SEC_PARAM_MITM                   0                                         
#define SEC_PARAM_IO_CAPABILITIES        BLE_GAP_IO_CAPS_NONE              
#define SEC_PARAM_OOB                    0                                        
#define SEC_PARAM_MIN_KEY_SIZE           7                                         
#define SEC_PARAM_MAX_KEY_SIZE           16                                       
#define DEAD_BEEF                        0xDEADBEEF                                
#define OUR_CHAR_TIMER_INTERVAL         APP_TIMER_TICKS(500, APP_TIMER_PRESCALER) 
#define APP_ADV_FAST_INTERVAL           0x0028                                      
#define APP_ADV_SLOW_INTERVAL           0x0C80                                      
#define APP_ADV_FAST_TIMEOUT            30                                          
#define APP_ADV_SLOW_TIMEOUT            180                                         


APP_TIMER_DEF(m_our_char_timer_id);
static ble_uuid_t m_adv_uuids[] = {{0x9999, BLE_UUID_TYPE_BLE}}; 
const nrf_drv_timer_t TIMER_LED = NRF_DRV_TIMER_INSTANCE(1);
static dm_application_instance_t        m_app_handle;     
static uint16_t  m_conn_handle = BLE_CONN_HANDLE_INVALID;  
static nrf_ppi_channel_t       m_ppi_channel;
ble_os_t m_our_service;




void assert_nrf_callback(uint16_t line_num, const uint8_t * p_file_name)
{
    app_error_handler(DEAD_BEEF, line_num, p_file_name);
}

static void timer_timeout_handler(void * p_context)
{
     nrf_gpio_pin_toggle(LED_2);
}

static void timers_init(void)
{   uint32_t err_code;
    APP_TIMER_INIT(APP_TIMER_PRESCALER, APP_TIMER_OP_QUEUE_SIZE, false);
    app_timer_create(&m_our_char_timer_id, APP_TIMER_MODE_REPEATED, timer_timeout_handler);
}


static void gap_params_init(void)
{
    uint32_t                err_code;
    ble_gap_conn_params_t   gap_conn_params;
    ble_gap_conn_sec_mode_t sec_mode;

    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&sec_mode);

    err_code = sd_ble_gap_device_name_set(&sec_mode,
                                          (const uint8_t *)DEVICE_NAME,
                                          strlen(DEVICE_NAME));
    APP_ERROR_CHECK(err_code);
    memset(&gap_conn_params, 0, sizeof(gap_conn_params));

    gap_conn_params.min_conn_interval = MIN_CONN_INTERVAL;
    gap_conn_params.max_conn_interval = MAX_CONN_INTERVAL;
    gap_conn_params.slave_latency     = SLAVE_LATENCY;
    gap_conn_params.conn_sup_timeout  = CONN_SUP_TIMEOUT;

    err_code = sd_ble_gap_ppcp_set(&gap_conn_params);
    APP_ERROR_CHECK(err_code);
}

static void services_init(void)
{
    our_service_init(&m_our_service);
}

static void on_conn_params_evt(ble_conn_params_evt_t * p_evt)
{
    uint32_t err_code;

    if (p_evt->evt_type == BLE_CONN_PARAMS_EVT_FAILED)
    {
        err_code = sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_CONN_INTERVAL_UNACCEPTABLE);
        APP_ERROR_CHECK(err_code);
    }
}

static void conn_params_error_handler(uint32_t nrf_error)
{
    APP_ERROR_HANDLER(nrf_error);
}

static void conn_params_init(void)
{
    uint32_t               err_code;
    ble_conn_params_init_t cp_init;

    memset(&cp_init, 0, sizeof(cp_init));

    cp_init.p_conn_params                  = NULL;
    cp_init.first_conn_params_update_delay = FIRST_CONN_PARAMS_UPDATE_DELAY;
    cp_init.next_conn_params_update_delay  = NEXT_CONN_PARAMS_UPDATE_DELAY;
    cp_init.max_conn_params_update_count   = MAX_CONN_PARAMS_UPDATE_COUNT;
    cp_init.start_on_notify_cccd_handle    = BLE_GATT_HANDLE_INVALID;
    cp_init.disconnect_on_fail             = false;
    cp_init.evt_handler                    = on_conn_params_evt;
    cp_init.error_handler                  = conn_params_error_handler;

    err_code = ble_conn_params_init(&cp_init);
    APP_ERROR_CHECK(err_code);
}


static void sleep_mode_enter(void)
{
    uint32_t err_code = bsp_indication_set(BSP_INDICATE_IDLE);
    APP_ERROR_CHECK(err_code);

    // Prepare wakeup buttons.
    err_code = bsp_btn_ble_sleep_mode_prepare();
    APP_ERROR_CHECK(err_code);

    // Go to system-off mode (this function will not return; wakeup will cause a reset).
    err_code = sd_power_system_off();
    APP_ERROR_CHECK(err_code);
}


static void on_adv_evt(ble_adv_evt_t ble_adv_evt)
{
    uint32_t err_code;

    switch (ble_adv_evt)
    {
        case BLE_ADV_EVT_FAST:
            err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING);
            APP_ERROR_CHECK(err_code);
            break;
        case BLE_ADV_EVT_IDLE:
          ble_advertising_start(BLE_ADV_MODE_FAST); //fast advertising will connect to any peer device, or filter with a whitelist if one exists. 
            //sleep_mode_enter();
            break;

        case BLE_ADV_EVT_SLOW:
            err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING_SLOW);
            APP_ERROR_CHECK(err_code);
            break;



        case BLE_ADV_EVT_WHITELIST_REQUEST:
            {
                   ble_gap_whitelist_t  whitelist;     
                   ble_gap_addr_t*      p_whitelist_addr[3];   
                   ble_gap_addr_t       whitelist_sensor_1     = {BLE_GAP_ADDR_TYPE_RANDOM_STATIC,{0xCE,0x1B,0x66,0x29,0xAE,0xEE}};    
                   ble_gap_addr_t       whitelist_sensor_2     = {BLE_GAP_ADDR_TYPE_RANDOM_STATIC,{0xDB,0xAC,0x83,0xC9,0x50,0x16}};    
                   ble_gap_addr_t       whitelist_sync_beacon  = {BLE_GAP_ADDR_TYPE_PUBLIC,{0x26,0xB3,0x55,0x50,0xCE,0x11}};  //BLE IPHONE MAC ADRESS   

                   p_whitelist_addr[0]     = &whitelist_sensor_1;  
                   p_whitelist_addr[1]     = &whitelist_sensor_2;  
                   p_whitelist_addr[2]     = &whitelist_sync_beacon;
                   whitelist.addr_count    = 3;
                   whitelist.pp_addrs      =  p_whitelist_addr;
                   whitelist.pp_irks       = NULL;
                   whitelist.irk_count     = 0;

                   
                    //err_code = dm_whitelist_create(&m_app_handle, &whitelist);
                    //APP_ERROR_CHECK(err_code);
                    err_code = ble_advertising_whitelist_reply(&whitelist);
                   APP_ERROR_CHECK(err_code);             
                break;
            }

        default:
            break;
    }
}

static void on_ble_evt(ble_evt_t * p_ble_evt)
{
    uint32_t err_code;

    switch (p_ble_evt->header.evt_id)
            {
        case BLE_GAP_EVT_CONNECTED:
            err_code = bsp_indication_set(BSP_INDICATE_CONNECTED);
            APP_ERROR_CHECK(err_code);
            m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
            app_timer_start(m_our_char_timer_id, OUR_CHAR_TIMER_INTERVAL, NULL);
            break;

        case BLE_GAP_EVT_DISCONNECTED:
            m_conn_handle = BLE_CONN_HANDLE_INVALID;
            app_timer_stop(m_our_char_timer_id);
            break;

        default:
            break;
    }
}


static void ble_evt_dispatch(ble_evt_t * p_ble_evt)
{
    dm_ble_evt_handler(p_ble_evt);
    ble_conn_params_on_ble_evt(p_ble_evt);
    bsp_btn_ble_on_ble_evt(p_ble_evt);
    on_ble_evt(p_ble_evt);
    ble_advertising_on_ble_evt(p_ble_evt);
    ble_our_service_on_ble_evt(&m_our_service, p_ble_evt);
}


static void sys_evt_dispatch(uint32_t sys_evt)
{
    pstorage_sys_event_handler(sys_evt);
    ble_advertising_on_sys_evt(sys_evt);
}


static void ble_stack_init(void)
{
    uint32_t err_code;

    nrf_clock_lf_cfg_t clock_lf_cfg = NRF_CLOCK_LFCLKSRC;

    SOFTDEVICE_HANDLER_INIT(&clock_lf_cfg, NULL);

    ble_enable_params_t ble_enable_params;
    err_code = softdevice_enable_get_default_config(CENTRAL_LINK_COUNT,
                                                    PERIPHERAL_LINK_COUNT,
                                                    &ble_enable_params);
    APP_ERROR_CHECK(err_code);

    //Check the ram settings against the used number of links
    CHECK_RAM_START_ADDR(CENTRAL_LINK_COUNT,PERIPHERAL_LINK_COUNT);

    // Enable BLE stack.
    ble_enable_params.gatts_enable_params.service_changed = IS_SRVC_CHANGED_CHARACT_PRESENT;
    err_code = softdevice_enable(&ble_enable_params);
    APP_ERROR_CHECK(err_code);

    err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch);
    APP_ERROR_CHECK(err_code);

    err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch);
    APP_ERROR_CHECK(err_code);
}

void bsp_event_handler(bsp_event_t event)
{
    uint32_t err_code;
    switch (event)
    {
        case BSP_EVENT_SLEEP:
            sleep_mode_enter();
            break;

        case BSP_EVENT_DISCONNECT:
            err_code = sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
            if (err_code != NRF_ERROR_INVALID_STATE)
            {
                APP_ERROR_CHECK(err_code);
            }
            break;



        default:
            break;
    }
}


static uint32_t device_manager_evt_handler(dm_handle_t const * p_handle,
                                           dm_event_t const  * p_event,
                                           ret_code_t        event_result)
{
    APP_ERROR_CHECK(event_result);

#ifdef BLE_DFU_APP_SUPPORT
    if (p_event->event_id == DM_EVT_LINK_SECURED)
    {
        app_context_load(p_handle);
    }
#endif // BLE_DFU_APP_SUPPORT

    return NRF_SUCCESS;
}


static void device_manager_init(bool erase_bonds)
{
    uint32_t               err_code;
    dm_init_param_t        init_param = {.clear_persistent_data = erase_bonds};
    dm_application_param_t register_param;

    // Initialize persistent storage module.
    err_code = pstorage_init();
    APP_ERROR_CHECK(err_code);

    err_code = dm_init(&init_param);
    APP_ERROR_CHECK(err_code);

    memset(&register_param.sec_param, 0, sizeof(ble_gap_sec_params_t));

    register_param.sec_param.bond         = SEC_PARAM_BOND;
    register_param.sec_param.mitm         = SEC_PARAM_MITM;
    register_param.sec_param.io_caps      = SEC_PARAM_IO_CAPABILITIES;
    register_param.sec_param.oob          = SEC_PARAM_OOB;
    register_param.sec_param.min_key_size = SEC_PARAM_MIN_KEY_SIZE;
    register_param.sec_param.max_key_size = SEC_PARAM_MAX_KEY_SIZE;
    register_param.evt_handler            = device_manager_evt_handler;
    register_param.service_type           = DM_PROTOCOL_CNTXT_GATT_SRVR_ID;

    err_code = dm_register(&m_app_handle, &register_param);
    APP_ERROR_CHECK(err_code);
}


static void advertising_init(void)
{
    uint32_t      err_code;
    ble_advdata_t advdata;
    memset(&advdata, 0, sizeof(advdata));

    advdata.name_type               = BLE_ADVDATA_FULL_NAME;
    advdata.flags                   = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;
    advdata.include_appearance      = true;
    advdata.uuids_complete.uuid_cnt = sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]);
    advdata.uuids_complete.p_uuids  = m_adv_uuids;


    ble_adv_modes_config_t options = {0};
    options.ble_adv_whitelist_enabled = BLE_ADV_WHITELIST_ENABLED; //added this
    options.ble_adv_fast_enabled  = BLE_ADV_FAST_ENABLED;
    options.ble_adv_fast_interval = APP_ADV_INTERVAL;
    options.ble_adv_fast_timeout  = APP_ADV_TIMEOUT_IN_SECONDS;

    err_code = ble_advertising_init(&advdata, NULL, &options, on_adv_evt, NULL);
    APP_ERROR_CHECK(err_code);
}


static void buttons_leds_init(bool * p_erase_bonds)
{
    bsp_event_t startup_event;

    uint32_t err_code = bsp_init(BSP_INIT_LED | BSP_INIT_BUTTONS,
                                 APP_TIMER_TICKS(100, APP_TIMER_PRESCALER),
                                 bsp_event_handler);
    APP_ERROR_CHECK(err_code);

    err_code = bsp_btn_ble_init(NULL, &startup_event);
    APP_ERROR_CHECK(err_code);

    *p_erase_bonds = (startup_event == BSP_EVENT_CLEAR_BONDING_DATA);
}


static void power_manage(void)
{
    uint32_t err_code = sd_app_evt_wait();
    APP_ERROR_CHECK(err_code);
}


int main(void)
{   
    uint32_t err_code;
    bool erase_bonds;

    timers_init();
    gpio_init();
    buttons_leds_init(&erase_bonds);
    ble_stack_init();
    device_manager_init(erase_bonds);
    gap_params_init();
    services_init();
    advertising_init();
    conn_params_init();
    // Start execution.
    err_code = ble_advertising_start(BLE_ADV_MODE_FAST);
    APP_ERROR_CHECK(err_code);

    // Enter main loop.
    for (;;)
    {
      power_manage();
    
    }

/**
 * @}
 */

[Nabil]

I know that it's without any sense. But I'm trying to see if I configure with size 0 if i'm able to connect to my device. Even with a size 0 the connection success.

[Petter Myhre]

The advertising module will check if the provided whitelist has entries (whitelist_has_entries()), if not it will go to the next advertising state.

[Nabil]

Thank you for your answer.

It's a little confusing.

Now with :

ble_advertising_start(BLE_ADV_MODE_FAST);

It will connect to any peer device if withelist doesn't exists. But i want to protect my device from unknown central.

It's seems that I'm not able to write manually on the whitelist..

[Nabil]

Start code

case BLE_ADV_EVT_WHITELIST_REQUEST:
        		    {
        		           ble_gap_whitelist_t  whitelist;     
        				   ble_gap_addr_t*      p_whitelist_addr[3];   
        				   ble_gap_addr_t       whitelist_sensor_1     = {BLE_GAP_ADDR_TYPE_RANDOM_STATIC,{0xCE,0x1B,0x66,0x29,0xAE,0xEE}};    
        				   ble_gap_addr_t       whitelist_sensor_2     = {BLE_GAP_ADDR_TYPE_RANDOM_STATIC,{0xDB,0xAC,0x83,0xC9,0x50,0x16}};    
        				   ble_gap_addr_t       whitelist_sync_beacon  = {BLE_GAP_ADDR_TYPE_PUBLIC,{0xC6,0x11,0x89,0x25,0x1C,0x28}};    
        
        				   p_whitelist_addr[0]     = &whitelist_sensor_1;  
        				   p_whitelist_addr[1]     = &whitelist_sensor_2;  
        				   p_whitelist_addr[2]     = &whitelist_sync_beacon;
        				   whitelist.addr_count    = 3;
        				   whitelist.pp_addrs      =  p_whitelist_addr;
        				   whitelist.pp_irks       = NULL;
        				   whitelist.irk_count     = 0;
        
        				   
        			        err_code = dm_whitelist_create(&m_app_handle, &whitelist);
        			        APP_ERROR_CHECK(err_code);
        					err_code = ble_advertising_whitelist_reply(&whitelist);
        				   APP_ERROR_CHECK(err_code);
        
        
        			       
        		        break;
        		    }

end code

dm_whitelist_create(&m_app_handle, &whitelist); err_code return 32782 and reset the board

When i comment dm_whitelist_create -> I have an error code 7 on

sd_ble_gap_adv_start(&adv_params);

[Petter Myhre]

Ok. Could you edit your question and upload your complete project so I can test it here?