ssc sam

https://www.jianshu.com/u/8dba4c15ff52

image.png

[图片上传失败...(image-7da7d8-1534316650184)]

image.png

https://blog.csdn.net/liuei633/article/details/81706189

四：Sensor SLPI层SAM Sensor实例分析

上文中，我们大致了解了物理sensor driver整个流程，但在项目中，一般写这种sensor driver的情况很少。这种sensor driver基本上都是各个vendor厂商提供的，我们也只需要看懂即可。

但是SAM sensor我们完全是可以自己写的，根据一些物理sensor的数据，来实现一些算法。

比如，实现拿起唤醒功能，这个功能在oem手机中非常常见。

基本功能就是：当用户拿起手机时，手机屏幕亮起，此时可以通过脸部识别，来解锁手机等等。

这时好多人可能会说，这不是很简单吗？在framework层就可以做，注册一个加速度传感器，并根据data做一定算法处理。根本不需要再SLPI侧再实现一个SAM sensor。这种思维就是典型的应用层程序员的思想，系统层程序员如果有这种思想，那就很危险了。

为什么不能再framework层上做算法处理呢？

framework层进行算法处理，当系统睡下去怎么办？若是注册Non-Wakeup的sensor的话，在系统suspend时，不会有任何数据上报，如何唤醒系统呢？若是注册Wakeup的sensor的话，系统会被wakelock住，根本睡不下去，这时系统功耗非常高。

可见在framework层做的想法是在系统层面不可能实施的。

那么在SLPI侧实现pick up sensor的思路是什么呢？

pick up sensor在LPSS侧是work的，APSS侧是可以suspend的，当pick up Sensor获取accel sensor的数据满足算法时，会publish event给APSS中client，此时会唤醒系统。唤醒系统后，framework层会根据该sensor type，做相应的操作，比如亮屏、震动等等。。。

Ok，下面我们以该pickup sensor为例，解析下SLPI 侧 SAM Sensor driver。

高通给我们参考的oem sensor实例，下面我们在oem sensor实例上实现pickup sensor。

1：build脚本

根据上文中介绍。各个sensor都是通过xxxx.scons静态添加sensor的。

oem sensor的source code在/slpi/ssc/sensors/oem1中。

if 'USES_SSC_STATIC_LIB_BUILDER' in env:

env.AddSSCSU(inspect.getfile(inspect.currentframe()),

register_func_name = "sns_oem1_register",

clean_pack_list = oem1_clean_pack_list,

binary_lib = oem1_binary_lib,

add_island_files = oem1_island_enable,

diag_ssid = ssid)

build脚本会通过register_func_name = “sns_oem1_register”，调到sns_oem1_register函数。

2：Initialization

sns_rc sns_oem1_register(sns_register_cb const *register_api)

{

register_api->init_sensor(sizeof(sns_oem1_sensor_state),

&sns_oem1_api,

&sns_oem1_sensor_instance_api);

return SNS_RC_SUCCESS;

}

sns_sensor_api sns_oem1_api =

{

.struct_len = sizeof(sns_sensor_api),

.init = &sns_oem1_init,

.deinit = &sns_oem1_deinit,

.get_sensor_uid = &sns_oem1_get_sensor_uid,

.set_client_request = &sns_oem1_set_client_request,

.notify_event = &sns_oem1_notify_event,

};

根据前文介绍。sns_register_sensor()注册函数后，会执行sns_sensor_api的init函数。

.init

sns_rc

sns_oem1_init(sns_sensor *const this)

