X-Git-Url: http://git.osdn.net/view?a=blobdiff_plain;f=sens.c;h=436cecff91ae432e085f70b97a8689de8336383a;hb=7a62a908ced944b3fcaa8fa407bdd632d153527e;hp=b7578ebe9c09f935580563067fa8ecbe27f74c6f;hpb=0aa1bbb1ec4bc14cd8067a5fd20986f9978d620e;p=android-x86%2Fhardware-intel-libsensors.git diff --git a/sens.c b/sens.c index b7578eb..436cecf 100644 --- a/sens.c +++ b/sens.c @@ -1,6 +1,18 @@ /* - * Copyright (C) 2014-2015 Intel Corporation. - */ +// Copyright (c) 2015 Intel Corporation +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +*/ #include #include @@ -10,6 +22,7 @@ #include #include #include +#include #include #include @@ -20,7 +33,9 @@ int usage(void) fprintf(stderr, "sens [activate | deactivate] sensor_id\n"); fprintf(stderr, "sens set_delay sensor_id delay\n"); fprintf(stderr, "sens poll\n"); + fprintf(stderr, "sens poll [duration] [number_of_events] \n"); fprintf(stderr, "sens poll_stop\n"); + fprintf(stderr, "sens check_sample_rate [rate] \n"); return 1; } @@ -64,23 +79,33 @@ static struct sensors_module_t *hmi; static struct hw_device_t *dev; static FILE *client; static pthread_mutex_t client_mutex = PTHREAD_MUTEX_INITIALIZER; - +static pthread_cond_t cond = PTHREAD_COND_INITIALIZER; +static int ready_to_close = 0; +static int number_of_events = 0; +static int non_param_poll = 1; +static int event_no = 0; +static int init_events = 0; +static int print_events = 1; +static long long timestamp = 0; +static long long event_init_poll_time = 0; +static long long poll_duration = 0; static void print_event(struct sensors_event_t *e) { FILE *f; pthread_mutex_lock(&client_mutex); - if (!client) { pthread_mutex_unlock(&client_mutex); return; } f = client; - fprintf(f, "event: version=%d sensor=%d type=%s timestamp=%lld\n", + fprintf(f, "event %d: version=%d sensor=%d type=%s timestamp=%lld\n",event_no, e->version, e->sensor, type_str(e->type), (long long)e->timestamp); - + if (poll_duration != 0) + fprintf(f,"Time remaining:%lld \n",poll_duration - ((long long)e->timestamp + - event_init_poll_time)); switch (e->type) { case SENSOR_TYPE_META_DATA: break; @@ -156,13 +181,59 @@ static void print_event(struct sensors_event_t *e) (unsigned long long)e->u64.step_counter); break; } - fprintf(f, "\n"); fflush(f); pthread_mutex_unlock(&client_mutex); } +static void print_result(int result) +{ + FILE *f; + pthread_mutex_lock(&client_mutex); + if (!client) { + pthread_mutex_unlock(&client_mutex); + return; + } + f = client; + fprintf(f, "Number of events: %d \n", event_no - init_events); + fprintf(f, "Duration: %lld \n\n", (long long) timestamp - event_init_poll_time); + if(!print_events){ + if(result) + fprintf(f, "Test passed\n\n"); + else + fprintf(f, "Test failed\n\n"); + } + fflush(f); + pthread_mutex_unlock(&client_mutex); + +} + +static void process_event(struct sensors_event_t *e) +{ + int is_poll_duration_over = 0; + int is_event_number_reached = 0; + + if (event_init_poll_time == 0) { + event_init_poll_time = (long long) e->timestamp; + init_events = event_no; + } + is_poll_duration_over = (long long) e->timestamp - event_init_poll_time <= poll_duration ? 0 : 1; + is_event_number_reached = (event_no - init_events) < number_of_events ? 0 : 1; + + if ((!is_poll_duration_over && !is_event_number_reached) || non_param_poll) + { + timestamp = e -> timestamp; + event_no++; + if(print_events) + print_event(e); + } else { + ready_to_close = 1; + print_result(is_event_number_reached); + pthread_cond_signal(&cond); + } +} + static void run_sensors_poll_v0(void) { struct sensors_poll_device_t *poll_dev = (struct sensors_poll_device_t *)dev; @@ -174,7 +245,7 @@ static void run_sensors_poll_v0(void) count = poll_dev->poll(poll_dev, events, sizeof(events)/sizeof(sensors_event_t)); for(i = 0; i < count; i++) - print_event(&events[i]); + process_event(&events[i]); } } @@ -305,14 +376,56 @@ static int dispatch_cmd(char *cmd, FILE *f) return sensor_set_delay(handle, delay); } else if (!strcmp(argv[0], "poll")) { - + if (argc == 1) { + non_param_poll = 1; + } else if (argc == 3) { + non_param_poll = 0; + poll_duration = atoll(argv[1]); + number_of_events = atoi(argv[2]); + event_init_poll_time = 0; + ready_to_close = 0; + } else { + CLIENT_ERR(f, "poll: no poll duration or number of events set"); + return -1; + } + print_events = 1; pthread_mutex_lock(&client_mutex); if (client) fclose(client); client = f; + + if (!non_param_poll) { + pthread_cond_wait(&cond, &client_mutex); + fclose(client); + client = NULL; + } + pthread_mutex_unlock(&client_mutex); return 1; + } else if (!strcmp(argv[0], "check_sample_rate")) { + + if (argc < 2) { + CLIENT_ERR(f, "check_sample_rate: no events rate"); + return -1; + } + + non_param_poll = 0; + poll_duration = 1000000000; + number_of_events = atoi(argv[1]); + event_init_poll_time = 0; + ready_to_close = 0; + print_events = 0; + + pthread_mutex_lock(&client_mutex); + if (client) + fclose(client); + client = f; + pthread_cond_wait(&cond, &client_mutex); + fclose(client); + client = NULL; + pthread_mutex_unlock(&client_mutex); + return 1; } else if (!strcmp(argv[0], "poll_stop")) { pthread_mutex_lock(&client_mutex); if (client){