int svc_send_calibration_cmd_to_core(ss_sensor_calibration_req_t *req)
{
struct ia_cmd *cmd = NULL;
uint8_t sensor_type = GET_SENSOR_TYPE(req->sensor);
uint8_t sensor_id = GET_SENSOR_ID(req->sensor);
uint16_t length = sizeof(struct ia_cmd)+sizeof(struct calibration)+req->data_length;
cmd = (struct ia_cmd*)balloc(length,NULL);
struct calibration *ia_param = (struct calibration*)cmd->param;
ia_param->sensor.sensor_type = sensor_type;
ia_param->sensor.dev_id = sensor_id;
ia_param->calibration_type= req->calibration_type;
ia_param->clb_cmd= req->clb_cmd;
cmd->cmd_id = CMD_CALIBRATION;
if((req->clb_cmd) == SET_CALIBRATION_CMD || (req->clb_cmd == REBOOT_AUTO_CALIBRATION_CMD)){
ia_param->data_length = req->data_length;
memcpy(ia_param->calib_params, req->value, ia_param->data_length);
/*write the clb data to falsh*/
if(ia_param->clb_cmd == SET_CALIBRATION_CMD)
sensor_clb_write_flash(sensor_type, sensor_id, ia_param->calib_params, ia_param->data_length);
}else{
ia_param->data_length = 0;
}
return ipc_2core_send(cmd);
}
/* handle for sensors data */
static void handle_sensor_subscribe_data(struct cfw_message *msg)
{
sensor_service_subscribe_data_event_t *p_evt =
(sensor_service_subscribe_data_event_t *)msg;
sensor_service_sensor_data_header_t *p_data_header =
&p_evt->sensor_data_header;
uint8_t sensor_type = GET_SENSOR_TYPE(p_evt->handle);
switch (sensor_type) {
case SENSOR_ABS_STEPCADENCE:;
struct stepcadence_result *p =
(struct stepcadence_result *)p_data_header->data;
/* New value of step cadence sensor */
/* BLE RSC profile reports stride cadence whereas the sensor reports
* step cadence => need to convert the sensor value before BLE notification:
* 1 stride = 2 steps */
pr_info(LOG_MODULE_MAIN, "stride cadence=%d", p->cadence / 2);
ble_rscs_update(0, p->cadence / 2);
break;
}
}
void sensor_core_svc_rsp_handle(struct cfw_message *p_msg, void *p_param)
{
switch (CFW_MESSAGE_ID(p_msg)) {
case MSG_ID_CFW_OPEN_SERVICE_RSP:
{
cfw_open_conn_rsp_msg_t *cnf = (cfw_open_conn_rsp_msg_t *)p_msg;
p_sc_service_conn = (cfw_service_conn_t *)cnf->service_conn;
if (NULL == p_sc_service_conn) {
SS_PRINT_ERR("Opening Score_svc failed");
return;
}
SS_PRINT_LOG("Opening Score_svc successful");
if (core_connected_cb) {
core_connected_cb(core_connected_cb_data);
}
} break;
case MSG_ID_CFW_REGISTER_EVT_RSP:
{
SS_PRINT_LOG("Register evt!!");
} break;
case MSG_ID_CFW_REGISTER_SVC_AVAIL_EVT_RSP:
break;
case MSG_ID_CFW_SVC_AVAIL_EVT:
{
uint16_t service_id =
((cfw_svc_available_evt_msg_t *)p_msg)->service_id;
SS_PRINT_LOG("AVAIL_EVT: %d", service_id);
if (ARC_SC_SVC_ID == service_id) {
cfw_open_service_conn(p_client, ARC_SC_SVC_ID, NULL);
} else {
SS_PRINT_LOG("AVAIL_EVT:service_id is error");
}
} break;
case MSG_ID_SENSOR_SERVICE_START_SCANNING_RSP:
{
SS_PRINT_LOG("[%s]Scanning rsp", __func__);
} break;
case MSG_ID_SENSOR_SERVICE_START_SCANNING_EVT:
{
sensor_service_scan_event_t *p_evt =
(sensor_service_scan_event_t *)p_msg;
uint8_t sensor_type = (uint8_t)(((uint32_t)p_evt->handle) >> 8);
uint8_t sensor_id = (uint8_t)(((uint32_t)p_evt->handle) & 0xff);
send_scan_evt_message_to_clients(sensor_type, sensor_id);
SS_PRINT_LOG("[%s]Scanning evt", __func__);
} break;
case MSG_ID_SENSOR_SERVICE_STOP_SCANNING_RSP:
{
SS_PRINT_LOG("[%s]Stop SCANNING RSP", __func__);
} break;
case MSG_ID_SENSOR_SERVICE_PAIR_RSP:
{
SS_PRINT_LOG("[%s]PAIR RSP", __func__);
} break;
case MSG_ID_SENSOR_SERVICE_SUBSCRIBE_DATA_RSP:
{
sensor_service_message_general_rsp_t *p_rsp =
(sensor_service_message_general_rsp_t *)p_msg;
uint8_t sensor_type = (uint8_t)(((uint32_t)p_rsp->handle) >> 8);
uint8_t sensor_id = (uint8_t)(((uint32_t)p_rsp->handle) & 0xff);
SS_PRINT_LOG("SUBSCRIBE_DATA_RSP:type=%d,id=%d,status=%d]", \
sensor_type, sensor_id, \
p_rsp->status);
send_sensor_subscribing_rsp_message_to_clients(sensor_type,
sensor_id,
p_rsp->status);
} break;
case MSG_ID_SENSOR_SERVICE_SUBSCRIBE_DATA_EVT:
{
sensor_service_subscribe_data_event_t *p_evt =
(sensor_service_subscribe_data_event_t *)p_msg;
sensor_service_sensor_data_header_t *p_data_header =
&p_evt->sensor_data_header;
uint8_t sensor_type = (uint8_t)(((uint32_t)p_evt->handle) >> 8);
uint8_t sensor_id = (uint8_t)(((uint32_t)p_evt->handle) & 0xff);
send_sensor_subscribing_evt_message_to_clients(
sensor_type, sensor_id, 0, \
p_data_header->
timestamp, \
(void *)
p_data_header->data, \
p_data_header->
data_length);
} break;
case MSG_ID_SENSOR_SERVICE_UNSUBSCRIBE_DATA_RSP:
{
SS_PRINT_LOG("[%s]UNSUBSCRIBED RSP", __func__);
ss_sensor_unsubscribe_data_rsp_t *p_rsp =
(ss_sensor_unsubscribe_data_rsp_t *)p_msg;
uint8_t sensor_type = GET_SENSOR_TYPE(p_rsp->handle);
uint8_t sensor_id = GET_SENSOR_ID(p_rsp->handle);
send_sensor_unsubscribing_rsp_message_to_clients(sensor_type,
sensor_id,
p_rsp->status);
} break;
case MSG_ID_SENSOR_SERVICE_UNPAIR_RSP:
break;
case MSG_ID_SS_SENSOR_UNLINK_EVT:
break;
default:
SS_PRINT_ERR("[%s]unhandled msg %d", __func__,
CFW_MESSAGE_ID(p_msg));
break;
}
cfw_msg_free(p_msg);
}
/* handle for sensors data */
static void handle_sensor_subscribe_data(struct cfw_message *msg)
{
ss_sensor_subscribe_data_event_t *p_evt =
(ss_sensor_subscribe_data_event_t *)msg;
ss_sensor_data_header_t *p_data_header = &p_evt->sensor_data_header;
uint8_t sensor_type = GET_SENSOR_TYPE(p_evt->handle);
switch (sensor_type) {
/* TODO: use a header from sensor service defining these structs:
* redifining message structure is not a good practice. */
case SENSOR_PATTERN_MATCHING_GESTURE: {
struct gs_personalize *p =
(struct gs_personalize *)p_data_header->data;
pr_info(LOG_MODULE_IQ, "GESTURE=%d,size=%d",
p->nClassLabel, p->size);
if(sensing_gesture_cb) {
sensing_gesture_cb(p_data_header->data);
}
}
break;
case SENSOR_ABS_TAPPING: {
struct tapping_result *p =
(struct tapping_result *)p_data_header->data;
pr_info(LOG_MODULE_IQ, "TAPPING=%d", p->tapping_cnt);
if(sensing_tapping_cb) {
sensing_tapping_cb(p->tapping_cnt);
}
}
break;
case SENSOR_ABS_STEPCOUNTER: {
struct stepcounter_result *p =
(struct stepcounter_result *)p_data_header->data;
pr_info(LOG_MODULE_IQ, "steps:%d activity:%d",
p->steps, p->activity);
if(sensing_stepcounter_cb) {
sensing_stepcounter_cb(p->steps,
p->activity,
p_data_header->timestamp);
}
}
break;
case SENSOR_ACCELEROMETER:
{
int i = 0;
static int accel_read_count = 0;
int data_len = p_data_header->data_length;
int data_num = data_len / sizeof(struct accel_phy_data);
uint8_t data_type = ACCEL_DATA;
if (accel_read_count++ >= 3) {
ss_sensor_unsubscribe_data(sensor_client, NULL,
p_evt->handle, &data_type, 1);
accel_read_count = 0;
break;
}
for (i = 0; i < data_num; i++) {
struct accel_phy_data *p_data =
(struct accel_phy_data *)p_data_header->data +
i;
pr_debug(
LOG_MODULE_SS_SVC,
"[APP][NUM=%d]stamp(ms):%d, x(mg):%d, y(mg):%d, z(mg):%d",
i, p_data_header->timestamp, (p_data->ax),
(p_data->ay), (p_data->az));
}
} break;
}
}
