void ScanController::SetScanDutyCycle(u16 interval, u16 window){
u32 err;
if (scanningState != SCAN_STATE_OFF)
{
err = sd_ble_gap_scan_stop();
if(err != NRF_SUCCESS){
//We'll just ignore NRF_ERROR_INVALID_STATE and hope that scanning is stopped
}
logt("C", "Scanning stopped");
}
if(interval != 0){
currentScanParams.interval = interval;
currentScanParams.window = window;
err = sd_ble_gap_scan_start(¤tScanParams);
if(err == NRF_SUCCESS){
logt("C", "Scanning started");
} else {
//Ignore all errors, scanning could not be started
scanningState = SCAN_STATE_OFF;
}
}
}
/**@breif Function to start scanning.
*/
static void scan_start(void)
{
ble_gap_whitelist_t whitelist;
ble_gap_addr_t * p_whitelist_addr[BLE_GAP_WHITELIST_ADDR_MAX_COUNT];
ble_gap_irk_t * p_whitelist_irk[BLE_GAP_WHITELIST_IRK_MAX_COUNT];
uint32_t err_code;
uint32_t count;
// Verify if there is any flash access pending, if yes delay starting scanning until
// it's complete.
err_code = pstorage_access_status_get(&count);
APP_ERROR_CHECK(err_code);
if (count != 0)
{
m_memory_access_in_progress = true;
return;
}
// Initialize whitelist parameters.
whitelist.addr_count = BLE_GAP_WHITELIST_ADDR_MAX_COUNT;
whitelist.irk_count = 0;
whitelist.pp_addrs = p_whitelist_addr;
whitelist.pp_irks = p_whitelist_irk;
// Request creating of whitelist.
err_code = dm_whitelist_create(&m_dm_app_id,&whitelist);
APP_ERROR_CHECK(err_code);
if (((whitelist.addr_count == 0) && (whitelist.irk_count == 0)) ||
(m_scan_mode != BLE_WHITELIST_SCAN))
{
// No devices in whitelist, hence non selective performed.
m_scan_param.active = 0; // Active scanning set.
m_scan_param.selective = 0; // Selective scanning not set.
m_scan_param.interval = SCAN_INTERVAL;// Scan interval.
m_scan_param.window = SCAN_WINDOW; // Scan window.
m_scan_param.p_whitelist = NULL; // No whitelist provided.
m_scan_param.timeout = 0x0000; // No timeout.
}
else
{
// Selective scanning based on whitelist first.
m_scan_param.active = 0; // Active scanning set.
m_scan_param.selective = 1; // Selective scanning not set.
m_scan_param.interval = SCAN_INTERVAL;// Scan interval.
m_scan_param.window = SCAN_WINDOW; // Scan window.
m_scan_param.p_whitelist = &whitelist; // Provide whitelist.
m_scan_param.timeout = 0x001E; // 30 seconds timeout.
// Set whitelist scanning state.
m_scan_mode = BLE_WHITELIST_SCAN;
}
err_code = sd_ble_gap_scan_start(&m_scan_param);
APP_ERROR_CHECK(err_code);
err_code = bsp_indication_set(BSP_INDICATE_SCANNING);
APP_ERROR_CHECK(err_code);
}
uint32_t conn_mw_ble_gap_scan_start(uint8_t const * const p_rx_buf,
uint32_t rx_buf_len,
uint8_t * const p_tx_buf,
uint32_t * const p_tx_buf_len)
{
SER_ASSERT_NOT_NULL(p_rx_buf);
SER_ASSERT_NOT_NULL(p_tx_buf);
SER_ASSERT_NOT_NULL(p_tx_buf_len);
ble_gap_addr_t * pp_addr_tab[BLE_GAP_WHITELIST_ADDR_MAX_COUNT];
ble_gap_irk_t * pp_irk_tab[BLE_GAP_WHITELIST_IRK_MAX_COUNT];
ble_gap_whitelist_t whitelist;
whitelist.addr_count = BLE_GAP_WHITELIST_ADDR_MAX_COUNT;
whitelist.pp_addrs = pp_addr_tab;
whitelist.irk_count = BLE_GAP_WHITELIST_IRK_MAX_COUNT;
whitelist.pp_irks = pp_irk_tab;
ble_gap_scan_params_t scan_params;
scan_params.p_whitelist = &whitelist;
ble_gap_scan_params_t * p_scan_params = &scan_params;
uint32_t err_code = NRF_SUCCESS;
uint32_t sd_err_code;
err_code = ble_gap_scan_start_req_dec(p_rx_buf, rx_buf_len, &p_scan_params);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
sd_err_code = sd_ble_gap_scan_start(p_scan_params);
err_code = ble_gap_scan_start_rsp_enc(sd_err_code, p_tx_buf, p_tx_buf_len);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
return err_code;
}
uint32_t conn_mw_ble_gap_scan_start(uint8_t const * const p_rx_buf,
uint32_t rx_buf_len,
uint8_t * const p_tx_buf,
uint32_t * const p_tx_buf_len)
{
SER_ASSERT_NOT_NULL(p_rx_buf);
SER_ASSERT_NOT_NULL(p_tx_buf);
SER_ASSERT_NOT_NULL(p_tx_buf_len);
uint32_t err_code = NRF_SUCCESS;
uint32_t sd_err_code;
ble_gap_scan_params_t scan_params;
ble_gap_scan_params_t * p_scan_params = &scan_params;
#if defined(NRF_SD_BLE_API_VERSION) && NRF_SD_BLE_API_VERSION > 5
ble_data_t adv_report_buffer;
ble_data_t * p_adv_report_buffer = &adv_report_buffer;
mp_scan_data = conn_ble_gap_ble_data_buf_alloc(SCAN_BUFFER_ID);
adv_report_buffer.p_data = mp_scan_data;
adv_report_buffer.len = SER_MAX_ADV_DATA;
err_code = ble_gap_scan_start_req_dec(p_rx_buf, rx_buf_len, &p_scan_params, &p_adv_report_buffer);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
if (p_adv_report_buffer)
{
conn_ble_gap_scan_data_set(p_adv_report_buffer->p_data);
}
sd_err_code = sd_ble_gap_scan_start(p_scan_params, p_adv_report_buffer);
if (sd_err_code != NRF_SUCCESS)
{
conn_ble_gap_scan_data_unset(true);
}
err_code = ble_gap_scan_start_rsp_enc(sd_err_code, p_adv_report_buffer, p_tx_buf, p_tx_buf_len);
#else
err_code = ble_gap_scan_start_req_dec(p_rx_buf, rx_buf_len, &p_scan_params);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
sd_err_code = sd_ble_gap_scan_start(p_scan_params);
err_code = ble_gap_scan_start_rsp_enc(sd_err_code, p_tx_buf, p_tx_buf_len);
#endif
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
return err_code;
}
uint32_t startScan()
{
sd_ble_gap_scan_stop(); // stop any in-progress scans
scan.num = 0;
scan.timestamp = now();
return sd_ble_gap_scan_start(&scan_params);
}
/* Function to start scanning devices */
void conn_start_scan(void)
{
uint32_t err_code;
err_code = sd_ble_gap_scan_start(&m_scan_params);
APP_ERROR_CHECK(err_code);
/* reset device list index */
devices_list_index = 0;
}
/**@brief Function for initiating scanning.
*/
static void scan_start(void)
{
ret_code_t err_code;
(void) sd_ble_gap_scan_stop();
err_code = sd_ble_gap_scan_start(&m_scan_param);
// It is okay to ignore this error since we are stopping the scan anyway.
if (err_code != NRF_ERROR_INVALID_STATE)
{
APP_ERROR_CHECK(err_code);
}
}
/**@brief Function for setting up advertising data.
*/
static void advertising_data_set(void)
{
uint32_t err_code;
ble_advdata_t const adv_data =
{
.name_type = BLE_ADVDATA_FULL_NAME,
.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE,
.include_appearance = false,
};
err_code = ble_advdata_set(&adv_data, NULL);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for starting advertising.
*/
void advertising_start(void)
{
ble_gap_adv_params_t const adv_params =
{
.type = BLE_GAP_ADV_TYPE_ADV_IND,
.p_peer_addr = NULL,
.fp = BLE_GAP_ADV_FP_ANY,
.interval = ADV_INTERVAL,
.timeout = 0,
};
NRF_LOG_INFO("Starting advertising.\r\n");
uint32_t err_code;
err_code = sd_ble_gap_adv_start(&adv_params);
APP_ERROR_CHECK(err_code);
bsp_board_led_on(LED_SCANNING_ADVERTISING);
}
/**@brief Function to start scanning.
*/
void scan_start(void)
{
NRF_LOG_INFO("Starting scan.\r\n");
ret_code_t err_code;
err_code = sd_ble_gap_scan_start(&m_scan_param);
APP_ERROR_CHECK(err_code);
bsp_board_led_on(LED_SCANNING_ADVERTISING);
}
/**@brief Function to start scanning.
*/
static void scan_start(void)
{
ret_code_t err_code;
err_code = sd_ble_gap_scan_stop();
// It is okay to ignore this error since we are stopping the scan anyway.
if (err_code != NRF_ERROR_INVALID_STATE)
{
APP_ERROR_CHECK(err_code);
}
NRF_LOG_PRINTF("[APP]: start scanning for device name %s\r\n", m_target_periph_name);
err_code = sd_ble_gap_scan_start(&m_scan_param);
APP_ERROR_CHECK(err_code);
}
/**@breif Function to start scanning.
*/
static void scan_start(void)
{
uint32_t err_code;
uint32_t count;
// Verify if there is any flash access pending, if yes delay starting scanning until
// it's complete.
err_code = pstorage_access_status_get(&count);
APP_ERROR_CHECK(err_code);
if (count != 0)
{
m_memory_access_in_progress = true;
return;
}
err_code = sd_ble_gap_scan_start(&m_scan_param);
APP_ERROR_CHECK(err_code);
}
//Start scanning with the specified scanning parameters
void ScanController::SetScanState(scanState newState)
{
u32 err = 0;
if (newState == scanningState) return;
//Stop scanning to either leave it stopped or update it
if (scanningState != SCAN_STATE_OFF)
{
err = sd_ble_gap_scan_stop();
if(err != NRF_SUCCESS){
//We'll just ignore NRF_ERROR_INVALID_STATE and hope that scanning is stopped
}
logt("C", "Scanning stopped");
}
if (newState == SCAN_STATE_HIGH)
{
currentScanParams.interval = Config->meshScanIntervalHigh;
currentScanParams.window = Config->meshScanWindowHigh;
}
else if (newState == SCAN_STATE_LOW)
{
currentScanParams.interval = Config->meshScanIntervalLow;
currentScanParams.window = Config->meshScanWindowLow;
}
//FIXME: Add Saveguard. Because if we are currently in connecting state, we can not scan
if (newState != SCAN_STATE_OFF)
{
err = sd_ble_gap_scan_start(¤tScanParams);
if(err == NRF_SUCCESS){
logt("C", "Scanning started");
} else {
//Ignore all errors, scanning could not be started
newState = SCAN_STATE_OFF;
}
}
scanningState = newState;
}
/*JSON{
"type" : "staticmethod",
"class" : "NRF",
"name" : "setScan",
"generate" : "jswrap_nrf_bluetooth_setScan",
"params" : [
["callback","JsVar","The callback to call with information about received, or undefined to stop"]
]
}
Start/stop listening for BLE advertising packets within range.
```
// Start scanning
NRF.setScan(function(d) {
console.log(JSON.stringify(d,null,2));
});
// prints {"rssi":-72, "addr":"##:##:##:##:##:##", "data":new ArrayBuffer([2,1,6,...])}
// Stop Scanning
NRF.setScan(false);
```
*/
void jswrap_nrf_bluetooth_setScan(JsVar *callback) {
uint32_t err_code;
// set the callback event variable
if (!jsvIsFunction(callback)) callback=0;
jsvObjectSetChild(execInfo.root, BLE_SCAN_EVENT, callback);
// either start or stop scanning
if (callback) {
ble_gap_scan_params_t m_scan_param;
// non-selective scan
m_scan_param.active = 0; // Active scanning set.
m_scan_param.selective = 0; // Selective scanning not set.
m_scan_param.interval = SCAN_INTERVAL;// Scan interval.
m_scan_param.window = SCAN_WINDOW; // Scan window.
m_scan_param.p_whitelist = NULL; // No whitelist provided.
m_scan_param.timeout = 0x0000; // No timeout.
err_code = sd_ble_gap_scan_start(&m_scan_param);
} else {
err_code = sd_ble_gap_scan_stop();
}
if (err_code)
jsExceptionHere(JSET_ERROR, "Got BLE error code %d", err_code);
}
ble_error_t nRF5xGap::startRadioScan(const GapScanningParams &scanningParams)
{
/* Allocate the stack's whitelist statically */
ble_gap_whitelist_t whitelist;
ble_gap_addr_t *whitelistAddressPtrs[YOTTA_CFG_WHITELIST_MAX_SIZE];
ble_gap_irk_t *whitelistIrkPtrs[YOTTA_CFG_IRK_TABLE_MAX_SIZE];
/* Initialize the whitelist */
whitelist.pp_addrs = whitelistAddressPtrs;
whitelist.pp_irks = whitelistIrkPtrs;
whitelist.addr_count = 0;
whitelist.irk_count = 0;
/* Add missing IRKs to whitelist from the bond table held by the SoftDevice */
if (scanningPolicyMode != Gap::SCAN_POLICY_IGNORE_WHITELIST) {
ble_error_t error = generateStackWhitelist(whitelist);
if (error != BLE_ERROR_NONE) {
return error;
}
}
ble_gap_scan_params_t scanParams = {
.active = scanningParams.getActiveScanning(), /**< If 1, perform active scanning (scan requests). */
.selective = scanningPolicyMode, /**< If 1, ignore unknown devices (non whitelisted). */
.p_whitelist = &whitelist, /**< Pointer to whitelist, NULL if none is given. */
.interval = scanningParams.getInterval(), /**< Scan interval between 0x0004 and 0x4000 in 0.625ms units (2.5ms to 10.24s). */
.window = scanningParams.getWindow(), /**< Scan window between 0x0004 and 0x4000 in 0.625ms units (2.5ms to 10.24s). */
.timeout = scanningParams.getTimeout(), /**< Scan timeout between 0x0001 and 0xFFFF in seconds, 0x0000 disables timeout. */
};
if (sd_ble_gap_scan_start(&scanParams) != NRF_SUCCESS) {
return BLE_ERROR_PARAM_OUT_OF_RANGE;
}
return BLE_ERROR_NONE;
}
ble_error_t nRF5xGap::stopScan(void) {
if (sd_ble_gap_scan_stop() == NRF_SUCCESS) {
return BLE_ERROR_NONE;
}
return BLE_STACK_BUSY;
}
#endif
/**************************************************************************/
/*!
@brief Stops the BLE HW and disconnects from any devices
@returns ble_error_t
@retval BLE_ERROR_NONE
Everything executed properly
@section EXAMPLE
@code
@endcode
*/
/**************************************************************************/
ble_error_t nRF5xGap::stopAdvertising(void)
{
/* Stop Advertising */
ASSERT_TRUE(ERROR_NONE == sd_ble_gap_adv_stop(), BLE_ERROR_PARAM_OUT_OF_RANGE);
state.advertising = 0;
return BLE_ERROR_NONE;
}
/**@breif Function to start scanning.
*/
static void scan_start(void)
{
uint32_t err_code = sd_ble_gap_scan_start(&m_scan_param);
APP_ERROR_CHECK(err_code);
}
