/**@brief Function for initializing the Advertising functionality.
*/
static void advertising_init(void)
{
ret_code_t err_code;
ble_advertising_init_t init;
memset(&init, 0, sizeof(init));
init.advdata.name_type = BLE_ADVDATA_FULL_NAME;
init.advdata.include_appearance = true;
init.advdata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;
init.srdata.uuids_complete.uuid_cnt = sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]);
init.srdata.uuids_complete.p_uuids = m_adv_uuids;
init.config.ble_adv_fast_enabled = true;
init.config.ble_adv_fast_interval = APP_ADV_INTERVAL;
init.config.ble_adv_fast_timeout = APP_ADV_DURATION;
init.evt_handler = on_adv_evt;
err_code = ble_advertising_init(&m_advertising, &init);
APP_ERROR_CHECK(err_code);
ble_advertising_conn_cfg_tag_set(&m_advertising, APP_BLE_CONN_CFG_TAG);
}
static void advertising_init(void)
{
uint32_t err_code;
ble_advdata_t advdata;
ble_advdata_manuf_data_t manfdata;
memset(&advdata, 0, sizeof(advdata));
// advertise the the full device name
advdata.name_type = BLE_ADVDATA_FULL_NAME;
// LE General Discoverable Mode, BR/EDR not supported.
advdata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;
// Set the manufacturer specific data below
memset(&manfdata, 0, sizeof(manfdata));
manfdata.company_identifier = 0x1234;
manfdata.data.size = strlen(APP_ADV_CUSTOM_DATA);
manfdata.data.p_data = (uint8_t *)APP_ADV_CUSTOM_DATA;
advdata.p_manuf_specific_data = &manfdata;
ble_adv_modes_config_t options = {0};
// enable fast advertisement
options.ble_adv_fast_enabled = BLE_ADV_FAST_ENABLED;
// set advertisement interval to 200 ms, 320 * 0.625ms
options.ble_adv_fast_interval = APP_ADV_INTERVAL;
// set advertisement timeout to infinite
options.ble_adv_fast_timeout = BLE_GAP_ADV_TIMEOUT_GENERAL_UNLIMITED;
err_code = ble_advertising_init(&advdata, NULL, &options, advertisement_evt_cb, NULL);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for initializing the Advertising functionality.
*
* @details Encodes the required advertising data and passes it to the stack.
* Also builds a structure to be passed to the stack when starting advertising.
*/
static void advertising_init(void)
{
uint32_t err_code;
ble_advdata_t advdata;
ble_advdata_t scanrsp;
// Build advertising data struct to pass into @ref ble_advertising_init.
memset(&advdata, 0, sizeof(advdata));
advdata.name_type = BLE_ADVDATA_FULL_NAME;
advdata.include_appearance = true;
advdata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;
ble_uuid_t scan_uuids[] = {{BLE_UUID_BATTERY_SERVICE, BLE_UUID_TYPE_BLE},
{BLE_UUID_DEVICE_INFORMATION_SERVICE, BLE_UUID_TYPE_BLE},
{BLE_UUID_OSSW_SERVICE, m_ossw.uuid_type}}; /**< Universally unique service identifiers. */
memset(&scanrsp, 0, sizeof(scanrsp));
scanrsp.uuids_complete.uuid_cnt = sizeof(scan_uuids) / sizeof(scan_uuids[0]);
scanrsp.uuids_complete.p_uuids = scan_uuids;
err_code = ble_advdata_set(&advdata, &scanrsp);
APP_ERROR_CHECK(err_code);
ble_adv_modes_config_t options = {0};
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);
}
// Function for initializing the Advertising functionality.
static void advertising_init(void)
{
uint32_t err_code;
ble_advdata_t advdata;
ble_advdata_t scanrsp;
ble_uuid_t m_adv_uuids[] = {{BLE_UUID_NUS_SERVICE,
BLE_UUID_TYPE_VENDOR_BEGIN}};
// Build advertising data struct to pass into @ref ble_advertising_init.
memset(&advdata, 0, sizeof(advdata));
advdata.name_type = BLE_ADVDATA_FULL_NAME;
advdata.include_appearance = false;
advdata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_LIMITED_DISC_MODE;
memset(&scanrsp, 0, sizeof(scanrsp));
scanrsp.uuids_complete.uuid_cnt =
sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]);
scanrsp.uuids_complete.p_uuids = m_adv_uuids;
ble_adv_modes_config_t options = {0};
options.ble_adv_fast_enabled = BLE_ADV_FAST_ENABLED;
options.ble_adv_fast_interval = 64;
options.ble_adv_fast_timeout = 180;
err_code = ble_advertising_init(&advdata, &scanrsp, &options,
on_adv_evt, NULL);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for initializing the Advertising functionality.
*/
static void advertising_init(void)
{
uint32_t err_code;
ble_advdata_t advdata;
ble_advdata_t scanrsp;
ble_adv_modes_config_t options;
// Build advertising data struct to pass into @ref ble_advertising_init.
memset(&advdata, 0, sizeof(advdata));
advdata.name_type = BLE_ADVDATA_FULL_NAME;
advdata.include_appearance = false;
advdata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_LIMITED_DISC_MODE;
memset(&scanrsp, 0, sizeof(scanrsp));
scanrsp.uuids_complete.uuid_cnt = sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]);
scanrsp.uuids_complete.p_uuids = m_adv_uuids;
memset(&options, 0, sizeof(options));
options.ble_adv_fast_enabled = true;
options.ble_adv_fast_interval = APP_ADV_INTERVAL;
options.ble_adv_fast_timeout = APP_ADV_TIMEOUT_IN_SECONDS;
err_code = ble_advertising_init(&advdata, &scanrsp, &options, on_adv_evt, NULL);
APP_ERROR_CHECK(err_code);
}
//============================================================================//
static void advertising_init(void)
{
uint32_t err_code;
ble_advdata_t advdata;
// Build advertising data struct to pass into @ref ble_advertising_init.
memset(&advdata, 0, sizeof(advdata));
advdata.name_type = BLE_ADVDATA_FULL_NAME;
//advdata.include_appearance = true;
advdata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;
//advdata.uuids_complete.uuid_cnt = sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]);
//advdata.uuids_complete.p_uuids = m_adv_uuids;
err_code = ble_advdata_set(&advdata, NULL);
APP_ERROR_CHECK(err_code);
ble_adv_modes_config_t options = {0};
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, 0, &options, on_adv_evt, NULL);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for initializing the advertising functionality.
*
* @details Encodes the required advertising data and passes it to the stack.
* Also builds a structure to be passed to the stack when starting advertising.
*/
static void advertising_init(void)
{
uint32_t err_code;
ble_advdata_t advdata;
// Build advertising data struct to pass into @ref ble_advertising_init.
memset(&advdata, 0, sizeof(advdata));
advdata.name_type = BLE_ADVDATA_FULL_NAME;
advdata.include_appearance = true;
advdata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;
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_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);
if (err_code == NRF_SUCCESS)
debug_printf("Advertising initialised!\r\n");
else
{
debug_printf("Ooops.. Something is wrong with initialising advertising..\r\n");
APP_ERROR_CHECK(err_code);
}
}
void advertising_init(void)
{
uint32_t err_code;
// Build advertising data struct to pass into @ref ble_advertising_init.
ble_advdata_t advdata;
memset(&advdata, 0, sizeof(advdata));
advdata.name_type = BLE_ADVDATA_FULL_NAME;
advdata.include_appearance = false;
advdata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;
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_fast_enabled = BLE_ADV_FAST_ENABLED;
options.ble_adv_fast_interval = APP_ADV_INTERVAL;
options.ble_adv_fast_timeout = APP_ADV_TIMEOUT_IN_SECONDS;
options.ble_adv_slow_enabled = BLE_ADV_SLOW_DISABLED;
options.ble_adv_directed_enabled = BLE_ADV_DIRECTED_DISABLED;
options.ble_adv_whitelist_enabled = BLE_ADV_WHITELIST_DISABLED;
err_code = ble_advertising_init(&advdata, NULL, &options, NULL /*on_adv_evt*/, NULL);
BLE_ERROR_CHECK(err_code);
setAdvData();
}
/**@brief Function for initializing the advertising functionality.
*/
static void advertising_init(void)
{
uint32_t err_code;
ble_advdata_t advdata;
// Build and set advertising data
memset(&advdata, 0, sizeof(advdata));
advdata.name_type = BLE_ADVDATA_FULL_NAME;
advdata.include_appearance = true;
advdata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_LIMITED_DISC_MODE;
advdata.uuids_complete.uuid_cnt = 0;
advdata.uuids_complete.p_uuids = NULL;
advdata.uuids_solicited.uuid_cnt = sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]);
advdata.uuids_solicited.p_uuids = m_adv_uuids;
ble_adv_modes_config_t options = {0};
options.ble_adv_whitelist_enabled = BLE_ADV_WHITELIST_ENABLED;
options.ble_adv_fast_enabled = BLE_ADV_FAST_ENABLED;
options.ble_adv_fast_interval = APP_ADV_FAST_INTERVAL;
options.ble_adv_fast_timeout = APP_ADV_FAST_TIMEOUT;
options.ble_adv_slow_enabled = BLE_ADV_SLOW_ENABLED;
options.ble_adv_slow_interval = APP_ADV_SLOW_INTERVAL;
options.ble_adv_slow_timeout = APP_ADV_SLOW_TIMEOUT;
err_code = ble_advertising_init(&advdata, NULL, &options, on_adv_evt, NULL);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for initializing the Advertising functionality.
*/
static void advertising_init(void)
{
uint32_t err_code;
manuf_data.company_identifier = 0x0059; // Nordics company ID
manuf_data.data.p_data = data;
manuf_data.data.size = sizeof(data);
// Build advertising data struct to pass into @ref ble_advertising_init.
memset(&advdata, 0, sizeof(advdata));
advdata.name_type = BLE_ADVDATA_SHORT_NAME;
advdata.short_name_len = 6;
//advdata.include_appearance = true;
advdata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;
advdata.uuids_complete.uuid_cnt = sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]);
advdata.uuids_complete.p_uuids = m_adv_uuids;
advdata.p_manuf_specific_data = &manuf_data;
ble_adv_modes_config_t options = {0};
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);
}
/**@brief Function for initializing the Advertising functionality.
*/
static void advertising_init(void)
{
uint32_t err_code;
ble_advdata_t advdata;
ble_advdata_t srddata;
ble_advdata_service_data_t adv_service_data;
// Add a custom base UUID.
ble_uuid128_t service128bit_uuid = {{0x42, 0x25, 0x84, 0x11, 0x24, 0xEA, 0xFB, 0xB5, 0x4E, 0x4B, 0xF3, 0x11, 0x30, 0x9B, 0x30, 0x2D}};
uint8_t service_data[4] = {1, 2, 3, 4};
uint8_t service_data_len = sizeof(service_data)/sizeof(service_data[0]);
// Dhavaltest section
adv_service_data.service_uuid = service128bit_uuid;
adv_service_data.data.size = service_data_len; //sizeof(DEVICE_NAME); //16; //
adv_service_data.data.p_data = &service_data; //(uint8_t *)DEVICE_NAME; //&battery_data; &bds_base_uuid.uuid128; //
// Build advertising data struct to pass into @ref ble_advertising_init.
memset(&advdata, 0, sizeof(advdata));
advdata.name_type = BLE_ADVDATA_NO_NAME; //BLE_ADVDATA_FULL_NAME;
advdata.include_appearance = false; // set to false 3-4 byte in adv pck
advdata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;
advdata.uuids_complete.uuid_cnt = sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]);
advdata.uuids_complete.p_uuids = m_adv_uuids;
// Dhavaltest 2 line
advdata.service_data_count = 1;
advdata.p_service_data_array = &adv_service_data;
// Build advertising data struct to pass into @ref ble_advertising_init.
memset(&srddata, 0, sizeof(srddata));
srddata.name_type = BLE_ADVDATA_FULL_NAME;
srddata.include_appearance = true;
//srddata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;
srddata.uuids_complete.uuid_cnt = sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]);
srddata.uuids_complete.p_uuids = m_adv_uuids;
// Dhavaltest 2 line
//srddata.service_data_count = 1;
//srddata.p_service_data_array = &service_data;
ble_adv_modes_config_t options = {0};
options.ble_adv_fast_enabled = BLE_ADV_FAST_ENABLED;
options.ble_adv_fast_interval = APP_ADV_INTERVAL;
#ifdef DHAVALTEST && SDK7110
options.ble_adv_fast_timeout = 0;
#else
options.ble_adv_fast_timeout = APP_ADV_TIMEOUT_IN_SECONDS;
#endif
err_code = ble_advertising_init(&advdata, &srddata, &options, on_adv_evt, NULL);
APP_ERROR_CHECK(err_code);
}
/**@snippet [UART Initialization] */
static void uart_init(void)
{
uint32_t err_code;
const app_uart_comm_params_t comm_params =
{
.rx_pin_no = RX_PIN_NUMBER,
.tx_pin_no = TX_PIN_NUMBER,
.rts_pin_no = RTS_PIN_NUMBER,
.cts_pin_no = CTS_PIN_NUMBER,
.flow_control = APP_UART_FLOW_CONTROL_DISABLED,
.use_parity = false,
.baud_rate = UART_BAUDRATE_BAUDRATE_Baud115200
};
APP_UART_FIFO_INIT(&comm_params,
UART_RX_BUF_SIZE,
UART_TX_BUF_SIZE,
uart_event_handle,
APP_IRQ_PRIORITY_LOWEST,
err_code);
APP_ERROR_CHECK(err_code);
}
/**@snippet [UART Initialization] */
/**@brief Function for initializing the Advertising functionality.
*/
static void advertising_init(void)
{
uint32_t err_code;
ble_advdata_t advdata;
ble_advdata_t scanrsp;
ble_adv_modes_config_t options;
// Build advertising data struct to pass into @ref ble_advertising_init.
memset(&advdata, 0, sizeof(advdata));
advdata.name_type = BLE_ADVDATA_FULL_NAME;
advdata.include_appearance = false;
advdata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_LIMITED_DISC_MODE;
memset(&scanrsp, 0, sizeof(scanrsp));
scanrsp.uuids_complete.uuid_cnt = sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]);
scanrsp.uuids_complete.p_uuids = m_adv_uuids;
memset(&options, 0, sizeof(options));
options.ble_adv_fast_enabled = true;
options.ble_adv_fast_interval = APP_ADV_INTERVAL;
options.ble_adv_fast_timeout = APP_ADV_TIMEOUT_IN_SECONDS;
err_code = ble_advertising_init(&advdata, &scanrsp, &options, on_adv_evt, NULL);
APP_ERROR_CHECK(err_code);
ble_advertising_conn_cfg_tag_set(CONN_CFG_TAG);
}
/**@brief Function for re-initializing the Advertising module with all advertising modes disabled.
*/
static void advertising_disable(void)
{
uint32_t err_code;
ble_adv_modes_config_t options = {0};
options.ble_adv_directed_enabled = false;
options.ble_adv_fast_enabled = false;
options.ble_adv_slow_enabled = false;
options.ble_adv_whitelist_enabled = false;
err_code = ble_advertising_init(&m_advdata, NULL, &options, on_adv_evt, NULL);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for re-initializing the Advertising module with fast advertising mode enabled.
*/
static void advertising_enable(void)
{
uint32_t err_code;
ble_adv_modes_config_t options = {0};
options.ble_adv_fast_enabled = true;
options.ble_adv_fast_interval = APP_ADV_INTERVAL;
options.ble_adv_fast_timeout = APP_ADV_TIMEOUT_IN_SECONDS;
options.ble_adv_whitelist_enabled = true;
err_code = ble_advertising_init(&m_advdata, NULL, &options, on_adv_evt, NULL);
APP_ERROR_CHECK(err_code);
}
void init_advertising_manager(ble_uuid_t *p_uuid)
{
uint32_t err_code;
/*
// アドバタイジングデータを構築する。
ble_advdata_t advdata;
memset(&advdata, 0, sizeof(advdata));
// Flags,サービスのUUIDを設定する
advdata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;
advdata.uuids_complete.uuid_cnt = 1;
advdata.uuids_complete.p_uuids = p_uuid;
// スキャンレスポンスを構築する。
// 完全なLocal nameを設定する。
ble_advdata_t scan_response_data;
memset(&scan_response_data, 0, sizeof(scan_response_data));
scan_response_data.name_type = BLE_ADVDATA_FULL_NAME;
*/
// アドバタイジングデータを構築する。
ble_advdata_t advdata;
memset(&advdata, 0, sizeof(advdata));
advdata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;
advdata.name_type = BLE_ADVDATA_FULL_NAME;
// スキャンレスポンスを構築する。
ble_advdata_t scan_response_data;
memset(&scan_response_data, 0, sizeof(scan_response_data));
if(p_uuid != NULL) {
scan_response_data.uuids_complete.uuid_cnt = 1;
scan_response_data.uuids_complete.p_uuids = p_uuid;
}
// アドバタイジングモードのオプション設定
ble_adv_modes_config_t options;
memset(&options, 0, sizeof(ble_adv_modes_config_t));
//directed modeはdisable (0設定)
options.ble_adv_fast_enabled = true;
options.ble_adv_fast_interval = ADV_FAST_INTERVAL_0625UNIT;
options.ble_adv_fast_timeout = ADV_FAST_TIMEOUT_SEC;
options.ble_adv_slow_enabled = true;
options.ble_adv_slow_interval = ADV_SLOW_INTERVAL_0625UNIT;
options.ble_adv_slow_timeout = ADV_SLOW_TIMEOUT_SEC;
err_code = ble_advertising_init(&advdata, &scan_response_data, &options, on_advertising_event, on_advertising_error);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for initializing the Advertising functionality.
*/
static void advertising_init(void)
{
uint32_t err_code;
ble_advdata_t advdata;
// Build advertising data struct to pass into ble_advertising_init().
memset(&advdata, 0, sizeof(advdata));
advdata.name_type = BLE_ADVDATA_FULL_NAME;
advdata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;
ble_adv_modes_config_t options = {0};
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;
// OUR_JOB: Create a scan response packet and include the list of UUIDs
err_code = ble_advertising_init(&advdata, NULL, &options, on_adv_evt, NULL);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for initializing the Advertising functionality.
*/
static void advertising_init(void)
{
uint32_t err_code;
ble_advdata_t advdata;
ble_advdata_t scanrsp;
// Build advertising data struct to pass into @ref ble_advertising_init.
setup_advdata(&advdata);
memset(&scanrsp, 0, sizeof(scanrsp));
scanrsp.uuids_complete.uuid_cnt = sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]);
scanrsp.uuids_complete.p_uuids = m_adv_uuids;
ble_adv_modes_config_t options = {0};
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, &scanrsp, &options, NULL, NULL);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for initializing the Advertising functionality.
*/
void advertising_init(void)
{
uint32_t err_code;
ble_advdata_t advdata;
ble_uuid_t adv_uuids[] = {{LBL_UUID_SERVICE,m_lbl.uuid_type}};
// Build and set advertising data
memset(&advdata, 0, sizeof(advdata));
advdata.name_type = BLE_ADVDATA_FULL_NAME;
advdata.include_appearance = false; //samples typically set this to true. I don't see why adv bytes should be wasted on this...
advdata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;
advdata.uuids_complete.uuid_cnt = sizeof(adv_uuids)/sizeof(adv_uuids[0]);
advdata.uuids_complete.p_uuids = adv_uuids;
//I'm setting these to the same as in the ble_app_template example
ble_adv_modes_config_t options = {0};
options.ble_adv_fast_enabled = BLE_ADV_FAST_ENABLED;
options.ble_adv_fast_interval = APP_ADV_INTERVAL;
options.ble_adv_fast_timeout = m_app_adv_timeout_in_seconds;
err_code = ble_advertising_init(&advdata, NULL, &options, on_adv_evt, NULL);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for initializing the Advertising functionality.
*/
void advertising_init(void)
{
uint32_t err_code;
ble_advdata_t advdata;
// Build advertising data struct to pass into @ref ble_advertising_init.
memset(&advdata, 0, sizeof(advdata));
advdata.name_type = BLE_ADVDATA_NO_NAME; //BLE_ADVDATA_FULL_NAME;
advdata.include_appearance = false;
advdata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;
advdata.uuids_complete.uuid_cnt = sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]);
advdata.uuids_complete.p_uuids = m_adv_uuids;
advdata.p_tx_power_level = &gap_tx_power;
ble_adv_modes_config_t options = {0};
options.ble_adv_slow_enabled = BLE_ADV_SLOW_ENABLED;
options.ble_adv_slow_interval = APP_ADV_INTERVAL;
options.ble_adv_slow_timeout = APP_ADV_TIMEOUT;
//err_code = ble_advdata_set(&advdata, NULL, options, on_adv_event);
err_code = ble_advertising_init(&advdata, NULL, &options, on_adv_evt, NULL);
APP_ERROR_CHECK(err_code);
}
/**
* \brief Main function for nRF52dk platform.
* \note This function doesn't return.
*/
int
main(void)
{
board_init();
leds_init();
clock_init();
rtimer_init();
watchdog_init();
process_init();
// Seed value is ignored since hardware RNG is used.
random_init(0);
#ifdef UART0_ENABLED
uart0_init();
#if SLIP_ARCH_CONF_ENABLE
slip_arch_init(0);
#else
uart0_set_input(serial_line_input_byte);
serial_line_init();
#endif
#endif
PRINTF("Starting " CONTIKI_VERSION_STRING "\n");
process_start(&etimer_process, NULL);
ctimer_init();
#if ENERGEST_CONF_ON
energest_init();
ENERGEST_ON(ENERGEST_TYPE_CPU);
#endif
#ifdef SOFTDEVICE_PRESENT
ble_stack_init();
ble_advertising_init(DEVICE_NAME);
#if NETSTACK_CONF_WITH_IPV6
netstack_init();
linkaddr_t linkaddr;
ble_get_mac(linkaddr.u8);
/* Set link layer address */
linkaddr_set_node_addr(&linkaddr);
/* Set device link layer address in uip stack */
memcpy(&uip_lladdr.addr, &linkaddr, sizeof(uip_lladdr.addr));
process_start(&ble_iface_observer, NULL);
process_start(&tcpip_process, NULL);
#endif /* NETSTACK_CONF_WITH_IPV6 */
#endif /* SOFTDEVICE_PRESENT */
process_start(&sensors_process, NULL);
autostart_start(autostart_processes);
watchdog_start();
#ifdef SOFTDEVICE_PRESENT
ble_advertising_start();
PRINTF("Advertising name [%s]\n", DEVICE_NAME);
#endif
while(1) {
uint8_t r;
do {
r = process_run();
watchdog_periodic();
} while(r > 0);
lpm_drop();
}
}
/**@brief Function for initializing the Advertising functionality.
*/
static void advertising_init(void)
{
uint32_t err_code;
ble_advdata_t advdata;
ble_advdata_t srddata;
ble_advdata_service_data_t adv_service_data;
// Add a custom base UUID.
ble_uuid128_t service128bit_uuid = {{0x8D, 0x69, 0xDE, 0x3D, 0x57, 0x37, 0x4F, 0xBD, 0x54, 0x41, 0xE8, 0x73, 0x64, 0x9B, 0xFE, 0x94}};
uint8_t service_data[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
uint8_t service_data_len = sizeof(service_data)/sizeof(service_data[0]);
// Dhavaltest section
adv_service_data.service_uuid = service128bit_uuid;
adv_service_data.data.size = service_data_len; //sizeof(DEVICE_NAME); //16; //
adv_service_data.data.p_data = &service_data; //(uint8_t *)DEVICE_NAME; //&battery_data; &bds_base_uuid.uuid128; //
// Build advertising data struct to pass into @ref ble_advertising_init.
memset(&advdata, 0, sizeof(advdata));
advdata.name_type = BLE_ADVDATA_NO_NAME; //BLE_ADVDATA_FULL_NAME;
advdata.include_appearance = false; // set to false 3-4 byte in adv pck
advdata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;
// advdata.uuids_complete.uuid_cnt = sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]);
// advdata.uuids_complete.p_uuids = m_adv_uuids;
// Dhavaltest 2 line
advdata.service_data_count = 1;
advdata.p_service_data_array = &adv_service_data;
// Build advertising data struct to pass into @ref ble_advertising_init.
memset(&srddata, 0, sizeof(srddata));
uint8_array_t adv_service_data_new;
uint8_t service_data_new[13] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};
adv_service_data_new.size = sizeof(service_data_new)/sizeof(service_data_new[0]);
adv_service_data_new.p_data = service_data_new;
ble_advdata_manuf_data_t manuf_data;
manuf_data.company_identifier = 0x4343;
manuf_data.data = adv_service_data_new;
srddata.name_type = BLE_ADVDATA_FULL_NAME;
// srddata.include_appearance = true;
//srddata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;
// srddata.uuids_complete.uuid_cnt = sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]);
// srddata.uuids_complete.p_uuids = m_adv_uuids;
// Dhavaltest 2 line
// srddata.service_data_count = 1;
// srddata.p_service_data_array->data = adv_service_data.data;
srddata.p_manuf_specific_data = &manuf_data;
ble_adv_modes_config_t options = {0};
options.ble_adv_fast_enabled = BLE_ADV_FAST_ENABLED;
options.ble_adv_fast_interval = APP_ADV_INTERVAL;
#if SOFTDEVICE_7_1_0 == 1
options.ble_adv_fast_timeout = 0;
#else
options.ble_adv_fast_timeout = APP_ADV_TIMEOUT_IN_SECONDS;
#endif
err_code = ble_advertising_init(&advdata, &srddata, &options, on_adv_evt, NULL);
APP_ERROR_CHECK(err_code);
}