uint32_t ble_ans_c_init(ble_ans_c_t * p_ans, const ble_ans_c_init_t * p_ans_init)
{
VERIFY_PARAM_NOT_NULL(p_ans);
VERIFY_PARAM_NOT_NULL(p_ans_init);
VERIFY_PARAM_NOT_NULL(p_ans_init->evt_handler);
// clear all handles
memset(p_ans, 0, sizeof(ble_ans_c_t));
memset(m_tx_buffer, 0, TX_BUFFER_SIZE);
p_ans->conn_handle = BLE_CONN_HANDLE_INVALID;
p_ans->evt_handler = p_ans_init->evt_handler;
p_ans->error_handler = p_ans_init->error_handler;
p_ans->message_buffer_size = p_ans_init->message_buffer_size;
p_ans->p_message_buffer = p_ans_init->p_message_buffer;
BLE_UUID_BLE_ASSIGN(p_ans->service.service.uuid, BLE_UUID_ALERT_NOTIFICATION_SERVICE);
BLE_UUID_BLE_ASSIGN(p_ans->service.new_alert.uuid, BLE_UUID_NEW_ALERT_CHAR);
BLE_UUID_BLE_ASSIGN(p_ans->service.alert_notif_ctrl_point.uuid,
BLE_UUID_ALERT_NOTIFICATION_CONTROL_POINT_CHAR);
BLE_UUID_BLE_ASSIGN(p_ans->service.unread_alert_status.uuid, BLE_UUID_UNREAD_ALERT_CHAR);
BLE_UUID_BLE_ASSIGN(p_ans->service.suported_new_alert_cat.uuid,
BLE_UUID_SUPPORTED_NEW_ALERT_CATEGORY_CHAR);
BLE_UUID_BLE_ASSIGN(p_ans->service.suported_unread_alert_cat.uuid,
BLE_UUID_SUPPORTED_UNREAD_ALERT_CATEGORY_CHAR);
BLE_UUID_BLE_ASSIGN(p_ans->service.new_alert_cccd.uuid, BLE_UUID_DESCRIPTOR_CLIENT_CHAR_CONFIG);
BLE_UUID_BLE_ASSIGN(p_ans->service.unread_alert_cccd.uuid,
BLE_UUID_DESCRIPTOR_CLIENT_CHAR_CONFIG);
return ble_db_discovery_evt_register(&p_ans->service.service.uuid);
}
uint32_t ble_qodome_init(void)
{
uint32_t err_code;
ble_uuid_t ble_uuid;
// Initialize service structure
ble_qodome_t * p_qodome = &m_qodome;
p_qodome->conn_handle = BLE_CONN_HANDLE_INVALID;
// Add service
BLE_UUID_BLE_ASSIGN(ble_uuid, QODOME_PUBLIC_SERVICE);
err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_uuid, &p_qodome->service_handle);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
// Add memory dump characteristic
err_code = hts_qodome_char_add(p_qodome);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
return NRF_SUCCESS;
}
uint32_t ble_bps_init(ble_bps_t * p_bps, const ble_bps_init_t * p_bps_init)
{
uint32_t err_code;
ble_uuid_t ble_uuid;
// Initialize service structure
p_bps->evt_handler = p_bps_init->evt_handler;
p_bps->conn_handle = BLE_CONN_HANDLE_INVALID;
p_bps->feature = p_bps_init->feature;
// Add service
BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_BLOOD_PRESSURE_SERVICE);
err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_uuid, &p_bps->service_handle);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
// Add measurement characteristic
err_code = bps_measurement_char_add(p_bps, p_bps_init);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
// Add feature characteristic
err_code = bps_feature_char_add(p_bps, p_bps_init);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
return NRF_SUCCESS;
}
uint32_t ble_bas_init(ble_bas_t * p_bas, const ble_bas_init_t * p_bas_init)
{
if (p_bas == NULL || p_bas_init == NULL)
{
return NRF_ERROR_NULL;
}
uint32_t err_code;
ble_uuid_t ble_uuid;
// Initialize service structure
p_bas->evt_handler = p_bas_init->evt_handler;
p_bas->conn_handle = BLE_CONN_HANDLE_INVALID;
p_bas->is_notification_supported = p_bas_init->support_notification;
p_bas->battery_level_last = INVALID_BATTERY_LEVEL;
// Add service
BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_BATTERY_SERVICE);
err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_uuid, &p_bas->service_handle);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
// Add battery level characteristic
return battery_level_char_add(p_bas, p_bas_init);
}
uint32_t ble_ias_init(ble_ias_t * p_ias, const ble_ias_init_t * p_ias_init)
{
uint32_t err_code;
ble_uuid_t ble_uuid;
// Initialize service structure
if (p_ias_init->evt_handler == NULL)
{
return NRF_ERROR_INVALID_PARAM;
}
p_ias->evt_handler = p_ias_init->evt_handler;
// Add service
BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_IMMEDIATE_ALERT_SERVICE);
err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY,
&ble_uuid,
&p_ias->service_handle);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
// Add alert level characteristic
return alert_level_char_add(p_ias);
}
uint32_t ble_cscs_init(ble_cscs_t * p_cscs, const ble_cscs_init_t * p_cscs_init)
{
uint32_t err_code;
ble_uuid_t ble_uuid;
ble_cs_ctrlpt_init_t sc_ctrlpt_init;
// Initialize service structure
p_cscs->evt_handler = p_cscs_init->evt_handler;
p_cscs->conn_handle = BLE_CONN_HANDLE_INVALID;
p_cscs->feature = p_cscs_init->feature;
// Add service
BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_CYCLING_SPEED_AND_CADENCE);
err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY,
&ble_uuid,
&p_cscs->service_handle);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
// Add cycling speed and cadence measurement characteristic
err_code = csc_measurement_char_add(p_cscs, p_cscs_init);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
// Add cycling speed and cadence feature characteristic
err_code = csc_feature_char_add(p_cscs, p_cscs_init);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
// Add Sensor Location characteristic (optional)
if (p_cscs_init->sensor_location != NULL)
{
err_code = csc_sensor_loc_char_add(p_cscs, p_cscs_init);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
}
//Add speed and cadence control point characteristic
sc_ctrlpt_init.error_handler = p_cscs_init->error_handler;
sc_ctrlpt_init.size_list_supported_locations = p_cscs_init->size_list_supported_locations;
sc_ctrlpt_init.supported_functions = p_cscs_init->ctrplt_supported_functions;
sc_ctrlpt_init.evt_handler = p_cscs_init->ctrlpt_evt_handler;
sc_ctrlpt_init.list_supported_locations = p_cscs_init->list_supported_locations;
sc_ctrlpt_init.sc_ctrlpt_attr_md = p_cscs_init->csc_ctrlpt_attr_md;
sc_ctrlpt_init.sensor_location_handle = p_cscs->sensor_loc_handles.value_handle;
sc_ctrlpt_init.service_handle = p_cscs->service_handle;
return ble_sc_ctrlpt_init(&p_cscs->ctrl_pt, &sc_ctrlpt_init);
}
static uint32_t indication_char_add(uint16_t uuid,
uint8_t *p_char_value,
uint16_t char_len,
const ble_srv_cccd_security_mode_t* idc_char_attr_md,
ble_gatts_char_handles_t* p_handles)
{
ble_gatts_char_md_t char_md;
ble_gatts_attr_md_t cccd_md;
ble_gatts_attr_md_t attr_md;
ble_gatts_attr_t attr_char_value;
ble_uuid_t ble_uuid;
APP_ERROR_CHECK_BOOL(p_char_value != NULL);
APP_ERROR_CHECK_BOOL(char_len > 0);
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;
cccd_md.write_perm = idc_char_attr_md->cccd_write_perm;
memset(&char_md, 0, sizeof(char_md));
char_md.char_props.indicate = 1;
char_md.p_char_user_desc = NULL;
char_md.p_char_pf = NULL;
char_md.p_user_desc_md = NULL;
char_md.p_cccd_md = &cccd_md;
char_md.p_sccd_md = NULL;
BLE_UUID_BLE_ASSIGN(ble_uuid, uuid);
memset(&attr_md, 0, sizeof(attr_md));
attr_md.vloc = BLE_GATTS_VLOC_STACK;
attr_md.read_perm = idc_char_attr_md->read_perm;
attr_md.write_perm = idc_char_attr_md->write_perm;
attr_md.rd_auth = 0;
attr_md.wr_auth = 0;
attr_md.vlen = 1;
memset(&attr_char_value, 0, sizeof(attr_char_value));
attr_char_value.p_uuid = &ble_uuid;
attr_char_value.p_attr_md = &attr_md;
attr_char_value.init_len = char_len;
attr_char_value.init_offs = 0;
attr_char_value.max_len = char_len;
attr_char_value.p_value = p_char_value;
return sd_ble_gatts_characteristic_add(service_handle, \
&char_md, \
&attr_char_value, \
p_handles);
}
/**@brief Function for adding Input Report characteristics.
*
* @param[in] p_hids HID Service structure.
* @param[in] uuid UUID of report characteristic to be added.
* @param[in] max_data_len Maximum length of report value.
* @param[in] p_sec_mode Characteristic security settings.
* @param[out] p_char_handles Handles of new characteristic.
*
* @return NRF_SUCCESS on success, otherwise an error code.
*/
static uint32_t boot_inp_rep_char_add(ble_hids_t * p_hids,
uint16_t uuid,
uint16_t max_data_len,
const ble_srv_cccd_security_mode_t * p_sec_mode,
ble_gatts_char_handles_t * p_char_handles)
{
ble_gatts_char_md_t char_md;
ble_gatts_attr_md_t cccd_md;
ble_gatts_attr_t attr_char_value;
ble_uuid_t ble_uuid;
ble_gatts_attr_md_t attr_md;
memset(&cccd_md, 0, sizeof(cccd_md));
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cccd_md.read_perm);
cccd_md.write_perm = p_sec_mode->cccd_write_perm;
cccd_md.vloc = BLE_GATTS_VLOC_STACK;
memset(&char_md, 0, sizeof(char_md));
char_md.char_props.read = 1;
char_md.char_props.write = (p_sec_mode->write_perm.sm) ? 1 : 0;
char_md.char_props.notify = 1;
char_md.p_char_user_desc = NULL;
char_md.p_char_pf = NULL;
char_md.p_user_desc_md = NULL;
char_md.p_cccd_md = &cccd_md;
char_md.p_sccd_md = NULL;
BLE_UUID_BLE_ASSIGN(ble_uuid, uuid);
memset(&attr_md, 0, sizeof(attr_md));
attr_md.read_perm = p_sec_mode->read_perm;
attr_md.write_perm = p_sec_mode->write_perm;
attr_md.vloc = BLE_GATTS_VLOC_STACK;
attr_md.rd_auth = 0;
attr_md.wr_auth = 0;
attr_md.vlen = 0;
memset(&attr_char_value, 0, sizeof(attr_char_value));
attr_char_value.p_uuid = &ble_uuid;
attr_char_value.p_attr_md = &attr_md;
attr_char_value.init_len = 0;
attr_char_value.init_offs = 0;
attr_char_value.max_len = max_data_len;
attr_char_value.p_value = NULL;
return sd_ble_gatts_characteristic_add(p_hids->service_handle,
&char_md,
&attr_char_value,
p_char_handles);
}
/**@brief Function for handling the Connect event.
*
* @param[in] p_ias_c Immediate Alert Service client structure.
* @param[in] p_ble_evt Event received from the BLE stack.
*/
static uint32_t on_connect(ble_ias_c_t * p_ias_c, ble_evt_t const * p_ble_evt)
{
ble_uuid_t ias_uuid;
p_ias_c->conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
// Discover Immediate alert service
BLE_UUID_BLE_ASSIGN(ias_uuid, BLE_UUID_IMMEDIATE_ALERT_SERVICE);
return sd_ble_gattc_primary_services_discover(p_ias_c->conn_handle, START_HANDLE, &ias_uuid);
}
/**@brief Function for adding the Heart Rate Measurement characteristic.
*
* @param[in] p_hrs Heart Rate Service structure.
* @param[in] p_hrs_init Information needed to initialize the service.
*
* @return NRF_SUCCESS on success, otherwise an error code.
*/
static uint32_t heart_rate_measurement_char_add(ble_hrs_t * p_hrs,
const ble_hrs_init_t * p_hrs_init)
{
simple_uart_putstring("add heart rate measurement");
ble_gatts_char_md_t char_md;
ble_gatts_attr_md_t cccd_md;
ble_gatts_attr_t attr_char_value;
ble_uuid_t ble_uuid;
ble_gatts_attr_md_t attr_md;
uint8_t encoded_initial_hrm[MAX_HRM_LEN];
memset(&cccd_md, 0, sizeof(cccd_md));
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cccd_md.read_perm);
cccd_md.write_perm = p_hrs_init->hrs_hrm_attr_md.cccd_write_perm;
cccd_md.vloc = BLE_GATTS_VLOC_STACK;
memset(&char_md, 0, sizeof(char_md));
char_md.char_props.notify = 1;
char_md.p_char_user_desc = NULL;
char_md.p_char_pf = NULL;
char_md.p_user_desc_md = NULL;
char_md.p_cccd_md = &cccd_md;
char_md.p_sccd_md = NULL;
BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_HEART_RATE_MEASUREMENT_CHAR);
memset(&attr_md, 0, sizeof(attr_md));
attr_md.read_perm = p_hrs_init->hrs_hrm_attr_md.read_perm;
attr_md.write_perm = p_hrs_init->hrs_hrm_attr_md.write_perm;
attr_md.vloc = BLE_GATTS_VLOC_STACK;
attr_md.rd_auth = 0;
attr_md.wr_auth = 0;
attr_md.vlen = 1;
memset(&attr_char_value, 0, sizeof(attr_char_value));
attr_char_value.p_uuid = &ble_uuid;
attr_char_value.p_attr_md = &attr_md;
attr_char_value.init_len = hrm_encode(p_hrs, INITIAL_VALUE_HRM, encoded_initial_hrm);
attr_char_value.init_offs = 0;
attr_char_value.max_len = MAX_HRM_LEN;
attr_char_value.p_value = encoded_initial_hrm;
return sd_ble_gatts_characteristic_add(p_hrs->service_handle,
&char_md,
&attr_char_value,
&p_hrs->hrm_handles);
}
/**@brief Add Health Thermometer Measurement characteristic.
*
* @param[in] p_hts Health Thermometer Service structure.
* @param[in] p_hts_init Information needed to initialize the service.
*
* @return NRF_SUCCESS on success, otherwise an error code.
*/
static uint32_t hts_measurement_char_add(ble_hts_t * p_hts, const ble_hts_init_t * p_hts_init)
{
ble_gatts_char_md_t char_md;
ble_gatts_attr_md_t cccd_md;
ble_gatts_attr_t attr_char_value;
ble_uuid_t ble_uuid;
ble_gatts_attr_md_t attr_md;
ble_hts_meas_t initial_htm;
uint8_t encoded_htm[MAX_HTM_LEN];
memset(&cccd_md, 0, sizeof(cccd_md));
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cccd_md.read_perm);
cccd_md.vloc = BLE_GATTS_VLOC_STACK;
cccd_md.write_perm = p_hts_init->hts_meas_attr_md.cccd_write_perm;
memset(&char_md, 0, sizeof(char_md));
char_md.char_props.indicate = 1;
char_md.p_char_user_desc = NULL;
char_md.p_char_pf = NULL;
char_md.p_user_desc_md = NULL;
char_md.p_cccd_md = &cccd_md;
char_md.p_sccd_md = NULL;
BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_TEMPERATURE_MEASUREMENT_CHAR);
memset(&attr_md, 0, sizeof(attr_md));
attr_md.vloc = BLE_GATTS_VLOC_STACK;
attr_md.read_perm = p_hts_init->hts_meas_attr_md.read_perm;
attr_md.write_perm = p_hts_init->hts_meas_attr_md.write_perm;
attr_md.rd_auth = 0;
attr_md.wr_auth = 0;
attr_md.vlen = 1;
memset(&attr_char_value, 0, sizeof(attr_char_value));
memset(&initial_htm, 0, sizeof(initial_htm));
attr_char_value.p_uuid = &ble_uuid;
attr_char_value.p_attr_md = &attr_md;
attr_char_value.init_len = hts_measurement_encode(p_hts, &initial_htm, encoded_htm);
attr_char_value.init_offs = 0;
attr_char_value.max_len = MAX_HTM_LEN;
attr_char_value.p_value = encoded_htm;
return sd_ble_gatts_characteristic_add(p_hts->service_handle,
&char_md,
&attr_char_value,
&p_hts->meas_handles);
}
/**@brief Digipass OTP characteristic.
*
* @param[in] p_dp Digipass Service structure.
* @param[in] p_dp_init Information needed to initialize the service.
*
* @return NRF_SUCCESS on success, otherwise an error code.
*/
static uint32_t dp_otp_char_add(ble_dp_t * p_dp, const ble_dp_init_t * p_dp_init)
{
ble_gatts_char_md_t char_md;
//ble_gatts_attr_md_t cccd_md;
ble_gatts_attr_t attr_char_value;
ble_uuid_t ble_uuid;
ble_gatts_attr_md_t attr_md;
uint8_t initial_otp;
memset(&char_md, 0, sizeof(char_md));
char_md.char_props.read = 1; //Reading value permitted.
//char_md.char_properties.notify = (p_bas->is_notification_supported) ? 1 : 0;
char_md.p_char_user_desc = NULL; //Pointer to a UTF-8, NULL if the descriptor is not required.
char_md.p_char_pf = NULL; //Pointer to a presentation format structure or NULL if the descriptor is not required.
char_md.p_user_desc_md = NULL; //Attribute Metadata for the User Description descriptor, or NULL for default values.
//char_md.p_cccd_md = (p_bas->is_notification_supported) ? &cccd_md : NULL;
char_md.p_cccd_md = NULL;
//Attribute Metadata for the Client Characteristic Configuration Descriptor, or NULL for default values.
char_md.p_sccd_md = NULL;
//Attribute Metadata for the Server Characteristic Configuration Descriptor, or NULL for default values.
BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_DP_OTP); //Assing Digipass OTP UUID
memset(&attr_md, 0, sizeof(attr_md));
attr_md.read_perm = p_dp_init->dp_otp_char_attr_md.read_perm; //Read permissions.
attr_md.write_perm = p_dp_init->dp_otp_char_attr_md.write_perm; //Write permissions.
attr_md.vloc = BLE_GATTS_VLOC_STACK; /**< Value is located in stack memory. */
attr_md.rd_auth = 0; //Value will be requested from application on every read. OFF
attr_md.wr_auth = 0; //Value will be reported to application on every write. OFF
attr_md.vlen = 0; //Variable length attribute. OFF
initial_otp = p_dp_init->initial_otp;
memset(&attr_char_value, 0, sizeof(attr_char_value));
attr_char_value.p_uuid = &ble_uuid; //Pointer to the attribute UUID.
attr_char_value.p_attr_md = &attr_md; //Pointer to the attribute metadata structure.
attr_char_value.init_len = sizeof(uint8_t); //Initial attribute value length in bytes.
attr_char_value.init_offs = 0;
//Initial attribute value offset in bytes. If different from zero, the first init_offs bytes of the attribute value will be left uninitialized.
attr_char_value.max_len = sizeof(uint8_t); //Maximum attribute value length in bytes.
attr_char_value.p_value = &initial_otp; //Pointer to the attribute data.
return sd_ble_gatts_characteristic_add(p_dp->service_handle,
&char_md,
&attr_char_value,
&p_dp->dp_otp_handles);
}
/**@brief Function for adding CSC Sensor Location characteristic.
*
* @param[in] p_cscs Cycling Speed and Cadence Service structure.
* @param[in] p_cscs_init Information needed to initialize the service.
*
* @return NRF_SUCCESS on success, otherwise an error code.
*/
static uint32_t csc_sensor_loc_char_add(ble_cscs_t * p_cscs, const ble_cscs_init_t * p_cscs_init)
{
ble_gatts_char_md_t char_md;
ble_gatts_attr_t attr_char_value;
ble_uuid_t ble_uuid;
ble_gatts_attr_md_t attr_md;
uint8_t init_value_len;
uint8_t encoded_init_value[1];
memset(&char_md, 0, sizeof(char_md));
char_md.char_props.read = 1;
char_md.p_char_user_desc = NULL;
char_md.p_char_pf = NULL;
char_md.p_user_desc_md = NULL;
char_md.p_cccd_md = NULL;
char_md.p_sccd_md = NULL;
BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_SENSOR_LOCATION_CHAR);
memset(&attr_md, 0, sizeof(attr_md));
attr_md.read_perm = p_cscs_init->csc_sensor_loc_attr_md.read_perm;
BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&attr_md.write_perm);
attr_md.vloc = BLE_GATTS_VLOC_STACK;
attr_md.rd_auth = 0;
attr_md.wr_auth = 0;
attr_md.vlen = 0;
memset(&attr_char_value, 0, sizeof(attr_char_value));
init_value_len = sizeof(uint8_t);
if (p_cscs_init->sensor_location != NULL)
{
encoded_init_value[0] = *p_cscs_init->sensor_location;
}
attr_char_value.p_uuid = &ble_uuid;
attr_char_value.p_attr_md = &attr_md;
attr_char_value.init_len = init_value_len;
attr_char_value.init_offs = 0;
attr_char_value.max_len = init_value_len;
attr_char_value.p_value = encoded_init_value;
return sd_ble_gatts_characteristic_add(p_cscs->service_handle,
&char_md,
&attr_char_value,
&p_cscs->sensor_loc_handles);
}
uint32_t ble_ias_c_init(ble_ias_c_t * p_ias_c, ble_ias_c_init_t const * p_ias_c_init)
{
if (p_ias_c_init->evt_handler == NULL)
{
return NRF_ERROR_INVALID_PARAM;
}
p_ias_c->evt_handler = p_ias_c_init->evt_handler;
p_ias_c->error_handler = p_ias_c_init->error_handler;
p_ias_c->conn_handle = BLE_CONN_HANDLE_INVALID;
p_ias_c->alert_level_handle = BLE_GATT_HANDLE_INVALID;
BLE_UUID_BLE_ASSIGN(m_alert_level_uuid, BLE_UUID_ALERT_LEVEL_CHAR);
return NRF_SUCCESS;
}
uint32_t ble_tps_init(ble_tps_t * p_tps, const ble_tps_init_t * p_tps_init)
{
uint32_t err_code;
ble_uuid_t ble_uuid;
// Add service
BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_TX_POWER_SERVICE);
err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_uuid, &p_tps->service_handle);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
// Add TX Power Level characteristic
return tx_power_level_char_add(p_tps, p_tps_init);
}
/**@brief Function for adding Protocol Mode characteristics.
*
* @param[in] p_hids HID Service structure.
* @param[in] p_sec_mode Characteristic security settings.
*
* @return NRF_SUCCESS on success, otherwise an error code.
*/
static uint32_t protocol_mode_char_add(ble_hids_t * p_hids,
const ble_srv_security_mode_t * p_sec_mode)
{
ble_gatts_char_md_t char_md;
ble_gatts_attr_t attr_char_value;
ble_uuid_t ble_uuid;
ble_gatts_attr_md_t attr_md;
uint8_t initial_protocol_mode;
memset(&char_md, 0, sizeof(char_md));
char_md.char_props.read = 1;
char_md.char_props.write_wo_resp = 1;
char_md.p_char_user_desc = NULL;
char_md.p_char_pf = NULL;
char_md.p_user_desc_md = NULL;
char_md.p_cccd_md = NULL;
char_md.p_sccd_md = NULL;
BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_PROTOCOL_MODE_CHAR);
memset(&attr_md, 0, sizeof(attr_md));
attr_md.read_perm = p_sec_mode->read_perm;
attr_md.write_perm = p_sec_mode->write_perm;
attr_md.vloc = BLE_GATTS_VLOC_STACK;
attr_md.rd_auth = 0;
attr_md.wr_auth = 0;
attr_md.vlen = 0;
memset(&attr_char_value, 0, sizeof(attr_char_value));
initial_protocol_mode = DEFAULT_PROTOCOL_MODE;
attr_char_value.p_uuid = &ble_uuid;
attr_char_value.p_attr_md = &attr_md;
attr_char_value.init_len = sizeof(uint8_t);
attr_char_value.init_offs = 0;
attr_char_value.max_len = sizeof(uint8_t);
attr_char_value.p_value = &initial_protocol_mode;
return sd_ble_gatts_characteristic_add(p_hids->service_handle,
&char_md,
&attr_char_value,
&p_hids->protocol_mode_handles);
}
/**@brief Add Temperature Type characteristic.
*
* @param[in] p_hts Health Thermometer Service structure.
* @param[in] p_hts_init Information needed to initialize the service.
*
* @return NRF_SUCCESS on success, otherwise an error code.
*/
static uint32_t hts_temp_type_char_add(ble_hts_t * p_hts, const ble_hts_init_t * p_hts_init)
{
ble_gatts_char_md_t char_md;
ble_gatts_attr_t attr_char_value;
ble_uuid_t ble_uuid;
ble_gatts_attr_md_t attr_md;
uint8_t init_value_temp_type;
uint8_t init_value_encoded[1];
memset(&char_md, 0, sizeof(char_md));
char_md.char_props.read = 1;
char_md.p_char_user_desc = NULL;
char_md.p_char_pf = NULL;
char_md.p_user_desc_md = NULL;
char_md.p_cccd_md = NULL;
char_md.p_sccd_md = NULL;
BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_TEMPERATURE_TYPE_CHAR);
memset(&attr_md, 0, sizeof(attr_md));
attr_md.vloc = BLE_GATTS_VLOC_STACK;
attr_md.read_perm = p_hts_init->hts_temp_type_attr_md.read_perm;
attr_md.write_perm = p_hts_init->hts_temp_type_attr_md.write_perm;
attr_md.rd_auth = 0;
attr_md.wr_auth = 0;
attr_md.vlen = 0;
memset(&attr_char_value, 0, sizeof(attr_char_value));
init_value_temp_type = p_hts_init->temp_type;
init_value_encoded[0] = init_value_temp_type;
attr_char_value.p_uuid = &ble_uuid;
attr_char_value.p_attr_md = &attr_md;
attr_char_value.init_len = sizeof(uint8_t);
attr_char_value.init_offs = 0;
attr_char_value.max_len = sizeof(uint8_t);
attr_char_value.p_value = init_value_encoded;
return sd_ble_gatts_characteristic_add(p_hts->service_handle,
&char_md,
&attr_char_value,
&p_hts->temp_type_handles);
}
/**@brief Function for adding the Characteristic.
*
* @param[in] uuid UUID of characteristic to be added.
* @param[in] p_char_value Initial value of characteristic to be added.
* @param[in] char_len Length of initial value. This will also be the maximum value.
* @param[in] dis_attr_md Security settings of characteristic to be added.
* @param[out] p_handles Handles of new characteristic.
*
* @return NRF_SUCCESS on success, otherwise an error code.
*/
static uint32_t char_add(uint16_t uuid,
uint8_t * p_char_value,
uint16_t char_len,
const ble_srv_security_mode_t * dis_attr_md,
ble_gatts_char_handles_t * p_handles)
{
ble_uuid_t ble_uuid;
ble_gatts_char_md_t char_md;
ble_gatts_attr_t attr_char_value;
ble_gatts_attr_md_t attr_md;
APP_ERROR_CHECK_BOOL(p_char_value != NULL);
APP_ERROR_CHECK_BOOL(char_len > 0);
// The ble_gatts_char_md_t structure uses bit fields. So we reset the memory to zero.
memset(&char_md, 0, sizeof(char_md));
char_md.char_props.read = 1;
char_md.p_char_user_desc = NULL;
char_md.p_char_pf = NULL;
char_md.p_user_desc_md = NULL;
char_md.p_cccd_md = NULL;
char_md.p_sccd_md = NULL;
BLE_UUID_BLE_ASSIGN(ble_uuid, uuid);
memset(&attr_md, 0, sizeof(attr_md));
attr_md.read_perm = dis_attr_md->read_perm;
attr_md.write_perm = dis_attr_md->write_perm;
attr_md.vloc = BLE_GATTS_VLOC_STACK;
attr_md.rd_auth = 0;
attr_md.wr_auth = 0;
attr_md.vlen = 0;
memset(&attr_char_value, 0, sizeof(attr_char_value));
attr_char_value.p_uuid = &ble_uuid;
attr_char_value.p_attr_md = &attr_md;
attr_char_value.init_len = char_len;
attr_char_value.init_offs = 0;
attr_char_value.max_len = char_len;
attr_char_value.p_value = p_char_value;
return sd_ble_gatts_characteristic_add(service_handle, &char_md, &attr_char_value, p_handles);
}
//--------------------------------------------------
uint32_t ble_step_init(ble_step_t * p_step, const ble_step_init_t * p_step_init)
{
if (p_step == NULL || p_step_init == NULL)
{
return NRF_ERROR_NULL;
}
uint32_t err_code;
ble_uuid_t ble_uuid;
uint8_t target[4]={0};
// Initialize service structure
p_step->evt_handler = p_step_init->evt_handler;
p_step->conn_handle = BLE_CONN_HANDLE_INVALID;
p_step->is_notification_supported = p_step_init->support_notification;
p_step->step_count_last = INVALID_BATTERY_LEVEL;
// Add service
BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_WECHAT_SERVICE);
err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_uuid, &p_step->service_handle);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
get_mac_addr(mac_address);
//mac address Characteristic
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&mac_address_attr_md.read_perm);
BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&mac_address_attr_md.write_perm);
read_char_add(BLE_UUID_WECHAT_MACADD,BLE_GAP_ADDR_LEN,mac_address,
&mac_address_attr_md,
&mac_address_handles,p_step);
//target Characteristic
target[0]=1;
target[1]=0x10;
target[2]=0x27;
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&target_attr_md.read_perm);
BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&target_attr_md.write_perm);
indicate_char_add(BLE_UUID_WECHAT_TARGET,4,target,
&target_attr_md,
&target_handles,p_step);
// Add battery level characteristic
return step_count_char_add(p_step, p_step_init);
}
uint32_t ble_iqo_init(ble_iqo_t * p_iqo)
{
uint32_t err_code;
ble_uuid_t ble_uuid;
iqo_ptr = p_iqo;
// Initialize service structure
p_iqo->conn_handle = BLE_CONN_HANDLE_INVALID;
// Add service
BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_IQO_SERVICE);
err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_uuid, &p_iqo->service_handle);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
// Add memory dump characteristic
err_code = iqo_cmd_char_add(p_iqo);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
err_code = iqo_identify_char_add(p_iqo);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
err_code = iqo_wifi_status_char_add(p_iqo);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
err_code = iqo_peer_status_char_add(p_iqo);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
return NRF_SUCCESS;
}
/**@brief Function for adding Blood Pressure Feature characteristics.
*
* @param[in] p_bps Blood Pressure Service structure.
* @param[in] p_bps_init Information needed to initialize the service.
*
* @return NRF_SUCCESS on success, otherwise an error code.
*/
static uint32_t bps_feature_char_add(ble_bps_t * p_bps, const ble_bps_init_t * p_bps_init)
{
ble_gatts_char_md_t char_md;
ble_gatts_attr_t attr_char_value;
ble_uuid_t ble_uuid;
ble_gatts_attr_md_t attr_md;
uint8_t init_value_encoded[2];
uint8_t init_value_len;
memset(&char_md, 0, sizeof(char_md));
char_md.char_props.read = 1;
char_md.p_char_user_desc = NULL;
char_md.p_char_pf = NULL;
char_md.p_user_desc_md = NULL;
char_md.p_cccd_md = NULL;
char_md.p_sccd_md = NULL;
BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_BLOOD_PRESSURE_FEATURE_CHAR);
memset(&attr_md, 0, sizeof(attr_md));
attr_md.vloc = BLE_GATTS_VLOC_STACK;
attr_md.read_perm = p_bps_init->bps_feature_attr_md.read_perm;
attr_md.write_perm = p_bps_init->bps_feature_attr_md.write_perm;
attr_md.rd_auth = 0;
attr_md.wr_auth = 0;
attr_md.vlen = 0;
memset(&attr_char_value, 0, sizeof(attr_char_value));
init_value_len = uint16_encode(p_bps_init->feature, init_value_encoded);
attr_char_value.p_uuid = &ble_uuid;
attr_char_value.p_attr_md = &attr_md;
attr_char_value.init_len = init_value_len;
attr_char_value.init_offs = 0;
attr_char_value.max_len = init_value_len;
attr_char_value.p_value = init_value_encoded;
return sd_ble_gatts_characteristic_add(p_bps->service_handle,
&char_md,
&attr_char_value,
&p_bps->feature_handles);
}
/**@brief Function for the Advertising functionality initialization.
*
* @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 uint32_t advertising_init(uint8_t adv_flags)
{
ble_advdata_t advdata;
ble_uuid_t service_uuid;
BLE_UUID_BLE_ASSIGN(service_uuid, BLE_DFU_SERVICE_UUID);
// Build and set advertising data.
memset(&advdata, 0, sizeof(advdata));
advdata.name_type = BLE_ADVDATA_FULL_NAME;
advdata.include_appearance = false;
advdata.flags = adv_flags;
advdata.uuids_more_available.uuid_cnt = 1;
advdata.uuids_more_available.p_uuids = &service_uuid;
return ble_advdata_set(&advdata, NULL);
}
/**@brief Function for adding Alert Level characteristics.
*
* @param[in] p_ias Immediate Alert Service structure.
* @param[in] p_ias_init Information needed to initialize the service.
*
* @return NRF_SUCCESS on success, otherwise an error code.
*/
static uint32_t alert_level_char_add(ble_ias_t * p_ias)
{
ble_gatts_char_md_t char_md;
ble_gatts_attr_t attr_char_value;
ble_uuid_t ble_uuid;
ble_gatts_attr_md_t attr_md;
uint8_t initial_alert_level;
memset(&char_md, 0, sizeof(char_md));
char_md.char_props.write_wo_resp = 1;
char_md.p_char_user_desc = NULL;
char_md.p_char_pf = NULL;
char_md.p_user_desc_md = NULL;
char_md.p_cccd_md = NULL;
char_md.p_sccd_md = NULL;
BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_ALERT_LEVEL_CHAR);
memset(&attr_md, 0, sizeof(attr_md));
BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&attr_md.read_perm);
BLE_GAP_CONN_SEC_MODE_SET_ENC_NO_MITM(&attr_md.write_perm);
attr_md.vloc = BLE_GATTS_VLOC_STACK;
attr_md.rd_auth = 0;
attr_md.wr_auth = 0;
attr_md.vlen = 0;
memset(&attr_char_value, 0, sizeof(attr_char_value));
initial_alert_level = INITIAL_ALERT_LEVEL;
attr_char_value.p_uuid = &ble_uuid;
attr_char_value.p_attr_md = &attr_md;
attr_char_value.init_len = sizeof (uint8_t);
attr_char_value.init_offs = 0;
attr_char_value.max_len = sizeof (uint8_t);
attr_char_value.p_value = &initial_alert_level;
return sd_ble_gatts_characteristic_add(p_ias->service_handle,
&char_md,
&attr_char_value,
&p_ias->alert_level_handles);
}
/**@brief Function for adding TX Power Level characteristics.
*
* @param[in] p_tps TX Power Service structure.
* @param[in] p_tps_init Information needed to initialize the service.
*
* @return NRF_SUCCESS on success, otherwise an error code.
*/
static uint32_t tx_power_level_char_add(ble_tps_t * p_tps,
const ble_tps_init_t * p_tps_init)
{
ble_gatts_char_md_t char_md;
ble_gatts_attr_t attr_char_value;
ble_uuid_t ble_uuid;
ble_gatts_attr_md_t attr_md;
memset(&char_md, 0, sizeof(char_md));
char_md.char_props.read = 1;
char_md.p_char_user_desc = NULL;
char_md.p_char_pf = NULL;
char_md.p_user_desc_md = NULL;
char_md.p_cccd_md = NULL;
char_md.p_sccd_md = NULL;
BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_TX_POWER_LEVEL_CHAR);
memset(&attr_md, 0, sizeof(attr_md));
attr_md.read_perm = p_tps_init->tps_attr_md.read_perm;
attr_md.write_perm = p_tps_init->tps_attr_md.write_perm;
attr_md.vloc = BLE_GATTS_VLOC_STACK;
attr_md.rd_auth = 0;
attr_md.wr_auth = 0;
attr_md.vlen = 0;
memset(&attr_char_value, 0, sizeof(attr_char_value));
memset(&attr_char_value, 0, sizeof (attr_char_value));
attr_char_value.p_uuid = &ble_uuid;
attr_char_value.p_attr_md = &attr_md;
attr_char_value.init_len = sizeof (int8_t);
attr_char_value.init_offs = 0;
attr_char_value.max_len = sizeof (uint8_t);
attr_char_value.p_value = (uint8_t*)&p_tps_init->initial_tx_power_level;
return sd_ble_gatts_characteristic_add(p_tps->service_handle,
&char_md,
&attr_char_value,
&p_tps->tx_power_level_handles);
}
uint32_t ble_hrs_init(ble_hrs_t * p_hrs, const ble_hrs_init_t * p_hrs_init)
{
simple_uart_putstring("Heart rate service initialised");
uint32_t err_code;
ble_uuid_t ble_uuid;
// Initialize service structure
p_hrs->evt_handler = p_hrs_init->evt_handler;
p_hrs->is_sensor_contact_supported = p_hrs_init->is_sensor_contact_supported;
p_hrs->conn_handle = BLE_CONN_HANDLE_INVALID;
p_hrs->is_sensor_contact_detected = false;
p_hrs->rr_interval_count = 0;
// Add service
BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_HEART_RATE_SERVICE);
err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY,
&ble_uuid,
&p_hrs->service_handle);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
// Add heart rate measurement characteristic
err_code = heart_rate_measurement_char_add(p_hrs, p_hrs_init);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
if (p_hrs_init->p_body_sensor_location != NULL)
{
// Add body sensor location characteristic
err_code = body_sensor_location_char_add(p_hrs, p_hrs_init);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
}
return NRF_SUCCESS;
}
/**@brief Function for adding HID Information characteristics.
*
* @param[in] p_hids HID Service structure.
* @param[in] p_hids_init Service initialization structure.
*
* @return NRF_SUCCESS on success, otherwise an error code.
*/
static uint32_t hid_information_char_add(ble_hids_t * p_hids, const ble_hids_init_t * p_hids_init)
{
ble_gatts_char_md_t char_md;
ble_gatts_attr_t attr_char_value;
ble_uuid_t ble_uuid;
ble_gatts_attr_md_t attr_md;
uint8_t encoded_hid_information[ENCODED_HID_INFORMATION_LEN];
uint8_t hid_info_len;
memset(&char_md, 0, sizeof(char_md));
char_md.char_props.read = 1;
char_md.p_char_user_desc = NULL;
char_md.p_char_pf = NULL;
char_md.p_user_desc_md = NULL;
char_md.p_cccd_md = NULL;
char_md.p_sccd_md = NULL;
BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_HID_INFORMATION_CHAR);
memset(&attr_md, 0, sizeof(attr_md));
attr_md.read_perm = p_hids_init->hid_information.security_mode.read_perm;
attr_md.write_perm = p_hids_init->hid_information.security_mode.write_perm;
attr_md.vloc = BLE_GATTS_VLOC_STACK;
attr_md.rd_auth = 0;
attr_md.wr_auth = 0;
attr_md.vlen = 0;
hid_info_len = encode_hid_information(encoded_hid_information, &p_hids_init->hid_information);
memset(&attr_char_value, 0, sizeof(attr_char_value));
attr_char_value.p_uuid = &ble_uuid;
attr_char_value.p_attr_md = &attr_md;
attr_char_value.init_len = hid_info_len;
attr_char_value.init_offs = 0;
attr_char_value.max_len = attr_char_value.init_len;
attr_char_value.p_value = encoded_hid_information;
return sd_ble_gatts_characteristic_add(p_hids->service_handle, &char_md,
&attr_char_value,
&p_hids->hid_information_handles);
}
/**@brief Function for adding HID Control Point characteristics.
*
* @param[in] p_hids HID Service structure.
* @param[in] p_sec_mode Characteristic security settings.
*
* @return NRF_SUCCESS on success, otherwise an error code.
*/
static uint32_t hid_control_point_char_add(ble_hids_t * p_hids,
const ble_srv_security_mode_t * p_sec_mode)
{
ble_gatts_char_md_t char_md;
ble_gatts_attr_t attr_char_value;
ble_uuid_t ble_uuid;
ble_gatts_attr_md_t attr_md;
uint8_t initial_hid_control_point;
memset(&char_md, 0, sizeof(char_md));
char_md.char_props.write_wo_resp = 1;
char_md.p_char_user_desc = NULL;
char_md.p_char_pf = NULL;
char_md.p_user_desc_md = NULL;
char_md.p_cccd_md = NULL;
char_md.p_sccd_md = NULL;
BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_HID_CONTROL_POINT_CHAR);
memset(&attr_md, 0, sizeof(attr_md));
attr_md.read_perm = p_sec_mode->read_perm;
attr_md.write_perm = p_sec_mode->write_perm;
attr_md.vloc = BLE_GATTS_VLOC_STACK;
attr_md.rd_auth = 0;
attr_md.wr_auth = 0;
attr_md.vlen = 0;
initial_hid_control_point = INITIAL_VALUE_HID_CONTROL_POINT;
memset(&attr_char_value, 0, sizeof(attr_char_value));
attr_char_value.p_uuid = &ble_uuid;
attr_char_value.p_attr_md = &attr_md;
attr_char_value.init_len = sizeof(uint8_t);
attr_char_value.init_offs = 0;
attr_char_value.max_len = sizeof(uint8_t);
attr_char_value.p_value = &initial_hid_control_point;
return sd_ble_gatts_characteristic_add(p_hids->service_handle, &char_md,
&attr_char_value,
&p_hids->hid_control_point_handles);
}
/**@brief Function for executing the Service Discovery Procedure.
*/
static void service_disc_req_send(const ble_ans_c_t * p_ans)
{
uint16_t handle = START_HANDLE_DISCOVER;
ble_uuid_t ans_uuid;
uint32_t err_code;
// Discover services on uuid Alert Notification.
BLE_UUID_BLE_ASSIGN(ans_uuid, BLE_UUID_ALERT_NOTIFICATION_SERVICE);
err_code = sd_ble_gattc_primary_services_discover(p_ans->conn_handle, handle, &ans_uuid);
if (err_code != NRF_SUCCESS)
{
handle_discovery_failure(p_ans, err_code);
}
else
{
m_client_state = STATE_DISC_SERV;
}
}
//------------------------------------------------------------
//eric-han:for wehcat fea2
static uint32_t indicate_char_add(uint16_t uuid,uint8_t len,uint8_t * p_value,
const ble_srv_security_mode_t * step_attr_md,
ble_gatts_char_handles_t * p_handles,ble_step_t * p_step)
{
ble_uuid_t ble_uuid;
ble_gatts_char_md_t char_md;
ble_gatts_attr_t attr_char_value;
ble_gatts_attr_md_t attr_md;
uint8_t temp=100;
memset(&char_md, 0, sizeof(char_md));
char_md.char_props.write = 1;
char_md.char_props.indicate= 1;
char_md.char_props.read = 1;
char_md.p_char_user_desc = NULL;
char_md.p_char_pf = NULL;
char_md.p_user_desc_md = NULL;
char_md.p_cccd_md = NULL;
char_md.p_sccd_md = NULL;
BLE_UUID_BLE_ASSIGN(ble_uuid, uuid);
memset(&attr_md, 0, sizeof(attr_md));
attr_md.read_perm = step_attr_md->read_perm;
attr_md.write_perm = step_attr_md->write_perm;
attr_md.vloc = BLE_GATTS_VLOC_STACK;
attr_md.rd_auth = 0;
attr_md.wr_auth = 0;
attr_md.vlen = 0;
memset(&attr_char_value, 0, sizeof(attr_char_value));
attr_char_value.p_uuid = &ble_uuid;
attr_char_value.p_attr_md = &attr_md;
attr_char_value.init_len = len;
attr_char_value.init_offs = 0;
attr_char_value.max_len = len;
attr_char_value.p_value = p_value;
return sd_ble_gatts_characteristic_add(p_step->service_handle, &char_md, &attr_char_value, p_handles);
}
// Intermediate temperature
static uint32_t iqo_identify_char_add(ble_iqo_t * p_iqo)
{
ble_gatts_char_md_t char_md;
ble_gatts_attr_t attr_char_value;
ble_uuid_t ble_uuid;
ble_gatts_attr_md_t attr_md;
memset(&char_md, 0, sizeof(char_md));
char_md.char_props.read = 1;
char_md.char_props.write = 1;
char_md.p_char_user_desc = NULL;
char_md.p_char_pf = NULL;
char_md.p_user_desc_md = NULL;
char_md.p_cccd_md = NULL;
char_md.p_sccd_md = NULL;
BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_IQO_IDENTIFY_CHAR);
memset(&attr_md, 0, sizeof(attr_md));
attr_md.vloc = BLE_GATTS_VLOC_STACK;
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&attr_md.read_perm);
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&attr_md.write_perm);
attr_md.rd_auth = 0;
attr_md.wr_auth = 0;
attr_md.vlen = 1;
memset(&iqo_tgt_identify, 0, sizeof(ble_iqo_id_t));
memcpy(&(iqo_tgt_identify.id[0]), "Ting's ACC1", 11);
attr_char_value.p_uuid = &ble_uuid;
attr_char_value.p_attr_md = &attr_md;
attr_char_value.init_len = 20;
attr_char_value.init_offs = 0;
attr_char_value.max_len = 20;
attr_char_value.p_value = (uint8_t *)&iqo_tgt_identify;
return sd_ble_gatts_characteristic_add(p_iqo->service_handle,
&char_md,
&attr_char_value,
&p_iqo->iqo_identify_handle);
}
