int ss_sensor_subscribe_data(cfw_service_conn_t *p_service_conn, void *p_priv, ss_sensor_t sensor,
uint8_t *data_type, uint8_t data_type_nr, uint16_t sampling_interval,
uint16_t reporting_interval)
{
ss_sensor_subscribe_data_req_t *p_msg;
if (data_type_nr == 0) {
return -1;
}
/* Allocate sensor subscribing data request message */
p_msg = (ss_sensor_subscribe_data_req_t *) cfw_alloc_message_for_service(p_service_conn,
MSG_ID_SS_SENSOR_SUBSCRIBE_DATA_REQ, (sizeof(*p_msg) + (data_type_nr - 1) *
sizeof(uint8_t)), p_priv);
if (p_msg == NULL) {
return -1;
}
/* Fill Request Parameter */
p_msg->sensor = sensor;
p_msg->data_type_nr = data_type_nr;
p_msg->sampling_interval = sampling_interval;
p_msg->reporting_interval = reporting_interval;
/* Fill Request Parameter */
memcpy(p_msg->data_type ,data_type ,sizeof(uint8_t) * data_type_nr);
/* Send the message */
return cfw_send_message(p_msg);
}
void sensor_service_set_calibration(cfw_service_conn_t *p_service_conn,
void *p_priv,
sensor_service_t sensor,
uint8_t calibration_type, uint8_t len,
uint8_t *value)
{
ss_sensor_calibration_req_t *p_msg;
/* Allocate sensor setting calibration request message */
p_msg = (ss_sensor_calibration_req_t *)cfw_alloc_message_for_service(
p_service_conn,
MSG_ID_SS_SENSOR_CALIBRATION_REQ,
sizeof(*p_msg) + len, p_priv);
if (p_msg == NULL) {
return;
}
p_msg->sensor = sensor;
p_msg->calibration_type = calibration_type;
p_msg->clb_cmd = SET_CALIBRATION_CMD;
p_msg->data_length = len;
/* Fill cal param*/
memcpy(p_msg->value, value, len);
/* Send the message */
cfw_send_message(p_msg);
}
int ss_send_sensor_cmd(cfw_service_conn_t *p_service_conn, void *p_priv,
sensor_service_t sensor, uint32_t cmd_id,
cmd_parameter_t parameter)
{
ss_send_sensor_cmd_req_t *p_msg;
int msg_size = parameter.length + sizeof(*p_msg) +
sizeof(parameter.length);
/* Allocate sending sensor cmd request message */
p_msg = (ss_send_sensor_cmd_req_t *)cfw_alloc_message_for_service(
p_service_conn,
MSG_ID_SS_SEND_SENSOR_CMD_REQ,
msg_size, p_priv);
if (p_msg == NULL) {
return -1;
}
/* Fill Request Parameter */
p_msg->sensor = sensor;
p_msg->cmd_id = cmd_id;
p_msg->parameter = parameter;
/* Send the message */
return cfw_send_message(p_msg);
}
int ble_gatts_add_descriptor(svc_client_handle_t * p_svc_handle,
const struct ble_gatts_descriptor * p_desc,
ble_gatts_add_desc_cback_t cback,
void * p_priv)
{
struct ble_gatts_add_desc_req_msg *req;
uint8_t * p;
int data_len = sizeof(struct ble_gatts_add_desc_req_msg);
/* Sanity check */
if (!p_desc || !p_desc->length || !p_desc->p_value || !p_desc->p_uuid)
return E_OS_ERR;
// compute the variable length part of the message
data_len += ble_sizeof_bt_uuid(p_desc->p_uuid);
data_len += p_desc->length;
req = (struct ble_gatts_add_desc_req_msg *)
cfw_alloc_message_for_service(p_svc_handle,
MSG_ID_BLE_GATTS_ADD_DESCRIPTOR_REQ,
data_len, p_priv);
req->cback = cback;
p = req->data;
p = ble_encode_bt_uuid(p_desc->p_uuid, p);
req->length = p_desc->length;
req->perms = p_desc->perms;
memcpy(p, p_desc->p_value, p_desc->length);
return cfw_send_message(req);
}
void sensor_service_unsubscribe_data(cfw_service_conn_t * p_service_conn,
void * p_priv,
sensor_service_t sensor,
uint8_t * data_type,
uint8_t data_type_nr)
{
ss_sensor_unsubscribe_data_req_t *p_msg;
if (data_type_nr == 0) {
return;
}
/* Allocate sensor unsubscribing data request message */
p_msg =
(ss_sensor_unsubscribe_data_req_t *)
cfw_alloc_message_for_service(
p_service_conn,
MSG_ID_SS_SENSOR_UNSUBSCRIBE_DATA_REQ,
sizeof(*p_msg) + (data_type_nr - 1) * sizeof(uint8_t),
p_priv);
if (p_msg == NULL) {
return;
}
/* Fill Request Parameter */
p_msg->sensor = sensor;
p_msg->data_type_nr = data_type_nr;
/* Fill Request Parammeter */
memcpy(p_msg->data_type, data_type, sizeof(uint8_t) * data_type_nr);
/* Send the message */
cfw_send_message(p_msg);
}
int ble_gatts_remove_service(svc_client_handle_t * p_svc_handle,
uint16_t svc_handle,
void *p_priv)
{
struct cfw_message *msg = cfw_alloc_message_for_service(p_svc_handle,
MSG_ID_BLE_GATTS_REMOVE_SERVICE_REQ,
sizeof(*msg),
p_priv);
return cfw_send_message(msg);
}
int ble_gatts_read_conn_attributes(svc_client_handle_t * p_svc_handle,
uint16_t conn_handle,
void *p_priv)
{
struct cfw_message *msg = cfw_alloc_message_for_service(p_svc_handle,
MSG_ID_BLE_GATTS_RD_CONN_ATTRIBUTES_REQ,
sizeof(*msg),
p_priv);
return cfw_send_message(msg);
}
int ble_gatts_add_included_svc(svc_client_handle_t * p_svc_handle,
uint16_t svc_handle,
uint16_t svc_handle_to_include,
void *p_priv)
{
struct cfw_message *msg = cfw_alloc_message_for_service(p_svc_handle,
MSG_ID_BLE_GATTS_ADD_INCL_SVC_REQ,
sizeof(*msg),
p_priv);
return cfw_send_message(msg);
}
int ble_gatts_send_svc_changed(svc_client_handle_t * p_svc_handle,
uint16_t conn_handle,
uint16_t start_handle,
uint16_t end_handle,
void *p_priv)
{
struct cfw_message *msg = cfw_alloc_message_for_service(p_svc_handle,
MSG_ID_BLE_GATTS_INDICATE_SERVICE_CHANGE_REQ,
sizeof(*msg),
p_priv);
return cfw_send_message(msg);
}
int ble_gatts_get_attribute_value(svc_client_handle_t * p_svc_handle,
uint16_t value_handle,
uint16_t len,
uint16_t offset,
void *p_priv)
{
struct cfw_message *msg = cfw_alloc_message_for_service(p_svc_handle,
MSG_ID_BLE_GATTS_GET_ATTRIBUTE_VALUE_REQ, sizeof(*msg),
p_priv);
return cfw_send_message(msg);
}
int ss_sensor_get_property(cfw_service_conn_t *p_service_conn, void *p_priv,
ss_sensor_t sensor)
{
ss_sensor_get_property_req_t *p_msg;
/* Allocate sensor setting calibration request message */
p_msg = (ss_sensor_get_property_req_t *) cfw_alloc_message_for_service(p_service_conn,
MSG_ID_SS_SENSOR_GET_PROPERTY_REQ, sizeof(*p_msg), p_priv);
if (p_msg == NULL) {
return -1;
}
p_msg->sensor = sensor;
/* Send the message */
return cfw_send_message(p_msg);
}
int ble_gatts_add_characteristic(svc_client_handle_t * p_svc_handle,
uint16_t svc_handle,
const struct ble_gatts_characteristic * p_char,
ble_gatts_add_char_cback_t cback,
void *p_priv)
{
struct ble_gatts_add_char_req_msg *msg;
int data_len = sizeof(struct ble_gatts_add_char_req_msg);
uint8_t * p;
// Sanity check
if (!p_char || !p_char->p_uuid)
return E_OS_ERR;
// compute the variable length part of the message
data_len += ble_sizeof_bt_uuid(p_char->p_uuid);
data_len += p_char->init_len;
if (p_char->p_user_desc)
data_len += p_char->p_user_desc->len;
if (p_char->p_char_pf_desc)
data_len += sizeof(struct ble_gatt_pf_desc);
msg = (struct ble_gatts_add_char_req_msg *)
cfw_alloc_message_for_service(p_svc_handle,
MSG_ID_BLE_GATTS_ADD_CHARACTERISTIC_REQ,
data_len, p_priv);
msg->cback = cback;
p = msg->data;
p = ble_encode_bt_uuid(p_char->p_uuid, p);
msg->svc_handle = svc_handle;
msg->perms = p_char->perms;
msg->props = p_char->props;
msg->max_len = p_char->max_len;
msg->init_len = p_char->init_len;
memcpy(p, p_char->p_value, p_char->init_len);
p += p_char->init_len;
if (p_char->p_user_desc) {
msg->ud_len = p_char->p_user_desc->len;
memcpy(p, p_char->p_user_desc->buffer, p_char->p_user_desc->len);
p += p_char->p_user_desc->len;
}
if (p_char->p_char_pf_desc) {
msg->pf_len = sizeof(struct ble_gatt_pf_desc);
memcpy(p, p_char->p_char_pf_desc, msg->pf_len);
p += msg->pf_len;
}
return cfw_send_message(msg);
}
int ss_stop_sensor_scanning(cfw_service_conn_t *p_service_conn, void *p_priv, uint32_t sensor_type_bit_map)
{
ss_stop_sensor_scanning_req_t *p_msg;
/* Allocate stopping sensor scanning request message */
p_msg = (ss_stop_sensor_scanning_req_t *) cfw_alloc_message_for_service(p_service_conn,
MSG_ID_SS_STOP_SENSOR_SCANNING_REQ, sizeof(*p_msg), p_priv);
if (p_msg == NULL) {
return -1;
}
/* Fill Request Parameter */
p_msg->sensor_type_bit_map = sensor_type_bit_map;
/* Send the message */
return cfw_send_message(p_msg);
}
int ss_sensor_stop(cfw_service_conn_t *p_service_conn, void *p_priv, ss_sensor_t sensor)
{
ss_sensor_stop_req_t *p_msg;
/* Allocate sensor stopping request message */
p_msg = (ss_sensor_stop_req_t *) cfw_alloc_message_for_service(p_service_conn,
MSG_ID_SS_SENSOR_STOP_REQ, sizeof(*p_msg), p_priv);
if (p_msg == NULL) {
return -1;
}
/* Fill Request Parameter */
p_msg->sensor = sensor;
/* Send the message */
return cfw_send_message(p_msg);
}
int ss_sensor_pair(cfw_service_conn_t *p_service_conn, void *p_priv, ss_pair_param_t *p_pair_param)
{
ss_sensor_pair_req_t *p_msg;
/* Allocate sensor pairing request message */
p_msg = (ss_sensor_pair_req_t *) cfw_alloc_message_for_service(p_service_conn,
MSG_ID_SS_SENSOR_PAIR_REQ, sizeof(*p_msg), p_priv);
if (p_msg == NULL) {
return -1;
}
/* Fill Request Parameter */
p_msg->pair_param = *p_pair_param;
/* Send the message */
return cfw_send_message(p_msg);
}
int ss_sensor_get_product_id(cfw_service_conn_t *p_service_conn, void *p_priv,
ss_sensor_t sensor)
{
ss_sensor_get_product_id_req_t *p_msg;
/* Allocate sensor getting product id request message */
p_msg = (ss_sensor_get_product_id_req_t *) cfw_alloc_message_for_service(p_service_conn,
MSG_ID_SS_SENSOR_GET_PRODUCT_ID_REQ, sizeof(*p_msg), p_priv);
if (p_msg == NULL) {
return -1;
}
/* Fill Request Parameter */
p_msg->sensor= sensor;
/* Send the message */
return cfw_send_message(p_msg);
}
int ss_set_mode(cfw_service_conn_t *p_service_conn, void *p_priv, uint8_t tether_mode)
{
ss_set_mode_req_t *p_msg;
/* Allocate sensor setting calibration request message */
p_msg = (ss_set_mode_req_t *) cfw_alloc_message_for_service(p_service_conn,
MSG_ID_SS_SET_MODE_REQ, sizeof(*p_msg), p_priv);
if (p_msg == NULL) {
return -1;
}
/* Fill Request Parameter */
p_msg->tether_mode = tether_mode;
/* Send the message */
return cfw_send_message(p_msg);
}
int ss_sensor_get_serial_number(cfw_service_conn_t *p_service_conn, void *p_priv,
ss_sensor_t sensor)
{
ss_sensor_get_serial_number_req_t *p_msg;
/* Allocate sensor getting serial number request message */
p_msg = (ss_sensor_get_serial_number_req_t *) cfw_alloc_message_for_service(p_service_conn,
MSG_ID_SS_SENSOR_GET_SERIAL_NUMBER_REQ, sizeof(*p_msg), p_priv);
if (p_msg == NULL) {
return -1;
}
/* Fill Request Parameter */
p_msg->sensor= sensor;
/* Send the message */
return cfw_send_message(p_msg);
}
int ss_sensor_get_hw_version(cfw_service_conn_t *p_service_conn, void *p_priv,
ss_sensor_t sensor)
{
ss_sensor_get_hw_version_req_t *p_msg;
/* Allocate sensor getting hardware version request message */
p_msg = (ss_sensor_get_hw_version_req_t *) cfw_alloc_message_for_service(p_service_conn,
MSG_ID_SS_SENSOR_GET_HW_VERSION_REQ, sizeof(*p_msg), p_priv);
if (p_msg == NULL) {
return -1;
}
/* Fill Request Parameter */
p_msg->sensor= sensor;
/* Send the message */
return cfw_send_message(p_msg);
}
int ble_gatts_add_service(svc_client_handle_t * p_svc_handle,
const struct bt_uuid * p_uuid,
uint8_t type,
ble_gatts_add_svc_cback_t cback,
void *p_priv)
{
struct ble_gatts_add_service_req_msg *msg =
(struct ble_gatts_add_service_req_msg *)
cfw_alloc_message_for_service(p_svc_handle,
MSG_ID_BLE_GATTS_ADD_SERVICE_REQ,
sizeof(*msg) + ble_sizeof_bt_uuid(p_uuid),
p_priv);
msg->cback = cback;
msg->type = type;
uint8_t *p = (uint8_t *)&msg->data;
ble_encode_bt_uuid(p_uuid, p);
return cfw_send_message(msg);
}
int ss_sensor_opt_calibration(cfw_service_conn_t *p_service_conn, void *p_priv,
ss_sensor_t sensor, uint8_t clb_cmd, uint8_t calibration_type)
{
ss_sensor_calibration_req_t *p_msg;
/* Allocate sensor getting calibration capability request message */
p_msg = (ss_sensor_calibration_req_t *) cfw_alloc_message_for_service(p_service_conn,
MSG_ID_SS_SENSOR_CALIBRATION_REQ, sizeof(*p_msg), p_priv);
if (p_msg == NULL) {
return -1;
}
/* Fill Request Parameter */
p_msg->sensor = sensor;
p_msg->clb_cmd= clb_cmd;
p_msg->calibration_type = calibration_type;
/* Send the message */
return cfw_send_message(p_msg);
}
int ss_sensor_unsubscribe_status(cfw_service_conn_t *p_service_conn, void *p_priv,
ss_sensor_t sensor, uint8_t status_type)
{
ss_sensor_unsubscribe_status_req_t *p_msg;
/* Allocate sensor unsubscribing status request message */
p_msg = (ss_sensor_unsubscribe_status_req_t *) cfw_alloc_message_for_service(p_service_conn,
MSG_ID_SS_SENSOR_UNSUBSCRIBE_STATUS_REQ, sizeof(*p_msg), p_priv);
if (p_msg == NULL) {
return -1;
}
/* Fill Request Parameter */
p_msg->sensor = sensor;
p_msg->status_type = status_type;
/* Send the message */
return cfw_send_message(p_msg);
}
int ss_release_sensor(cfw_service_conn_t *p_service_conn, void *p_priv,
sensor_service_t sensor)
{
ss_release_sensor_req_t *p_msg;
/* Allocate releasing sensor request message */
p_msg = (ss_release_sensor_req_t *)cfw_alloc_message_for_service(
p_service_conn,
MSG_ID_SS_RELEASE_SENSOR_REQ,
sizeof(*p_msg), p_priv);
if (p_msg == NULL) {
return -1;
}
/* Fill Request Parameter */
p_msg->sensor = sensor;
/* Send the message */
return cfw_send_message(p_msg);
}
int ss_sensor_set_property(cfw_service_conn_t *p_service_conn, void *p_priv,
ss_sensor_t sensor, uint8_t len, uint8_t *value)
{
ss_sensor_set_property_req_t *p_msg;
/* Allocate sensor setting calibration request message */
p_msg = (ss_sensor_set_property_req_t *) cfw_alloc_message_for_service(p_service_conn,
MSG_ID_SS_SENSOR_SET_PROPERTY_REQ, sizeof(*p_msg)+len, p_priv);
if ((p_msg == NULL) || (value == NULL) || (len == 0)) {
return -1;
}
p_msg->sensor = sensor;
p_msg->data_length= len;
/* Fill cal param*/
memcpy(p_msg->value, value, len);
/* Send the message */
return cfw_send_message(p_msg);
}
int ble_gatts_send_ind(svc_client_handle_t * p_svc_handle,
uint16_t conn_handle,
const ble_gatts_ind_params_t * p_params,
ble_gatts_notif_ind_cback_t cback,
void *p_priv)
{
struct ble_gatts_send_notif_ind_msg *msg =
(struct ble_gatts_send_notif_ind_msg *)
cfw_alloc_message_for_service(p_svc_handle,
MSG_ID_BLE_GATTS_SEND_IND_REQ,
sizeof(*msg) + p_params->len,
p_priv);
msg->cback = cback;
msg->params.conn_handle = conn_handle;
msg->params.val_handle = p_params->val_handle;
msg->params.len = p_params->len;
msg->params.offset = p_params->offset;
memcpy(msg->params.data, p_params->p_data, msg->params.len);
return cfw_send_message(msg);
}
static void quark_svc_sensor_subscribe_req_handler(
ss_sensor_subscribe_data_req_t *p_req,
void * param)
{
ss_sensor_subscribe_data_req_t *p_msg;
p_msg = (ss_sensor_subscribe_data_req_t *)cfw_alloc_message_for_service(
p_sc_service_conn,
MSG_ID_SS_SENSOR_SUBSCRIBE_DATA_REQ,
sizeof(*p_msg), NULL);
if (p_msg == NULL) {
SS_PRINT_ERR("err p_req msg");
force_panic();
}
/* Fill Request Parameter */
p_msg->sensor = p_req->sensor;
p_msg->data_type = p_req->data_type;
p_msg->sampling_interval = p_req->sampling_interval;
p_msg->reporting_interval = p_req->reporting_interval;
/* Send the message */
cfw_send_message(p_msg);
}
int ble_gatts_set_attribute_value(svc_client_handle_t * p_svc_handle,
uint16_t value_handle,
uint16_t len,
const uint8_t * p_value,
uint16_t offset,
void *p_priv)
{
int i;
struct ble_gatts_set_attribute_value_msg *msg =
(struct ble_gatts_set_attribute_value_msg *)
cfw_alloc_message_for_service(p_svc_handle,
MSG_ID_BLE_GATTS_SET_ATTRIBUTE_VALUE_REQ,
sizeof(*msg)+len,
p_priv);
msg->value_handle = value_handle;
msg->len = len;
msg->offset = offset;
for (i = 0; i < len; i++)
msg->data[i] = p_value[i];
return cfw_send_message(msg);
}
