Home | History | Annotate | Download | only in nusensors
      1 /*
      2  * Copyright (C) 2008 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #include <string.h>
     18 #include <stdint.h>
     19 #include <string.h>
     20 #include <sys/cdefs.h>
     21 #include <sys/types.h>
     22 
     23 #include <cutils/log.h>
     24 
     25 #include <hardware/sensors.h>
     26 #include <utils/Timers.h>
     27 
     28 char const* getSensorName(int type) {
     29     switch(type) {
     30         case SENSOR_TYPE_ACCELEROMETER:
     31             return "Acc";
     32         case SENSOR_TYPE_MAGNETIC_FIELD:
     33             return "Mag";
     34         case SENSOR_TYPE_ORIENTATION:
     35             return "Ori";
     36         case SENSOR_TYPE_GYROSCOPE:
     37             return "Gyr";
     38         case SENSOR_TYPE_LIGHT:
     39             return "Lux";
     40         case SENSOR_TYPE_PRESSURE:
     41             return "Bar";
     42         case SENSOR_TYPE_TEMPERATURE:
     43             return "Tmp";
     44         case SENSOR_TYPE_PROXIMITY:
     45             return "Prx";
     46         case SENSOR_TYPE_GRAVITY:
     47             return "Grv";
     48         case SENSOR_TYPE_LINEAR_ACCELERATION:
     49             return "Lac";
     50         case SENSOR_TYPE_ROTATION_VECTOR:
     51             return "Rot";
     52         case SENSOR_TYPE_RELATIVE_HUMIDITY:
     53             return "Hum";
     54         case SENSOR_TYPE_AMBIENT_TEMPERATURE:
     55             return "Tam";
     56     }
     57     return "ukn";
     58 }
     59 
     60 int main(int argc, char** argv)
     61 {
     62     int err;
     63     struct sensors_poll_device_t* device;
     64     struct sensors_module_t* module;
     65 
     66     err = hw_get_module(SENSORS_HARDWARE_MODULE_ID, (hw_module_t const**)&module);
     67     if (err != 0) {
     68         printf("hw_get_module() failed (%s)\n", strerror(-err));
     69         return 0;
     70     }
     71 
     72     err = sensors_open(&module->common, &device);
     73     if (err != 0) {
     74         printf("sensors_open() failed (%s)\n", strerror(-err));
     75         return 0;
     76     }
     77 
     78     struct sensor_t const* list;
     79     int count = module->get_sensors_list(module, &list);
     80     printf("%d sensors found:\n", count);
     81     for (int i=0 ; i<count ; i++) {
     82         printf("%s\n"
     83                 "\tvendor: %s\n"
     84                 "\tversion: %d\n"
     85                 "\thandle: %d\n"
     86                 "\ttype: %d\n"
     87                 "\tmaxRange: %f\n"
     88                 "\tresolution: %f\n"
     89                 "\tpower: %f mA\n",
     90                 list[i].name,
     91                 list[i].vendor,
     92                 list[i].version,
     93                 list[i].handle,
     94                 list[i].type,
     95                 list[i].maxRange,
     96                 list[i].resolution,
     97                 list[i].power);
     98     }
     99 
    100     static const size_t numEvents = 16;
    101     sensors_event_t buffer[numEvents];
    102 
    103     for (int i=0 ; i<count ; i++) {
    104         err = device->activate(device, list[i].handle, 0);
    105         if (err != 0) {
    106             printf("deactivate() for '%s'failed (%s)\n",
    107                     list[i].name, strerror(-err));
    108             return 0;
    109         }
    110     }
    111 
    112     for (int i=0 ; i<count ; i++) {
    113         err = device->activate(device, list[i].handle, 1);
    114         if (err != 0) {
    115             printf("activate() for '%s'failed (%s)\n",
    116                     list[i].name, strerror(-err));
    117             return 0;
    118         }
    119         device->setDelay(device, list[i].handle, ms2ns(10));
    120     }
    121 
    122     do {
    123         int n = device->poll(device, buffer, numEvents);
    124         if (n < 0) {
    125             printf("poll() failed (%s)\n", strerror(-err));
    126             break;
    127         }
    128 
    129         printf("read %d events:\n", n);
    130         for (int i=0 ; i<n ; i++) {
    131             const sensors_event_t& data = buffer[i];
    132 
    133             if (data.version != sizeof(sensors_event_t)) {
    134                 printf("incorrect event version (version=%d, expected=%d",
    135                         data.version, sizeof(sensors_event_t));
    136                 break;
    137             }
    138 
    139             switch(data.type) {
    140                 case SENSOR_TYPE_ACCELEROMETER:
    141                 case SENSOR_TYPE_MAGNETIC_FIELD:
    142                 case SENSOR_TYPE_ORIENTATION:
    143                 case SENSOR_TYPE_GYROSCOPE:
    144                 case SENSOR_TYPE_GRAVITY:
    145                 case SENSOR_TYPE_LINEAR_ACCELERATION:
    146                 case SENSOR_TYPE_ROTATION_VECTOR:
    147                     printf("sensor=%s, time=%lld, value=<%5.1f,%5.1f,%5.1f>\n",
    148                             getSensorName(data.type),
    149                             data.timestamp,
    150                             data.data[0],
    151                             data.data[1],
    152                             data.data[2]);
    153                     break;
    154 
    155                 case SENSOR_TYPE_LIGHT:
    156                 case SENSOR_TYPE_PRESSURE:
    157                 case SENSOR_TYPE_TEMPERATURE:
    158                 case SENSOR_TYPE_PROXIMITY:
    159                 case SENSOR_TYPE_RELATIVE_HUMIDITY:
    160                 case SENSOR_TYPE_AMBIENT_TEMPERATURE:
    161                     printf("sensor=%s, time=%lld, value=%f\n",
    162                             getSensorName(data.type),
    163                             data.timestamp,
    164                             data.data[0]);
    165                     break;
    166 
    167                 default:
    168                     printf("sensor=%d, time=%lld, value=<%f,%f,%f, ...>\n",
    169                             data.type,
    170                             data.timestamp,
    171                             data.data[0],
    172                             data.data[1],
    173                             data.data[2]);
    174                     break;
    175             }
    176         }
    177     } while (1); // fix that
    178 
    179 
    180     for (int i=0 ; i<count ; i++) {
    181         err = device->activate(device, list[i].handle, 0);
    182         if (err != 0) {
    183             printf("deactivate() for '%s'failed (%s)\n",
    184                     list[i].name, strerror(-err));
    185             return 0;
    186         }
    187     }
    188 
    189     err = sensors_close(device);
    190     if (err != 0) {
    191         printf("sensors_close() failed (%s)\n", strerror(-err));
    192     }
    193     return 0;
    194 }
    195