/**@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);
}
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);
}
/**@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;
// 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;;
ble_enable_params.gap_enable_params.role = BLE_GAP_ROLE_PERIPH;
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 initializing the BLE stack.
*
* @details Initializes the SoftDevice and the BLE event interrupt.
*/
static void ble_stack_init(void)
{
uint32_t err_code;
// 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 = false;
ble_enable_params.gap_enable_params.role = BLE_GAP_ROLE_CENTRAL;
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);
}
//============================================================================//
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;
// Initialize the SoftDevice handler module.
SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, 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 System events.
err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch);
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);
}
uint32_t softdevice_enable(ble_enable_params_t * p_ble_enable_params)
{
#if (defined(S130) || defined(S132) || defined(S332))
uint32_t err_code;
uint32_t app_ram_base;
#if defined ( __CC_ARM )
extern uint32_t Image$$RW_IRAM1$$Base;
const volatile uint32_t ram_start = (uint32_t) &Image$$RW_IRAM1$$Base;
#elif defined ( __ICCARM__ )
extern uint32_t __ICFEDIT_region_RAM_start__;
volatile uint32_t ram_start = (uint32_t) &__ICFEDIT_region_RAM_start__;
#elif defined ( __GNUC__ )
extern uint32_t __data_start__;
volatile uint32_t ram_start = (uint32_t) &__data_start__;
#endif
app_ram_base = ram_start;
NRF_LOG_DEBUG("sd_ble_enable: RAM start at 0x%x\r\n",
app_ram_base);
err_code = sd_ble_enable(p_ble_enable_params, &app_ram_base);
if (app_ram_base != ram_start)
{
NRF_LOG_WARNING("sd_ble_enable: RAM start should be adjusted to 0x%x\r\n",
app_ram_base);
NRF_LOG_WARNING("RAM size should be adjusted to 0x%x \r\n",
ram_end_address_get() - app_ram_base);
}
else if (err_code != NRF_SUCCESS)
{
NRF_LOG_ERROR("sd_ble_enable: error 0x%x\r\n", err_code);
}
return err_code;
#else
return NRF_SUCCESS;
#endif //defined(S130) || defined(S132) || defined(S332)
}
/**@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);
}
}
/**@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);
}
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;
/* 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
}
uint32_t softdevice_handler_init(nrf_clock_lfclksrc_t clock_source,
void * p_evt_buffer,
uint16_t evt_buffer_size,
softdevice_evt_schedule_func_t evt_schedule_func)
{
uint32_t err_code;
// Save configuration.
#if defined (BLE_STACK_SUPPORT_REQD) || defined (ANT_STACK_SUPPORT_REQD)
// Check that buffer is not NULL.
if (p_evt_buffer == NULL)
{
return NRF_ERROR_INVALID_PARAM;
}
// Check that buffer is correctly aligned.
if (!is_word_aligned(p_evt_buffer))
{
return NRF_ERROR_INVALID_PARAM;
}
m_evt_buffer = (uint8_t *)p_evt_buffer;
#else
// The variable p_evt_buffer is not needed if neither BLE Stack nor ANT stack support is
// required.
UNUSED_PARAMETER(p_evt_buffer);
#endif
#if defined (BLE_STACK_SUPPORT_REQD)
m_ble_evt_buffer_size = evt_buffer_size;
#else
// The variable evt_buffer_size is not needed if BLE Stack support is NOT required.
UNUSED_PARAMETER(evt_buffer_size);
#endif
m_evt_schedule_func = evt_schedule_func;
// Initialize SoftDevice.
err_code = sd_softdevice_enable(clock_source, softdevice_assertion_handler);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
/**
* Using this call, the application can select whether to include the
* Service Changed characteristic in the GATT Server. The default in all
* previous releases has been to include the Service Changed characteristic,
* but this affects how GATT clients behave. Specifically, it requires
* clients to subscribe to this attribute and not to cache attribute handles
* between connections unless the devices are bonded. If the application
* does not need to change the structure of the GATT server attributes at
* runtime this adds unnecessary complexity to the interaction with peer
* clients. If the SoftDevice is enabled with the Service Changed
* Characteristics turned off, then clients are allowed to cache attribute
* handles making applications simpler on both sides.
*/
ble_enable_params_t enableParams = {
.gatts_enable_params = {
.service_changed = 0
}
};
if ((err_code = sd_ble_enable(&enableParams)) != NRF_SUCCESS) {
return err_code;
}
ble_gap_addr_t addr;
if ((err_code = sd_ble_gap_address_get(&addr)) != NRF_SUCCESS) {
return err_code;
}
if ((err_code = sd_ble_gap_address_set(BLE_GAP_ADDR_CYCLE_MODE_NONE, &addr)) != NRF_SUCCESS) {
return err_code;
}
m_softdevice_enabled = true;
// Enable BLE event interrupt (interrupt priority has already been set by the stack).
return sd_nvic_EnableIRQ(SWI2_IRQn);
}
void nRF51822::begin(unsigned char advertisementDataType,
unsigned char advertisementDataLength,
const unsigned char* advertisementData,
unsigned char scanDataType,
unsigned char scanDataLength,
const unsigned char* scanData,
BLELocalAttribute** localAttributes,
unsigned char numLocalAttributes,
BLERemoteAttribute** remoteAttributes,
unsigned char numRemoteAttributes)
{
#ifdef __RFduino__
sd_softdevice_enable(NRF_CLOCK_LFCLKSRC_SYNTH_250_PPM, NULL);
#else
sd_softdevice_enable(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, NULL); // sd_nvic_EnableIRQ(SWI2_IRQn);
#endif
#ifdef NRF51_S130
ble_enable_params_t enableParams = {
.gatts_enable_params = {
.service_changed = true
}
};
sd_ble_enable(&enableParams);
#endif
#ifdef NRF_51822_DEBUG
ble_version_t version;
sd_ble_version_get(&version);
Serial.print(F("version = "));
Serial.print(version.version_number);
Serial.print(F(" "));
Serial.print(version.company_id);
Serial.print(F(" "));
Serial.print(version.subversion_number);
Serial.println();
#endif
ble_gap_conn_params_t gap_conn_params;
gap_conn_params.min_conn_interval = 40; // in 1.25ms units
gap_conn_params.max_conn_interval = 80; // in 1.25ms unit
gap_conn_params.slave_latency = 0;
gap_conn_params.conn_sup_timeout = 4000 / 10; // in 10ms unit
sd_ble_gap_ppcp_set(&gap_conn_params);
sd_ble_gap_tx_power_set(0);
unsigned char srData[31];
unsigned char srDataLen = 0;
this->_advDataLen = 0;
// flags
this->_advData[this->_advDataLen + 0] = 2;
this->_advData[this->_advDataLen + 1] = 0x01;
this->_advData[this->_advDataLen + 2] = 0x06;
this->_advDataLen += 3;
if (advertisementDataType && advertisementDataLength && advertisementData) {
this->_advData[this->_advDataLen + 0] = advertisementDataLength + 1;
this->_advData[this->_advDataLen + 1] = advertisementDataType;
this->_advDataLen += 2;
memcpy(&this->_advData[this->_advDataLen], advertisementData, advertisementDataLength);
this->_advDataLen += advertisementDataLength;
}
if (scanDataType && scanDataLength && scanData) {
srData[0] = scanDataLength + 1;
srData[1] = scanDataType;
memcpy(&srData[2], scanData, scanDataLength);
srDataLen = 2 + scanDataLength;
}
sd_ble_gap_adv_data_set(this->_advData, this->_advDataLen, srData, srDataLen);
sd_ble_gap_appearance_set(0);
for (int i = 0; i < numLocalAttributes; i++) {
BLELocalAttribute *localAttribute = localAttributes[i];
if (localAttribute->type() == BLETypeCharacteristic) {
this->_numLocalCharacteristics++;
}
}
this->_numLocalCharacteristics -= 3; // 0x2a00, 0x2a01, 0x2a05
this->_localCharacteristicInfo = (struct localCharacteristicInfo*)malloc(sizeof(struct localCharacteristicInfo) * this->_numLocalCharacteristics);
unsigned char localCharacteristicIndex = 0;
uint16_t handle = 0;
BLEService *lastService = NULL;
for (int i = 0; i < numLocalAttributes; i++) {
BLELocalAttribute *localAttribute = localAttributes[i];
BLEUuid uuid = BLEUuid(localAttribute->uuid());
const unsigned char* uuidData = uuid.data();
unsigned char value[255];
ble_uuid_t nordicUUID;
if (uuid.length() == 2) {
nordicUUID.uuid = (uuidData[1] << 8) | uuidData[0];
nordicUUID.type = BLE_UUID_TYPE_BLE;
} else {
unsigned char uuidDataTemp[16];
memcpy(&uuidDataTemp, uuidData, sizeof(uuidDataTemp));
nordicUUID.uuid = (uuidData[13] << 8) | uuidData[12];
uuidDataTemp[13] = 0;
uuidDataTemp[12] = 0;
sd_ble_uuid_vs_add((ble_uuid128_t*)&uuidDataTemp, &nordicUUID.type);
}
if (localAttribute->type() == BLETypeService) {
BLEService *service = (BLEService *)localAttribute;
if (strcmp(service->uuid(), "1800") == 0 || strcmp(service->uuid(), "1801") == 0) {
continue; // skip
}
sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &nordicUUID, &handle);
lastService = service;
} else if (localAttribute->type() == BLETypeCharacteristic) {
BLECharacteristic *characteristic = (BLECharacteristic *)localAttribute;
if (strcmp(characteristic->uuid(), "2a00") == 0) {
ble_gap_conn_sec_mode_t secMode;
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&secMode); // no security is needed
sd_ble_gap_device_name_set(&secMode, characteristic->value(), characteristic->valueLength());
} else if (strcmp(characteristic->uuid(), "2a01") == 0) {
const uint16_t *appearance = (const uint16_t*)characteristic->value();
sd_ble_gap_appearance_set(*appearance);
} else if (strcmp(characteristic->uuid(), "2a05") == 0) {
// do nothing
} else {
uint8_t properties = characteristic->properties() & 0xfe;
uint16_t valueLength = characteristic->valueLength();
this->_localCharacteristicInfo[localCharacteristicIndex].characteristic = characteristic;
this->_localCharacteristicInfo[localCharacteristicIndex].notifySubscribed = false;
this->_localCharacteristicInfo[localCharacteristicIndex].indicateSubscribed = false;
this->_localCharacteristicInfo[localCharacteristicIndex].service = lastService;
ble_gatts_char_md_t characteristicMetaData;
ble_gatts_attr_md_t clientCharacteristicConfigurationMetaData;
ble_gatts_attr_t characteristicValueAttribute;
ble_gatts_attr_md_t characteristicValueAttributeMetaData;
memset(&characteristicMetaData, 0, sizeof(characteristicMetaData));
memcpy(&characteristicMetaData.char_props, &properties, 1);
characteristicMetaData.p_char_user_desc = NULL;
characteristicMetaData.p_char_pf = NULL;
characteristicMetaData.p_user_desc_md = NULL;
characteristicMetaData.p_cccd_md = NULL;
characteristicMetaData.p_sccd_md = NULL;
if (properties & (BLENotify | BLEIndicate)) {
memset(&clientCharacteristicConfigurationMetaData, 0, sizeof(clientCharacteristicConfigurationMetaData));
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&clientCharacteristicConfigurationMetaData.read_perm);
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&clientCharacteristicConfigurationMetaData.write_perm);
clientCharacteristicConfigurationMetaData.vloc = BLE_GATTS_VLOC_STACK;
characteristicMetaData.p_cccd_md = &clientCharacteristicConfigurationMetaData;
}
memset(&characteristicValueAttributeMetaData, 0, sizeof(characteristicValueAttributeMetaData));
if (properties & (BLERead | BLENotify | BLEIndicate)) {
if (this->_bondStore) {
BLE_GAP_CONN_SEC_MODE_SET_ENC_NO_MITM(&characteristicValueAttributeMetaData.read_perm);
} else {
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&characteristicValueAttributeMetaData.read_perm);
}
}
if (properties & (BLEWriteWithoutResponse | BLEWrite)) {
if (this->_bondStore) {
BLE_GAP_CONN_SEC_MODE_SET_ENC_NO_MITM(&characteristicValueAttributeMetaData.write_perm);
} else {
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&characteristicValueAttributeMetaData.write_perm);
}
}
characteristicValueAttributeMetaData.vloc = BLE_GATTS_VLOC_STACK;
characteristicValueAttributeMetaData.rd_auth = 0;
characteristicValueAttributeMetaData.wr_auth = 0;
characteristicValueAttributeMetaData.vlen = !characteristic->fixedLength();
for (int j = (i + 1); j < numLocalAttributes; j++) {
localAttribute = localAttributes[j];
if (localAttribute->type() != BLETypeDescriptor) {
break;
}
BLEDescriptor *descriptor = (BLEDescriptor *)localAttribute;
if (strcmp(descriptor->uuid(), "2901") == 0) {
characteristicMetaData.p_char_user_desc = (uint8_t*)descriptor->value();
characteristicMetaData.char_user_desc_max_size = descriptor->valueLength();
characteristicMetaData.char_user_desc_size = descriptor->valueLength();
} else if (strcmp(descriptor->uuid(), "2904") == 0) {
characteristicMetaData.p_char_pf = (ble_gatts_char_pf_t *)descriptor->value();
}
}
memset(&characteristicValueAttribute, 0, sizeof(characteristicValueAttribute));
characteristicValueAttribute.p_uuid = &nordicUUID;
characteristicValueAttribute.p_attr_md = &characteristicValueAttributeMetaData;
characteristicValueAttribute.init_len = valueLength;
characteristicValueAttribute.init_offs = 0;
characteristicValueAttribute.max_len = characteristic->valueSize();
characteristicValueAttribute.p_value = NULL;
sd_ble_gatts_characteristic_add(BLE_GATT_HANDLE_INVALID, &characteristicMetaData, &characteristicValueAttribute, &this->_localCharacteristicInfo[localCharacteristicIndex].handles);
if (valueLength) {
for (int j = 0; j < valueLength; j++) {
value[j] = (*characteristic)[j];
}
sd_ble_gatts_value_set(this->_localCharacteristicInfo[localCharacteristicIndex].handles.value_handle, 0, &valueLength, value);
}
localCharacteristicIndex++;
}
} else if (localAttribute->type() == BLETypeDescriptor) {
BLEDescriptor *descriptor = (BLEDescriptor *)localAttribute;
if (strcmp(descriptor->uuid(), "2901") == 0 ||
strcmp(descriptor->uuid(), "2902") == 0 ||
strcmp(descriptor->uuid(), "2903") == 0 ||
strcmp(descriptor->uuid(), "2904") == 0) {
continue; // skip
}
uint16_t valueLength = descriptor->valueLength();
ble_gatts_attr_t descriptorAttribute;
ble_gatts_attr_md_t descriptorMetaData;
memset(&descriptorAttribute, 0, sizeof(descriptorAttribute));
memset(&descriptorMetaData, 0, sizeof(descriptorMetaData));
descriptorMetaData.vloc = BLE_GATTS_VLOC_STACK;
descriptorMetaData.vlen = (valueLength == descriptor->valueLength()) ? 0 : 1;
if (this->_bondStore) {
BLE_GAP_CONN_SEC_MODE_SET_ENC_NO_MITM(&descriptorMetaData.read_perm);
} else {
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&descriptorMetaData.read_perm);
}
descriptorAttribute.p_uuid = &nordicUUID;
descriptorAttribute.p_attr_md = &descriptorMetaData;
descriptorAttribute.init_len = valueLength;
descriptorAttribute.max_len = descriptor->valueLength();
descriptorAttribute.p_value = NULL;
sd_ble_gatts_descriptor_add(BLE_GATT_HANDLE_INVALID, &descriptorAttribute, &handle);
if (valueLength) {
for (int j = 0; j < valueLength; j++) {
value[j] = (*descriptor)[j];
}
sd_ble_gatts_value_set(handle, 0, &valueLength, value);
}
}
}
if ( numRemoteAttributes > 0) {
numRemoteAttributes -= 2; // 0x1801, 0x2a05
}
for (int i = 0; i < numRemoteAttributes; i++) {
BLERemoteAttribute *remoteAttribute = remoteAttributes[i];
if (remoteAttribute->type() == BLETypeService) {
this->_numRemoteServices++;
} else if (remoteAttribute->type() == BLETypeCharacteristic) {
this->_numRemoteCharacteristics++;
}
}
this->_remoteServiceInfo = (struct remoteServiceInfo*)malloc(sizeof(struct remoteServiceInfo) * this->_numRemoteServices);
this->_remoteCharacteristicInfo = (struct remoteCharacteristicInfo*)malloc(sizeof(struct remoteCharacteristicInfo) * this->_numRemoteCharacteristics);
BLERemoteService *lastRemoteService = NULL;
unsigned char remoteServiceIndex = 0;
unsigned char remoteCharacteristicIndex = 0;
for (int i = 0; i < numRemoteAttributes; i++) {
BLERemoteAttribute *remoteAttribute = remoteAttributes[i];
BLEUuid uuid = BLEUuid(remoteAttribute->uuid());
const unsigned char* uuidData = uuid.data();
ble_uuid_t nordicUUID;
if (uuid.length() == 2) {
nordicUUID.uuid = (uuidData[1] << 8) | uuidData[0];
nordicUUID.type = BLE_UUID_TYPE_BLE;
} else {
unsigned char uuidDataTemp[16];
memcpy(&uuidDataTemp, uuidData, sizeof(uuidDataTemp));
nordicUUID.uuid = (uuidData[13] << 8) | uuidData[12];
uuidDataTemp[13] = 0;
uuidDataTemp[12] = 0;
sd_ble_uuid_vs_add((ble_uuid128_t*)&uuidDataTemp, &nordicUUID.type);
}
if (remoteAttribute->type() == BLETypeService) {
this->_remoteServiceInfo[remoteServiceIndex].service = lastRemoteService = (BLERemoteService *)remoteAttribute;
this->_remoteServiceInfo[remoteServiceIndex].uuid = nordicUUID;
memset(&this->_remoteServiceInfo[remoteServiceIndex].handlesRange, 0, sizeof(this->_remoteServiceInfo[remoteServiceIndex].handlesRange));
remoteServiceIndex++;
} else if (remoteAttribute->type() == BLETypeCharacteristic) {
this->_remoteCharacteristicInfo[remoteCharacteristicIndex].characteristic = (BLERemoteCharacteristic *)remoteAttribute;
this->_remoteCharacteristicInfo[remoteCharacteristicIndex].service = lastRemoteService;
this->_remoteCharacteristicInfo[remoteCharacteristicIndex].uuid = nordicUUID;
memset(&this->_remoteCharacteristicInfo[remoteCharacteristicIndex].properties, 0, sizeof(this->_remoteCharacteristicInfo[remoteCharacteristicIndex].properties));
this->_remoteCharacteristicInfo[remoteCharacteristicIndex].valueHandle = 0;
remoteCharacteristicIndex++;
}
}
if (this->_bondStore && this->_bondStore->hasData()) {
#ifdef NRF_51822_DEBUG
Serial.println(F("Restoring bond data"));
#endif
#ifdef NRF51_S130
this->_bondStore->getData(this->_bondData, 0, sizeof(this->_bondData));
#else
this->_bondStore->getData(this->_authStatusBuffer, 0, sizeof(this->_authStatusBuffer));
#endif
}
this->startAdvertising();
#ifdef __RFduino__
RFduinoBLE_enabled = 1;
#endif
}
/** @brief main function */
int main(void)
{
uart_init();
PUTS("LED Mesh initializing");
/* Enable Softdevice (including sd_ble before framework */
uint32_t error_code =
sd_softdevice_enable(NRF_CLOCK_LFCLKSRC_XTAL_75_PPM, sd_assert_handler);
APP_ERROR_CHECK(error_code);
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;
ble_enable_params.gatts_enable_params.attr_tab_size = BLE_GATTS_ATTR_TAB_SIZE_DEFAULT;
error_code = sd_ble_enable(&ble_enable_params);
APP_ERROR_CHECK(error_code);
/* init leds and pins */
gpio_init();
#ifdef RBC_MESH_SERIAL
/* only want to enable serial interface, and let external host setup the framework */
mesh_aci_init();
#else
/* Enable mesh framework on channel 37, min adv interval at 100ms,
2 characteristics */
rbc_mesh_init_params_t init_params;
init_params.access_addr = 0xA541A68F;
init_params.adv_int_ms = 100;
init_params.channel = 38;
init_params.handle_count = 2;
init_params.packet_format = RBC_MESH_PACKET_FORMAT_ORIGINAL;
init_params.radio_mode = RBC_MESH_RADIO_MODE_BLE_1MBIT;
error_code = rbc_mesh_init(init_params);
APP_ERROR_CHECK(error_code);
/* request values for both LEDs on the mesh */
error_code = rbc_mesh_value_enable(1);
APP_ERROR_CHECK(error_code);
error_code = rbc_mesh_value_enable(2);
APP_ERROR_CHECK(error_code);
/* init BLE gateway softdevice application: */
nrf_adv_conn_init();
#endif
/* enable softdevice IRQ */
error_code = sd_nvic_EnableIRQ(SD_EVT_IRQn);
#ifndef BUTTONS
/* sleep */
while (true)
{
sd_app_evt_wait();
}
#else
uint8_t mesh_data[16] = {0,0};
while (true)
{
// red off
if(nrf_gpio_pin_read(BUTTON_1) == 0)
{
PUTS("BUTTON_1 pressed");
while(nrf_gpio_pin_read(BUTTON_1) == 0);
mesh_data[0] = 0;
rbc_mesh_value_set(1, mesh_data, 1);
}
// red on
if(nrf_gpio_pin_read(BUTTON_2) == 0)
{
PUTS("BUTTON_1 pressed");
while(nrf_gpio_pin_read(BUTTON_2) == 0);
mesh_data[0] = 1;
rbc_mesh_value_set(1, mesh_data, 1);
}
// green off
if(nrf_gpio_pin_read(BUTTON_3) == 0)
{
PUTS("BUTTON_3 pressed");
while(nrf_gpio_pin_read(BUTTON_3) == 0);
mesh_data[0] = 0;
rbc_mesh_value_set(2, mesh_data, 1);
}
// green on
if(nrf_gpio_pin_read(BUTTON_4) == 0)
{
PUTS("BUTTON_4 pressed");
while(nrf_gpio_pin_read(BUTTON_4) == 0);
mesh_data[0] = 1;
rbc_mesh_value_set(2, mesh_data, 1);
}
}
#endif
}
uint32_t mesh_srv_init(uint8_t mesh_value_count,
uint32_t access_address, uint8_t channel, uint32_t adv_int_ms)
{
if (mesh_value_count > MAX_VALUE_COUNT)
{
return NRF_ERROR_INVALID_PARAM;
}
if (is_initialized)
{
return NRF_ERROR_INVALID_STATE;
}
is_initialized = true;
ble_enable_params_t ble_enable_params;
ble_enable_params.gatts_enable_params.service_changed = 0;
sd_ble_enable(&ble_enable_params);
g_mesh_service.value_count = mesh_value_count;
ble_uuid_t ble_srv_uuid;
/* add the mesh base UUID */
uint32_t error_code = sd_ble_uuid_vs_add(&mesh_base_uuid, &mesh_base_uuid_type);
if (error_code != NRF_SUCCESS)
{
return NRF_ERROR_INTERNAL;
}
ble_srv_uuid.type = mesh_base_uuid_type;
ble_srv_uuid.uuid = MESH_SRV_UUID;
error_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY,
&ble_srv_uuid, &g_mesh_service.service_handle);
if (error_code != NRF_SUCCESS)
{
return NRF_ERROR_INTERNAL;
}
/* Add metadata characteristic */
mesh_metadata_char_t mesh_metadata;
mesh_metadata.mesh_access_addr = access_address;
mesh_metadata.mesh_adv_int_ms = adv_int_ms;
mesh_metadata.mesh_channel = channel;
mesh_metadata.mesh_value_count = mesh_value_count;
mesh_md_char_add(&mesh_metadata);
uint32_t md_len = sizeof(mesh_char_metadata_t) * g_mesh_service.value_count;
/* allocate metadata array */
g_mesh_service.char_metadata = (mesh_char_metadata_t*) malloc(md_len);
memset(g_mesh_service.char_metadata, 0, md_len);
/* add characteristics to mesh service */
for (uint8_t i = 0; i < g_mesh_service.value_count; ++i)
{
error_code = mesh_value_char_add(i);
if (error_code != NRF_SUCCESS)
{
return error_code;
}
}
trickle_setup(1000 * adv_int_ms, 600, 3);
return NRF_SUCCESS;
}
void
simble_adv_start(void)
{
struct ble_gap_advdata advdata = { .length = 0 };
struct ble_gap_ad_flags flags = {
.payload_length = 1,
.type = BLE_GAP_AD_TYPE_FLAGS,
.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE,
};
simble_add_advdata(&flags, &advdata);
struct ble_gap_ad_name name;
uint16_t namelen = sizeof(advdata);
if (sd_ble_gap_device_name_get(name.name, &namelen) != NRF_SUCCESS)
namelen = 0;
name.type = BLE_GAP_AD_TYPE_COMPLETE_LOCAL_NAME;
name.payload_length = namelen;
simble_add_advdata(&name, &advdata);
sd_ble_gap_adv_data_set(advdata.data, advdata.length, NULL, 0);
ble_gap_adv_params_t adv_params = {
.type = BLE_GAP_ADV_TYPE_ADV_IND,
.fp = BLE_GAP_ADV_FP_ANY,
.interval = 0x400,
};
sd_ble_gap_adv_start(&adv_params);
onboard_led(ONBOARD_LED_ON);
}
static void
simble_srv_tx_init(void)
{
uint16_t srv_handle;
ble_uuid_t srv_uuid = {.type = BLE_UUID_TYPE_BLE, .uuid = 0x1804};
sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY,
&srv_uuid,
&srv_handle);
ble_gatts_char_handles_t chr_handles;
ble_gatts_char_md_t char_meta = {.char_props = {.read = 1}};
ble_uuid_t chr_uuid = {.type = BLE_UUID_TYPE_BLE, .uuid = 0x2a07};
ble_gatts_attr_md_t chr_attr_meta = {
.vloc = BLE_GATTS_VLOC_STACK,
};
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&chr_attr_meta.read_perm);
BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&chr_attr_meta.write_perm);
uint8_t tx_val = 0;
ble_gatts_attr_t chr_attr = {
.p_uuid = &chr_uuid,
.p_attr_md = &chr_attr_meta,
.init_offs = 0,
.init_len = sizeof(tx_val),
.max_len = sizeof(tx_val),
.p_value = &tx_val,
};
sd_ble_gatts_characteristic_add(srv_handle,
&char_meta,
&chr_attr,
&chr_handles);
}
/* DM requires a `app_error_handler` */
void __attribute__((weak))
app_error_handler(uint32_t error_code, uint32_t line_num, const uint8_t * p_file_name)
{
app_trace_log("[simble]: err: %d, line: %d, file: %s\r\n", error_code, line_num, p_file_name);
for (;;) {
/* NOTHING */
}
}
void
simble_init(const char *name)
{
app_trace_init();
sd_softdevice_enable(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, NULL); /* XXX assertion handler */
ble_enable_params_t ble_params = {
#if defined(SD120)
.gap_enable_params = {
.role = BLE_GAP_ROLE_PERIPH,
},
#endif
.gatts_enable_params = {
.service_changed = 1,
},
};
sd_ble_enable(&ble_params);
ble_gap_conn_sec_mode_t mode;
BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&mode);
sd_ble_gap_device_name_set(&mode, (const uint8_t *)name, strlen(name));
// flash storage
pstorage_init();
simble_srv_tx_init();
}
uint8_t
simble_get_vendor_uuid_class(void)
{
ble_uuid128_t vendorid = {{0x13,0xb0,0xa0,0x71,0xfe,0x62,0x4c,0x01,0xaa,0x4d,0xd8,0x03,0,0,0x0b,0xd0}};
static uint8_t vendor_type = BLE_UUID_TYPE_UNKNOWN;
if (vendor_type != BLE_UUID_TYPE_UNKNOWN)
return (vendor_type);
sd_ble_uuid_vs_add(&vendorid, &vendor_type);
return (vendor_type);
}
void
simble_srv_register(struct service_desc *s)
{
s->next = services;
services = s;
sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY,
&s->uuid,
&s->handle);
for (int i = 0; i < s->char_count; ++i) {
struct char_desc *c = &s->chars[i];
ble_gatts_attr_md_t cccd_md;
memset(&cccd_md, 0, sizeof(cccd_md));
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cccd_md.read_perm);
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cccd_md.write_perm);
cccd_md.vloc = BLE_GATTS_VLOC_STACK;
int have_write = c->write_cb != NULL;
ble_gatts_char_md_t char_meta = {
.char_props = {
.broadcast = 0,
.read = 1,
.write_wo_resp = have_write,
.write = have_write,
.notify = c->notify,
.indicate = c->indicate,
.auth_signed_wr = have_write,
},
.p_char_user_desc = (uint8_t *)c->desc,
.char_user_desc_size = strlen(c->desc),
.char_user_desc_max_size = strlen(c->desc),
.p_char_pf = c->format.format != 0 ? &c->format : NULL,
.p_cccd_md = (c->notify || c->indicate) ? &cccd_md : NULL,
};
ble_gatts_attr_md_t chr_attr_meta = {
.vlen = 1,
.vloc = BLE_GATTS_VLOC_STACK,
.rd_auth = 1,
.wr_auth = 1,
};
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&chr_attr_meta.read_perm);
if (have_write)
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&chr_attr_meta.write_perm);
else
BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&chr_attr_meta.write_perm);
ble_gatts_attr_t chr_attr = {
.p_uuid = &c->uuid,
.p_attr_md = &chr_attr_meta,
.init_offs = 0,
.init_len = 0,
.max_len = c->length,
};
sd_ble_gatts_characteristic_add(s->handle,
&char_meta,
&chr_attr,
&c->handles);
}
}
void
simble_srv_init(struct service_desc *s, uint8_t type, uint16_t id)
{
*s = (struct service_desc){
.uuid = {.type = type,
.uuid = id},
.char_count = 0,
};
};
void
simble_srv_char_add(struct service_desc *s, struct char_desc *c, uint8_t type, uint16_t id, const char *desc, uint16_t length)
{
*c = (struct char_desc){
.uuid = {
.type = type,
.uuid = id
},
.desc = desc,
.length = length,
};
