void conn_interval_select(void) { NRF_LOG_INFO("Select a connection interval:\r\n"); NRF_LOG_INFO(" 1) 7.5 ms\r\n"); NRF_LOG_INFO(" 2) 50 ms\r\n"); NRF_LOG_INFO(" 3) 400 ms\r\n"); NRF_LOG_FLUSH(); switch (NRF_LOG_GETCHAR()) { case ONE: default: m_test_params.conn_interval = (uint16_t)(MSEC_TO_UNITS(7.5, UNIT_1_25_MS)); break; case TWO: m_test_params.conn_interval = (uint16_t)(MSEC_TO_UNITS(50, UNIT_1_25_MS)); break; case THREE: m_test_params.conn_interval = (uint16_t)(MSEC_TO_UNITS(400, UNIT_1_25_MS)); break; } NRF_LOG_INFO("Connection interval set to 0x%x.\r\n", m_test_params.conn_interval); NRF_LOG_FLUSH(); }
// Function for the GAP initialization. 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); const char deviceName[] = "RGB LED"; err_code = sd_ble_gap_device_name_set(&sec_mode, (const uint8_t *) deviceName, strlen(deviceName)); APP_ERROR_CHECK(err_code); memset(&gap_conn_params, 0, sizeof(gap_conn_params)); gap_conn_params.min_conn_interval = MSEC_TO_UNITS(20, UNIT_1_25_MS); gap_conn_params.max_conn_interval = MSEC_TO_UNITS(75, UNIT_1_25_MS); gap_conn_params.slave_latency = 0; gap_conn_params.conn_sup_timeout = MSEC_TO_UNITS(4000, UNIT_10_MS); err_code = sd_ble_gap_ppcp_set(&gap_conn_params); APP_ERROR_CHECK(err_code); }
void BLEHelper::setConnectionInterval(float minInterval, float maxInterval) { uint16_t minVal = (uint16_t)MSEC_TO_UNITS(minInterval, UNIT_1_25_MS); uint16_t maxVal = (uint16_t)MSEC_TO_UNITS(maxInterval, UNIT_1_25_MS); _conn_params.interval_min = minVal; _conn_params.interval_max = maxVal; updateConnectionInterval(); }
void BLECentral::setScanParam(float interval, float window) { bt_le_scan_param_t scan_param; scan_param.type = BT_HCI_LE_SCAN_ACTIVE; scan_param.filter_dup = BT_HCI_LE_SCAN_FILTER_DUP_ENABLE; scan_param.interval = (uint16_t)MSEC_TO_UNITS(interval, UNIT_0_625_MS);; scan_param.window = (uint16_t)MSEC_TO_UNITS(window, UNIT_0_625_MS);; BLECentralRole::instance()->setScanParam(scan_param); }
void BLEHelper::setConnectionInterval(float minInterval, float maxInterval, uint16_t latency, uint16_t timeout) { uint16_t minVal = (uint16_t)MSEC_TO_UNITS(minInterval, UNIT_1_25_MS); uint16_t maxVal = (uint16_t)MSEC_TO_UNITS(maxInterval, UNIT_1_25_MS); uint16_t timeoutVal = MSEC_TO_UNITS(timeout, UNIT_10_MS); _conn_params.interval_min = minVal; _conn_params.interval_max = maxVal; _conn_params.timeout = timeoutVal; updateConnectionInterval(); }
/** * @brief Advertising開始 */ void app_ble_start(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 = MSEC_TO_UNITS(APP_ADV_INTERVAL, UNIT_0_625_MS); adv_params.timeout = APP_ADV_TIMEOUT_IN_SECONDS; #ifdef APP_ADV_DISABLE_CH37 adv_params.channel_mask.ch_37_off = 1; #endif //APP_ADV_DISABLE_CH37 #ifdef APP_ADV_DISABLE_CH38 adv_params.channel_mask.ch_38_off = 1; #endif //APP_ADV_DISABLE_CH38 #ifdef APP_ADV_DISABLE_CH39 adv_params.channel_mask.ch_39_off = 1; #endif //APP_ADV_DISABLE_CH39 err_code = sd_ble_gap_adv_start(&adv_params); APP_ERROR_CHECK(err_code); led_on(LED_PIN_NO_ADVERTISING); app_trace_log("advertising start\r\n"); }
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; }
bool BLECentral::connect(const bt_addr_le_t *addr, const ble_conn_param_t *param) { bt_le_conn_param_t conn_param; conn_param.latency = param->latency; conn_param.interval_max = (uint16_t)MSEC_TO_UNITS(param->interval_max, UNIT_1_25_MS); conn_param.interval_min = (uint16_t)MSEC_TO_UNITS(param->interval_min, UNIT_1_25_MS); conn_param.timeout = MSEC_TO_UNITS(param->timeout, UNIT_10_MS); pr_debug(LOG_MODULE_BLE,"Latency-%d\r\nInterval min-%d, max-%d\r\ntimeout:%d", conn_param.latency, conn_param.interval_min, conn_param.interval_max, conn_param.timeout); return BLECentralRole::instance()->connect(addr, &conn_param); }
/**@brief Function for starting connectable advertising of the eddystone beacon to register it * @details Used by the eddystone_registration_ui module as a callback when the registration button is pressed. */ static void eddystone_ble_registr_adv_cb(void) { if (m_is_connectable_adv != true && m_is_connected == false) { all_advertising_halt(); uint32_t err_code; ble_advdata_t adv_data; ble_advdata_t scrsp_data; ble_uuid_t adv_uuids[] = {{EDDYSTONE_UUID, BLE_UUID_TYPE_BLE}}; ble_uuid_t scrp_uuids[] = {{BLE_UUID_ECS_SERVICE, m_ecs_uuid_type}}; uint8_array_t eddystone_data_array; // Array for Service Data structure. eddystone_data_array.size = 0; eddystone_data_array.p_data = NULL; ble_advdata_service_data_t service_data; // Structure to hold Service Data. service_data.service_uuid = APP_EDDYSTONE_UUID; // Eddystone UUID to allow discoverability on iOS devices. service_data.data = eddystone_data_array; // Array for service advertisement data. // Build and set advertising data. memset(&adv_data, 0, sizeof(adv_data)); adv_data.name_type = BLE_ADVDATA_NO_NAME; adv_data.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE; adv_data.uuids_complete.uuid_cnt = sizeof(adv_uuids) / sizeof(adv_uuids[0]); adv_data.uuids_complete.p_uuids = adv_uuids; adv_data.p_service_data_array = &service_data; // Pointer to Service Data structure. adv_data.service_data_count = 1; memset(&scrsp_data, 0, sizeof(scrsp_data)); scrsp_data.name_type = BLE_ADVDATA_FULL_NAME; scrsp_data.include_appearance = false; scrsp_data.uuids_complete.uuid_cnt = sizeof(scrp_uuids) / sizeof(scrp_uuids[0]); scrsp_data.uuids_complete.p_uuids = scrp_uuids; err_code = ble_advdata_set(&adv_data, &scrsp_data); APP_ERROR_CHECK(err_code); memset(&m_conn_adv_params, 0, sizeof(m_conn_adv_params)); m_conn_adv_params.type = BLE_GAP_ADV_TYPE_ADV_IND; m_non_conn_adv_params.p_peer_addr = NULL; // Undirected advertisement. m_non_conn_adv_params.fp = BLE_GAP_ADV_FP_ANY; m_conn_adv_params.interval = MSEC_TO_UNITS(APP_CFG_CONNECTABLE_ADV_INTERVAL_MS, UNIT_0_625_MS); m_conn_adv_params.timeout = APP_CFG_CONNECTABLE_ADV_TIMEOUT; m_is_connectable_adv = true; eddystone_ble_advertising_start(EDDYSTONE_BLE_ADV_CONNECTABLE_TRUE); } }
/**@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( uint8_t slot ) { uint32_t err_code; ble_advdata_t adv_data; ble_uuid_t adv_uuids[] = {{EDDYSTONE_UUID, BLE_UUID_TYPE_BLE}}; uint8_array_t eddystone_data_array; // Array for Service Data structure. fetch_adv_data_from_slot(slot,&eddystone_data_array); ble_advdata_service_data_t service_data; // Structure to hold Service Data. service_data.service_uuid = APP_EDDYSTONE_UUID; // Eddystone UUID to allow discoverability on iOS devices. service_data.data = eddystone_data_array; // Array for service advertisement data. // Build and set advertising data. memset(&adv_data, 0, sizeof(adv_data)); adv_data.name_type = BLE_ADVDATA_NO_NAME; adv_data.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE; adv_data.uuids_complete.uuid_cnt = sizeof(adv_uuids) / sizeof(adv_uuids[0]); adv_data.uuids_complete.p_uuids = adv_uuids; adv_data.p_service_data_array = &service_data; // Pointer to Service Data structure. adv_data.service_data_count = 1; //DEBUG_PRINTF(0, "Slot [%d] - Service Data Size: %d \r\n", slot, service_data.data.size); err_code = ble_advdata_set(&adv_data, NULL); APP_ERROR_CHECK(err_code); // Initialize advertising parameters (used when starting advertising). memset(&m_non_conn_adv_params, 0, sizeof(m_non_conn_adv_params)); /*Non-connectable*/ m_non_conn_adv_params.type = BLE_GAP_ADV_TYPE_ADV_NONCONN_IND; m_non_conn_adv_params.p_peer_addr = NULL; // Undirected advertisement. m_non_conn_adv_params.fp = BLE_GAP_ADV_FP_ANY; m_non_conn_adv_params.interval = MSEC_TO_UNITS(m_intervals.adv_intrvl, UNIT_0_625_MS); m_non_conn_adv_params.timeout = APP_CFG_NON_CONN_ADV_TIMEOUT; }
/** * @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; /* 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); } /* デバイス名設定 */ { //デバイス名への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_ios_init_t ios_init; ios_init.evt_handler_in = svc_ios_handler_in; //ios_init.evt_handler_out = svc_ios_handler_out; ios_init.len_in = 64; ios_init.len_out = 32; ble_ios_init(&m_ios, &ios_init); } /* * Advertising初期化 */ { ble_uuid_t adv_uuids[] = { { IOS_UUID_SERVICE, m_ios.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}; /* APP_TIMER_PRESCALER = 0 */ cp_init.p_conn_params = NULL; cp_init.first_conn_params_update_delay = APP_TIMER_TICKS(CONN_FIRST_PARAMS_UPDATE_DELAY, 0); cp_init.next_conn_params_update_delay = APP_TIMER_TICKS(CONN_NEXT_PARAMS_UPDATE_DELAY, 0); 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 }
#include "nordic_common.h" #include "softdevice_handler.h" #include "ble_debug_assert_handler.h" #include "nrf_log.h" #include "led.h" #include "simple_ble.h" #include "simple_adv.h" // Intervals for advertising and connections static simple_ble_config_t ble_config = { .platform_id = 0x40, // used as 4th octect in device BLE address .device_id = DEVICE_ID_DEFAULT, .adv_name = "RTTTEST", // used in advertisements if there is room .adv_interval = MSEC_TO_UNITS(500, UNIT_0_625_MS), .min_conn_interval = MSEC_TO_UNITS(500, UNIT_1_25_MS), .max_conn_interval = MSEC_TO_UNITS(1000, UNIT_1_25_MS) }; int main (void) { uint32_t err_code; // Setup BLE simple_ble_init(&ble_config); // Advertise because why not simple_adv_only_name(); // RTT code
/**@brief Function for handling the Application's BLE Stack events. * * @param[in] p_ble_evt Bluetooth stack event. */ 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: // continue advertising nonconnectably app.conn_handle = p_ble_evt->evt.gap_evt.conn_handle; m_adv_params.type = BLE_GAP_ADV_TYPE_ADV_NONCONN_IND; advertising_start(); break; case BLE_GAP_EVT_DISCONNECTED: app.conn_handle = BLE_CONN_HANDLE_INVALID; // advertise connectivity advertising_stop(); m_adv_params.type = BLE_GAP_ADV_TYPE_ADV_IND; advertising_start(); break; case BLE_GATTS_EVT_WRITE: { ble_gatts_evt_write_t* write_data = &(p_ble_evt->evt.gatts_evt.params.write); if (write_data->context.char_uuid.uuid == test_char_uuid16) { if (write_data->data[0] == 0x42) { //led_on(BLEES_LED_PIN); // enable higher connection interval. Only lasts for this connection ble_gap_conn_params_t gap_conn_params; memset(&gap_conn_params, 0, sizeof(gap_conn_params)); gap_conn_params.min_conn_interval = 0x06; // 7.5 ms gap_conn_params.max_conn_interval = MSEC_TO_UNITS(30, UNIT_1_25_MS); gap_conn_params.slave_latency = 0; gap_conn_params.conn_sup_timeout = CONN_SUP_TIMEOUT; err_code = sd_ble_gap_conn_param_update(app.conn_handle, &gap_conn_params); APP_ERROR_CHECK(err_code); } } } break; case BLE_GAP_EVT_SEC_PARAMS_REQUEST: err_code = sd_ble_gap_sec_params_reply(app.conn_handle, BLE_GAP_SEC_STATUS_SUCCESS, &m_sec_params, NULL); APP_ERROR_CHECK(err_code); break; case BLE_GATTS_EVT_SYS_ATTR_MISSING: err_code = sd_ble_gatts_sys_attr_set(app.conn_handle, NULL, 0, 0); APP_ERROR_CHECK(err_code); break; case BLE_GAP_EVT_AUTH_STATUS: break; case BLE_GAP_EVT_SEC_INFO_REQUEST: // No keys found for this device. err_code = sd_ble_gap_sec_info_reply(app.conn_handle, NULL, NULL, NULL); APP_ERROR_CHECK(err_code); break; case BLE_GAP_EVT_TIMEOUT: if (p_ble_evt->evt.gap_evt.params.timeout.src == BLE_GAP_TIMEOUT_SRC_ADVERTISING) { err_code = sd_power_system_off(); APP_ERROR_CHECK(err_code); } break; default: break; } }
#include "ble.h" #include "ble_hci.h" #include "ble_advdata.h" #include "pstorage.h" #include "app_timer.h" #include "timeslot.h" } const uint16_t BLETransceiver::u16_appAdvInterval = 64; const uint8_t BLETransceiver::IS_SRVC_CHANGED_CHARACT_PRESENT = 0; const uint32_t BLETransceiver::FIRST_CONN_PARAMS_UPDATE_DELAY = APP_TIMER_TICKS(20000, APP_TIMER_PRESCALER); const uint32_t BLETransceiver::NEXT_CONN_PARAMS_UPDATE_DELAY = APP_TIMER_TICKS(5000, APP_TIMER_PRESCALER); const uint8_t BLETransceiver::MAX_CONN_PARAMS_UPDATE_COUNT = 3; const uint16_t BLETransceiver::u16_minConnInterval = MSEC_TO_UNITS(100, UNIT_1_25_MS); const uint16_t BLETransceiver::u16_maxConnInterval = MSEC_TO_UNITS(200, UNIT_1_25_MS); const uint16_t BLETransceiver::SLAVE_LATENCY = 0; const uint16_t BLETransceiver::CONN_SUP_TIMEOUT = MSEC_TO_UNITS(4000, UNIT_10_MS); const uint16_t BLETransceiver::SEC_PARAM_TIMEOUT = 30; const uint8_t BLETransceiver::SEC_PARAM_BOND = 1; const uint8_t BLETransceiver::SEC_PARAM_MITM = 0; const uint8_t BLETransceiver::SEC_PARAM_IO_CAPABILITIES = BLE_GAP_IO_CAPS_NONE; const uint8_t BLETransceiver::SEC_PARAM_OOB = 0; const uint8_t BLETransceiver::SEC_PARAM_MIN_KEY_SIZE = 7; const uint8_t BLETransceiver::SEC_PARAM_MAX_KEY_SIZE = 16; uint16_t BLETransceiver::u16_connHandle = BLE_CONN_HANDLE_INVALID; ble_nus_t BLETransceiver::nus; ble_gap_sec_params_t BLETransceiver::secParams;
.uuid128 = {{0x2e, 0x5d, 0x5e, 0x39, 0x31, 0x52, 0x45, 0x0c, 0x90, 0xee, 0x3f, 0xa2, 0x31, 0x52, 0x8c, 0xd6}} }; simple_ble_char_t char_range_handle = {.uuid16 = TRITAG_CHAR_LOCATION_SHORT_UUID}; simple_ble_char_t char_calibration_index_handle = {.uuid16 = TRITAG_CHAR_CALIBRATION_SHORT_UUID}; simple_ble_char_t char_ranging_enable_handle = {.uuid16 = TRITAG_CHAR_RANGING_ENABLE_SHORT_UUID}; simple_ble_char_t char_status_handle = {.uuid16 = TRITAG_CHAR_STATUS_SHORT_UUID}; // Intervals for advertising and connections static simple_ble_config_t ble_config = { // c0:98:e5:45:xx:xx .platform_id = 0x45, // used as 4th octect in device BLE address .device_id = DEVICE_ID_DEFAULT, .adv_name = DEVICE_NAME, // used in advertisements if there is room .adv_interval = MSEC_TO_UNITS(1000, UNIT_0_625_MS), // .min_conn_interval = MSEC_TO_UNITS(500, UNIT_1_25_MS), // .max_conn_interval = MSEC_TO_UNITS(1000, UNIT_1_25_MS), .min_conn_interval = MSEC_TO_UNITS(8, UNIT_1_25_MS), .max_conn_interval = MSEC_TO_UNITS(10, UNIT_1_25_MS), }; // Copy address from flash uint8_t _ble_address[6]; /******************************************************************************* * State for this application ******************************************************************************/ // Main application state simple_ble_app_t* simple_ble_app; static ble_app_t app;