uint32_t conn_mw_ble_gap_adv_stop(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;
#if NRF_SD_BLE_API_VERSION > 5
uint8_t adv_handle;
err_code = ble_gap_adv_stop_req_dec(p_rx_buf, rx_buf_len, &adv_handle);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
sd_err_code = sd_ble_gap_adv_stop(adv_handle);
#else
sd_err_code = sd_ble_gap_adv_stop();
#endif
err_code = ble_gap_adv_stop_rsp_enc(sd_err_code, p_tx_buf, p_tx_buf_len);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
return err_code;
}
/**@brief Function for stopping all advertising and all running timers */
void all_advertising_halt(void)
{
sd_ble_gap_adv_stop();
app_timer_stop(m_eddystone_adv_interval_timer);
app_timer_stop(m_eddystone_adv_slot_timer);
app_timer_stop(m_eddystone_etlm_cycle_timer);
}
/**@brief Function for stopping advertising.
*/
static void advertising_stop(void)
{
uint32_t err_code;
err_code = sd_ble_gap_adv_stop();
APP_ERROR_CHECK(err_code);
}
/**@brief Function for handling BLE_GAP_EVT_CONNECTED events.
* Save the connection handle and GAP role, then discover the peer DB.
*/
void on_ble_gap_evt_connected(ble_gap_evt_t const * p_gap_evt)
{
m_conn_handle = p_gap_evt->conn_handle;
m_gap_role = p_gap_evt->params.connected.role;
if (m_gap_role == BLE_GAP_ROLE_PERIPH)
{
NRF_LOG_INFO("Connected as a peripheral.\r\n");
}
else if (m_gap_role == BLE_GAP_ROLE_CENTRAL)
{
NRF_LOG_INFO("Connected as a central.\r\n");
}
// Stop scanning and advertising.
(void) sd_ble_gap_scan_stop();
(void) sd_ble_gap_adv_stop();
NRF_LOG_INFO("Discovering GATT database...\r\n");
// Zero the database before starting discovery.
memset(&m_ble_db_discovery, 0x00, sizeof(m_ble_db_discovery));
ret_code_t err_code;
err_code = ble_db_discovery_start(&m_ble_db_discovery, p_gap_evt->conn_handle);
APP_ERROR_CHECK(err_code);
bsp_board_leds_off();
}
/**@brief Function for handling BLE_GAP_ADV_REPORT events.
* Search for a peer with matching device name.
* If found, stop advertising and send a connection request to the peer.
*/
void on_ble_gap_evt_adv_report(ble_gap_evt_t const * p_gap_evt)
{
if (!find_adv_name(&p_gap_evt->params.adv_report, m_target_periph_name))
{
return;
}
NRF_LOG_INFO("Device \"%s\" found, sending a connection request.\r\n",
(uint32_t) m_target_periph_name);
// Stop advertising.
(void) sd_ble_gap_adv_stop();
// Initiate connection.
m_conn_param.min_conn_interval = CONN_INTERVAL_DEFAULT;
m_conn_param.max_conn_interval = CONN_INTERVAL_DEFAULT;
ret_code_t err_code;
err_code = sd_ble_gap_connect(&p_gap_evt->params.adv_report.peer_addr,
&m_scan_param,
&m_conn_param);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_ERROR("sd_ble_gap_connect() failed: 0x%x.\r\n", err_code);
}
}
bool advertise_advertise(void)
{
if (IS_CONNECTING)
{
return false;
}
//If advertising before, stop it.
if (IS_ADVERTISING)
{
sd_ble_gap_adv_stop();
}
advertise_set_data();
ble_gap_adv_params_t adv_settings = { 0 };
adv_settings.type = BLE_GAP_ADV_TYPE_ADV_IND;
adv_settings.fp = BLE_GAP_ADV_FP_ANY;
adv_settings.interval = MSEC_TO_UNITS(25, UNIT_0_625_MS);
adv_settings.timeout = BLE_GAP_ADV_TIMEOUT_GENERAL_UNLIMITED;
APP_ERROR_CHECK(sd_ble_gap_adv_start(&adv_settings));
status_set(STATUS_ADVERTISING);
return true;
}
uint32_t ble_advertising_restart_without_whitelist(void)
{
uint32_t err_code;
if( m_adv_modes_config.ble_adv_whitelist_enabled == BLE_ADV_WHITELIST_ENABLED
&& !m_whitelist_temporarily_disabled)
{
if (m_adv_mode_current != BLE_ADV_MODE_IDLE)
{
err_code = sd_ble_gap_adv_stop();
if(err_code != NRF_SUCCESS)
{
return err_code;
}
}
m_whitelist_temporarily_disabled = true;
err_code = ble_advertising_start(m_adv_mode_current);
if ((err_code != NRF_SUCCESS) && (m_error_handler != NULL))
{
m_error_handler(err_code);
}
}
return NRF_SUCCESS;
}
void ble_device_stop_advertising(void)
{
uint32_t err_code;
err_code = sd_ble_gap_adv_stop();
APP_ERROR_CHECK(err_code);
}
ble_error_t nRF5xGap::stopAdvertising(void)
{
/* Stop Advertising */
ASSERT(ERROR_NONE == sd_ble_gap_adv_stop(), BLE_ERROR_PARAM_OUT_OF_RANGE);
state.advertising = 0;
return BLE_ERROR_NONE;
}
static void advertising_stop(void)
{
uint32_t err_code;
err_code = sd_ble_gap_adv_stop();
APP_ERROR_CHECK(err_code);
nrf_gpio_pin_clear(ADVERTISING_LED_PIN_NO);
}
/**@brief Timeout handler for the adv_slot_timer*/
static void adv_slot_timeout(void * p_context)
{
static uint8_t slot_counter = 0;
uint8_t slot_no = m_currently_configured_slots[slot_counter];
m_etlm_adv_counter.eid_slot_counter = 0;
if(slot_no != 0xFF)
{
sd_ble_gap_adv_stop();
static uint8_t tick_tock = 0;
tick_tock++;
if (tick_tock % 2 == 0)
{
LEDS_ON(1<<LED_1);
}
else
{
LEDS_OFF(1<<LED_1);
}
eddystone_adv_slot_params_t adv_slot_params;
eddystone_adv_slot_params_get(slot_no, &adv_slot_params);
if (eddystone_adv_slot_is_configured(slot_no) && !m_is_connectable_adv)
{
DEBUG_PRINTF(0,"Slot [%d] - frame type: 0x%02x \r\n", slot_no, adv_slot_params.frame_type);
if ((adv_slot_params.frame_type == EDDYSTONE_FRAME_TYPE_TLM)
&& eddystone_adv_slot_num_of_current_eids(m_etlm_adv_counter.eid_positions, NULL) != 0)
{
etlm_cycle_timer_start(slot_no);
etlm_cycle_timeout(NULL);
//Trigger a timeout to advertisie right away
}
else
{
//Regular TLM slot
advertising_init(slot_no);
eddystone_ble_advertising_start(EDDYSTONE_BLE_ADV_CONNECTABLE_FALSE);
}
}
}
slot_counter++;
if (slot_counter >= eddystone_adv_slot_num_of_configured_slots(m_currently_configured_slots))
{
DEBUG_PRINTF(0,"End of Slots: \r\n");
slot_counter = 0;
}
else
{
adv_slot_timer_start();
}
}
/**@brief Function for stopping advertising.
*/
static void advertising_stop(void)
{
uint32_t err_code;
//stop eddystone as well
app_beacon_stop();
err_code = sd_ble_gap_adv_stop();
APP_ERROR_CHECK(err_code);
}
void advertise_cancel(void)
{
if (!IS_ADVERTISING)
{
return;
}
status_clear(STATUS_ADVERTISING);
sd_ble_gap_adv_stop();
}
void app_ble_stop(void)
{
uint32_t err_code;
err_code = sd_ble_gap_adv_stop();
APP_ERROR_CHECK(err_code);
led_off(LED_PIN_NO_ADVERTISING);
app_trace_log("advertising stop\r\n");
}
/**@brief Function for stopping advertising.
*/
static void advertising_stop(void)
{
uint32_t err_code;
err_code = sd_ble_gap_adv_stop();
APP_ERROR_CHECK(err_code);
err_code = bsp_indication_set(BSP_INDICATE_IDLE);
APP_ERROR_CHECK(err_code);
}
static void adv_stop(void)
{
ret_code_t err_code;
err_code = sd_ble_gap_adv_stop();
if (err_code != NRF_ERROR_INVALID_STATE)
{
APP_ERROR_CHECK(err_code);
}
es_adv_timing_stop();
}
/*JSON{
"type" : "staticmethod",
"class" : "NRF",
"name" : "sleep",
"generate" : "jswrap_nrf_bluetooth_sleep"
}*/
void jswrap_nrf_bluetooth_sleep(void) {
uint32_t err_code;
// If connected, disconnect.
if (m_conn_handle != BLE_CONN_HANDLE_INVALID) {
err_code = sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
}
// Stop advertising
err_code = sd_ble_gap_adv_stop();
NRF_RADIO->TASKS_DISABLE = (1UL);
}
/**@brief Function for stopping advertising.
*/
static void advertising_stop(void)
{
if (m_is_advertising)
{
uint32_t err_code;
err_code = sd_ble_gap_adv_stop();
APP_ERROR_CHECK(err_code);
m_is_advertising = false;
}
}
void app_beacon_stop(void)
{
uint32_t err_code;
err_code = sd_ble_gap_adv_stop();
if (err_code != NRF_SUCCESS)
{
if (m_beacon.error_handler != NULL)
{
m_beacon.error_handler(err_code);
}
}
}
/**@brief Function for stopping advertising.
*/
static void advertising_stop(void)
{
if (m_is_advertising)
{
uint32_t err_code;
err_code = sd_ble_gap_adv_stop();
APP_ERROR_CHECK(err_code);
nrf_gpio_pin_set(ADVERTISING_LED_PIN_NO);
m_is_advertising = false;
}
}
void dfu_reset_prepare(void)
{
uint32_t err_code;
if (m_conn_handle != BLE_CONN_HANDLE_INVALID)
{
err_code = sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
APP_ERROR_CHECK(err_code);
}
else
{
err_code = sd_ble_gap_adv_stop();
APP_ERROR_CHECK(err_code);
}
}
/**@brief Timeout handler for the etlm_cycle_timer*/
static void etlm_cycle_timeout(void * p_context)
{
sd_ble_gap_adv_stop();
if (m_etlm_adv_counter.eid_slot_counter >= eddystone_adv_slot_num_of_current_eids(NULL, NULL))
{
m_etlm_adv_counter.eid_slot_counter = 0;
app_timer_stop(m_eddystone_etlm_cycle_timer);
}
else
{
etlm_adv(m_temporary_slot_no);
//this will incremement eid_slot_counter
}
}
void bleApp_advertisingStop() {
uint32_t err_code;
err_code = sd_ble_gap_adv_stop();
/* Allow invalid state errors, trap everything else. We do this because we
* may not be advertising at the moment when we try to stop advertising,
* and even though that generates an error, it's okay. */
if (err_code == NRF_ERROR_INVALID_STATE) {
;
} else {
APP_ERROR_CHECK(err_code);
}
led_setState(LED_BLUE, LED_STATE_OFF);
}
/**@brief Function for stopping advertising.
*/
static uint32_t advertising_stop(void)
{
uint32_t err_code;
if ((m_flags & DFU_BLE_FLAG_IS_ADVERTISING) == 0)
{
return NRF_SUCCESS;
}
err_code = sd_ble_gap_adv_stop();
VERIFY_SUCCESS(err_code);
nrf_gpio_pin_set(ADVERTISING_LED_PIN_NO);
m_flags |= DFU_BLE_FLAG_IS_ADVERTISING;
return NRF_SUCCESS;
}
BLETransceiver::Error BLETransceiver::stopAdvertisement(void)
{
uint32_t err_code;
Error loc_s8_err = GENERAL_ERROR;
err_code = sd_ble_gap_adv_stop();
if(err_code != NRF_SUCCESS)
{
APP_ERROR_CHECK(err_code);
}
else
{
b_isAdvertising = false;
loc_s8_err = NO_ERROR;
}
return loc_s8_err;
}
/**@brief Function for stopping advertising.
*/
static uint32_t advertising_stop(void)
{
uint32_t err_code;
if ((m_flags & DFU_BLE_FLAG_IS_ADVERTISING) == 0)
{
return NRF_SUCCESS;
}
err_code = sd_ble_gap_adv_stop();
VERIFY_SUCCESS(err_code);
dfu_set_status(DFUS_ADVERTISING_STOP);
m_flags |= DFU_BLE_FLAG_IS_ADVERTISING;
return NRF_SUCCESS;
}
uint32_t conn_mw_ble_gap_adv_stop(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;
sd_err_code = sd_ble_gap_adv_stop();
err_code = ble_gap_adv_stop_rsp_enc(sd_err_code, p_tx_buf, p_tx_buf_len);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
return err_code;
}
/**@brief Stop advertising.
*/
static void advertising_stop(void)
{
//uint32_t err_code;
// If connected, disconnect
if (m_conn_handle != BLE_CONN_HANDLE_INVALID)
{
sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
}
// Stop advertising
sd_ble_gap_adv_stop();
// Disable the radio tasks as scytulip suggested
// https://devzone.nordicsemi.com/question/13984/completely-disabling-bluetooth/
NRF_RADIO->TASKS_DISABLE;
}
void advertising_stop(void)
{
uint32_t err_code;
ble_gap_adv_params_t adv_params;
// Start advertising
memset(&adv_params, 0, sizeof(adv_params));
adv_params.type = BLE_GAP_ADV_TYPE_ADV_IND;
adv_params.p_peer_addr = NULL;
adv_params.fp = BLE_GAP_ADV_FP_ANY;
adv_params.interval = APP_ADV_INTERVAL;
adv_params.timeout = APP_ADV_TIMEOUT_IN_SECONDS;
err_code = sd_ble_gap_adv_stop();
APP_ERROR_CHECK(err_code);
err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING);
APP_ERROR_CHECK(err_code);
}
/**@brief Function handling events from @ref es_adv_timing.c.
*
* @param[in] p_evt Advertisement timing event.
*/
static void adv_timing_callback(const es_adv_timing_evt_t * p_evt)
{
ret_code_t err_code;
ble_gap_adv_params_t non_connectable_adv_params;
const es_slot_reg_t * p_reg = es_slot_get_registry();
// As new advertisement data will be loaded, stop advertising.
err_code = sd_ble_gap_adv_stop();
if (err_code != NRF_ERROR_INVALID_STATE)
{
APP_ERROR_CHECK(err_code);
}
// If a non-eTLM frame is to be advertised.
if (p_evt->evt_id == ES_ADV_TIMING_EVT_ADV_SLOT)
{
err_code = sd_ble_gap_tx_power_set(p_reg->slots[p_evt->slot_no].radio_tx_pwr);
APP_ERROR_CHECK(err_code);
es_adv_frame_fill_non_connectable_adv_data(p_evt->slot_no, false);
}
// If an eTLM frame is to be advertised
else if (p_evt->evt_id == ES_ADV_TIMING_EVT_ADV_ETLM)
{
err_code = sd_ble_gap_tx_power_set(p_reg->slots[p_reg->tlm_slot].radio_tx_pwr);
APP_ERROR_CHECK(err_code);
es_adv_frame_fill_non_connectable_adv_data(p_evt->slot_no, true);
}
invoke_callback(ES_ADV_EVT_NON_CONN_ADV);
get_adv_params(&non_connectable_adv_params, true, m_remain_connectable);
adv_start(&non_connectable_adv_params);
}