void ble_stack_start(void)
{
uint32_t err_code;
SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, NULL);
// Enable BLE stack
ble_enable_params_t ble_enable_params;
memset(&ble_enable_params, 0, sizeof(ble_enable_params));
#ifdef S130
ble_enable_params.gatts_enable_params.attr_tab_size = BLE_GATTS_ATTR_TAB_SIZE_DEFAULT;
#endif
ble_enable_params.gatts_enable_params.service_changed = IS_SRVC_CHANGED_CHARACT_PRESENT;
err_code = sd_ble_enable(&ble_enable_params);
APP_ERROR_CHECK(err_code);
err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch);
APP_ERROR_CHECK(err_code);
}
/**@brief BLE + ANT stack initialization.
*
* @details Initializes the SoftDevice and the stack event interrupt.
*/
static void ble_ant_stack_init(void)
{
// Initialize SoftDevice
SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, false);
// Subscribe for BLE events.
uint32_t err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch);
APP_ERROR_CHECK(err_code);
// Subscribe for ANT events.
err_code = softdevice_ant_evt_handler_set(on_ant_evt);
APP_ERROR_CHECK(err_code);
#ifdef BONDING_ENABLE
// Register with the SoftDevice handler module for BLE events.
err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch);
APP_ERROR_CHECK(err_code);
#endif // BONDING_ENABLE
}
// Function for the S110 SoftDevice initialization.
static void ble_stack_init(void)
{
uint32_t err_code;
// Initialize SoftDevice.
SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, NULL);
// Enable BLE stack.
ble_enable_params_t ble_enable_params;
memset(&ble_enable_params, 0, sizeof(ble_enable_params));
ble_enable_params.gatts_enable_params.service_changed = 0;
err_code = sd_ble_enable(&ble_enable_params);
APP_ERROR_CHECK(err_code);
// Subscribe for BLE events.
err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch);
APP_ERROR_CHECK(err_code);
}
/**@brief Main function of the connectivity application. */
int main(void)
{
uint32_t err_code = NRF_SUCCESS;
#if ( defined(SER_PHY_HCI_DEBUG_ENABLE) || defined(SER_PHY_DEBUG_APP_ENABLE))
debug_init(NULL);
#endif
/* Initialize scheduler queue. */
APP_SCHED_INIT(SER_CONN_SCHED_MAX_EVENT_DATA_SIZE, SER_CONN_SCHED_QUEUE_SIZE);
/* Initialize SoftDevice.
* SoftDevice Event IRQ is not scheduled but immediately copies BLE events to the application
* scheduler queue */
SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, false);
/* Subscribe for BLE events. */
err_code = softdevice_ble_evt_handler_set(ser_conn_ble_event_handle);
APP_ERROR_CHECK(err_code);
/* Open serialization HAL Transport layer and subscribe for HAL Transport events. */
err_code = ser_hal_transport_open(ser_conn_hal_transport_event_handle);
APP_ERROR_CHECK(err_code);
/* Enter main loop. */
for (;;)
{
/* Process SoftDevice events. */
app_sched_execute();
/* Process received packets.
* We can NOT add received packets as events to the application scheduler queue because
* received packets have to be processed before SoftDevice events but the scheduler queue
* does not have priorities. */
err_code = ser_conn_rx_process();
APP_ERROR_CHECK(err_code);
/* Sleep waiting for an application event. */
err_code = sd_app_evt_wait();
APP_ERROR_CHECK(err_code);
}
}
// Initialize newlib
void hardware_init_hook(void) {
// Configure LED-pins as outputs.
LEDS_CONFIGURE(LEDS_MASK);
LEDS_OFF(LEDS_MASK);
// Initialize UART
Driver_UART_DEBUG.Initialize(NULL);
#if defined(__CMSIS_RTOS) && defined(SOFTDEVICE_PRESENT)
// Initialize the SoftDevice handler module.
SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, NULL);
// We need to configure the interrupt before starting the kernel as we cannot call an SVC in an SVC Handler
uint32_t err_code = sd_nvic_SetPriority(RTC1_IRQn, NRF_APP_PRIORITY_LOW);
assert(err_code == NRF_SUCCESS);
err_code = sd_nvic_EnableIRQ(RTC1_IRQn);
assert(err_code == NRF_SUCCESS);
#endif
}
static void softdevice_init(void)
{
uint32_t err_code;
// Initialize the SoftDevice handler module.
SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, NULL);
// Enable BLE stack.
ble_enable_params_t ble_enable_params;
memset(&ble_enable_params, 0, sizeof(ble_enable_params));
// Tell the Central that Services on Peripheral changed. Without this line,
// the Central won't update the services list of our device.
ble_enable_params.gatts_enable_params.service_changed = 1;
err_code = sd_ble_enable(&ble_enable_params);
APP_ERROR_CHECK(err_code);
// Subscribe for BLE events.
err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch);
APP_ERROR_CHECK(err_code);
}
/**
* \callgraph
* @brief Function for initializing the BLE stack.
*
* @details Initializes the SoftDevice and the BLE event interrupt.
*/
static void ble_stack_init(void)
{
uint32_t err_code;
// Initialize the SoftDevice handler module.
SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_SYNTH_250_PPM, NULL);
// Enable BLE stack
ble_enable_params_t ble_enable_params;
memset(&ble_enable_params, 0, sizeof(ble_enable_params));
ble_enable_params.gatts_enable_params.service_changed = IS_SRVC_CHANGED_CHARACT_PRESENT;
err_code = sd_ble_enable(&ble_enable_params);
APP_ERROR_CHECK(err_code);
// Register with the SoftDevice handler module for BLE events.
err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch);
APP_ERROR_CHECK(err_code);
// Register with the SoftDevice handler module for BLE events.
err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for the S110 SoftDevice initialization.
*
* @details This function initializes the S110 SoftDevice and the BLE event interrupt.
*/
static void ble_stack_init(void)
{
uint32_t err_code;
// Initialize SoftDevice.
SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, NULL);
// Enable BLE stack.
ble_enable_params_t ble_enable_params;
memset(&ble_enable_params, 0, sizeof(ble_enable_params));
#if (defined(S130) || defined(S132))
ble_enable_params.gatts_enable_params.attr_tab_size = BLE_GATTS_ATTR_TAB_SIZE_DEFAULT;
#endif
ble_enable_params.gatts_enable_params.service_changed = IS_SRVC_CHANGED_CHARACT_PRESENT;
err_code = sd_ble_enable(&ble_enable_params);
APP_ERROR_CHECK(err_code);
// Subscribe for BLE events.
err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch);
APP_ERROR_CHECK(err_code);
}
//============================================================================//
void CP_StackInit(void)
{
uint32_t err_code;
// Initialize the SoftDevice handler module.
SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, NULL);
#ifdef S110
// Enable BLE stack.
ble_enable_params_t ble_enable_params;
memset(&ble_enable_params, 0, sizeof(ble_enable_params));
// ble_enable_params.gatts_enable_params.attr_tab_size = BLE_GATTS_ATTR_TAB_SIZE_MIN;
ble_enable_params.gatts_enable_params.service_changed = IS_SRVC_CHANGED_CHARACT_PRESENT;
err_code = sd_ble_enable(&ble_enable_params);
APP_ERROR_CHECK(err_code);
#endif
// Register with the SoftDevice handler module for BLE events.
err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch);
APP_ERROR_CHECK(err_code);
// Register with the SoftDevice handler module for BLE events.
err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for initializing the BLE stack.
*
* @details Initializes the SoftDevice and the BLE event interrupt.
*/
static void ble_stack_init(void)
{
uint32_t err_code;
nrf_clock_lf_cfg_t clock_lf_cfg = NRF_CLOCK_LFCLKSRC;
// Initialize the SoftDevice handler module.
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.
err_code = softdevice_enable(&ble_enable_params);
APP_ERROR_CHECK(err_code);
}
/* Function for initializing the BLE stack.
Initializes the SoftDevice and the BLE event interrupt.
*/
static void ble_stack_init(bool is_central)
{
uint32_t err_code;
/* Initialize the SoftDevice handler module. */
SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, NULL);
/* Enable BLE stack. */
ble_enable_params_t ble_enable_params;
memset(&ble_enable_params, 0, sizeof(ble_enable_params));
ble_enable_params.gatts_enable_params.attr_tab_size = BLE_GATTS_ATTR_TAB_SIZE_DEFAULT;
ble_enable_params.gatts_enable_params.service_changed = false;
/* enable BLE */
err_code = sd_ble_enable(&ble_enable_params);
APP_ERROR_CHECK(err_code);
/* Register with the SoftDevice handler module for BLE events in central role */
err_code = softdevice_ble_evt_handler_set(ble_c_evt_dispatch);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for the SoftDevice initialization.
*
* @details This function initializes the SoftDevice and the BLE event interrupt.
*/
static void ble_stack_init(void)
{
uint32_t err_code;
// Initialize SoftDevice.
SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, 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.
err_code = softdevice_enable(&ble_enable_params);
APP_ERROR_CHECK(err_code);
// Subscribe for BLE events.
err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for initializing the BLE stack.
*
* @details Initializes the SoftDevice and the BLE event interrupt.
*/
static void ble_stack_init(void)
{
uint32_t err_code;
// Initialize the SoftDevice handler module.
SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, NULL);
// Enable BLE stack.
ble_enable_params_t ble_enable_params;
memset(&ble_enable_params, 0, sizeof(ble_enable_params));
#ifdef S130
ble_enable_params.gatts_enable_params.attr_tab_size = BLE_GATTS_ATTR_TAB_SIZE_DEFAULT;
#endif
err_code = sd_ble_enable(&ble_enable_params);
APP_ERROR_CHECK(err_code);
// Register with the SoftDevice handler module for BLE events.
err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch);
APP_ERROR_CHECK(err_code);
// Register with the SoftDevice handler module for System events.
err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch);
APP_ERROR_CHECK(err_code);
err_code = softdevice_ant_evt_handler_set(ant_evt_dispatch);
APP_ERROR_CHECK(err_code);
// TODO check this
err_code = ant_stack_static_config();
APP_ERROR_CHECK(err_code);
err_code = sd_ant_network_address_set(ANTPLUS_NETWORK_NUMBER, m_network_key);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for initializing the BLE stack.
*
* @details Initializes the SoftDevice and the BLE event interrupt.
*/
static void ble_stack_init (void) {
uint32_t err_code;
// Initialize the SoftDevice handler module.
SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_RC_250_PPM_8000MS_CALIBRATION,
false);
// Enable BLE stack
ble_enable_params_t ble_enable_params;
memset(&ble_enable_params, 0, sizeof(ble_enable_params));
ble_enable_params.gatts_enable_params.service_changed = IS_SRVC_CHANGED_CHARACT_PRESENT;
err_code = sd_ble_enable(&ble_enable_params);
APP_ERROR_CHECK(err_code);
//Register with the SoftDevice handler module for BLE events.
err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch);
APP_ERROR_CHECK(err_code);
// Register with the SoftDevice handler module for BLE events.
err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch);
APP_ERROR_CHECK(err_code);
// Set the MAC address of the device
{
ble_gap_addr_t gap_addr;
// Get the current original address
sd_ble_gap_address_get(&gap_addr);
// Set the new BLE address with the Michigan OUI
gap_addr.addr_type = BLE_GAP_ADDR_TYPE_PUBLIC;
memcpy(gap_addr.addr+2, MAC_ADDR+2, sizeof(gap_addr.addr)-2);
err_code = sd_ble_gap_address_set(BLE_GAP_ADDR_CYCLE_MODE_NONE,
&gap_addr);
APP_ERROR_CHECK(err_code);
}
}
int main(void) {
uint32_t err_code;
// Initialization
led_init(LED_0);
led_init(LED_1);
led_init(LED_2);
led_on(LED_0);
// Setup clock
SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_RC_250_PPM_8000MS_CALIBRATION, false);
// Setup and start timeri
//APP_SCHED_INIT(APP_TIMER_SCHED_EVT_SIZE, 20);
timers_init();
timers_start();
while (1) {
//app_sched_execute();
power_manage();
//led_toggle(LED_1);
}
}
/**@brief Function for initializing the BLE stack.
*
* @details Initializes the SoftDevice and the BLE event interrupt.
*/
void ble_stack_init(void)
{
uint32_t err_code;
//Copied from pca10028.h to cut dependence on bsp/
#define NRF_CLOCK_LFCLKSRC {.source = NRF_CLOCK_LF_SRC_XTAL, \
.rc_ctiv = 0, \
.rc_temp_ctiv = 0, \
.xtal_accuracy = NRF_CLOCK_LF_XTAL_ACCURACY_20_PPM}
nrf_clock_lf_cfg_t clock_lf_cfg = NRF_CLOCK_LFCLKSRC;
// Initialize the SoftDevice handler module.
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);
ble_enable_params.common_enable_params.vs_uuid_count = VENDOR_SPECIFIC_UUID_COUNT;
//Check the ram settings against the used number of links
CHECK_RAM_START_ADDR(CENTRAL_LINK_COUNT,PERIPHERAL_LINK_COUNT);
// Enable BLE stack.
err_code = softdevice_enable(&ble_enable_params);
APP_ERROR_CHECK(err_code);
// Register with the SoftDevice handler module for BLE events.
err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch);
APP_ERROR_CHECK(err_code);
// Register with the SoftDevice handler module for System events.
err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch);
APP_ERROR_CHECK(err_code);
}
static void ble_stack_init(void)
{
uint32_t err_code;
//Initiate softdevice, with external low-freq crystal
SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, NULL);
ble_enable_params_t ble_enable_params;
memset(&ble_enable_params, 0, sizeof(ble_enable_params));
ble_enable_params.gatts_enable_params.attr_tab_size = BLE_GATTS_ATTR_TAB_SIZE_DEFAULT;
ble_enable_params.gatts_enable_params.service_changed = IS_SRVC_CHANGED_CHARACT_PRESENT;
err_code = sd_ble_enable(&ble_enable_params);
BLE_ERROR_CHECK(err_code);
// Register with the SoftDevice handler module for BLE events.
err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch);
BLE_ERROR_CHECK(err_code);
// Register with the SoftDevice handler module for system events.
err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch);
BLE_ERROR_CHECK(err_code);
}
/**
* @brief BLEスタック初期化
*
* @detail BLE関連の初期化を行う。
* -# SoftDeviceハンドラ初期化
* -# システムイベントハンドラ初期化
* -# BLEスタック有効化
* -# BLEイベントハンドラ設定
* -# デバイス名設定
* -# Appearance設定(GAP_USE_APPEARANCE定義時)
* -# PPCP設定
* -# Service初期化
* -# Advertising初期化
* -# Connection初期化
*/
static void ble_stack_init(void)
{
uint32_t err_code;
/*
* SoftDeviceの初期化
* スケジューラの使用：あり
*/
// SOFTDEVICE_HANDLER_APPSH_INIT(NRF_CLOCK_LFCLKSRC_RC_250_PPM_4000MS_CALIBRATION, true);
SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_RC_250_PPM_4000MS_CALIBRATION, NULL);
/* システムイベントハンドラの設定 */
err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch);
APP_ERROR_CHECK(err_code);
/* BLEスタックの有効化 */
{
ble_enable_params_t ble_enable_params;
memset(&ble_enable_params, 0, sizeof(ble_enable_params));
ble_enable_params.gatts_enable_params.service_changed = IS_SRVC_CHANGED_CHARACT_PRESENT;
err_code = sd_ble_enable(&ble_enable_params);
APP_ERROR_CHECK(err_code);
}
/* BLEイベントハンドラの設定 */
{
err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch);
APP_ERROR_CHECK(err_code);
}
device_manager_init(false);
/* デバイス名設定 */
{
//デバイス名へのWrite Permission(no protection, open link)
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 *)GAP_DEVICE_NAME,
strlen(GAP_DEVICE_NAME));
APP_ERROR_CHECK(err_code);
}
#ifdef GAP_USE_APPEARANCE
/* Appearance設定 */
err_code = sd_ble_gap_appearance_set(GAP_USE_APPEARANCE);
APP_ERROR_CHECK(err_code);
#endif //GAP_USE_APPEARANCE
/*
* Peripheral Preferred Connection Parameters(PPCP)
* ここで設定しておくと、Connection Parameter Update Reqを送信せずに済むらしい。
*/
{
ble_gap_conn_params_t gap_conn_params = {0};
gap_conn_params.min_conn_interval = MSEC_TO_UNITS(CONN_MIN_INTERVAL, UNIT_1_25_MS);
gap_conn_params.max_conn_interval = MSEC_TO_UNITS(CONN_MAX_INTERVAL, UNIT_1_25_MS);
gap_conn_params.slave_latency = CONN_SLAVE_LATENCY;
gap_conn_params.conn_sup_timeout = MSEC_TO_UNITS(CONN_SUP_TIMEOUT, UNIT_10_MS);
err_code = sd_ble_gap_ppcp_set(&gap_conn_params);
APP_ERROR_CHECK(err_code);
}
/*
* Service初期化
*/
{
ble_fps_init_t fps_init;
fps_init.evt_handler_ndef = svc_fps_handler_ndef;
err_code = ble_fps_init(&m_fps, &fps_init);
APP_ERROR_CHECK(err_code);
}
/*
* Advertising初期化
*/
{
ble_uuid_t adv_uuids[] = { { FPS_UUID_SERVICE, m_fps.uuid_type } };
ble_advdata_t advdata;
ble_advdata_t scanrsp;
memset(&advdata, 0, sizeof(advdata));
memset(&scanrsp, 0, sizeof(scanrsp));
/*
* ble_advdata_name_type_t (ble_advdata.h)
*
* BLE_ADVDATA_NO_NAME : デバイス名無し
* BLE_ADVDATA_SHORT_NAME : デバイス名あり «Shortened Local Name»
* BLE_ADVDATA_FULL_NAME : デバイス名あり «Complete Local Name»
*
* https://www.bluetooth.org/en-us/specification/assigned-numbers/generic-access-profile
* https://developer.nordicsemi.com/nRF51_SDK/nRF51_SDK_v7.x.x/doc/7.2.0/s110/html/a01015.html#ga03c5ccf232779001be9786021b1a563b
*/
advdata.name_type = BLE_ADVDATA_FULL_NAME;
/*
* Appearanceが含まれるかどうか
*/
#ifdef GAP_USE_APPEARANCE
advdata.include_appearance = true;
#else //GAP_USE_APPEARANCE
advdata.include_appearance = false;
#endif //GAP_USE_APPEARANCE
/*
* Advertisingフラグの設定
* CSS_v4 : Part A 1.3 FLAGS
* https://developer.nordicsemi.com/nRF51_SDK/nRF51_SDK_v7.x.x/doc/7.2.0/s110/html/a00802.html
*
* BLE_GAP_ADV_FLAGS_LE_ONLY_LIMITED_DISC_MODE = BLE_GAP_ADV_FLAG_LE_LIMITED_DISC_MODE | BLE_GAP_ADV_FLAG_BR_EDR_NOT_SUPPORTED
* BLE_GAP_ADV_FLAG_LE_LIMITED_DISC_MODE : LE Limited Discoverable Mode
* BLE_GAP_ADV_FLAG_BR_EDR_NOT_SUPPORTED : BR/EDR not supported
*/
advdata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_LIMITED_DISC_MODE; //探索時間に制限あり
/* SCAN_RSPデータ設定 */
scanrsp.uuids_complete.uuid_cnt = ARRAY_SIZE(adv_uuids);
scanrsp.uuids_complete.p_uuids = adv_uuids;
err_code = ble_advdata_set(&advdata, &scanrsp);
APP_ERROR_CHECK(err_code);
}
/*
* Connection初期化
*/
{
ble_conn_params_init_t cp_init = {0};
cp_init.p_conn_params = NULL;
cp_init.first_conn_params_update_delay = APP_TIMER_TICKS(CONN_FIRST_PARAMS_UPDATE_DELAY, APP_TIMER_PRESCALER);
cp_init.next_conn_params_update_delay = APP_TIMER_TICKS(CONN_NEXT_PARAMS_UPDATE_DELAY, APP_TIMER_PRESCALER);
cp_init.max_conn_params_update_count = CONN_MAX_PARAMS_UPDATE_COUNT;
cp_init.start_on_notify_cccd_handle = BLE_GATT_HANDLE_INVALID;
cp_init.disconnect_on_fail = false;
cp_init.evt_handler = conn_params_evt_handler;
cp_init.error_handler = conn_params_error_handler;
err_code = ble_conn_params_init(&cp_init);
APP_ERROR_CHECK(err_code);
}
#ifdef BLE_DFU_APP_SUPPORT
/** @snippet [DFU BLE Service initialization] */
{
ble_dfu_init_t dfus_init;
// Initialize the Device Firmware Update Service.
memset(&dfus_init, 0, sizeof(dfus_init));
dfus_init.evt_handler = dfu_app_on_dfu_evt;
dfus_init.error_handler = NULL; //service_error_handler - Not used as only the switch from app to DFU mode is required and not full dfu service.
dfus_init.evt_handler = dfu_app_on_dfu_evt;
dfus_init.revision = DFU_REVISION;
err_code = ble_dfu_init(&m_dfus, &dfus_init);
APP_ERROR_CHECK(err_code);
dfu_app_reset_prepare_set(dfu_reset_prepare);
}
/** @snippet [DFU BLE Service initialization] */
#endif // BLE_DFU_APP_SUPPORT
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(hello_world_process, ev, data)
{
PROCESS_BEGIN();
uint32_t err_code;
// Initialize the SoftDevice handler module.
SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, false);
// Register with the SoftDevice handler module for BLE events.
err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch);
APP_ERROR_CHECK(err_code);
// Register with the SoftDevice handler module for BLE events.
err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch);
APP_ERROR_CHECK(err_code);
ble_gap_conn_sec_mode_t sec_mode;
char name_buffer[9];
sprintf(name_buffer, "%08X",(unsigned int) NRF_FICR->DEVICEID[0]);
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&sec_mode);
err_code = sd_ble_gap_device_name_set(&sec_mode,
(const uint8_t *)name_buffer,
strlen(name_buffer));
APP_ERROR_CHECK(err_code);
ble_advdata_t advdata;
uint8_t flags = BLE_GAP_ADV_FLAG_BR_EDR_NOT_SUPPORTED;
ble_advdata_service_data_t service_data[2];
uint8_t battery_data = 98;//battery_level_get();
uint32_t temperature_data = 0xFE001213;
service_data[0].service_uuid = BLE_UUID_BATTERY_SERVICE;
service_data[0].data.size = sizeof(battery_data);
service_data[0].data.p_data = &battery_data;
service_data[1].service_uuid = BLE_UUID_HEALTH_THERMOMETER_SERVICE;
service_data[1].data.size = sizeof(temperature_data);
service_data[1].data.p_data = (uint8_t *) &temperature_data;
// Build and set advertising data
memset(&advdata, 0, sizeof(advdata));
advdata.name_type = BLE_ADVDATA_FULL_NAME;
advdata.include_appearance = false;
advdata.flags.size = sizeof(flags);
advdata.flags.p_data = &flags;
advdata.service_data_count = 2;
advdata.p_service_data_array = service_data;
err_code = ble_advdata_set(&advdata, NULL);
APP_ERROR_CHECK(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_NONCONN_IND;
adv_params.p_peer_addr = NULL;
adv_params.fp = BLE_GAP_ADV_FP_ANY;
adv_params.interval = ADV_INTERVAL;
adv_params.timeout = ADV_TIMEOUT_IN_SECONDS;
err_code = sd_ble_gap_adv_start(&adv_params);
APP_ERROR_CHECK(err_code);
leds_off(LEDS_ALL);
leds_on(LEDS_RED);
PROCESS_PAUSE();
etimer_set(&et_hello, CLOCK_SECOND/2);
rand_val = 0;
blinks = 0;
while(1) {
PROCESS_WAIT_EVENT();
if(ev == PROCESS_EVENT_TIMER) {
sd_rand_application_vector_get(&blinks,1);
printf("Sensor says #%X\n", (unsigned int) blinks);
etimer_reset(&et_hello);
}
}
PROCESS_END();
}
static void ble_stack_init(void)
{
// Initialize the SoftDevice handler module.
SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_SYNTH_250_PPM, false);
}
/**
* @brief Initialize SoftDevice
*/
void init_softdevice()
{
// Initialize the SoftDevice's event handler
SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, false);
}
/**@brief Function for initializing the BLE stack.
*
* @details Initializes the SoftDevice and the BLE event interrupt.
*/
static void ble_stack_init(void)
{
uint32_t err_code;
// Initialize the SoftDevice handler module.
SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, NULL);
ble_enable_params_t ble_enable_params;
err_code = softdevice_enable_get_default_config(CENTRAL_LINK_COUNT,
PERIPHERAL_LINK_COUNT,
&ble_enable_params);
if (err_code == NRF_SUCCESS)
debug_printf("Softdevice configured with links and ble parameters!\r\n");
else
{
debug_printf("Ooops.. Something is wrong with setting softdevice parameters..\r\n");
APP_ERROR_CHECK(err_code);
}
#ifdef BLE_DFU_APP_SUPPORT
ble_enable_params.gatts_enable_params.service_changed = 1;
#endif // BLE_DFU_APP_SUPPORT
//Check the ram settings against the used number of links
CHECK_RAM_START_ADDR(CENTRAL_LINK_COUNT,PERIPHERAL_LINK_COUNT);
//memset(&ble_enable_params, 0, sizeof(ble_enable_params));
ble_enable_params.common_enable_params.vs_uuid_count = 2;
//ble_enable_params.gatts_enable_params.attr_tab_size = 0x0900; //changing stack size?
// Enable BLE stack.
err_code = softdevice_enable(&ble_enable_params);
if (err_code == NRF_SUCCESS)
debug_printf("Softdevice enabled successfully!\r\n");
else
{
debug_printf("Ooops.. Something is wrong with enabling softdevice..\r\n");
APP_ERROR_CHECK(err_code);
}
// Register with the SoftDevice handler module for BLE events.
err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch);
if (err_code == NRF_SUCCESS)
debug_printf("Softdevice registered for BLE events!\r\n");
else
{
debug_printf("Ooops.. Something went wrong with registering to BLE events..\r\n");
APP_ERROR_CHECK(err_code);
}
// Register with the SoftDevice handler module for SYS events.
err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch);
if (err_code == NRF_SUCCESS)
debug_printf("Softdevice registered for SYS events!\r\n");
else
{
debug_printf("Ooops.. Something went wrong with registering to SYS events..\r\n");
APP_ERROR_CHECK(err_code);
}
}
