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;