{

sns_oem1_sensor_state *state = (sns_oem1_sensor_state*)this->state->state;

struct sns_service_manager *smgr = this->cb->get_service_manager(this);

float data[3];

state->diag_service = (sns_diag_service*)

smgr->get_service(smgr, SNS_DIAG_SERVICE);

// set default output value corresponding to OEM1_FACING_DOWN to 50. will

// rewrite if registry sensor is available

state->config.down_value = 50.0;

state->first_pass = true;

// determine encoded output event size

state->config.encoded_data_event_len =

pb_get_encoded_size_sensor_stream_event(data, 3);

SNS_SUID_LOOKUP_INIT(state->suid_lookup_data, NULL);

sns_suid_lookup_add(this, &state->suid_lookup_data, "accel");//No.1

sns_suid_lookup_add(this, &state->suid_lookup_data, "amd"); //No.2

#ifndef SUPPORT_DIRECT_SENSOR_REQUEST

sns_suid_lookup_add(this, &state->suid_lookup_data, "resampler");//No.3

#endif

publish_attributes(this); //No.4

SNS_PRINTF(MED, this, "OEM1 init success and attributes published");

return SNS_RC_SUCCESS;

}

No.1：sns_suid_look_add添加所需要的sensor。

No.2：添加amd sensor。

No.3：添加resampler sensor。

No.4：并pushlish atrribute。比如sensor name、type、vendor等，Client层会根据该attribute，设置sensor的一些属性，比如on_change、streaming等等

.get_sensor_uid

static sns_sensor_uid const*

sns_oem1_get_sensor_uid(sns_sensor const *this)

{

UNUSED_VAR(this);

static const sns_sensor_uid oem1_suid = OEM1_SUID;

return &oem1_suid;

}

oem1_suid是指定的，返回的是oem_suid。

.notify

sns_rc

sns_oem1_notify_event(sns_sensor *const this)

{

sns_oem1_sensor_state *state = (sns_oem1_sensor_state*)this->state->state;

SNS_PRINTF(LOW, this, "sns_oem1_notify_event");

sns_suid_lookup_handle(this, &state->suid_lookup_data);

#ifdef SUPPORT_REGISTRY

if(NULL != state->registry_stream)

{

handle_oem1_registry_event(this);

}

#endif

if(sns_suid_lookup_complete(&state->suid_lookup_data))

{

#ifdef SUPPORT_REGISTRY

if(state->first_pass == true){

state->first_pass = false;

sns_oem1_registry_req(this);

}

#endif

publish_available(this);

sns_suid_lookup_deinit(this, &state->suid_lookup_data);

}

return SNS_RC_SUCCESS;

}

该notify，主要处理init中的event。

通过sns_suid_lookup_handle()，handle一个suid或者attribute event。

通过sns_suid_lookup_complete()，来返回所有sensor data 的suid是否找到。

Initialization分析完毕，Initialization重要东西不多，主要是添加所需要的dependency sensor，比如accel、amd、resampler等等，并获取oem1_suid。然后通过notify_event来查看sensor type的suid是否找到。

3： Activation

sns_sensor_instance_api sns_oem1_sensor_instance_api =

{

.struct_len = sizeof(sns_sensor_instance_api),

.init = &sns_oem1_inst_init,

.deinit = &sns_oem1_inst_deinit,

.set_client_config = &sns_oem1_inst_set_client_config,

.notify_event = &sns_oem1_inst_notify_event

};

当client发送request时，先进入sns_sensor_api中的.set_client_config。

.set_client_config

sns_sensor_instance*

sns_oem1_set_client_request(sns_sensor *const this,

sns_request const *curr_req,

sns_request const *new_req,

bool remove)

