diff options
Diffstat (limited to 'include')
| -rwxr-xr-x | include/SLP_SensorFW_PG.h | 807 | ||||
| -rwxr-xr-x | include/sensor.h | 345 | ||||
| -rwxr-xr-x | include/sensor_accel.h | 113 | ||||
| -rwxr-xr-x | include/sensor_barometer.h | 84 | ||||
| -rwxr-xr-x | include/sensor_fusion.h | 74 | ||||
| -rwxr-xr-x | include/sensor_geomag.h | 84 | ||||
| -rwxr-xr-x | include/sensor_gyro.h | 79 | ||||
| -rwxr-xr-x | include/sensor_light.h | 78 | ||||
| -rwxr-xr-x | include/sensor_motion.h | 154 | ||||
| -rwxr-xr-x | include/sensor_proxi.h | 80 |
10 files changed, 1898 insertions, 0 deletions
diff --git a/include/SLP_SensorFW_PG.h b/include/SLP_SensorFW_PG.h new file mode 100755 index 0000000..b799459 --- /dev/null +++ b/include/SLP_SensorFW_PG.h @@ -0,0 +1,807 @@ +/* + * libslp-sensor + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: JuHyun Kim <jh8212.kim@samsung.com> + * + * 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. + * + */ + + + +/** + * + * @ingroup SLP_PG + * @defgroup SENSOR_FRAMEWORK_PG SensorFW +@{ + + +<h1 class="pg">Introduction</h1> +<h2 class="pg">Purpose</h2> + +The purpose of this document is to describe how applications can use the Sensor Framework APIs to perform different operations on different supported sensors through the sensor-server. This document gives programming guidelines to application engineers. + + + +<h2 class="pg">Scope</h2> + +The scope of this document is limited to Sensor framework library API usage. + +<h2 class="pg">Abbreviations</h2> + +<table> + <tr> + <td> + API + </td> + <td> + Application Programming Interface + </td> + </tr> + <tr> + <td> + TCP + </td> + <td> + Transmission Control Protocol + </td> + </tr> +</table> + +<h1 class="pg">Sensor Framework Overview</h1> + +<h2 class="pg">What is sensor framework</h2> + +Sensor devices are used widely in mobile devices to enhance user experience. Most modern mobile OS have a framework which manages sensor hardware on the platform and provides convenient APIs for applications. + +<b>Sensors Framework</b> is a middleware, which provides a sensor server for creating plug-ins and a medium through which the client applications are connected with the sensor hardware to exchange sensor data. The sensor plug-ins retrieve data from sensor hardware and enable the client applications to use the data for specific requirements. + +The following sensor types are supported by the sensor framework provided that the device supports them: + + +<b>Accelerometer</b> sensor<br> +<b>Geomagnetic</b> sensor<br> +<b>Proximity</b> sensor<br> +<b>Light</b> sensor<br> +<b>Gyroscope</b> sensor<br> + +@} +@defgroup SENSOR_Architecture 1.Architecture +@ingroup SENSOR_FRAMEWORK_PG +@{ + +<h2 class="pg">Sensor Framework Architecture</h2> + +Sensor framework is basically a client-server architecture. It is mainly composed of two parts: +- <b>Sensor Server</b>: Sensor server is a daemon, which uniquely talks to sensor drivers in the system and dispatches sensor data to applications. Sensor server takes care of interacting with sensor driver in hardware initialization, driver configuration and data fetching, to manage all sensors on platform. + +- <b>Sensor API Library</b> (also called as <b>client</b> library): Applications wanting to access sensor services should communicate with the daemon through the sensor API library. An API library allows application to access sensor service. As shown in the diagram applications/middleware frameworks can have the sensor-framework client library in their process context. + +Unix Socket is used as IPC for communication between API library and daemon, including data transportation and command exchange. + + +The client library provides different functionality to the application like attaching an application to a sensor, getting data from it, getting updates if a value is changed etc. It contains API's designed to fulfill these features. + +@image html SLP_SensorFW_PG_image1.png +@} +@defgroup SENSOR_Feature 2.Feature +@ingroup SENSOR_FRAMEWORK_PG +@{ + +<h2 class="pg">Sensor Framework Features</h2> +<b>Sensor framework client features</b> +-# Available in shared library form. +-# Provides set of APIs for accessing data from sensors. +-# Provide unique access control mechanism through client server architecture. +-# Provision to get processed/raw data from sensors. +-# Provides functionality for application to register its own callback for the case of a sensor value change. +-# Provides information about a sensor like maximum/minimum polling time. +-# Direct knowledge of rotation status with raw data access. + +<b>Sensor framework server features</b> +-# The actual implementation of the features supported by sensor-framework library is done in the sensor-server. +-# Sensor-server checks the devices periodically and if there is an event that meets any conditions that are being monitored, the event is reported to applications which have registered for it. +-# Sensor framework maintains a separate thread for every connection request which is called a "ipc worker". +-# IPC Workers extract the work to be done in the form of command packets. +-# These command packets are maintained in a command queue in server. +-# This queue is further fed to a command executer which extracts the command from the packets. +-# As per the command, the server allocates a plug-in worker which interacts with the device-driver interfaces. +-# Server has predefined information about the sensor. + +@} +<h1 class="pg">Sensor Framework Functions</h1> + +@defgroup Use_Cases1 Getting Information about available sensors +@ingroup SENSOR_UC Use Cases +@{ + +<h2 class="pg">Getting Information about available sensors</h2> + +<b>API : sf_is_sensor_event_available</b><br> +<b>Parameter In</b> : sensor_type_t desired_sensor_type , unsigned int desired_event_type<br> +<b>Parameter Return</b> : int <br> +<b>Functionality</b> : This API checks the availability of the sensor type and event type specified by the input parameters. Some of the supported sensor types are ACCELEROMETER_SENSOR_TYPE, GEOMAGNETIC_SENSOR_TYPE etc. This API will return 0 when the event is available and negative value when it is not available.<br> + + +<b>API : sf_get_properties</b><br> +<b>Parameter In</b> : sensor_type_t sensor_type <br> +<b>Parameter Out</b> : sensor_properties_t *sensor_properties<br> +<b>Parameter Return</b> : int <br> +<b>Functionality</b> This API retrieves the properties of a sensor type, such as unit of sensor data, max/min range of sensor data and sensor resolution to the output parameter sensor_properties.<br> + + + + +Sample Code (Showing how to get basic information about available sensors) + +@code +#include <stdio.h> +#include <sensor.h> +#include <malloc.h> +int main() +{ + printf("\n Sensor test : Start of the program \n"); + int ret_val=0; + sensor_properties_t *sensor_properties; + sensor_type_t sensor_type = ACCELEROMETER_SENSOR; + int event_type = ACCELEROMETER_EVENT_ROTATION_CHECK; + + //Check whether the sensor type and the event is available + + ret_val = sf_is_sensor_event_available (sensor_type,event_type); + printf("\n Sensor Error : Return value is %d \n",ret_val); + if(ret_val != 0) + { + printf("\n Sensor test : sensor %d is not present\n ", + sensor_type); + return -1; + } + printf("\n Sensor test : Sensor type is available and valid \n"); + + //Get the sensor properties + sensor_properties = (sensor_properties_t *)malloc(sizeof(sensor_properties_t)); + + ret_val = sf_get_properties (sensor_type, sensor_properties); + if(ret_val != 0) + { + printf("\n Sensor Error : sensor_property get FAILED with code %d",ret_val); + return -1; + } + printf("\nSensor test : sensor_properties are \n unit ID : %d \n max range : %f \n + min range : %f \n sensor_resolution : %f \n ", + sensor_properties->sensor_unit_idx, sensor_properties->sensor_min_range, + sensor_properties->sensor_max_range, sensor_properties->sensor_resolution); + + if(sensor_properties) + free(sensor_properties); + + return 0; +@endcode + + +@} +@defgroup Use_Cases2 Connecting and disconnecting a sensor +@ingroup SENSOR_UC Use Cases +@{ + + +<h2 class="pg">Connecting and disconnecting a sensor</h2> + +<b>Accelerometer sensor:</b><br> +The accelerometer sensor is used to measure the acceleration of the device. The three dimensional coordinate system is used to illustrate direction of the acceleration as shown in figure 2 below. The X- and Y- axis defines a plane where Z-axis direction is perpendicular to the XY plane. When a phone is moving along an axis, the acceleration is positive if movement is towards positive direction and negative if movement is on negative direction. E.g. when a phone is moving along x-axis to the direction of -x, the acceleration is negative. + +<b>Geomagnetic sensor:</b><br> +Geomagnetic sensor indicates the strength of the geomagnetic flux density in the X, Y and Z axes. This sensor is used to finds the orientation or attitude of a body is a description of how it is aligned to the space it is in. + +<b>Proximity sensor:</b><br> +A proximity sensor is a sensor able to detect the presence of nearby objects without any physical contact. i.e. It indicates if the device is close or not close to the user. +A proximity sensor often emits an electromagnetic or electrostatic field, or a beam of electromagnetic radiation (infrared, for instance), and looks for changes in the field or return signal. The object being sensed is often referred to as the proximity sensor's target + +<b>Light sensor</b><br> +Light sensor measures the amount of light that it receives or the surrounding light conditions. The ambient light state is measured as a step value, where 0 is very dark and 10 is bright sunlight. A number of predefined brightness level constants are specified in the data class reference. + +<b>Gyroscope sensor:</b><br> +A gyroscope is a device used primarily for navigation and measurement of angular velocity. Gyroscopes, also called angular rate sensors, measure how quickly an object rotates. This rate of rotation can be measured along any of the three axes X, Y and Z. 3-axis gyroscopes are often implemented with a 3-axis accelerometer to provide a full 6 degree-of-freedom (DoF) motion tracking system. + +@image html SLP_SensorFW_PG_image2.png + +<b>API : sf_connect</b><br> +<b>Parameter In</b>: sensor_type_t sensor_type<br> +<b>Parameter Return</b>: int <br> +<b>Functionality</b>: This API connects a sensor type to respective sensor. The application calls this API with the type of the sensor (e.g. ACCELEROMETER_SENSOR) on the basis that the server takes the decision of which plug-in is to be connected. Once the sensor is connected, the application can proceed with data processing. +This API returns a positive handle which should be used by application to communicate on sensor type. +<br> +<b>API : sf_disconnect</b><br> +<b>Parameter In</b>: int handle<br> +<b>Parameter Return</b>: int <br> +<b>Functionality</b>: This API disconnects an attached sensor from an application. Application must use the handle retuned after attaching the sensor. After detaching, the corresponding handle will be released.<br> + +@} +@defgroup Use_Cases3 Processing data after connecting to a sensor +@ingroup SENSOR_UC Use Cases +@{ + +<h2 class="pg">Processing data after connecting to a sensor</h2> +Once the application is connected to a sensor, data processing can be done using these API's + +<b>API : sf_start</b><br> +<b>Parameter In</b>: Int handle, int option <br> +<b>Parameter Return</b>: int <br> +<b>Functionality</b>: This API sends a start command to the sensor server. This informs the server that the client side is ready to handle data and start processing. The option input parameter should be set to '0' for current usage.<br> + + +<b>API : sf_get_data</b><br> +<b>Parameter In</b>: int handle, int data_id<br> +<b>Parameter Out</b>:sensor_data_t* values<br> +<b>Parameter Return</b>: int <br> +<b>Functionality</b>: This API gets the processed data (sensor information) from a sensor through the sensor server. The data is loaded in the values output parameter.<br> + + +<b>API : sf_stop</b><br> +<b>Parameter In</b>: int handle<br> +<b>Parameter Return</b>: int <br> +<b>Functionality</b>: This API sends a stop command to the Sensor server indicating that the data processing has stopped from the application side for this time.<br> + +@} +@defgroup Use_Cases4 Processing data without connecting to a sensor +@ingroup SENSOR_UC Use Cases +@{ + +<h2 class="pg">Processing data without connecting to a sensor</h2> + + +<b>API : sf_check_rotation</b><br> +<b>Parameter Out</b>: unsigned long *state<br> +<b>Parameter Return</b>: int <br> +<b>Functionality</b>: This API used to get the current rotation state. (i.e. ROTATION_EVENT_0, ROTATION_EVENT_90, ROTATION_EVENT_180 & ROTATION_EVENT_270 ). This API will directly access the sensor without connecting the process with the sensor-server. Result will be stored in the output parameter state.<br> + + + + +Sample Code (Showing how to connect to server and get data (processed/raw)) + +@code +#include <stdio.h> +#include <sensor.h> +#include <malloc.h> + +int main() +{ + printf("\n Sensor test : Start of the program \n"); + + int ret_val=0; + int my_handle = 0; + int get_data_id =ACCELEROMETER_BASE_DATA_SET; + + float raw_data[3]; + size_t size = 3; + + unsigned long rotaion_state = 0; + sensor_data_t *sensor_data = (sensor_data_t*)malloc(sizeof(sensor_data_t)); + sensor_properties_t *sensor_properties = NULL; + + sensor_type_t sensor_type = ACCELEROMETER_SENSOR; + int event_type = ACCELEROMETER_EVENT_ROTATION_CHECK; + + //Check whether the Accelerometer sensor type and the event is available + ret_val = sf_is_sensor_event_available (sensor_type,event_type); + + printf("\n Sensor Error : Return value is %d \n",ret_val); + if(ret_val != 0) + { + printf("\n Sensor test : sensor %d is not present\n ", sensor_type); + return -1; + } + printf("\n Sensor test : Sensor type is available and valid \n"); + + //Get the sensor properties + sensor_properties = (sensor_properties_t *)malloc(sizeof(sensor_properties_t)); + + ret_val = sf_get_properties (sensor_type, sensor_properties); + if(ret_val != 0) + { + printf("\n Sensor Error : sf_get_property get FAILED with code %d",ret_val); + return -1; + } + printf("\nSensor test : sensor_properties are \n unit ID : %d \n max range : %f \n + min range : %f \n sensor_resolution : %f \n ", + sensor_properties->sensor_unit_idx, sensor_properties->sensor_min_range, + sensor_properties->sensor_max_range, sensor_properties->sensor_resolution); + + + //Connect to the sensor through server . + my_handle = sf_connect(sensor_type); + if(my_handle < 0) + { + printf("\n Sensor Error : sf_connect FAILED with code %d",my_handle); + return -1; + } + + printf("\n Sensor test : sf_connect : handle is %d",my_handle); + + + //Start the communication + ret_val = sf_start(my_handle,0); + if(ret_val != 0) + { + printf("\n Sensor Error : sensor_start FAILED with code %d",ret_val); + return -1; + } + + + //Get the processed data from server + ret_val = sf_get_data(my_handle,get_data_id,sensor_data); + if(ret_val != 0) + { + printf("\n Sensor Error : sensor_get_data FAILED with code %d",ret_val); + return -1; + } + printf("\n Sensor Test: Gathered Data : \n X : %f \n Y : %f \n Z : %f \n Accuracy : %d \n + Unit ID : %d \n Time Stamp : %lld", sensor_data->values[0], sensor_data->values[1], + sensor_data->values[2], sensor_data->data_accuracy, sensor_data->data_unit_idx, + sensor_data->time_stamp); + + + //Get the rotation/orientation + ret_val = sf_check_rotation(&rotaion_state); + + if(ret_val != 0) + { + printf("\n Sensor Error : sf_check_rotation FAILED with code %d",ret_val); + return -1; + } + + switch(rotaion_state) + { + case ROTATION_EVENT_0 : + printf("\n Sensor test : Rotation ROTATION_EVENT_0 \n"); + break; + case ROTATION_EVENT_90: + printf("\n Sensor test : Rotation is ROTATION_EVENT_90 \n"); + break; + case ROTATION_EVENT_180 : + printf("\n Sensor test : Rotation is ROTATION_EVENT_180 \n"); + break; + case ROTATION_EVENT_270 : + printf("\n Sensor test : Rotation ROTATION_EVENT_270 \n"); + break; + default : + printf("\n Sensor test : Rotation is ROTATION_UNKNOWN \n"); + + } + + if(sensor_properties) + free(sensor_properties); + + if(sensor_data) + free(sensor_data); + + return 0; +} +@endcode + + +@} +@defgroup Use_Cases5 Subscribing and unsubscribing a Callback function for sensor events +@ingroup SENSOR_UC Use Cases +@{ + +<h2 class="pg">Subscribing and unsubscribing a Callback function for sensor events</h2> + +<b>API : sf_register_event</b><br> +<b>Parameter In</b> : int handle , unsigned int event_type , event_conditon_t *event_condition , sensor_callback_func_t cb , void *cb_data<br> +<b>Parameter Return</b> : int <br> +<b>Functionality</b> : This API registers a user defined callback function with a connected sensor for a particular event. This callback function will be called when there is a change in the state of respective sensor. cb_data will be the parameter used during the callback call. Callback interval can be adjusted using the event_condition_t argument.<br> + + + +<b>API : sf_unregister_event</b><br> +<b>Parameter In</b> : int handle, unsigned int event_type<br> +<b>Parameter Return</b> : int <br> +<b>Functionality</b> : This API de-registers a user defined callback function with a sensor registered with the specified handle. After unsubscribing, no event will be sent to the application.<br> + + +Sample code (This is an example showing how rotation event can be handled easily just by using these sensor framework API's) + + + +@code +#include <stdio.h> +#include <glib.h> +#include <sensor.h> + +static GMainLoop *mainloop; + +void my_callback_func(unsigned int event_type, sensor_event_data_t *event, void *data) +{ + int *my_event_data; + + if (event_type != ACCELEROMETER_EVENT_ROTATION_CHECK) { + printf("my_callback_func received data fail\n"); + return; + } + my_event_data = (int *)(event); + + switch( *my_event_data ) { + case ROTATION_EVENT_0: + printf("my_callback_func received data ROTATION_EVENT_0\n"); + break; + case ROTATION_EVENT_90: + printf("my_callback_func received data ROTATION_EVENT_90\n"); + break; + case ROTATION_EVENT_180: + printf("my_callback_func received data ROTATION_EVENT_180\n"); + break; + case ROTATION_EVENT_270: + printf("my_callback_func received data ROTATION_EVENT_270\n"); + break; + + default: + printf("my_callback_func received data unexpected\n"); + break; + } + +} + +static void sig_quit(int signo) +{ + if (mainloop) + { + g_main_loop_quit(mainloop); + } +} + +int main(int argc, char *argv[]) +{ + int handle; + int state; + + signal(SIGINT, sig_quit); + signal(SIGTERM, sig_quit); + signal(SIGQUIT, sig_quit); + + mainloop = g_main_loop_new(NULL, FALSE); + + handle = sf_connect( ACCELEROMETER_SENSOR ); + if (handle<0) { + printf("sensor attach fail\n"); + return -1; + + } + + + state = sf_register_event(handle, ACCELEROMETER_EVENT_ROTATION_CHECK, NULL , my_callback_func,NULL); + if (state<0) { + printf("sensor_register_cb fail\n"); + + } + + printf("Start SF\n"); + state = sf_start(handle, 0); + if (state<0) { + printf("SLP_sensor_start fail\n"); + + } + printf("Start SF done\n"); + + g_main_loop_run(mainloop); + g_main_loop_unref(mainloop); + + state = sf_unregister_event(handle, ACCELEROMETER_EVENT_ROTATION_CHECK ); + if (handle<0) { + printf("t sensor_unregister_cb fail\n"); + } + sf_stop(handle); + sf_disconnect(handle); + return 0; +} +@endcode + + + +@} +@defgroup Reference +@ingroup SENSOR_FRAMEWORK_PG +@{ + +<sub class="ref">Also see</sub> [ @ref SENSOR_FRAMEWORK API reference] + +<h1 class="pg">Appendixes</h1> + +<h2 class="pg">API Overview</h2> + + + +<table> + <tr> + <th>S No</th> + <th>API NAME</th> + <th>In parameter</th> + <th>Functionality</th> + </tr> + <tr> + <td>1</td> + <td>sf_is_sensor_event_available</td> + <td>sensor_type_t desired_sensor_type , unsigned int desired_event_type</td> + <td>This checks the availability of the sensor type and event type specified by the input parameters.</td> + </tr> + <tr> + <td>2</td> + <td>sf_get_properties</td> + <td>sensor_type_t sensor_type, sensor_properties_t *return_properties</td> + <td>This API retrieves the properties of a sensor type like data unit ID, max range, min range and resolution</td> + </tr> + <tr> + <td>3</td> + <td>sf_connect</td> + <td>sensor_type_t sensor_type</td> + <td>This API attaches/connects to a supplied type of sensor and returns an handle</td> + </tr> + <tr> + <td>4</td> + <td>sf_disconnect</td> + <td>sensor_type_t sensor_type</td> + <td>This API detaches/disconnects the handle from the sensor</td> + </tr> + <tr> + <td>5</td> + <td>sf_start</td> + <td>Int handle</td> + <td>This API sends start command to the sensor</td> + </tr> + <tr> + <td>6</td> + <td>sf_stop</td> + <td>Int handle</td> + <td>This API sends stop command to the sensor</td> + </tr> + <tr> + <td>7</td> + <td>sf_register_event</td> + <td>int handle , unsigned int event_type , event_conditon_t *event_condition , sensor_callback_func_t cb , void *cb_data</td> + <td>This API registers a user callback function with sensor . Whenever there is a change in the sensor state on a predefined event, this callback will be called</td> + </tr> + <tr> + <td>8</td> + <td>sf_unregister_event</td> + <td>int handle, unsigned int event_type</td> + <td>This API de-registers the user callback function for the change in stage of a predefined event</td> + </tr> + <tr> + <td>9</td> + <td>sf_get_data</td> + <td>int handle , unsigned int data_id , sensor_data_t* values</td> + <td>This API gets tje data (processed)from a sensor through the sensor server</td> + </tr> + <tr> + <td>10</td> + <td>sf_check_rotation</td> + <td>unsigned long *curr_state</td> + <td>This API gets the current rotation value such as ROTATION_LANDSCAPE_LEFT , ROTATION_PORTRAIT_TOP etc</td> + </tr> +</table> + + + +<h2 class="pg">Data structures</h2> +Few reference sample codes are attached for application developer to well understand the System Framework Module. + +<b>Sensor Type:</b> +@code +typedef enum { + UNKNOWN_SENSOR = 0x0000, + ACCELEROMETER_SENSOR = 0x0001, + GEOMAGNETIC_SENSOR = 0x0002, + LIGHT_SENSOR = 0x0004, + PROXIMITY_SENSOR = 0x0008, + THERMOMETER_SENSOR = 0x0010, + GYROSCOPE_SENSOR = 0x0020, + PRESSURE_SENSOR = 0x0040 +} sensor_type_t; +@endcode + +<b>Event Condition:</b> +@code +typedef enum { + CONDITION_NO_OP, + CONDITION_EQUAL, + CONDITION_GREAT_THAN, + CONDITION_LESS_THAN, +} condition_op_t; + +typedef struct { + condition_op_t cond_op; + float cond_value1; +} event_conditon_t; +@endcode + +<b>Sensor Event Data:</b> +@code +typedef struct { + size_t event_data_size; + void *event_data; +} sensor_event_data_t; +@endcode + + +<b>Call back function:</b> +@code +typedef void (*sensor_callback_func_t)(unsigned int, sensor_event_data_t *, void *); + +<b>Sensor Data:</b> +@code +typedef struct { + int data_accuracy; + int data_unit_idx; + unsigned long long time_stamp; + int values_num; + float values[12]; +} sensor_data_t; +@endcode + + +<b>Sensor Properties:</b> +@code +typedef struct { + int sensor_unit_idx; + float sensor_min_range; + float sensor_max_range; + float sensor_resolution; +} sensor_properties_t; +@endcode + + +<b>Sensor data unit index:</b> +@code +enum sensor_data_unit_idx { + SENSOR_UNDEFINED_UNIT, + SENSOR_UNIT_METRE_PER_SECOND_SQUARED, + SENSOR_UNIT_MICRO_TESLA, + SENSOR_UNIT_DEGREE, + SENSOR_UNIT_LUX, + SENSOR_UNIT_CENTIMETER, + SENSOR_UNIT_LEVEL_1_TO_10, + SENSOR_UNIT_STATE_ON_OFF, + SENSOR_UNIT_DEGREE_PER_SECOND, + SENSOR_UNIT_IDX_END +}; +@endcode + + +<b>Accelerometer Data ID:</b> +@code +enum accelerometer_data_id { + ACCELEROMETER_BASE_DATA_SET = (ACCELEROMETER_SENSOR<<16) | 0x0001, +}; +@endcode + + +<b>Accelerometer Event Type:</b> +@code +enum accelerometer_evet_type { + ACCELEROMETER_EVENT_ROTATION_CHECK + = (ACCELEROMETER_SENSOR<<16) |0x0001, + ACCELEROMETER_EVENT_RAW_DATA_REPORT_ON_TIME + = (ACCELEROMETER_SENSOR<<16) |0x0002, + ACCELEROMETER_EVENT_CALIBRATION_NEEDED + = (ACCELEROMETER_SENSOR<<16) |0x0004, +}; +@endcode + + +<b>Accelerometer Rotate state:</b> +@code +enum accelerometer_rotate_state { + ROTATION_UNKNOWN = 0, + ROTATION_LANDSCAPE_LEFT = 1, + ROTATION_PORTRAIT_TOP = 2, + ROTATION_PORTRAIT_BTM = 3, + ROTATION_LANDSCAPE_RIGHT = 4, + ROTATION_EVENT_0 = 2, + ROTATION_EVENT_90 = 1, + ROTATION_EVENT_180 = 3, + ROTATION_EVENT_270 = 4, +}; +@endcode + + +<b>Geo Magnetic Data ID:</b> +@code +enum geomag_data_id { + GEOMAGNETIC_BASE_DATA_SET = (GEOMAGNETIC_SENSOR<<16) | 0x0001, + GEOMAGNETIC_RAW_DATA_SET = (GEOMAGNETIC_SENSOR<<16) | 0x0002, +}; +@endcode + + +<b>Geo Magnetic Event Type:</b> +@code +enum geomag_evet_type { + GEOMAGNETIC_EVENT_CALIBRATION_NEEDED = (GEOMAGNETIC_SENSOR<<16) |0x0001, + GEOMAGNETIC_EVENT_ATTITUDE_DATA_REPORT_ON_TIME = (GEOMAGNETIC_SENSOR<<16) |0x0002, + GEOMAGNETIC_EVENT_RAW_DATA_REPORT_ON_TIME = (GEOMAGNETIC_SENSOR<<16) |0x0004, +}; +@endcode + + +<b>Gyro Data ID:</b> +@code +enum gyro_data_id { + GYRO_BASE_DATA_SET = (GYROSCOPE_SENSOR<<16) | 0x0001, +}; +@endcode + + +<b>Gyro Event Type:</b> +@code +enum gyro_evet_type { + GYROSCOPE_EVENT_RAW_DATA_REPORT_ON_TIME = (GYROSCOPE_SENSOR<<16) |0x0001, +}; +@endcode + + +<b>Light Data ID:</b> +@code +enum light_data_id { + LIGHT_BASE_DATA_SET = (LIGHT_SENSOR<<16) | 0x0001, +}; +@endcode + + +<b>Light Event Type:</b> +@code +enum light_evet_type { + LIGHT_EVENT_CHANGE_LEVEL = (LIGHT_SENSOR<<16) |0x0001, + LIGHT_EVENT_LEVEL_DATA_REPORT_ON_TIME = (LIGHT_SENSOR<<16) |0x0002, +}; +@endcode + + +<b>Proximity Data ID:</b> +@code +enum proxi_data_id { + PROXIMITY_BASE_DATA_SET = (PROXIMITY_SENSOR<<16) | 0x0001, +}; +@endcode + + +<b>Proximity Event Type:</b> +@code +enum proxi_evet_type { + PROXIMITY_EVENT_CHANGE_STATE = (PROXIMITY_SENSOR<<16) |0x0001, + PROXIMITY_EVENT_STATE_REPORT_ON_TIME = (PROXIMITY_SENSOR<<16) |0x0002, +}; +@endcode + + +<b>Proximity Change State:</b> +@code +enum proxi_change_state { + PROXIMITY_STATE_FAR = 0, + PROXIMITY_STATE_NEAR = 1, +}; +@endcode + + + +*/ +/** +*@} +*/ + +/** + * @defgroup SENSOR_UC Use Cases + * @ingroup SENSOR_FRAMEWORK_PG +*/ diff --git a/include/sensor.h b/include/sensor.h new file mode 100755 index 0000000..9f57e43 --- /dev/null +++ b/include/sensor.h @@ -0,0 +1,345 @@ +/* + * libslp-sensor + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: JuHyun Kim <jh8212.kim@samsung.com> + * + * 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. + * + */ + + + +#ifndef __SAMSUNG_LINUX_SENSOR_COMMON_H__ +#define __SAMSUNG_LINUX_SENSOR_COMMON_H__ + +#ifndef DEPRECATED +#define DEPRECATED __attribute__((deprecated)) +#endif + +#ifdef __cplusplus +extern "C" +{ +#endif + +#include <sys/types.h> + +/** + * @defgroup SENSOR_FRAMEWORK SensorFW + * To support the unified API for the various sensors + */ + +/** + * @defgroup SENSOR_FRAMEWORK_COMMON Sensor Framework Common API + * @ingroup SENSOR_FRAMEWORK + * + * These APIs are used to control the sensors. + * @{ + */ + +/** + * @file sensor.h + * @brief Sensor Framework common API header file + * for supporting application layer and communicate between App and Sensor Framework + * server. + * + * @author JuHyun Kim(jh8212.kim@samsung.com) + * @version 1.0 +*/ + + +typedef enum { + UNKNOWN_SENSOR = 0x0000, + ACCELEROMETER_SENSOR = 0x0001, + GEOMAGNETIC_SENSOR = 0x0002, + LIGHT_SENSOR = 0x0004, + PROXIMITY_SENSOR = 0x0008, + THERMOMETER_SENSOR = 0x0010, + GYROSCOPE_SENSOR = 0x0020, + BAROMETER_SENSOR = 0x0040, + MOTION_SENSOR = 0x0080, + FUSION_SENSOR = 0x0100, +} sensor_type_t; + +/*header for each sensor type*/ +#include <sensor_accel.h> +#include <sensor_geomag.h> +#include <sensor_light.h> +#include <sensor_proxi.h> +#include <sensor_motion.h> +#include <sensor_gyro.h> +#include <sensor_barometer.h> +#include <sensor_fusion.h> + +#define MAX_KEY_LEN 64 +#define MAX_VALUE_SIZE 12 + +typedef enum { + CONDITION_NO_OP, + CONDITION_EQUAL, + CONDITION_GREAT_THAN, + CONDITION_LESS_THAN, +} condition_op_t; + +typedef struct { + condition_op_t cond_op; + float cond_value1; +} event_condition_t; + + +typedef struct { + size_t event_data_size; + void *event_data; +} sensor_event_data_t; + +typedef void (*sensor_callback_func_t)(unsigned int, sensor_event_data_t *, void *); /**/ + +enum sensor_data_unit_idx { + SENSOR_UNDEFINED_UNIT, + SENSOR_UNIT_METRE_PER_SECOND_SQUARED, + SENSOR_UNIT_MICRO_TESLA, + SENSOR_UNIT_DEGREE, + SENSOR_UNIT_LUX, + SENSOR_UNIT_CENTIMETER, + SENSOR_UNIT_LEVEL_1_TO_10, + SENSOR_UNIT_STATE_ON_OFF, + SENSOR_UNIT_DEGREE_PER_SECOND, + SENSOR_UNIT_IDX_END +}; + +enum sensor_data_accuracy { + SENSOR_ACCURACY_UNDEFINED = -1, + SENSOR_ACCURACY_BAD = 0, + SENSOR_ACCURACY_NORMAL =1, + SENSOR_ACCURACY_GOOD = 2, + SENSOR_ACCURACY_VERYGOOD = 3 +}; + +enum sensor_start_option { + SENSOR_OPTION_DEFAULT = 0, + SENSOR_OPTION_ALWAYS_ON = 1, +}; + +typedef struct { + int data_accuracy; + int data_unit_idx; + unsigned long long time_stamp; + int values_num; + float values[MAX_VALUE_SIZE]; +} sensor_data_t; + +typedef struct { + int x; + int y; +} sensor_panning_data_t; + + +typedef struct { + int sensor_unit_idx; + float sensor_min_range; + float sensor_max_range; + float sensor_resolution; + char sensor_name[MAX_KEY_LEN]; + char sensor_vendor[MAX_KEY_LEN]; +} sensor_properties_t; + +typedef struct { + int sensor_unit_idx; + float sensor_min_range; + float sensor_max_range; + float sensor_resolution; +} sensor_data_properties_t; + + +/** + * @fn int sf_is_sensor_event_available ( sensor_type_t desired_sensor_type , unsigned int desired_event_type ) + * @brief This API loads the in parameter available list with the type of sensor available for operation . Some of the supported types are ACCELEROMETER_SENSOR_TYPE, GEOMAGNETIC_SENSOR_TYPE etc. This API will return 0 when it is available and negative value when it does not available. + * @param[in] desired_sensor_type your desired sensor type to check + * @param[in] desired_event_type your desired event type to check , if you want to check only sensor-available , set "0" value + * @return if it succeed, it return zero value(available) , otherwise negative value return (not available) + */ +int sf_is_sensor_event_available ( sensor_type_t desired_sensor_type , unsigned int desired_event_type ); + +/** + * @fn int sf_get_data_properties(unsigned data_id, sensor_dada_properties_t *return_data_properties) + * @brief This API loads the properties of data ID like unit of sensor data, max/min range of sensor data etc to the output parameter sensor_data_properties. + * @param[in] data_id your desired data ID + * @param[out] return_data_properties property information of your desired data ID + * @return if it succeed, it return zero value , otherwise negative value return + */ +int sf_get_data_properties(unsigned int data_id, sensor_data_properties_t *return_data_properties); + +/** + * @fn int sf_get_properties(sensor_type_t sensor_type, sensor_properties_t *return_properties) + * @brief This API loads the properties of sensor type like unit of sensor data, max/min range of sensor data etc to the output parameter sensor_properties. + * @param[in] sensor_type your desired sensor type + * @param[out] return_properties property information of your desired sensor + * @return if it succeed, it return zero value , otherwise negative value return + */ +int sf_get_properties(sensor_type_t sensor_type, sensor_properties_t *return_properties); + + +/** + * @fn int sf_set_property(sensor_type_t sensor_type, unsigned int property_id, long value) + * @brief This API set the property of sensor type like calibration, enable wakeup event, etc + * @param[in] sensor_type your desired sensor type, property_id your desired property ID, value for property input + * @return if it succeed, it return zero value , otherwise negative value return + */ +int sf_set_property(sensor_type_t sensor_type, unsigned int property_id, long value); + + +/** + * @fn int sf_connect(sensor_type_t sensor_type) + * @brief This API connects a sensor type to respective sensor. The application calls with the type of the sensor (ex. ACCELEROMETER_SENSOR) and on basis of that server takes decision of which plug-in to be connected. Once sensor connected application can proceed for data processing. This API returns a positive handle which should be used by application to communicate on sensor type. + * @param[in] sensor_type your desired sensor type + * @return if it succeed, it return handle value( >=0 ) , otherwise negative value return + */ +int sf_connect(sensor_type_t sensor_type); + + +/** + * @fn int sf_disconnect(int handle) + * @brief This API disconnects an attached sensor from an application. Application must use the handle retuned after attaching the sensor. After detaching, the corresponding handle will be released. + * @param[in] handle received handle value by sf_connect() + * @return if it succeed, it return zero value , otherwise negative value return + */ +int sf_disconnect(int handle); + + +/** + * @fn int sf_start(int handle , int option) + * @brief This API sends a start command to sensor server. This intimates server that the client side is ready to handle data and start processing. The parameter option should be '0' for current usages. + * @param[in] handle received handle value by sf_connect() + * @param[in] option With SENSOR_OPTION_DEFAULT, it stops to sense when LCD is off, and with SENSOR_OPTION_ALWAYS_ON, it continues to sense even when LCD is off + * @return if it succeed, it return zero value , otherwise negative value return + */ +int sf_start(int handle , int option); + + +/** + * @fn int sf_stop(int handle) + * @brief This API sends a stop command to the Sensor server indicating that the data processing is stopped from application side for this time. + * @param[in] handle received handle value by sf_connect() + * @return if it succeed, it return zero value , otherwise negative value return + */ +int sf_stop(int handle); + +/** + * @fn int sf_register_event(int handle , unsigned int event_type , event_conditon_t *event_condition , sensor_callback_func_t cb , void *cb_data ) + * @brief This API registers a user defined callback function with a connected sensor for a particular event. This callback function will be called when there is a change in the state of respective sensor. cb_data will be the parameter used during the callback call. Callback interval can be adjusted using even_contion_t argument. + * @param[in] handle received handle value by sf_connect() + * @param[in] event_type your desired event_type to register it + * @param[in] event_condition input event_condition for special event. if you want to register without event_condition, just use a NULL value + * @param[in] cb your define callback function + * @param[in] cb_data your option data that will be send when your define callback function called. if you don't have any option data, just use a NULL value + * @return if it succeed, it return zero value , otherwise negative value return + */ +int sf_register_event(int handle , unsigned int event_type , event_condition_t *event_condition , sensor_callback_func_t cb , void *cb_data ); + + +/** + * @fn int sf_unregister_event(int handle, unsigned int event_type) + * @brief This API de-registers a user defined callback function with a sensor registered with the specified handle. After unsubscribe, no event will be sent to the application. + * @param[in] handle received handle value by sf_connect() + * @param[in] event_type your desired event_type that you want to unregister event + * @return if it succeed, it return zero value , otherwise negative value return + */ +int sf_unregister_event(int handle, unsigned int event_type); + + +/** + * @fn int sf_get_data(int handle , unsigned int data_id , sensor_data_t* values) + * @brief This API gets raw data from a sensor with connecting the sensor-server. The type of sensor is supplied and return data is stored in the output parameter values []. + * @param[in] handle received handle value by sf_connect() + * @param[in] data_id predefined data_ID as every sensor in own header - sensor_xxx.h , enum xxx_data_id {} + * @param[out] values return values + * @return if it succeed, it return zero value , otherwise negative value return + */ +int sf_get_data(int handle , unsigned int data_id , sensor_data_t* values); + + +/** + * @fn int sf_check_rotation( unsigned long *curr_state) + * @brief This API used to get the current rotation state. (i.e. ROTATION_EVENT_0, ROTATION_EVENT_90, ROTATION_EVENT_180 & ROTATION_EVENT_270 ). This API will directly access the sensor without connection process with the sensor-server. Result will be stored in the output parameter state. + * @param[out] curr_state it will return enum accelerometer_rotate_state value + * @return if it succeed, it return zero value , otherwise negative value return + */ +int sf_check_rotation( unsigned long *curr_state); + + +/** + * @fn int sf_set_wakeup(sensor_type_t sensor_type) + * @brief This API used to set wakeup AP. + * @return if it succeed, it return zero value , otherwise negative value return + */ +int sf_set_wakeup(sensor_type_t sensor_type); + + +/** + * @fn int sf_unset_wakeup(sensor_type_t sensor_type) + * @brief This API used to unset wakeup function. + * @return if it succeed, it return zero value , otherwise negative value return + */ +int sf_unset_wakeup(sensor_type_t sensor_type); + + +/** + * @fn int sf_is_wakeup_supported(void) + * @brief This API will return 0 when it is available and negative value when it does not available + * @return if it succeed, it return zero value , otherwise negative value return + */ +int sf_is_wakeup_supported(sensor_type_t sensor_type); + + + +/** + * @fn int sf_is_wakeup_enabled(void) + * @brief This API check that wakeup is setted or unsetted + * @return if it succeed, it return zero value , otherwise negative value return + */ +int sf_is_wakeup_enabled(sensor_type_t sensor_type); + + + +/** + * @fn int sf_change_event_condition(int handle, unsigned int event_type, event_condition_t *event_condition) + * @brief This API change a user defined callback function condition with a sensor registered with the specified handle. + * @param[in] handle received handle value by sf_connect() + * @param[in] event_type your desired event_type that you want to unregister event + * @param[in] event_condition your desired event condition that you want to change event + * @return if it succeed, it return zero value , otherwise negative value return + */ +int sf_change_event_condition(int handle, unsigned int event_type, event_condition_t *event_condition); + + +/** + * @fn int sf_change_sensor_option(int handle, int option) + * @brief This API change sensor option . + * @param[in] handle received handle value by sf_connect() + * @param[in] option your desired option that you want to turn on sensor during LCD OFF + * @return if it succeed, it return zero value , otherwise negative value return + */ + +int sf_change_sensor_option(int handle, int option); +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + + +#endif +//! End of a file diff --git a/include/sensor_accel.h b/include/sensor_accel.h new file mode 100755 index 0000000..8befc8e --- /dev/null +++ b/include/sensor_accel.h @@ -0,0 +1,113 @@ +/* + * libslp-sensor + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: JuHyun Kim <jh8212.kim@samsung.com> + * + * 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. + * + */ + + + +#ifndef __SAMSUNG_LINUX_SENSOR_ACCEL_H__ +#define __SAMSUNG_LINUX_SENSOR_ACCEL_H__ + + +//! Pre-defined events for the accelometer sensor +//! Sensor Plugin developer can add more event to their own headers + +#ifdef __cplusplus +extern "C" +{ +#endif + +/** + * @defgroup SENSOR_ACCEL Accelerometer Sensor + * @ingroup SENSOR_FRAMEWORK + * + * These APIs are used to control the Accelerometer sensor. + * @{ + */ + +/** + * @file sensor_accel.h + * @brief This file contains the prototypes of the Accelerometer sensor API + * @author JuHyun Kim(jh8212.kim@samsung.com) + * @date 2010-01-24 + * @version 0.1 + */ + + +enum accelerometer_data_id { + ACCELEROMETER_BASE_DATA_SET = (ACCELEROMETER_SENSOR << 16) | 0x0001, + ACCELEROMETER_ORIENTATION_DATA_SET = (ACCELEROMETER_SENSOR << 16) | 0x0002, + ACCELEROMETER_LINEAR_ACCELERATION_DATA_SET = (ACCELEROMETER_SENSOR << 16) | 0x0004, + ACCELEROMETER_GRAVITY_DATA_SET = (ACCELEROMETER_SENSOR << 16) | 0x0008, +}; + +enum accelerometer_event_type { + ACCELEROMETER_EVENT_ROTATION_CHECK = (ACCELEROMETER_SENSOR << 16) | 0x0001, + ACCELEROMETER_EVENT_RAW_DATA_REPORT_ON_TIME = (ACCELEROMETER_SENSOR << 16) | 0x0002, + ACCELEROMETER_EVENT_CALIBRATION_NEEDED = (ACCELEROMETER_SENSOR << 16) | 0x0004, + ACCELEROMETER_EVENT_SET_HORIZON = (ACCELEROMETER_SENSOR << 16) | 0x0008, + ACCELEROMETER_EVENT_SET_WAKEUP = (ACCELEROMETER_SENSOR << 16) | 0x0010, + ACCELEROMETER_EVENT_ORIENTATION_DATA_REPORT_ON_TIME = (ACCELEROMETER_SENSOR << 16) | 0x0020, + ACCELEROMETER_EVENT_LINEAR_ACCELERATION_DATA_REPORT_ON_TIME = (ACCELEROMETER_SENSOR << 16) | 0x0040, + ACCELEROMETER_EVENT_GRAVITY_DATA_REPORT_ON_TIME = (ACCELEROMETER_SENSOR << 16) | 0x0080, +}; + + +enum accelerometer_rotate_state { + ROTATION_UNKNOWN = 0, + ROTATION_LANDSCAPE_LEFT = 1, + ROTATION_PORTRAIT_TOP = 2, + ROTATION_PORTRAIT_BTM = 3, + ROTATION_LANDSCAPE_RIGHT = 4, + ROTATION_EVENT_0 = 2, /*CCW base*/ + ROTATION_EVENT_90 = 1, /*CCW base*/ + ROTATION_EVENT_180 = 3, /*CCW base*/ + ROTATION_EVENT_270 = 4, /*CCW base*/ +}; + +enum accelerometer_property_id { + ACCELEROMETER_PROPERTY_UNKNOWN = 0, + ACCELEROMETER_PROPERTY_SET_CALIBRATION, + ACCELEROMETER_PROPERTY_CHECK_CALIBRATION_STATUS, + ACCELEROMETER_PROPERTY_SET_WAKEUP, + ACCELEROMETER_PROPERTY_CHECK_WAKEUP_STATUS, + ACCELEROMETER_PROPERTY_CHECK_WAKEUP_SUPPORTED, +}; + +enum accelerometer_wakeup_state { + WAKEUP_UNSET = 0, + WAKEUP_SET = 1, +}; + +struct rotation_event { + enum accelerometer_rotate_state rotation; + enum accelerometer_rotate_state rm[2]; +}; + + +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + +#endif +//! End of a file diff --git a/include/sensor_barometer.h b/include/sensor_barometer.h new file mode 100755 index 0000000..85820e6 --- /dev/null +++ b/include/sensor_barometer.h @@ -0,0 +1,84 @@ +/* + * libslp-sensor + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: JuHyun Kim <jh8212.kim@samsung.com> + * + * 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. + * + */ + + + +#ifndef __SAMSUNG_LINUX_SENSOR_BAROMETER_H__ +#define __SAMSUNG_LINUX_SENSOR_BAROMETER_H__ + +//! Pre-defined events for the barometerscope sensor +//! Sensor Plugin developer can add more event to their own headers + +#ifdef __cplusplus +extern "C" +{ +#endif + + +/** + * @defgroup SENSOR_BAROMETER barometer Sensor + * @ingroup SENSOR_FRAMEWORK + * + * These APIs are used to control the barometer sensor. + * @{ + */ + +/** + * @file sensor_barometer.h + * @brief This file contains the prototypes of the barometer sensor API + * @author JuHyun Kim(jh8212.kim@samsung.com) + * @date 2010-01-24 + * @version 0.1 + */ + + +enum barometer_data_id { + BAROMETER_BASE_DATA_SET = (BAROMETER_SENSOR<<16) | 0x0001, + BAROMETER_TEMPERATURE_DATA_SET = (BAROMETER_SENSOR<<16) | 0x0002, + BAROMETER_ALTITUDE_DATA_SET = (BAROMETER_SENSOR<<16) | 0x0004, +}; + + +enum barometer_evet_type { + BAROMETER_EVENT_RAW_DATA_REPORT_ON_TIME = (BAROMETER_SENSOR<<16) |0x0001, + BAROMETER_EVENT_TEMPERATURE_DATA_REPORT_ON_TIME = (BAROMETER_SENSOR<<16) |0x0002, + BAROMETER_EVENT_ALTITUDE_DATA_REPORT_ON_TIME = (BAROMETER_SENSOR<<16) |0x0004, + +}; + +enum barometer_property_id { + BAROMETER_PROPERTY_UNKNOWN = 0, + BAROMETER_PROPERTY_SET_CALIBRATION, + BAROMETER_PROPERTY_CHECK_CALIBRATION, +}; + + +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + + +#endif +//! End of a file diff --git a/include/sensor_fusion.h b/include/sensor_fusion.h new file mode 100755 index 0000000..d10add6 --- /dev/null +++ b/include/sensor_fusion.h @@ -0,0 +1,74 @@ +/* + * libslp-sensor + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: JuHyun Kim <jh8212.kim@samsung.com> + * + * 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. + * + */ + + + +#ifndef __SAMSUNG_LINUX_SENSOR_FUSION_H__ +#define __SAMSUNG_LINUX_SENSOR_FUSION_H__ + + +//! Pre-defined events for the accelometer sensor +//! Sensor Plugin developer can add more event to their own headers + +#ifdef __cplusplus +extern "C" +{ +#endif + +/** + * @defgroup SENSOR_FUSION Fusion Sensor + * @ingroup SENSOR_FRAMEWORK + * + * These APIs are used to control the Fusion sensor. + * @{ + */ + +/** + * @file sensor_accel.h + * @brief This file contains the prototypes of the Accelerometer sensor API + * @author JuHyun Kim(jh8212.kim@samsung.com) + * @date 2010-01-24 + * @version 0.1 + */ + + +enum fusion_data_id { + FUSION_BASE_DATA_SET = (FUSION_SENSOR << 16) | 0x0001, + FUSION_ROTATION_VECTOR_DATA_SET = (FUSION_SENSOR<< 16) | 0x0002, + FUSION_ROTATION_MATRIX_DATA_SET = (FUSION_SENSOR << 16) | 0x0004, +}; +enum fusion_evet_type_t { + FUSION_SENSOR_EVENT_RAW_DATA_REPORT_ON_TIME = (FUSION_SENSOR << 16) | 0x0001, + FUSION_ROTATION_VECTOR_EVENT_DATA_REPORT_ON_TIME = (FUSION_SENSOR << 16) | 0x0002, + FUSION_ROTATION_MATRIX_EVENT_DATA_REPORT_ON_TIME = (FUSION_SENSOR << 16) | 0x0004, +}; + + +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + +#endif +//! End of a file diff --git a/include/sensor_geomag.h b/include/sensor_geomag.h new file mode 100755 index 0000000..3c9c1ee --- /dev/null +++ b/include/sensor_geomag.h @@ -0,0 +1,84 @@ +/* + * libslp-sensor + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: JuHyun Kim <jh8212.kim@samsung.com> + * + * 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. + * + */ + + + +#ifndef __SAMSUNG_LINUX_SENSOR_GEOMAG_H__ +#define __SAMSUNG_LINUX_SENSOR_GEOMAG_H__ + +//! Pre-defined events for the geomagnetic sensor +//! Sensor Plugin developer can add more event to their own headers + +#ifdef __cplusplus +extern "C" +{ +#endif + + +/** + * @defgroup SENSOR_GEOMAG Geomagnetic Sensor + * @ingroup SENSOR_FRAMEWORK + * + * These APIs are used to control the Geomagnatic sensor. + * @{ + */ + +/** + * @file sensor_geomag.h + * @brief This file contains the prototypes of the Geomagnatic sensor API + * @author JuHyun Kim(jh8212.kim@samsung.com) + * @date 2010-01-24 + * @version 0.1 + */ + + + +enum geomag_data_id { + GEOMAGNETIC_BASE_DATA_SET = (GEOMAGNETIC_SENSOR<<16) | 0x0001, + GEOMAGNETIC_RAW_DATA_SET = (GEOMAGNETIC_SENSOR<<16) | 0x0001, + GEOMAGNETIC_ATTITUDE_DATA_SET = (GEOMAGNETIC_SENSOR<<16) | 0x0002, +}; + + +enum geomag_evet_type { + GEOMAGNETIC_EVENT_CALIBRATION_NEEDED = (GEOMAGNETIC_SENSOR<<16) |0x0001, + GEOMAGNETIC_EVENT_RAW_DATA_REPORT_ON_TIME = (GEOMAGNETIC_SENSOR<<16) |0x0002, + GEOMAGNETIC_EVENT_ATTITUDE_DATA_REPORT_ON_TIME = (GEOMAGNETIC_SENSOR<<16) |0x0004, +}; + +enum geomag_property_id { + GEOMAGNETIC_PROPERTY_UNKNOWN = 0, + GEOMAGNETIC_PROPERTY_SET_ACCEL_CALIBRATION, + GEOMAGNETIC_PROPERTY_CHECK_ACCEL_CALIBRATION, +}; + + +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + + +#endif +//! End of a file diff --git a/include/sensor_gyro.h b/include/sensor_gyro.h new file mode 100755 index 0000000..bd2574b --- /dev/null +++ b/include/sensor_gyro.h @@ -0,0 +1,79 @@ +/* + * libslp-sensor + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: JuHyun Kim <jh8212.kim@samsung.com> + * + * 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. + * + */ + + + +#ifndef __SAMSUNG_LINUX_SENSOR_GYRO_H__ +#define __SAMSUNG_LINUX_SENSOR_GYRO_H__ + +//! Pre-defined events for the gyroscope sensor +//! Sensor Plugin developer can add more event to their own headers + +#ifdef __cplusplus +extern "C" +{ +#endif + + +/** + * @defgroup SENSOR_GYRO Gyro Sensor + * @ingroup SENSOR_FRAMEWORK + * + * These APIs are used to control the gyro sensor. + * @{ + */ + +/** + * @file sensor_gyro.h + * @brief This file contains the prototypes of the gyro sensor API + * @author JuHyun Kim(jh8212.kim@samsung.com) + * @date 2010-01-24 + * @version 0.1 + */ + + +enum gyro_data_id { + GYRO_BASE_DATA_SET = (GYROSCOPE_SENSOR<<16) | 0x0001, +}; + + +enum gyro_evet_type { + GYROSCOPE_EVENT_RAW_DATA_REPORT_ON_TIME = (GYROSCOPE_SENSOR<<16) |0x0001, +}; + +enum gyro_property_id { + GYROSCOPE_PROPERTY_UNKNOWN = 0, + GYROSCOPE_PROPERTY_SET_CALIBRATION, + GYROSCOPE_PROPERTY_CHECK_CALIBRATION, +}; + + +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + + +#endif +//! End of a file diff --git a/include/sensor_light.h b/include/sensor_light.h new file mode 100755 index 0000000..c4af180 --- /dev/null +++ b/include/sensor_light.h @@ -0,0 +1,78 @@ +/* + * libslp-sensor + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: JuHyun Kim <jh8212.kim@samsung.com> + * + * 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. + * + */ + + + +#ifndef __SAMSUNG_LINUX_SENSOR_LIGHT_H__ +#define __SAMSUNG_LINUX_SENSOR_LIGHT_H__ + +//! Pre-defined events for the light sensor +//! Sensor Plugin developer can add more event to their own headers + +#ifdef __cplusplus +extern "C" +{ +#endif + +/** + * @defgroup SENSOR_LIGHT Light Sensor + * @ingroup SENSOR_FRAMEWORK + * + * These APIs are used to control the light sensor. + * @{ + */ + +/** + * @file sensor_light.h + * @brief This file contains the prototypes of the light sensor API + * @author JuHyun Kim(jh8212.kim@samsung.com) + * @date 2010-01-24 + * @version 0.1 + */ + + +enum light_data_id { + LIGHT_BASE_DATA_SET = (LIGHT_SENSOR<<16) | 0x0001, + LIGHT_LUX_DATA_SET = (LIGHT_SENSOR<<16) | 0x0002, +}; + + +enum light_evet_type { + LIGHT_EVENT_CHANGE_LEVEL = (LIGHT_SENSOR<<16) |0x0001, + LIGHT_EVENT_LEVEL_DATA_REPORT_ON_TIME = (LIGHT_SENSOR<<16) |0x0002, + LIGHT_EVENT_LUX_DATA_REPORT_ON_TIME = (LIGHT_SENSOR<<16) |0x0004, +}; + +enum light_property_id { + LIGHT_PROPERTY_UNKNOWN = 0, +}; + +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + + +#endif +//! End of a file diff --git a/include/sensor_motion.h b/include/sensor_motion.h new file mode 100755 index 0000000..82448cc --- /dev/null +++ b/include/sensor_motion.h @@ -0,0 +1,154 @@ +/* + * libslp-sensor + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: JuHyun Kim <jh8212.kim@samsung.com> + * + * 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. + * + */ + + + +#ifndef __SAMSUNG_LINUX_SENSOR_MOTION_H__ +#define __SAMSUNG_LINUX_SENSOR_MOTION_H__ + + +//! Pre-defined events for the motion sensor +//! Sensor Plugin developer can add more event to their own headers + +#ifdef __cplusplus +extern "C" +{ +#endif + + +enum motion_evet_type { + MOTION_ENGINE_EVENT_SNAP = (MOTION_SENSOR<<16) | 0x0001, + MOTION_ENGINE_EVENT_SHAKE = (MOTION_SENSOR<<16) | 0x0002, + MOTION_ENGINE_EVENT_DOUBLETAP = (MOTION_SENSOR<<16) | 0x0004, + MOTION_ENGINE_EVENT_PANNING = (MOTION_SENSOR<<16) | 0x0008, + MOTION_ENGINE_EVENT_TOP_TO_BOTTOM = (MOTION_SENSOR<<16) | 0x0010, + MOTION_ENGINE_EVENT_DIRECT_CALL = (MOTION_SENSOR<<16) | 0x0020, + MOTION_ENGINE_EVENT_TILT_TO_UNLOCK = (MOTION_SENSOR<<16) | 0x0040, + MOTION_ENGINE_EVENT_LOCK_EXECUTE_CAMERA = (MOTION_SENSOR<<16) | 0x0080, + MOTION_ENGINE_EVENT_SMART_ALERT = (MOTION_SENSOR<<16) | 0x0100, + MOTION_ENGINE_EVENT_TILT = (MOTION_SENSOR<<16) | 0x0200, + MOTION_ENGINE_EVENT_PANNING_BROWSE = (MOTION_SENSOR<<16) | 0x0400, + MOTION_ENGINE_EVENT_NO_MOVE = (MOTION_SENSOR<<16) | 0x0800, +}; + +enum motion_snap_event { + MOTION_ENGIEN_SNAP_NONE = 0, + MOTION_ENGIEN_NEGATIVE_SNAP_X = 1, + MOTION_ENGIEN_POSITIVE_SNAP_X = 2, + MOTION_ENGIEN_NEGATIVE_SNAP_Y = 3, + MOTION_ENGIEN_POSITIVE_SNAP_Y = 4, + MOTION_ENGIEN_NEGATIVE_SNAP_Z = 5, + MOTION_ENGIEN_POSITIVE_SNAP_Z = 6, + MOTION_ENGIEN_SNAP_LEFT = MOTION_ENGIEN_NEGATIVE_SNAP_X, + MOTION_ENGIEN_SNAP_RIGHT = MOTION_ENGIEN_POSITIVE_SNAP_X, + MOTION_ENGINE_SNAP_NONE = 0, + MOTION_ENGINE_NEGATIVE_SNAP_X = 1, + MOTION_ENGINE_POSITIVE_SNAP_X = 2, + MOTION_ENGINE_NEGATIVE_SNAP_Y = 3, + MOTION_ENGINE_POSITIVE_SNAP_Y = 4, + MOTION_ENGINE_NEGATIVE_SNAP_Z = 5, + MOTION_ENGINE_POSITIVE_SNAP_Z = 6, + MOTION_ENGINE_SNAP_LEFT = MOTION_ENGINE_NEGATIVE_SNAP_X, + MOTION_ENGINE_SNAP_RIGHT = MOTION_ENGINE_POSITIVE_SNAP_X, + + +}; + +enum motion_shake_event { + MOTION_ENGIEN_SHAKE_NONE = 0, + MOTION_ENGIEN_SHAKE_DETECTION = 1, + MOTION_ENGIEN_SHAKE_CONTINUING = 2, + MOTION_ENGIEN_SHAKE_FINISH = 3, + MOTION_ENGINE_SHAKE_BREAK = 4, + MOTION_ENGINE_SHAKE_NONE = 0, + MOTION_ENGINE_SHAKE_DETECTION = 1, + MOTION_ENGINE_SHAKE_CONTINUING = 2, + MOTION_ENGINE_SHAKE_FINISH = 3, + +}; + +enum motion_doubletap_event { + MOTION_ENGIEN_DOUBLTAP_NONE = 0, + MOTION_ENGIEN_DOUBLTAP_DETECTION = 1, + MOTION_ENGINE_DOUBLTAP_NONE = 0, + MOTION_ENGINE_DOUBLTAP_DETECTION = 1, + +}; + +enum motion_top_to_bottom_event { + MOTION_ENGIEN_TOP_TO_BOTTOM_NONE = 0, + MOTION_ENGIEN_TOP_TO_BOTTOM_WAIT = 1, + MOTION_ENGIEN_TOP_TO_BOTTOM_DETECTION = 2, + MOTION_ENGINE_TOP_TO_BOTTOM_NONE = 0, + MOTION_ENGINE_TOP_TO_BOTTOM_WAIT = 1, + MOTION_ENGINE_TOP_TO_BOTTOM_DETECTION = 2, + +}; + +enum motion_direct_call_event_t { + MOTION_ENGINE_DIRECT_CALL_NONE, + MOTION_ENGINE_DIRECT_CALL_DETECTION, +}; + +enum motion_tilt_to_unlock_event_t { + MOTION_ENGINE_TILT_TO_UNLOCK_NONE, + MOTION_ENGINE_TILT_TO_UNLOCK_DETECTION, +}; + +enum motion_lock_execute_camera_event_t { + MOTION_ENGINE_LOCK_EXECUTE_CAMERA_NONE, + MOTION_ENGINE_LOCK_EXECUTE_CAMERA_L_DETECTION, + MOTION_ENGINE_LOCK_EXECUTE_CAMERA_R_DETECTION, +}; + +enum motion_smart_alert_t { + MOTION_ENGINE_SMART_ALERT_NONE, + MOTION_ENGINE_SMART_ALERT_DETECTION, +}; + +enum motion_no_move_t { + MOTION_ENGINE_NO_MOVE_NONE, + MOTION_ENGINE_NO_MOVE_DETECTION, +}; + +enum motion_property_id { + MOTION_PROPERTY_UNKNOWN = 0, + MOTION_PROPERTY_CHECK_ACCEL_SENSOR, + MOTION_PROPERTY_CHECK_GYRO_SENSOR, + MOTION_PROPERTY_CHECK_GEO_SENSOR, + MOTION_PROPERTY_CHECK_PRIXI_SENSOR, + MOTION_PROPERTY_CHECK_LIGHT_SENSOR, + MOTION_PROPERTY_CHECK_BARO_SENSOR, + MOTION_PROPERTY_LCD_TOUCH_ON, + MOTION_PROPERTY_LCD_TOUCH_OFF, +}; + + +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + +#endif +//! End of a file diff --git a/include/sensor_proxi.h b/include/sensor_proxi.h new file mode 100755 index 0000000..fafc0fd --- /dev/null +++ b/include/sensor_proxi.h @@ -0,0 +1,80 @@ +/* + * libslp-sensor + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: JuHyun Kim <jh8212.kim@samsung.com> + * + * 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. + * + */ + + + +#ifndef __SAMSUNG_LINUX_SENSOR_PROXI_H__ +#define __SAMSUNG_LINUX_SENSOR_PROXI_H__ + +#ifdef __cplusplus +extern "C" +{ +#endif + + +/** + * @defgroup SENSOR_PROXY Proximity Sensor + * @ingroup SENSOR_FRAMEWORK + * + * These APIs are used to control the Proxymaty sensor. + * @{ + */ + +/** + * @file sensor_proxi.h + * @brief This file contains the prototypes of the proximaty sensor API + * @author JuHyun Kim(jh8212.kim@samsung.com) + * @date 2010-01-24 + * @version 0.1 + */ + + +enum proxi_data_id { + PROXIMITY_BASE_DATA_SET = (PROXIMITY_SENSOR<<16) | 0x0001, + PROXIMITY_DISTANCE_DATA_SET = (PROXIMITY_SENSOR<<16) | 0x0002, +}; + +enum proxi_evet_type { + PROXIMITY_EVENT_CHANGE_STATE = (PROXIMITY_SENSOR<<16) |0x0001, + PROXIMITY_EVENT_STATE_REPORT_ON_TIME = (PROXIMITY_SENSOR<<16) |0x0002, + PROXIMITY_EVENT_DISTANCE_DATA_REPORT_ON_TIME = (PROXIMITY_SENSOR<<16) |0x0004, +}; + +enum proxi_change_state { + PROXIMITY_STATE_FAR = 0, + PROXIMITY_STATE_NEAR = 1, +}; + +enum proxi_property_id { + PROXIMITY_PROPERTY_UNKNOWN = 0, +}; + +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + + +#endif +//! End of a file |