{

sns_sensor_instance *curr_inst =

sns_sensor_util_find_instance(

this,

curr_req,

this->sensor_api->get_sensor_uid(this));

sns_sensor_instance *rv_inst = NULL;

SNS_PRINTF(MED, this, "sns_oem1_set_client_request");

if((NULL != curr_inst) && (NULL != new_req) && //No.1

(SNS_STD_MSGID_SNS_STD_FLUSH_REQ == new_req->message_id))

{

SNS_PRINTF(HIGH, this, "Received Flush Request");

this->instance_api->set_client_config(curr_inst, new_req);

rv_inst = curr_inst;

}

else if(remove) //No.2

{

if(NULL != curr_inst)

{

curr_inst->cb->remove_client_request(curr_inst, curr_req);

}

else //No.3

{

pb_istream_t stream;

sns_std_sensor_config config = {0};

sns_std_request request = sns_std_request_init_default;

pb_simple_cb_arg arg =

{ .decoded_struct = &config, .fields = sns_std_sensor_config_fields };

request.payload = (struct pb_callback_s)

{ .funcs.decode = &pb_decode_simple_cb, .arg = &arg };

stream = pb_istream_from_buffer(new_req->request, new_req->request_len);

if(pb_decode(&stream, sns_std_request_fields, &request))

{

sns_request decoded_req = {.message_id = new_req->message_id,

.request_len = sizeof(config), .request = &config };

sns_sensor_instance *match_inst = sns_sensor_util_find_instance_match(

this, &decoded_req, &find_instance_match);

if(NULL == curr_inst)

{

// If this is a request from a new client

if(NULL == match_inst)

{

rv_inst = this->cb->create_instance(this,

(sizeof(sns_oem1_inst_state)));

}

else

{

rv_inst = match_inst;

}

else

{

if(NULL != curr_req)

{

curr_inst->cb->remove_client_request(curr_inst, curr_req);

}

if(NULL != match_inst)

{

rv_inst = match_inst;

}

else

{

rv_inst = this->cb->create_instance(this,

(sizeof(sns_oem1_inst_state)));

}

if(NULL != rv_inst)

{

rv_inst->cb->add_client_request(rv_inst, new_req);

this->instance_api->set_client_config(rv_inst, &decoded_req);

}

else

{

SNS_PRINTF(ERROR, this, "failed to decode request");

}

if(NULL != curr_inst && NULL == curr_inst->cb->get_client_request(

curr_inst, this->sensor_api->get_sensor_uid(this), true))

{

this->cb->remove_instance(curr_inst);

}

return rv_inst;

}

该函数很简单，

No.1：处理message_id=SNS_STD_MSGID_SNS_STD_FLUSH_REQ ，此时会将该message_id传送给sns_oem1_inst_set_client_config，并做相应的处理。

No.2：为remove分支

No.3：正常情况下走的流程。

（1）先判断是否有与new_req匹配的sns_sensor_instance，若有直接用match的；

（2）若无，判断是否有当前的curr_inst即旧的sns_sensor_instance存在。若有，则通过curr_inst->cb->remove_client_request函数remove掉旧的curr_req client。，并通过this->cb->create_instance()创建一个新的sns_sensor_instance。若无，则直接创建一个新的sns_sensor_instance即rv_inst。

（3）创建好的sns_sensor_instance叫rv_inst，然后通过rv_inst->cb->add_client_request添加新的client request。

（4）并通过this->instance_api->set_client_config处理该新建的sns_sensor_instance ，即rv_inst。

（5）若curr_inst不为空，并且curr_inst还可以获取到client_reqeust。这时要remove掉curr_inst即当前的sns_sensor_instance。

Ok，create_instance()执行后便进入sns_sensor_instance_api.init()。

set_client_config()执行后便进入sns_sensor_instance_api.set_client_config()。

.init

sns_rc

sns_oem1_inst_init(sns_sensor_instance *this,

sns_sensor_state const *state)

{

sns_rc rc = SNS_RC_SUCCESS;

sns_oem1_inst_state *inst_state =

(sns_oem1_inst_state*)this->state->state;

sns_oem1_sensor_state *sensor_state =

(sns_oem1_sensor_state*)state->state;

sns_service_manager *service_mgr = this->cb->get_service_manager(this);

#ifdef SUPPORT_DIRECT_SENSOR_REQUEST

sns_stream_service *stream_service = (sns_stream_service*)

service_mgr->get_service(service_mgr, SNS_STREAM_SERVICE);

#endif

#ifdef SUPPORT_DIRECT_SENSOR_REQUEST

sns_suid_lookup_get(&sensor_state->suid_lookup_data, "accel", &inst_state->accel_suid);

#else

sns_suid_lookup_get(&sensor_state->suid_lookup_data, "resampler", &inst_state->resampler_suid);

sns_suid_lookup_get(&sensor_state->suid_lookup_data, "accel", &inst_state->accel_suid);

#endif

inst_state->diag_service = (sns_diag_service*)

service_mgr->get_service(service_mgr, SNS_DIAG_SERVICE);

inst_state->down_value = sensor_state->config.down_value;

#ifdef SUPPORT_DIRECT_SENSOR_REQUEST

// start regular stream for accel

stream_service->api->create_sensor_instance_stream(

stream_service,

this,

inst_state->accel_suid,

&inst_state->accel_stream);

#endif

inst_state->inst_config.previous_state = OEM1_UNKNOWN;

inst_state->inst_config.current_state = OEM1_UNKNOWN;

// read platform specific configuration

sns_memscpy(&inst_state->config,

sizeof(inst_state->config),

&sensor_state->config,

sizeof(sensor_state->config) );

return rc;

}

该函数，主要是获取resampler、accel等的suid。将suid放到inst_state->xxxx_suid中。

.set_client_config

sns_rc

sns_oem1_inst_set_client_config(sns_sensor_instance *const this,

sns_request const *client_request)

{

sns_rc rc = SNS_RC_SUCCESS;

sns_oem1_inst_state *state = (sns_oem1_inst_state*)this->state->state;

SNS_INST_PRINTF(LOW, this, "sns_oem1_inst_set_client_config");

if(SNS_STD_SENSOR_MSGID_SNS_STD_SENSOR_CONFIG == client_request->message_id)

{

// initialize state here

sns_std_sensor_config *client_req =

(sns_std_sensor_config *)(client_request->request);

sns_memscpy(&state->client_config,

sizeof(state->client_config),

client_request->request,

client_request->request_len);

state->config.sample_rate = client_req->sample_rate;

#ifndef SUPPORT_DIRECT_SENSOR_REQUEST

// start streaming from resampler

SNS_INST_PRINTF(LOW, this, "Enable resampler at rate %f", client_req->sample_rate);

sns_service_manager *manager =

this->cb->get_service_manager(this);

sns_stream_service *stream_service =

(sns_stream_service*)manager->get_service(manager, SNS_STREAM_SERVICE);

sns_resampler_config resampler_config = sns_resampler_config_init_default;

size_t encoded_len;

uint8_t buffer[100];

client_req->sample_rate = 25.0f;

sns_memscpy(&resampler_config.sensor_uid, //No.1

sizeof(resampler_config.sensor_uid),

&state->accel_suid,

sizeof(state->accel_suid));

resampler_config.resampled_rate = client_req->sample_rate;

resampler_config.rate_type = SNS_RESAMPLER_RATE_MINIMUM;

resampler_config.filter = false;

// create connection with resampler sensor

stream_service->api->create_sensor_instance_stream( //No.2

stream_service,

this,

state->resampler_suid,

&state->resampler_stream);

if(NULL != state->resampler_stream)

{

encoded_len = pb_encode_request(buffer, sizeof(buffer),

&resampler_config, sns_resampler_config_fields, NULL);

if(0 < encoded_len)

{

sns_request request = (sns_request){

.message_id = SNS_RESAMPLER_MSGID_SNS_RESAMPLER_CONFIG,

.request_len = encoded_len, .request = buffer };

rc = state->resampler_stream->api->send_request(state->resampler_stream, &request);

SNS_INST_PRINTF(MED, this, "oem1 sent accel request to resampler at rate %f", client_req->sample_rate);

}

else

{

SNS_INST_PRINTF(ERROR, this, "oem1 failed to encode resampler config");

}

else

{

SNS_INST_PRINTF(ERROR, this, "oem1 resampler stream creation failed");

}

#else // not using the resampler, request accel directly

size_t encoded_len;

uint8_t buffer[20];

// enable accel here

sns_memset(buffer, 0, sizeof(buffer));

client_req->sample_rate = 25.0f;

sns_std_sensor_config accel_config = {.sample_rate = client_req->sample_rate};

SNS_INST_PRINTF(LOW, this, "Enable accel at rate %f", client_req->sample_rate);

encoded_len = pb_encode_request(buffer,

sizeof(buffer),

&accel_config,

sns_std_sensor_config_fields,

NULL);

if(0 < encoded_len && NULL != state->accel_stream )

{

sns_request request = (sns_request){

.message_id = SNS_STD_SENSOR_MSGID_SNS_STD_SENSOR_CONFIG,

.request_len = encoded_len, .request = buffer };

state->accel_stream->api->send_request(state->accel_stream, &request);

}

else

{

SNS_INST_PRINTF(ERROR, this, "Error in creating accel stream OR encoding failed");

rc = SNS_RC_NOT_SUPPORTED;

}

SNS_INST_PRINTF(LOW, this, "Processed oem1 config request: enabled accel with"

"sample rate %f, result: %u", state->client_config.sample_rate, rc);

#endif

}

else if(client_request->message_id == SNS_STD_MSGID_SNS_STD_FLUSH_REQ)

{

sns_sensor_util_send_flush_event(NULL, this);

}

else

{

SNS_INST_PRINTF(ERROR, this, "Unsupported request message id %u",

client_request->message_id);

rc = SNS_RC_NOT_SUPPORTED;

}

return rc;

}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

该函数，首先根据client传入的msg_id做处理。

当message_id = SNS_STD_SENSOR_MSGID_SNS_STD_SENSOR_CONFIG时，这时，我们就需要发送accel的request，来获取accel的data了。

这里面有个宏SUPPORT_DIRECT_SENSOR_REQUEST，这里我们不support这个宏，走的是resampler。若support这个宏，则直接发送request给accel。

这里用resampler后，会先发送request给resampler sensor，resampler sensor再获取accel的数据。

No.1中，填充sns_resampler_config。并将state->accel_suid赋给resampler_config.sensor_uid。

No.2中，create_sensor_instance_stream会创建data stream，以后resampler request和event都会走该data stream。

然后通过pb_encode_request，将sns_resampler_config 编码成buffer。

最后填充sns_request request，可以看到request message_id = SNS_RESAMPLER_MSGID_SNS_RESAMPLER_CONFIG ，.request = buffer。然后通过send_request发送出去。

sns_oem1_inst_set_client_config发送完毕后，接下来就是接收event了。

.notify_event

static sns_rc

sns_oem1_inst_notify_event(sns_sensor_instance *const this)

{

sns_rc rc = SNS_RC_SUCCESS;

sns_oem1_process_resampler_event(this);

return rc;

static sns_rc sns_oem1_process_resampler_event(sns_sensor_instance *const this)

{

sns_rc rc = SNS_RC_SUCCESS;

sns_oem1_inst_state *state = (sns_oem1_inst_state*)this->state->state;

sns_sensor_event *resampler_event_in = NULL;

SNS_INST_PRINTF(LOW, this, "sns_oem1_inst_process_resampler_event");

resampler_event_in = state->resampler_stream->api->peek_input(state->resampler_stream);

while( NULL != resampler_event_in )

{

if(SNS_STD_SENSOR_MSGID_SNS_STD_SENSOR_EVENT == resampler_event_in->message_id) //No.1

{

float data[3] = { 0 };

float oem1_payload[OEM1_NUM_ELEMS];

uint8_t arr_index = 0;

pb_float_arr_arg arg = {

.arr = data,

.arr_len = ARR_SIZE(data),

.arr_index = &arr_index

};

pb_istream_t stream = pb_istream_from_buffer((pb_byte_t*)resampler_event_in->event,resampler_event_in->event_len);

sns_std_sensor_event resampler_data = sns_std_sensor_event_init_default;

resampler_data.data = (struct pb_callback_s) {

.funcs.decode = &pb_decode_float_arr_cb, .arg = &arg

};

if(!pb_decode(&stream, sns_std_sensor_event_fields, &resampler_data)) //No.2

{

SNS_INST_PRINTF(ERROR, this, "Error in decoding resampler event");

}

else

{

if (SNS_STD_SENSOR_SAMPLE_STATUS_UNRELIABLE == resampler_data.status)

{

SNS_INST_PRINTF(LOW, this, " OEM1 received unreliable accel data"

" from resampler ignoring..");

resampler_event_in = state->resampler_stream->api->get_next_input(state->resampler_stream);

continue;

}

//This is dummy logic for OEM1 demonstration purposes

//OEMs can replace with their algo logic

oem1_facing_state current_state = OEM1_UNKNOWN;

SNS_INST_PRINTF(LOW, this,

"resampler accel data: x %d/1000, y %d/1000, z %d/1000",

(int) (1000*data[0]),(int)( 1000*data[1]),(int)(1000*data[2]));

//sns_oem1_procces(this, &input);

state->inst_config.previous_state = state->inst_config.current_state;

if(0 < data[2]) //No.3

{

current_state = OEM1_FACING_UP;

oem1_payload[0]=100;

oem1_payload[1]=data[1];

oem1_payload[2]=data[2];

}

else

{

current_state = OEM1_FACING_DOWN;

oem1_payload[0]= state->down_value;

oem1_payload[1]=data[1];

oem1_payload[2]=data[2];

}

state->inst_config.current_state = current_state;

SNS_INST_PRINTF(LOW, this, "OEM1 output: x %d/1000, y %d/1000, z %d/1000",

(int) (1000*oem1_payload[0]),(int)( 1000*oem1_payload[1]),(int)(1000*oem1_payload[2]));

#ifdef SUPPORT_EVENT_TYPE

if(state->inst_config.current_state != state->inst_config.previous_state)

{

#endif

SNS_INST_PRINTF(MED, this,

"OEM1 last %d current %d",

state->inst_config.current_state,

state->inst_config.previous_state);

rc = pb_send_sensor_stream_event(this, //No.4

NULL,

resampler_event_in->timestamp,

SNS_OEM1_MSGID_SNS_OEM1_DATA,

SNS_STD_SENSOR_SAMPLE_STATUS_ACCURACY_HIGH,

oem1_payload,

OEM1_NUM_ELEMS,

state->config.encoded_data_event_len);

if(SNS_RC_SUCCESS != rc)

{

SNS_INST_PRINTF(ERROR, this, "sns_oem1_inst_notify_event - Error in sending event");

}

#ifdef SUPPORT_EVENT_TYPE

}

#endif

}

// check next sample

resampler_event_in = state->resampler_stream->api->get_next_input(state->resampler_stream);

}

return rc;

}

100

101

102

103

104

No.1：接收到accel的message_id。

No.2：将stream解码成resampler_data的格式。resampler_data.data.arr即为accel的sensor data。

No.3：该处是根据accel数据做算法处理。比如panel朝向，panel加速度等等。

No.4：pb_send_sensor_stream_event来publish event，若算法满足，可以通过该函数publish event，client便接收到event来唤醒系统，最终实现wake up。

Ok，SAM sensor分析完毕，该文与上一篇文章流程基本相似，唯一不同点就是SAM Sensor会Dependency other sensor，并在sns_sensor_instance_api.set_client_config中发送Dependency sensor的request，然后在sns_sensor_instance_api.notify_event中处理获取到的dependency sensor 数据

---------------------

原文链接：https://blog.csdn.net/liuei633/article/details/81706189