j3d1/esp-open-rtos
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

minor changes and typos

Browse source
This commit is contained in:
Gunar Schorcht 2017-12-30 17:35:56 +01:00
parent 2ae145dcc0
commit 561c700531
5 changed files with 519 additions and 428 deletions
Download patch file Download diff file Expand all files Collapse all files

101
examples/lis3dh/lis3dh_example.c
View file

@ -30,13 +30,13 @@
/* -- use following constants to define the example mode ----------- */ /* -- use following constants to define the example mode ----------- */
// #define SPI_USED // if defined SPI is used, otherwise I2C // #define SPI_USED // SPI interface is used, otherwise I2C
// #define DATA_INT // data ready and FIFO status interrupts
// #define CLICK_INT // click detection interrupt
// #define ACTIVITY_INT // wake-up, free fall or 6D/4D orientation detection
// #define FIFO_MODE // multiple sample read mode // #define FIFO_MODE // multiple sample read mode
// #define INT_DATA // data interrupts used (data ready and FIFO status)
// #define INT_EVENT // inertial event interrupts used (wake-up, free fall or 6D/4D orientation)
// #define INT_CLICK // click detection interrupts used
#if defined(DATA_INT) || defined(ACTIVITY_INT) || defined(CLICK_INT) #if defined(INT_DATA) || defined(INT_EVENT) || defined(INT_CLICK)
#define INT_USED #define INT_USED
#endif #endif
@ -146,23 +146,40 @@ void user_task_interrupt (void *pvParameters)
{ {
if (xQueueReceive(gpio_evt_queue, &gpio_num, portMAX_DELAY)) if (xQueueReceive(gpio_evt_queue, &gpio_num, portMAX_DELAY))
{ {
lis3dh_int_activity_source_t activity_src; lis3dh_int_data_source_t data_src = {};
lis3dh_int_data_source_t data_src; lis3dh_int_event_source_t event_src = {};
lis3dh_int_click_source_t click_src; lis3dh_int_click_source_t click_src = {};
// get the source of the interrupt and reset INT signals // get the source of the interrupt and reset *INTx* signals
lis3dh_get_int_activity_source (sensor, &activity_src, lis3dh_int1_signal); #ifdef INT_DATA
lis3dh_get_int_data_source (sensor, &data_src); lis3dh_get_int_data_source (sensor, &data_src);
lis3dh_get_int_click_source (sensor, &click_src); #elif INT_EVENT
lis3dh_get_int_event_source (sensor, &event_src, lis3dh_int_event1_gen);
#elif INT_CLICK
lis3dh_get_int_click_source (sensor, &click_src);
#endif
// in case of DRDY interrupt or activity interrupt read one data sample // in case of DRDY interrupt or inertial event interrupt read one data sample
if (data_src.data_ready || activity_src.active) if (data_src.data_ready)
read_data (); read_data ();
// in case of FIFO interrupts read the whole FIFO // in case of FIFO interrupts read the whole FIFO
else if (data_src.fifo_watermark || data_src.fifo_overrun) else if (data_src.fifo_watermark || data_src.fifo_overrun)
read_data (); read_data ();
// in case of event interrupt
else if (event_src.active)
{
printf("%.3f LIS3DH ", (double)sdk_system_get_time()*1e-3);
if (event_src.x_low) printf("x is lower than threshold\n");
if (event_src.y_low) printf("y is lower than threshold\n");
if (event_src.z_low) printf("z is lower than threshold\n");
if (event_src.x_high) printf("x is higher than threshold\n");
if (event_src.y_high) printf("y is higher than threshold\n");
if (event_src.z_high) printf("z is higher than threshold\n");
}
// in case of click detection interrupt
else if (click_src.active) else if (click_src.active)
printf("%.3f LIS3DH %s\n", (double)sdk_system_get_time()*1e-3, printf("%.3f LIS3DH %s\n", (double)sdk_system_get_time()*1e-3,
click_src.s_click ? "single click" : "double click"); click_src.s_click ? "single click" : "double click");
@ -260,41 +277,42 @@ void user_init(void)
// set polarity of INT signals if necessary // set polarity of INT signals if necessary
// lis3dh_config_int_signals (sensor, lis3dh_high_active); // lis3dh_config_int_signals (sensor, lis3dh_high_active);
#ifdef DATA_INT #ifdef INT_DATA
// enable data interrupts on INT1 (data ready or FIFO status interrupts) // enable data interrupts on INT1 (data ready or FIFO status interrupts)
// data ready and FIFO status interrupts must not be enabled at the same time // data ready and FIFO status interrupts must not be enabled at the same time
#ifdef FIFO_MODE #ifdef FIFO_MODE
lis3dh_enable_int_data (sensor, lis3dh_fifo_overrun, true); lis3dh_enable_int (sensor, lis3dh_int_fifo_overrun , lis3dh_int1_signal, true);
lis3dh_enable_int_data (sensor, lis3dh_fifo_watermark, true); lis3dh_enable_int (sensor, lis3dh_int_fifo_watermark, lis3dh_int1_signal, true);
#else #else
lis3dh_enable_int_data (sensor, lis3dh_data_ready, true); lis3dh_enable_int (sensor, lis3dh_int_data_ready, lis3dh_int1_signal, true);
#endif // FIFO_MODE #endif // FIFO_MODE
#endif // DATA_INT #endif // INT_DATA
#ifdef ACTIVITY_INT #ifdef INT_EVENT
// enable data interrupts on INT1 // enable data interrupts on INT1
lis3dh_int_activity_config_t act_config; lis3dh_int_event_config_t event_config;
act_config.activity = lis3dh_wake_up; event_config.mode = lis3dh_wake_up;
// act_config.activity = lis3dh_free_fall; // event_config.mode = lis3dh_free_fall;
// act_config.activity = lis3dh_6d_movement; // event_config.mode = lis3dh_6d_movement;
// act_config.activity = lis3dh_6d_position; // event_config.mode = lis3dh_6d_position;
// act_config.activity = lis3dh_4d_movement; // event_config.mode = lis3dh_4d_movement;
// act_config.activity = lis3dh_4d_position; // event_config.mode = lis3dh_4d_position;
act_config.threshold = 10; event_config.threshold = 10;
act_config.x_low_enabled = false; event_config.x_low_enabled = false;
act_config.x_high_enabled = true; event_config.x_high_enabled = true;
act_config.y_low_enabled = false; event_config.y_low_enabled = false;
act_config.y_high_enabled = true; event_config.y_high_enabled = true;
act_config.z_low_enabled = false; event_config.z_low_enabled = false;
act_config.z_high_enabled = true; event_config.z_high_enabled = true;
act_config.duration = 0; event_config.duration = 0;
act_config.latch = true; event_config.latch = true;
lis3dh_set_int_activity_config (sensor, lis3dh_int1_signal, &act_config); lis3dh_set_int_event_config (sensor, &event_config, lis3dh_int_event1_gen);
#endif // ACTIVITY_INT lis3dh_enable_int (sensor, lis3dh_int_event1, lis3dh_int1_signal, true);
#endif // INT_EVENT
#ifdef CLICK_INT #ifdef INT_CLICK
// enable click interrupt on INT1 // enable click interrupt on INT1
lis3dh_int_click_config_t click_config; lis3dh_int_click_config_t click_config;
@ -310,8 +328,9 @@ void user_init(void)
click_config.time_latency = 1; click_config.time_latency = 1;
click_config.time_window = 3; click_config.time_window = 3;
lis3dh_set_int_click_config (sensor, lis3dh_int1_signal, &click_config); lis3dh_set_int_click_config (sensor, &click_config);
#endif // CLICK_INT lis3dh_enable_int (sensor, lis3dh_int_click, lis3dh_int1_signal, true);
#endif // INT_CLICK
#ifdef FIFO_MODE #ifdef FIFO_MODE
// clear FIFO and activate FIFO mode if needed // clear FIFO and activate FIFO mode if needed

240
extras/lis3dh/README.md
View file

@ -153,7 +153,7 @@ The high pass filter can independently apply to
- the raw output data, - the raw output data,
- the data used for click detection, and - the data used for click detection, and
- the data used for interrupt generation like wake-up, free fall or 6D/4D orientation detection. - the data used for inertial interrupt generation like wake-up, free fall or 6D/4D orientation detection.
The mode and the cutoff frequency of the high pass filter can be configured using function ```lis3dh_config_hpf```. Following HPF modes are available: The mode and the cutoff frequency of the high pass filter can be configured using function ```lis3dh_config_hpf```. Following HPF modes are available:
@ -241,26 +241,26 @@ void user_task_periodic (void *pvParameters)
The LIS3DH supports two dedicated interrupt signals **```INT1```** and **```INT2```** and three different types of interrupts: The LIS3DH supports two dedicated interrupt signals **```INT1```** and **```INT2```** and three different types of interrupts:
- data ready and FIFO status interrupts, - data interrupts (data ready and FIFO status),
- activity detection interrupts like wake-up, free fall, and 6D/4D orientation detection, and - inertial event interrupts (axis movement, wake-up, free fall, and 6D/4D orientation detection), and
- click detection interrupts. - click detection interrupts.
While activity detection and click detection interrupts can be configured for both interrupt signals, data ready and FIFO status interrupts can be configured only for interrupt signal ```INT1```. While inertial event interrupts and click detection interrupts can be configured for both interrupt signals, data ready and FIFO status interrupts can be configured only for interrupt signal ```INT1```.
#### Data ready and FIFO status interrupts #### Data interrupts (data ready and FIFO status)
Following sources can generate an interrupt on signal ```INT1```: Following sources can generate an interrupt on signal ```INT1```:
Interrupt source | Driver symbol Interrupt source | Driver symbol
:-----------------|:------------- :-----------------|:-------------
Output data become ready to read | lis3dh_data_ready Output data become ready to read | lis3dh_int_data_ready
FIFO content exceeds the watermark level | lis3dh_fifo_watermark FIFO content exceeds the watermark level | lis3dh_int_fifo_watermark
FIFO is completely filled | lis3dh_fifo_overrun FIFO is completely filled | lis3dh_int_fifo_overrun
Each of these interrupt sources can be enabled or disabled separately with function ```lis3dh_enable_int_data```. By default all interrupt sources are disabled. Each of these interrupt sources can be enabled or disabled separately with function ```lis3dh_enable_int```. By default all interrupt sources are disabled.
``` ```
lis3dh_enable_int_data (sensor, lis3dh_data_ready, true); lis3dh_enable_int (sensor, lis3dh_int_data_ready, lis3dh_int1_signal, true);
``` ```
Whenever an interrupt is generated at interrupt signal ```INT1```, the function ```lis3dh_get_int_data_source``` can be used to determine the source of the interrupt. This function returns a data structure of type ```lis3dh_int_data_source_t``` that contain a boolean member for each source that can be tested for true. Whenever an interrupt is generated at interrupt signal ```INT1```, the function ```lis3dh_get_int_data_source``` can be used to determine the source of the interrupt. This function returns a data structure of type ```lis3dh_int_data_source_t``` that contain a boolean member for each source that can be tested for true.
@ -270,114 +270,118 @@ void int1_handler ()
{ {
lis3dh_int_data_source_t data_src; lis3dh_int_data_source_t data_src;
// get interrupt source of INT1 // get the interrupt source of INT1
lis3dh_get_int_data_source (sensor, &data_src); lis3dh_get_int_data_source (sensor, &data_src);
// if data ready interrupt, get the results and do something with them // in case of data ready interrupt, get the results and do something with them
if (data_src.data_ready) if (data_src.data_ready)
// ... read data // ... read data
// in case of FIFO interrupts read the whole FIFO // in case of FIFO interrupts read the whole FIFO
else if (data_src.fifo_watermark || data_src.fifo_overrun) else if (data_src.fifo_watermark || data_src.fifo_overrun)
// read FIFO data // ... read FIFO data
... ...
} }
``` ```
#### Activity detection interrupts #### Inertial event interrupts
Activity detection allows to generate interrupts whenever a configured condition occur. If activated, the acceleration of each axis is compared with a defined threshold to check whether it is below or above the threshold. The results of all activated comparisons are then combined OR or AND to generate the interrupt signal. Inertial interrupt generators allow to generate interrupts when certain inertial event occures (event interrupts), that is, the acceleration of defined axes is higher or lower than a defined threshold. If activated, the acceleration of each axis is compared with a defined threshold to check whether it is below or above the threshold. The results of all activated comparisons are then combined OR or AND to generate the interrupt signal.
The configuration of the threshold valid for all axes, the activated comparisons and the selected AND/OR combination allows to recognize special situations: The configuration of the threshold valid for all axes, the activated comparisons and the selected AND/OR combination allows to recognize special situations:
- **Wake-up detection** refers the special condition that the acceleration measured along any axis is above the defined threshold (```lis3dh_wake_up```). - **Wake-up detection** refers the special condition that the acceleration measured along any axis is above the defined threshold (```lis3dh_wake_up```).
- **Free fall detection** refers the special condition that the acceleration measured along all the axes goes to zero (```lis3dh_free_fall```). - **Free fall detection** refers the special condition that the acceleration measured along all the axes goes to zero (```lis3dh_free_fall```).
- **6D/4D Orientation Detection** refers to the special condition that the measured acceleration along certain axes is above and along the other axes is below the threshold which indicates a particular orientation (```lis3dh_6d_movement```, ```lis3dh_6d_position```, ```lis3dh_4d_movement```, ```lis3dh_4d_position```). - **6D/4D orientation detection** refers to the special condition that the measured acceleration along certain axes is above and along the other axes is below the threshold which indicates a particular orientation (```lis3dh_6d_movement```, ```lis3dh_6d_position```, ```lis3dh_4d_movement```, ```lis3dh_4d_position```).
Activity detection interrupts can be configured with the function ```lis3dh_get_int_activity_config```. This function requires as parameters the configuration of type ```lis3dh_int_activity_config_t``` and the interrupt signal to be used for activity detection interrupts. Inertial event interrupts can be configured with the function ```lis3dh_get_int_event_config```. This function requires as parameters the configuration of type ```lis3dh_int_event_config_t``` and the interrupt generator to be used for inertial event interrupts.
Inertial event interrupts have to be enabled or disabled using function ```lis3dh_enable_int```. The interrupt signal on which the interrupts are generated is given as parameter.
For example, wake-up detection interrupt on signal ```INT1``` could be configured as following: For example, wake-up detection interrupt on signal ```INT1``` could be configured as following:
``` ```
lis3dh_int_activity_config_t act_config; lis3dh_int_event_config_t event_config;
act_config.activity = lis3dh_wake_up; event_config.mode = lis3dh_wake_up;
act_config.threshold = 10; event_config.threshold = 10;
act_config.x_low_enabled = false; event_config.x_low_enabled = false;
act_config.x_high_enabled = true; event_config.x_high_enabled = true;
act_config.y_low_enabled = false; event_config.y_low_enabled = false;
act_config.y_high_enabled = true; event_config.y_high_enabled = true;
act_config.z_low_enabled = false; event_config.z_low_enabled = false;
act_config.z_high_enabled = true; event_config.z_high_enabled = true;
act_config.duration = 0; event_config.duration = 0;
act_config.latch = true; event_config.latch = true;
lis3dh_set_int_activity_config (sensor, lis3dh_int1_signal, &act_config); lis3dh_set_int_event_config (sensor, &event_config, lis3dh_int_event1_gen);
``` lis3dh_enable_int (sensor, lis3dh_int_event1, lis3dh_int1_signal, true);
```
The parameter of type ```lis3dh_int_activity_config_t``` also configures The parameter of type ```lis3dh_int_event_config_t``` also configures
- whether the interrupt signal should latched until the interrupt source is read, and - whether the interrupt should be latched until the interrupt source is read, and
- which time in 1/ODR an interrupt condition has to be given before the interrupt is generated. - which time given in 1/ODR an interrupt condition has to be given before the interrupt is generated.
As with data ready and FIFO status interrupts, function ```lis3dh_get_int_activity_source``` can be used to determine the source of an activity interrupt whenever it is generated. This function returns a data structure of type ```lis3dh_int_activity_source_t``` which contains a boolean member for each source that can be tested for true. As with data ready and FIFO status interrupts, function ```lis3dh_get_int_event_source``` can be used to determine the source of an inertial event interrupt whenever it is generated. This function returns a data structure of type ```lis3dh_int_event_source_t``` which contains a boolean member for each source that can be tested for true.
``` ```
void int1_handler () void int1_handler ()
{ {
lis3dh_int_data_source_t data_src; lis3dh_int_data_source_t data_src;
lis3dh_int_activity_source_t activity_src; lis3dh_int_event_source_t event_src;
// get interrupt source of INT1 // get the interrupt source of INT1
lis3dh_get_int_data_source (sensor, &data_src); lis3dh_get_int_data_source (sensor, &data_src);
lis3dh_get_int_activity_source (sensor, &activity_src, lis3dh_int1_signal); lis3dh_get_int_event_source (sensor, &event_src, lis3dh_int_event1_gen);
// if data ready interrupt, get the results and do something with them // in case of data ready interrupt, get the results and do something with them
if (data_src.data_ready) if (data_src.data_ready)
// ... read data // ... read data
// in case of FIFO interrupts read the whole FIFO // in case of FIFO interrupts read the whole FIFO
else if (data_src.fifo_watermark || data_src.fifo_overrun) else if (data_src.fifo_watermark || data_src.fifo_overrun)
// read FIFO data // ... read FIFO data
// in case of activity interrupt // in case of inertial event interrupt
else if (activity_src.active) else if (event_src.active)
// ... read data // ... read data
... ...
} }
``` ```
**Please note** Activating all threshold comparisons and the OR combination (```lis3dh_wake_up```) is the most flexible way to deal with activity interrupts. Functions such as free fall detection and so on can then be realized by suitably combining the various interrupt sources by the user task. Following example realizes the free fall detection in user task. **Please note** Activating all threshold comparisons and the OR combination (```lis3dh_wake_up```) is the most flexible way to deal with inertial event interrupts. Functions such as free fall detection and so on can then be realized by suitably combining the various interrupt sources by the user task. Following example realizes the free fall detection in user task.
``` ```
lis3dh_int_activity_config_t act_config; lis3dh_int_event_config_t event_config;
act_config.activity = lis3dh_wake_up; event_config.mode = lis3dh_wake_up;
act_config.threshold = 10; event_config.threshold = 10;
act_config.x_low_enabled = true; event_config.x_low_enabled = true;
act_config.x_high_enabled = true; event_config.x_high_enabled = true;
act_config.y_low_enabled = true; event_config.y_low_enabled = true;
act_config.y_high_enabled = true; event_config.y_high_enabled = true;
act_config.z_low_enabled = true; event_config.z_low_enabled = true;
act_config.z_high_enabled = true; event_config.z_high_enabled = true;
act_config.duration = 0; event_config.duration = 0;
act_config.latch = true; event_config.latch = true;
lis3dh_set_int_activity_config (sensor, lis3dh_int1_signal, &act_config); lis3dh_set_int_event_config (sensor, &event_config, lis3dh_int_event1_gen);
lis3dh_enable_int (sensor, lis3dh_int_event1, lis3dh_int1_signal, true);
``` ```
``` ```
void int1_handler () void int1_handler ()
{ {
lis3dh_int_activity_source_t activity_src; lis3dh_int_event_source_t event_src;
// get interrupt source of INT1 // get the interrupt source of INT1
lis3dh_get_int_activity_source (sensor, &activity_src, lis3dh_int1_signal); lis3dh_get_int_event_source (sensor, &event_src, lis3dh_int1_signal);
// detect free fall (all accelerations are below the threshold) // detect free fall (all accelerations are below the threshold)
if (activity_src.x_low && activity_src.y_low && activity_src.z_low) if (event_src.x_low && event_src.y_low && event_src.z_low)
... ...
... ...
} }
@ -390,6 +394,8 @@ A sequence of acceleration values over time measured along certain axes can be u
Click detection interrupts are configured with function ```lis3dh_set_int_click_config```. This function requires as parameters the configuration of type ```lis3dh_int_click_config_t``` and the interrupt signal to be used for click detection interrupts. Click detection interrupts are configured with function ```lis3dh_set_int_click_config```. This function requires as parameters the configuration of type ```lis3dh_int_click_config_t``` and the interrupt signal to be used for click detection interrupts.
Inertial event interrupts have to be enabled or disabled using function ```lis3dh_enable_int```. The interrupt signal on which the interrupts are generated is given as parameter.
In following example, the single click detection for z-axis is enabled with a time limit of 1/ODR, a time latency of 1/ODR and a time window of 3/ODR. In following example, the single click detection for z-axis is enabled with a time limit of 1/ODR, a time latency of 1/ODR and a time window of 3/ODR.
``` ```
@ -407,7 +413,8 @@ click_config.time_limit = 1;
click_config.time_latency = 1; click_config.time_latency = 1;
click_config.time_window = 3; click_config.time_window = 3;
lis3dh_set_int_click_config (sensor, lis3dh_int1_signal, &click_config); lis3dh_set_int_click_config (sensor, &click_config);
lis3dh_enable_int (sensor, lis3dh_int_click, lis3dh_int1_signal, true);
``` ```
As with other interrupts, the function ```lis3dh_get_int_click_source``` can be used to determine the source of the interrupt signal whenever it is generated. This function returns a data structure of type ```lis3dh_int_click_source_t``` that contains a boolean member for each source that can be tested for true. As with other interrupts, the function ```lis3dh_get_int_click_source``` can be used to determine the source of the interrupt signal whenever it is generated. This function returns a data structure of type ```lis3dh_int_click_source_t``` that contains a boolean member for each source that can be tested for true.
@ -417,7 +424,7 @@ void int1_handler ()
{ {
lis3dh_int_click_source_t click_src; lis3dh_int_click_source_t click_src;
// get interrupt source of INT1 // get the interrupt source of INT1
lis3dh_get_int_click_source (sensor, &click_src); lis3dh_get_int_click_source (sensor, &click_src);
// detect single click along z-axis // detect single click along z-axis
@ -690,15 +697,13 @@ lis3dh_set_mode (sensor, lis3dh_odr_10, lis3dh_high_res, true, true, true);
## Full Example ## Full Example
``` ```
/* -- use following constants to define the example mode ----------- */ // #define SPI_USED // SPI interface is used, otherwise I2C
// #define SPI_USED // if defined SPI is used, otherwise I2C
#define DATA_INT // data ready and FIFO status interrupts
// #define CLICK_INT // click detection interrupt
// #define ACTIVITY_INT // wake-up, free fall or 6D/4D orientation detection
// #define FIFO_MODE // multiple sample read mode // #define FIFO_MODE // multiple sample read mode
// #define INT_DATA // data interrupts used (data ready and FIFO status)
// #define INT_EVENT // inertial event interrupts used (wake-up, free fall or 6D/4D orientation)
// #define INT_CLICK // click detection interrupts used
#if defined(DATA_INT) || defined(ACTIVITY_INT) || defined(CLICK_INT) #if defined(INT_DATA) || defined(INT_EVENT) || defined(INT_CLICK)
#define INT_USED #define INT_USED
#endif #endif
@ -744,7 +749,7 @@ lis3dh_set_mode (sensor, lis3dh_odr_10, lis3dh_high_res, true, true, true);
#define INT1_PIN 5 #define INT1_PIN 5
#define INT2_PIN 4 #define INT2_PIN 4
/* -- user tasks ---------------------------------------------- */ /* -- user tasks --------------------------------------------------- */
static lis3dh_sensor_t* sensor; static lis3dh_sensor_t* sensor;
@ -802,29 +807,46 @@ static QueueHandle_t gpio_evt_queue = NULL;
void user_task_interrupt (void *pvParameters) void user_task_interrupt (void *pvParameters)
{ {
uint32_t gpio_num; uint8_t gpio_num;
while (1) while (1)
{ {
if (xQueueReceive(gpio_evt_queue, &gpio_num, portMAX_DELAY)) if (xQueueReceive(gpio_evt_queue, &gpio_num, portMAX_DELAY))
{ {
lis3dh_int_activity_source_t activity_src; lis3dh_int_data_source_t data_src = {};
lis3dh_int_data_source_t data_src; lis3dh_int_event_source_t event_src = {};
lis3dh_int_click_source_t click_src; lis3dh_int_click_source_t click_src = {};
// get the source of the interrupt and reset INT signals // get the source of the interrupt and reset *INTx* signals
lis3dh_get_int_activity_source (sensor, &activity_src, lis3dh_int1_signal); #ifdef INT_DATA
lis3dh_get_int_data_source (sensor, &data_src); lis3dh_get_int_data_source (sensor, &data_src);
lis3dh_get_int_click_source (sensor, &click_src); #elif INT_EVENT
lis3dh_get_int_event_source (sensor, &event_src, lis3dh_int_event1_gen);
#elif INT_CLICK
lis3dh_get_int_click_source (sensor, &click_src);
#endif
// in case of DRDY interrupt or activity interrupt read one data sample // in case of DRDY interrupt or inertial event interrupt read one data sample
if (data_src.data_ready || activity_src.active) if (data_src.data_ready)
read_data (); read_data ();
// in case of FIFO interrupts read the whole FIFO // in case of FIFO interrupts read the whole FIFO
else if (data_src.fifo_watermark || data_src.fifo_overrun) else if (data_src.fifo_watermark || data_src.fifo_overrun)
read_data (); read_data ();
// in case of event interrupt
else if (event_src.active)
{
printf("%.3f LIS3DH ", (double)sdk_system_get_time()*1e-3);
if (event_src.x_low) printf("x is lower than threshold\n");
if (event_src.y_low) printf("y is lower than threshold\n");
if (event_src.z_low) printf("z is lower than threshold\n");
if (event_src.x_high) printf("x is higher than threshold\n");
if (event_src.y_high) printf("y is higher than threshold\n");
if (event_src.z_high) printf("z is higher than threshold\n");
}
// in case of click detection interrupt
else if (click_src.active) else if (click_src.active)
printf("%.3f LIS3DH %s\n", (double)sdk_system_get_time()*1e-3, printf("%.3f LIS3DH %s\n", (double)sdk_system_get_time()*1e-3,
click_src.s_click ? "single click" : "double click"); click_src.s_click ? "single click" : "double click");
@ -862,7 +884,7 @@ void user_task_periodic(void *pvParameters)
#endif // INT_USED #endif // INT_USED
/* -- main program ---------------------------------------------- */ /* -- main program ------------------------------------------------- */
void user_init(void) void user_init(void)
{ {
@ -922,41 +944,42 @@ void user_init(void)
// set polarity of INT signals if necessary // set polarity of INT signals if necessary
// lis3dh_config_int_signals (sensor, lis3dh_high_active); // lis3dh_config_int_signals (sensor, lis3dh_high_active);
#ifdef DATA_INT #ifdef INT_DATA
// enable data interrupts on INT1 (data ready or FIFO status interrupts) // enable data interrupts on INT1 (data ready or FIFO status interrupts)
// data ready and FIFO status interrupts must not be enabled at the same time // data ready and FIFO status interrupts must not be enabled at the same time
#ifdef FIFO_MODE #ifdef FIFO_MODE
lis3dh_enable_int_data (sensor, lis3dh_fifo_overrun, true); lis3dh_enable_int (sensor, lis3dh_int_fifo_overrun , lis3dh_int1_signal, true);
lis3dh_enable_int_data (sensor, lis3dh_fifo_watermark, true); lis3dh_enable_int (sensor, lis3dh_int_fifo_watermark, lis3dh_int1_signal, true);
#else #else
lis3dh_enable_int_data (sensor, lis3dh_data_ready, true); lis3dh_enable_int (sensor, lis3dh_int_data_ready, lis3dh_int1_signal, true);
#endif // FIFO_MODE #endif // FIFO_MODE
#endif // DATA_INT #endif // INT_DATA
#ifdef ACTIVITY_INT #ifdef INT_EVENT
// enable data interrupts on INT1 // enable data interrupts on INT1
lis3dh_int_activity_config_t act_config; lis3dh_int_event_config_t event_config;
act_config.activity = lis3dh_wake_up; event_config.mode = lis3dh_wake_up;
// act_config.activity = lis3dh_free_fall; // event_config.mode = lis3dh_free_fall;
// act_config.activity = lis3dh_6d_movement; // event_config.mode = lis3dh_6d_movement;
// act_config.activity = lis3dh_6d_position; // event_config.mode = lis3dh_6d_position;
// act_config.activity = lis3dh_4d_movement; // event_config.mode = lis3dh_4d_movement;
// act_config.activity = lis3dh_4d_position; // event_config.mode = lis3dh_4d_position;
act_config.threshold = 10; event_config.threshold = 10;
act_config.x_low_enabled = false; event_config.x_low_enabled = false;
act_config.x_high_enabled = true; event_config.x_high_enabled = true;
act_config.y_low_enabled = false; event_config.y_low_enabled = false;
act_config.y_high_enabled = true; event_config.y_high_enabled = true;
act_config.z_low_enabled = false; event_config.z_low_enabled = false;
act_config.z_high_enabled = true; event_config.z_high_enabled = true;
act_config.duration = 0; event_config.duration = 0;
act_config.latch = true; event_config.latch = true;
lis3dh_set_int_activity_config (sensor, lis3dh_int1_signal, &act_config); lis3dh_set_int_event_config (sensor, &event_config, lis3dh_int_event1_gen);
#endif // ACTIVITY_INT lis3dh_enable_int (sensor, lis3dh_int_event1, lis3dh_int1_signal, true);
#endif // INT_EVENT
#ifdef CLICK_INT #ifdef INT_CLICK
// enable click interrupt on INT1 // enable click interrupt on INT1
lis3dh_int_click_config_t click_config; lis3dh_int_click_config_t click_config;
@ -972,8 +995,9 @@ void user_init(void)
click_config.time_latency = 1; click_config.time_latency = 1;
click_config.time_window = 3; click_config.time_window = 3;
lis3dh_set_int_click_config (sensor, lis3dh_int1_signal, &click_config); lis3dh_set_int_click_config (sensor, &click_config);
#endif // CLICK_INT lis3dh_enable_int (sensor, lis3dh_int_click, lis3dh_int1_signal, true);
#endif // INT_CLICK
#ifdef FIFO_MODE #ifdef FIFO_MODE
// clear FIFO and activate FIFO mode if needed // clear FIFO and activate FIFO mode if needed

347
extras/lis3dh/lis3dh.c
View file

@ -258,10 +258,10 @@ static bool lis3dh_spi_write (lis3dh_sensor_t* dev, uint8_t reg, uint8_t *d
#define lis3dh_update_reg(dev,addr,type,elem,value) \ #define lis3dh_update_reg(dev,addr,type,elem,value) \
{ \ { \
struct type __reg; \ struct type __reg; \
if (!lis3dh_read_reg (dev, (addr), (uint8_t*)&__reg, 1)) \ if (!lis3dh_reg_read (dev, (addr), (uint8_t*)&__reg, 1)) \
return false; \ return false; \
__reg.elem = (value); \ __reg.elem = (value); \
if (!lis3dh_write_reg (dev, (addr), (uint8_t*)&__reg, 1)) \ if (!lis3dh_reg_write (dev, (addr), (uint8_t*)&__reg, 1)) \
return false; \ return false; \
} }
@ -325,7 +325,7 @@ bool lis3dh_set_mode (lis3dh_sensor_t* dev,
uint8_t old_odr; uint8_t old_odr;
// read current register values // read current register values
if (!lis3dh_read_reg (dev, LIS3DH_REG_CTRL1, (uint8_t*)&reg, 1)) if (!lis3dh_reg_read (dev, LIS3DH_REG_CTRL1, (uint8_t*)&reg, 1))
return false; return false;
old_odr = reg.ODR; old_odr = reg.ODR;
@ -340,7 +340,7 @@ bool lis3dh_set_mode (lis3dh_sensor_t* dev,
lis3dh_update_reg (dev, LIS3DH_REG_CTRL4, lis3dh_reg_ctrl4, lis3dh_update_reg (dev, LIS3DH_REG_CTRL4, lis3dh_reg_ctrl4,
HR, (res == lis3dh_high_res)); HR, (res == lis3dh_high_res));
if (!lis3dh_write_reg (dev, LIS3DH_REG_CTRL1, (uint8_t*)&reg, 1)) if (!lis3dh_reg_write (dev, LIS3DH_REG_CTRL1, (uint8_t*)&reg, 1))
return false; return false;
// if sensor was in power down mode it takes at least 100 ms to start in another mode // if sensor was in power down mode it takes at least 100 ms to start in another mode
@ -366,7 +366,7 @@ bool lis3dh_set_scale (lis3dh_sensor_t* dev, lis3dh_scale_t scale)
bool lis3dh_set_fifo_mode (lis3dh_sensor_t* dev, lis3dh_fifo_mode_t mode, bool lis3dh_set_fifo_mode (lis3dh_sensor_t* dev, lis3dh_fifo_mode_t mode,
uint8_t thresh, lis3dh_int_signals_t trigger) uint8_t thresh, lis3dh_int_signal_t trigger)
{ {
if (!dev) return false; if (!dev) return false;
@ -383,7 +383,7 @@ bool lis3dh_set_fifo_mode (lis3dh_sensor_t* dev, lis3dh_fifo_mode_t mode,
}; };
// write FIFO_CTRL register // write FIFO_CTRL register
if (!lis3dh_write_reg (dev, LIS3DH_REG_FIFO_CTRL, (uint8_t*)&fifo_ctrl, 1)) if (!lis3dh_reg_write (dev, LIS3DH_REG_FIFO_CTRL, (uint8_t*)&fifo_ctrl, 1))
return false; return false;
return true; return true;
@ -400,7 +400,7 @@ bool lis3dh_new_data (lis3dh_sensor_t* dev)
{ {
struct lis3dh_reg_status status; struct lis3dh_reg_status status;
if (!lis3dh_read_reg (dev, LIS3DH_REG_STATUS, (uint8_t*)&status, 1)) if (!lis3dh_reg_read (dev, LIS3DH_REG_STATUS, (uint8_t*)&status, 1))
{ {
error_dev ("Could not get sensor status", __FUNCTION__, dev); error_dev ("Could not get sensor status", __FUNCTION__, dev);
return false; return false;
@ -411,7 +411,7 @@ bool lis3dh_new_data (lis3dh_sensor_t* dev)
{ {
struct lis3dh_reg_fifo_src fifo_src; struct lis3dh_reg_fifo_src fifo_src;
if (!lis3dh_read_reg (dev, LIS3DH_REG_FIFO_SRC, (uint8_t*)&fifo_src, 1)) if (!lis3dh_reg_read (dev, LIS3DH_REG_FIFO_SRC, (uint8_t*)&fifo_src, 1))
{ {
error_dev ("Could not get fifo source register data", __FUNCTION__, dev); error_dev ("Could not get fifo source register data", __FUNCTION__, dev);
return false; return false;
@ -483,7 +483,7 @@ bool lis3dh_get_raw_data (lis3dh_sensor_t* dev, lis3dh_raw_data_t* raw)
} }
// read raw data sample // read raw data sample
if (!lis3dh_read_reg (dev, LIS3DH_REG_OUT_X_L, (uint8_t*)raw, 6)) if (!lis3dh_reg_read (dev, LIS3DH_REG_OUT_X_L, (uint8_t*)raw, 6))
{ {
error_dev ("Could not get raw data sample", __FUNCTION__, dev); error_dev ("Could not get raw data sample", __FUNCTION__, dev);
dev->error_code |= LIS3DH_GET_RAW_DATA_FAILED; dev->error_code |= LIS3DH_GET_RAW_DATA_FAILED;
@ -507,7 +507,7 @@ uint8_t lis3dh_get_raw_data_fifo (lis3dh_sensor_t* dev, lis3dh_raw_data_fifo_t r
struct lis3dh_reg_fifo_src fifo_src; struct lis3dh_reg_fifo_src fifo_src;
// read FIFO state // read FIFO state
if (!lis3dh_read_reg (dev, LIS3DH_REG_FIFO_SRC, (uint8_t*)&fifo_src, 1)) if (!lis3dh_reg_read (dev, LIS3DH_REG_FIFO_SRC, (uint8_t*)&fifo_src, 1))
{ {
error_dev ("Could not get fifo source register data", __FUNCTION__, dev); error_dev ("Could not get fifo source register data", __FUNCTION__, dev);
return 0; return 0;
@ -521,14 +521,14 @@ uint8_t lis3dh_get_raw_data_fifo (lis3dh_sensor_t* dev, lis3dh_raw_data_fifo_t r
// read samples from FIFO // read samples from FIFO
for (int i = 0; i < samples; i++) for (int i = 0; i < samples; i++)
if (!lis3dh_read_reg (dev, LIS3DH_REG_OUT_X_L, (uint8_t*)&raw[i], 6)) if (!lis3dh_reg_read (dev, LIS3DH_REG_OUT_X_L, (uint8_t*)&raw[i], 6))
{ {
error_dev ("Could not get raw data samples", __FUNCTION__, dev); error_dev ("Could not get raw data samples", __FUNCTION__, dev);
dev->error_code |= LIS3DH_GET_RAW_DATA_FIFO_FAILED; dev->error_code |= LIS3DH_GET_RAW_DATA_FIFO_FAILED;
return i; return i;
} }
lis3dh_read_reg (dev, LIS3DH_REG_FIFO_SRC, (uint8_t*)&fifo_src, 1); lis3dh_reg_read (dev, LIS3DH_REG_FIFO_SRC, (uint8_t*)&fifo_src, 1);
// if FFS is not 0 after all samples read, ODR is higher than fetching rate // if FFS is not 0 after all samples read, ODR is higher than fetching rate
if (fifo_src.FFS) if (fifo_src.FFS)
@ -550,9 +550,124 @@ uint8_t lis3dh_get_raw_data_fifo (lis3dh_sensor_t* dev, lis3dh_raw_data_fifo_t r
} }
bool lis3dh_set_int_activity_config (lis3dh_sensor_t* dev, bool lis3dh_enable_int (lis3dh_sensor_t* dev,
lis3dh_int_signals_t signal, lis3dh_int_type_t type,
lis3dh_int_activity_config_t* config) lis3dh_int_signal_t signal, bool value)
{
if (!dev) return false;
dev->error_code = LIS3DH_OK;
struct lis3dh_reg_ctrl3 ctrl3;
struct lis3dh_reg_ctrl6 ctrl6;
uint8_t* reg = NULL;
uint8_t addr;
// determine the addr of the register to change
if (type == lis3dh_int_data_ready ||
type == lis3dh_int_fifo_watermark ||
type == lis3dh_int_fifo_overrun)
{
reg = (uint8_t*)&ctrl3;
addr = LIS3DH_REG_CTRL3;
}
else if (signal == lis3dh_int1_signal)
{
reg = (uint8_t*)&ctrl3;
addr = LIS3DH_REG_CTRL3;
}
else
{
reg = (uint8_t*)&ctrl6;
addr = LIS3DH_REG_CTRL6;
}
// read the register
if (!lis3dh_reg_read (dev, addr, reg, 1))
{
error_dev ("Could not read interrupt control registers", __FUNCTION__, dev);
dev->error_code |= LIS3DH_CONFIG_INT_FAILED;
return false;
}
// change the register
switch (type)
{
case lis3dh_int_data_ready: ctrl3.IT_DRDY1 = value;
break;
case lis3dh_int_fifo_watermark: ctrl3.I1_WTM1 = value;
break;
case lis3dh_int_fifo_overrun: ctrl3.I1_OVERRUN = value;
break;
case lis3dh_int_event1: if (signal == lis3dh_int1_signal)
ctrl3.I1_AOI1 = value;
else
ctrl6.I2_AOI1 = value;
break;
case lis3dh_int_event2: if (signal == lis3dh_int1_signal)
ctrl3.I1_AOI2 = value;
else
ctrl6.I2_AOI2 = value;
break;
case lis3dh_int_click: if (signal == lis3dh_int1_signal)
ctrl3.I1_CLICK = value;
else
ctrl6.I2_CLICK = value;
break;
default: dev->error_code = LIS3DH_WRONG_INT_TYPE;
error_dev ("Wrong interrupt type", __FUNCTION__, dev);
return false;
}
if (!lis3dh_reg_write (dev, addr, reg, 1))
{
error_dev ("Could not enable/disable interrupt", __FUNCTION__, dev);
dev->error_code |= LIS3DH_CONFIG_INT_FAILED;
return false;
}
return true;
}
bool lis3dh_get_int_data_source (lis3dh_sensor_t* dev,
lis3dh_int_data_source_t* source)
{
if (!dev || !source) return false;
dev->error_code = LIS3DH_OK;
struct lis3dh_reg_ctrl3 ctrl3;
struct lis3dh_reg_status status;
struct lis3dh_reg_fifo_src fifo_src;
if (!lis3dh_reg_read (dev, LIS3DH_REG_CTRL3 , (uint8_t*)&ctrl3 , 1) ||
!lis3dh_reg_read (dev, LIS3DH_REG_STATUS , (uint8_t*)&status , 1) ||
!lis3dh_reg_read (dev, LIS3DH_REG_FIFO_SRC, (uint8_t*)&fifo_src, 1))
{
error_dev ("Could not read source of interrupt INT2 from sensor", __FUNCTION__, dev);
dev->error_code |= LIS3DH_INT_SOURCE_FAILED;
return false;
}
source->data_ready = status.ZYXDA & ctrl3.IT_DRDY1;
source->fifo_watermark = fifo_src.WTM & ctrl3.I1_WTM1;
source->fifo_overrun = fifo_src.OVRN_FIFO & ctrl3.I1_OVERRUN;
return true;
}
bool lis3dh_set_int_event_config (lis3dh_sensor_t* dev,
lis3dh_int_event_config_t* config,
lis3dh_int_event_gen_t gen)
{ {
if (!dev || !config) return false; if (!dev || !config) return false;
@ -571,7 +686,7 @@ bool lis3dh_set_int_activity_config (lis3dh_sensor_t* dev,
bool d4d_int = false; bool d4d_int = false;
switch (config->activity) switch (config->mode)
{ {
case lis3dh_wake_up : intx_cfg.AOI = 0; intx_cfg.SIXD = 0; break; case lis3dh_wake_up : intx_cfg.AOI = 0; intx_cfg.SIXD = 0; break;
case lis3dh_free_fall : intx_cfg.AOI = 1; intx_cfg.SIXD = 0; break; case lis3dh_free_fall : intx_cfg.AOI = 1; intx_cfg.SIXD = 0; break;
@ -583,66 +698,58 @@ bool lis3dh_set_int_activity_config (lis3dh_sensor_t* dev,
case lis3dh_6d_position : intx_cfg.AOI = 1; intx_cfg.SIXD = 1; break; case lis3dh_6d_position : intx_cfg.AOI = 1; intx_cfg.SIXD = 1; break;
} }
uint8_t intx_cfg_addr = !signal ? LIS3DH_REG_INT1_CFG : LIS3DH_REG_INT2_CFG; uint8_t intx_cfg_addr = (gen == lis3dh_int_event1_gen) ? LIS3DH_REG_INT1_CFG : LIS3DH_REG_INT2_CFG;
uint8_t intx_ths_addr = !signal ? LIS3DH_REG_INT1_THS : LIS3DH_REG_INT2_THS; uint8_t intx_ths_addr = (gen == lis3dh_int_event1_gen) ? LIS3DH_REG_INT1_THS : LIS3DH_REG_INT2_THS;
uint8_t intx_dur_addr = !signal ? LIS3DH_REG_INT1_DUR : LIS3DH_REG_INT2_DUR; uint8_t intx_dur_addr = (gen == lis3dh_int_event1_gen) ? LIS3DH_REG_INT1_DUR : LIS3DH_REG_INT2_DUR;
if (// write the thresholds to registers IG_THS_* if (// write the thresholds to registers IG_THS_*
!lis3dh_write_reg (dev, intx_ths_addr, &config->threshold, 1) || !lis3dh_reg_write (dev, intx_ths_addr, &config->threshold, 1) ||
// write duration configuration to IG_DURATION // write duration configuration to IG_DURATION
!lis3dh_write_reg (dev, intx_dur_addr, &config->duration, 1) || !lis3dh_reg_write (dev, intx_dur_addr, &config->duration, 1) ||
// write INT1 configuration to IG_CFG // write INT1 configuration to IG_CFG
!lis3dh_write_reg (dev, intx_cfg_addr, (uint8_t*)&intx_cfg, 1)) !lis3dh_reg_write (dev, intx_cfg_addr, (uint8_t*)&intx_cfg, 1))
{ {
error_dev ("Could not configure interrupt INT1", __FUNCTION__, dev); error_dev ("Could not configure interrupt INT1", __FUNCTION__, dev);
dev->error_code |= LIS3DH_CONFIG_INT_FAILED; dev->error_code |= LIS3DH_CONFIG_INT_FAILED;
return false; return false;
} }
bool enable = intx_cfg.XLIE || intx_cfg.XHIE || if (gen == lis3dh_int_event1_gen)
intx_cfg.YLIE || intx_cfg.YHIE ||
intx_cfg.ZLIE || intx_cfg.ZHIE;
if (!signal)
{ {
lis3dh_update_reg (dev, LIS3DH_REG_CTRL5, lis3dh_reg_ctrl5, LIR_INT1, config->latch); lis3dh_update_reg (dev, LIS3DH_REG_CTRL5, lis3dh_reg_ctrl5, LIR_INT1, config->latch);
lis3dh_update_reg (dev, LIS3DH_REG_CTRL5, lis3dh_reg_ctrl5, D4D_INT1, d4d_int); lis3dh_update_reg (dev, LIS3DH_REG_CTRL5, lis3dh_reg_ctrl5, D4D_INT1, d4d_int);
// enable or disable I1_AOI
lis3dh_update_reg (dev, LIS3DH_REG_CTRL3, lis3dh_reg_ctrl3, I1_AOI1, enable);
} }
else else
{ {
lis3dh_update_reg (dev, LIS3DH_REG_CTRL5, lis3dh_reg_ctrl5, LIR_INT2, config->latch); lis3dh_update_reg (dev, LIS3DH_REG_CTRL5, lis3dh_reg_ctrl5, LIR_INT2, config->latch);
lis3dh_update_reg (dev, LIS3DH_REG_CTRL5, lis3dh_reg_ctrl5, D4D_INT2, d4d_int); lis3dh_update_reg (dev, LIS3DH_REG_CTRL5, lis3dh_reg_ctrl5, D4D_INT2, d4d_int);
// enable or disable I2_AOI
lis3dh_update_reg (dev, LIS3DH_REG_CTRL3, lis3dh_reg_ctrl6, I2_AOI1, enable);
} }
return true; return true;
} }
bool lis3dh_get_int_activity_config (lis3dh_sensor_t* dev, bool lis3dh_get_int_event_config (lis3dh_sensor_t* dev,
lis3dh_int_signals_t signal, lis3dh_int_event_config_t* config,
lis3dh_int_activity_config_t* config) lis3dh_int_event_gen_t gen)
{ {
if (!dev || !config) return false; if (!dev || !config) return false;
dev->error_code = LIS3DH_OK; dev->error_code = LIS3DH_OK;
uint8_t intx_cfg_addr = !signal ? LIS3DH_REG_INT1_CFG : LIS3DH_REG_INT2_CFG; uint8_t intx_cfg_addr = (gen == lis3dh_int_event1_gen) ? LIS3DH_REG_INT1_CFG : LIS3DH_REG_INT2_CFG;
uint8_t intx_ths_addr = !signal ? LIS3DH_REG_INT1_THS : LIS3DH_REG_INT2_THS; uint8_t intx_ths_addr = (gen == lis3dh_int_event1_gen) ? LIS3DH_REG_INT1_THS : LIS3DH_REG_INT2_THS;
uint8_t intx_dur_addr = !signal ? LIS3DH_REG_INT1_DUR : LIS3DH_REG_INT2_DUR; uint8_t intx_dur_addr = (gen == lis3dh_int_event1_gen) ? LIS3DH_REG_INT1_DUR : LIS3DH_REG_INT2_DUR;
struct lis3dh_reg_intx_cfg intx_cfg; struct lis3dh_reg_intx_cfg intx_cfg;
struct lis3dh_reg_ctrl5 ctrl5; struct lis3dh_reg_ctrl5 ctrl5;
if (!lis3dh_read_reg (dev, intx_cfg_addr, (uint8_t*)&intx_cfg, 1) || if (!lis3dh_reg_read (dev, intx_cfg_addr, (uint8_t*)&intx_cfg, 1) ||
!lis3dh_read_reg (dev, intx_ths_addr, (uint8_t*)&config->threshold, 1) || !lis3dh_reg_read (dev, intx_ths_addr, (uint8_t*)&config->threshold, 1) ||
!lis3dh_read_reg (dev, intx_dur_addr, (uint8_t*)&config->duration, 1) || !lis3dh_reg_read (dev, intx_dur_addr, (uint8_t*)&config->duration, 1) ||
!lis3dh_read_reg (dev, LIS3DH_REG_CTRL5, (uint8_t*)&ctrl5, 1)) !lis3dh_reg_read (dev, LIS3DH_REG_CTRL5, (uint8_t*)&ctrl5, 1))
{ {
error_dev ("Could not read interrupt configuration from sensor", __FUNCTION__, dev); error_dev ("Could not read interrupt configuration from sensor", __FUNCTION__, dev);
dev->error_code |= LIS3DH_CONFIG_INT_FAILED; dev->error_code |= LIS3DH_CONFIG_INT_FAILED;
@ -660,7 +767,7 @@ bool lis3dh_get_int_activity_config (lis3dh_sensor_t* dev,
bool d4d_int = false; bool d4d_int = false;
if (!signal) if (gen == lis3dh_int_event1_gen)
{ {
config->latch = ctrl5.LIR_INT1; config->latch = ctrl5.LIR_INT1;
d4d_int = ctrl5.D4D_INT1; d4d_int = ctrl5.D4D_INT1;
@ -674,29 +781,29 @@ bool lis3dh_get_int_activity_config (lis3dh_sensor_t* dev,
if (intx_cfg.AOI) if (intx_cfg.AOI)
{ {
if (intx_cfg.SIXD && d4d_int) if (intx_cfg.SIXD && d4d_int)
config->activity = lis3dh_4d_position; config->mode = lis3dh_4d_position;
else if (intx_cfg.SIXD && !d4d_int) else if (intx_cfg.SIXD && !d4d_int)
config->activity = lis3dh_6d_position; config->mode = lis3dh_6d_position;
else else
config->activity = lis3dh_free_fall; config->mode = lis3dh_free_fall;
} }
else else
{ {
if (intx_cfg.SIXD && d4d_int) if (intx_cfg.SIXD && d4d_int)
config->activity = lis3dh_4d_movement; config->mode = lis3dh_4d_movement;
else if (intx_cfg.SIXD && !d4d_int) else if (intx_cfg.SIXD && !d4d_int)
config->activity = lis3dh_6d_movement; config->mode = lis3dh_6d_movement;
else else
config->activity = lis3dh_wake_up; config->mode = lis3dh_wake_up;
} }
return true; return true;
} }
bool lis3dh_get_int_activity_source (lis3dh_sensor_t* dev, bool lis3dh_get_int_event_source (lis3dh_sensor_t* dev,
lis3dh_int_activity_source_t* source, lis3dh_int_event_source_t* source,
lis3dh_int_signals_t signal) lis3dh_int_event_gen_t gen)
{ {
if (!dev || !source) return false; if (!dev || !source) return false;
@ -705,11 +812,11 @@ bool lis3dh_get_int_activity_source (lis3dh_sensor_t* dev,
struct lis3dh_reg_intx_cfg intx_cfg; struct lis3dh_reg_intx_cfg intx_cfg;
struct lis3dh_reg_intx_src intx_src; struct lis3dh_reg_intx_src intx_src;
uint8_t intx_cfg_addr = (!signal) ? LIS3DH_REG_INT1_CFG : LIS3DH_REG_INT2_CFG; uint8_t intx_cfg_addr = (gen == lis3dh_int_event1_gen) ? LIS3DH_REG_INT1_CFG : LIS3DH_REG_INT2_CFG;
uint8_t intx_src_addr = (!signal) ? LIS3DH_REG_INT1_SRC : LIS3DH_REG_INT2_SRC; uint8_t intx_src_addr = (gen == lis3dh_int_event1_gen) ? LIS3DH_REG_INT1_SRC : LIS3DH_REG_INT2_SRC;
if (!lis3dh_read_reg (dev, intx_src_addr, (uint8_t*)&intx_src, 1) || if (!lis3dh_reg_read (dev, intx_src_addr, (uint8_t*)&intx_src, 1) ||
!lis3dh_read_reg (dev, intx_cfg_addr, (uint8_t*)&intx_cfg, 1)) !lis3dh_reg_read (dev, intx_cfg_addr, (uint8_t*)&intx_cfg, 1))
{ {
error_dev ("Could not read source of interrupt INT1/INT2 from sensor", __FUNCTION__, dev); error_dev ("Could not read source of interrupt INT1/INT2 from sensor", __FUNCTION__, dev);
dev->error_code |= LIS3DH_INT_SOURCE_FAILED; dev->error_code |= LIS3DH_INT_SOURCE_FAILED;
@ -728,66 +835,7 @@ bool lis3dh_get_int_activity_source (lis3dh_sensor_t* dev,
} }
bool lis3dh_enable_int_data (lis3dh_sensor_t* dev,
lis3dh_int_data_t type, bool value)
{
if (!dev) return false;
dev->error_code = LIS3DH_OK;
switch (type)
{
case lis3dh_data_ready: lis3dh_update_reg (dev, LIS3DH_REG_CTRL3,
lis3dh_reg_ctrl3,
IT_DRDY1, value);
break;
case lis3dh_fifo_watermark: lis3dh_update_reg (dev, LIS3DH_REG_CTRL3,
lis3dh_reg_ctrl3,
I1_WTM1, value);
break;
case lis3dh_fifo_overrun: lis3dh_update_reg (dev, LIS3DH_REG_CTRL3,
lis3dh_reg_ctrl3,
I1_OVERRUN, value);
break;
default: dev->error_code = LIS3DH_WRONG_INT_TYPE;
error_dev ("Wrong interrupt type", __FUNCTION__, dev);
return false;
}
return true;
}
bool lis3dh_get_int_data_source (lis3dh_sensor_t* dev,
lis3dh_int_data_source_t* source)
{
if (!dev || !source) return false;
dev->error_code = LIS3DH_OK;
struct lis3dh_reg_ctrl3 ctrl3;
struct lis3dh_reg_status status;
struct lis3dh_reg_fifo_src fifo_src;
if (!lis3dh_read_reg (dev, LIS3DH_REG_CTRL3 , (uint8_t*)&ctrl3 , 1) ||
!lis3dh_read_reg (dev, LIS3DH_REG_STATUS , (uint8_t*)&status , 1) ||
!lis3dh_read_reg (dev, LIS3DH_REG_FIFO_SRC, (uint8_t*)&fifo_src, 1))
{
error_dev ("Could not read source of interrupt INT2 from sensor", __FUNCTION__, dev);
dev->error_code |= LIS3DH_INT_SOURCE_FAILED;
return false;
}
source->data_ready = status.ZYXDA & ctrl3.IT_DRDY1;
source->fifo_watermark = fifo_src.WTM & ctrl3.I1_WTM1;
source->fifo_overrun = fifo_src.OVRN_FIFO & ctrl3.I1_OVERRUN;
return true;
}
bool lis3dh_set_int_click_config (lis3dh_sensor_t* dev, bool lis3dh_set_int_click_config (lis3dh_sensor_t* dev,
lis3dh_int_signals_t signal,
lis3dh_int_click_config_t* config) lis3dh_int_click_config_t* config)
{ {
if (!dev || !config) return false; if (!dev || !config) return false;
@ -807,34 +855,21 @@ bool lis3dh_set_int_click_config (lis3dh_sensor_t* dev,
uint8_t click_ths = config->threshold | ((config->latch) ? 0x80 : 0x00); uint8_t click_ths = config->threshold | ((config->latch) ? 0x80 : 0x00);
if (!lis3dh_write_reg (dev, LIS3DH_REG_CLICK_CFG , (uint8_t*)&click_cfg, 1) || if (!lis3dh_reg_write (dev, LIS3DH_REG_CLICK_CFG , (uint8_t*)&click_cfg, 1) ||
!lis3dh_write_reg (dev, LIS3DH_REG_CLICK_THS , (uint8_t*)&click_ths, 1) || !lis3dh_reg_write (dev, LIS3DH_REG_CLICK_THS , (uint8_t*)&click_ths, 1) ||
!lis3dh_write_reg (dev, LIS3DH_REG_TIME_LIMIT , (uint8_t*)&config->time_limit, 1) || !lis3dh_reg_write (dev, LIS3DH_REG_TIME_LIMIT , (uint8_t*)&config->time_limit, 1) ||
!lis3dh_write_reg (dev, LIS3DH_REG_TIME_LATENCY, (uint8_t*)&config->time_latency, 1) || !lis3dh_reg_write (dev, LIS3DH_REG_TIME_LATENCY, (uint8_t*)&config->time_latency, 1) ||
!lis3dh_write_reg (dev, LIS3DH_REG_TIME_WINDOW , (uint8_t*)&config->time_window, 1)) !lis3dh_reg_write (dev, LIS3DH_REG_TIME_WINDOW , (uint8_t*)&config->time_window, 1))
{ {
error_dev ("Could not configure click detection interrupt", __FUNCTION__, dev); error_dev ("Could not configure click detection interrupt", __FUNCTION__, dev);
dev->error_code |= LIS3DH_CONFIG_CLICK_FAILED; dev->error_code |= LIS3DH_CONFIG_CLICK_FAILED;
return false; return false;
} }
bool enable = click_cfg.XS || click_cfg.XD ||
click_cfg.YS || click_cfg.YD ||
click_cfg.ZS || click_cfg.ZD;
if (!signal)
{
lis3dh_update_reg (dev, LIS3DH_REG_CTRL3, lis3dh_reg_ctrl3, I1_CLICK, enable);
}
else
{
lis3dh_update_reg (dev, LIS3DH_REG_CTRL3, lis3dh_reg_ctrl6, I2_CLICK, enable);
}
return true; return true;
} }
bool lis3dh_get_int_click_config (lis3dh_sensor_t* dev, bool lis3dh_get_int_click_config (lis3dh_sensor_t* dev,
lis3dh_int_signals_t signal,
lis3dh_int_click_config_t* config) lis3dh_int_click_config_t* config)
{ {
if (!dev || !config) return false; if (!dev || !config) return false;
@ -844,11 +879,11 @@ bool lis3dh_get_int_click_config (lis3dh_sensor_t* dev,
struct lis3dh_reg_click_cfg click_cfg; struct lis3dh_reg_click_cfg click_cfg;
uint8_t click_ths; uint8_t click_ths;
if (!lis3dh_read_reg (dev, LIS3DH_REG_CLICK_CFG , (uint8_t*)&click_cfg, 1) || if (!lis3dh_reg_read (dev, LIS3DH_REG_CLICK_CFG , (uint8_t*)&click_cfg, 1) ||
!lis3dh_read_reg (dev, LIS3DH_REG_CLICK_THS , (uint8_t*)&click_ths, 1) || !lis3dh_reg_read (dev, LIS3DH_REG_CLICK_THS , (uint8_t*)&click_ths, 1) ||
!lis3dh_read_reg (dev, LIS3DH_REG_TIME_LIMIT , (uint8_t*)&config->time_limit, 1) || !lis3dh_reg_read (dev, LIS3DH_REG_TIME_LIMIT , (uint8_t*)&config->time_limit, 1) ||
!lis3dh_read_reg (dev, LIS3DH_REG_TIME_LATENCY, (uint8_t*)&config->time_latency, 1) || !lis3dh_reg_read (dev, LIS3DH_REG_TIME_LATENCY, (uint8_t*)&config->time_latency, 1) ||
!lis3dh_read_reg (dev, LIS3DH_REG_TIME_WINDOW , (uint8_t*)&config->time_window, 1)) !lis3dh_reg_read (dev, LIS3DH_REG_TIME_WINDOW , (uint8_t*)&config->time_window, 1))
{ {
error_dev ("Could not configure click detection interrupt", __FUNCTION__, dev); error_dev ("Could not configure click detection interrupt", __FUNCTION__, dev);
dev->error_code |= LIS3DH_CONFIG_CLICK_FAILED; dev->error_code |= LIS3DH_CONFIG_CLICK_FAILED;
@ -877,7 +912,7 @@ bool lis3dh_get_int_click_source (lis3dh_sensor_t* dev,
dev->error_code = LIS3DH_OK; dev->error_code = LIS3DH_OK;
if (!lis3dh_read_reg (dev, LIS3DH_REG_CLICK_SRC, (uint8_t*)source, 1)) if (!lis3dh_reg_read (dev, LIS3DH_REG_CLICK_SRC, (uint8_t*)source, 1))
{ {
error_dev ("Could not read source of click interrupt from sensor", __FUNCTION__, dev); error_dev ("Could not read source of click interrupt from sensor", __FUNCTION__, dev);
dev->error_code |= LIS3DH_CLICK_SOURCE_FAILED; dev->error_code |= LIS3DH_CLICK_SOURCE_FAILED;
@ -918,7 +953,7 @@ bool lis3dh_config_hpf (lis3dh_sensor_t* dev,
reg.HPIS1 = int1; reg.HPIS1 = int1;
reg.HPIS2 = int2; reg.HPIS2 = int2;
if (!lis3dh_write_reg (dev, LIS3DH_REG_CTRL2, (uint8_t*)&reg, 1)) if (!lis3dh_reg_write (dev, LIS3DH_REG_CTRL2, (uint8_t*)&reg, 1))
{ {
error_dev ("Could not configure high pass filter", __FUNCTION__, dev); error_dev ("Could not configure high pass filter", __FUNCTION__, dev);
dev->error_code |= LIS3DH_CONFIG_HPF_FAILED; dev->error_code |= LIS3DH_CONFIG_HPF_FAILED;
@ -935,7 +970,7 @@ bool lis3dh_set_hpf_ref (lis3dh_sensor_t* dev, int8_t ref)
dev->error_code = LIS3DH_OK; dev->error_code = LIS3DH_OK;
if (!lis3dh_write_reg (dev, LIS3DH_REG_REFERENCE, (uint8_t*)&ref, 1)) if (!lis3dh_reg_write (dev, LIS3DH_REG_REFERENCE, (uint8_t*)&ref, 1))
{ {
error_dev ("Could not set high pass filter reference", __FUNCTION__, dev); error_dev ("Could not set high pass filter reference", __FUNCTION__, dev);
dev->error_code |= LIS3DH_CONFIG_HPF_FAILED; dev->error_code |= LIS3DH_CONFIG_HPF_FAILED;
@ -954,7 +989,7 @@ int8_t lis3dh_get_hpf_ref (lis3dh_sensor_t* dev)
int8_t ref; int8_t ref;
if (!lis3dh_read_reg (dev, LIS3DH_REG_REFERENCE, (uint8_t*)&ref, 1)) if (!lis3dh_reg_read (dev, LIS3DH_REG_REFERENCE, (uint8_t*)&ref, 1))
{ {
error_dev ("Could not get high pass filter reference", __FUNCTION__, dev); error_dev ("Could not get high pass filter reference", __FUNCTION__, dev);
dev->error_code |= LIS3DH_CONFIG_HPF_FAILED; dev->error_code |= LIS3DH_CONFIG_HPF_FAILED;
@ -975,7 +1010,7 @@ int8_t lis3dh_enable_adc (lis3dh_sensor_t* dev, bool adc, bool tmp)
reg |= (adc) ? 0x80 : 0; reg |= (adc) ? 0x80 : 0;
reg |= (tmp) ? 0x40 : 0; reg |= (tmp) ? 0x40 : 0;
return lis3dh_write_reg (dev, LIS3DH_REG_TEMP_CFG, (uint8_t*)&reg, 1); return lis3dh_reg_write (dev, LIS3DH_REG_TEMP_CFG, (uint8_t*)&reg, 1);
} }
@ -990,9 +1025,9 @@ bool lis3dh_get_adc (lis3dh_sensor_t* dev,
uint8_t temp_cfg; uint8_t temp_cfg;
struct lis3dh_reg_ctrl1 ctrl1; struct lis3dh_reg_ctrl1 ctrl1;
if (!lis3dh_read_reg (dev, LIS3DH_REG_OUT_ADC1_L, data, 6) || if (!lis3dh_reg_read (dev, LIS3DH_REG_OUT_ADC1_L, data, 6) ||
!lis3dh_read_reg (dev, LIS3DH_REG_CTRL1, (uint8_t*)&ctrl1, 1) || !lis3dh_reg_read (dev, LIS3DH_REG_CTRL1, (uint8_t*)&ctrl1, 1) ||
!lis3dh_read_reg (dev, LIS3DH_REG_TEMP_CFG, &temp_cfg, 1)) !lis3dh_reg_read (dev, LIS3DH_REG_TEMP_CFG, &temp_cfg, 1))
{ {
error_dev ("Could not get adc data", __FUNCTION__, dev); error_dev ("Could not get adc data", __FUNCTION__, dev);
dev->error_code |= LIS3DH_GET_ADC_DATA_FAILED; dev->error_code |= LIS3DH_GET_ADC_DATA_FAILED;
@ -1025,7 +1060,7 @@ static bool lis3dh_is_available (lis3dh_sensor_t* dev)
dev->error_code = LIS3DH_OK; dev->error_code = LIS3DH_OK;
if (!lis3dh_read_reg (dev, LIS3DH_REG_WHO_AM_I, &chip_id, 1)) if (!lis3dh_reg_read (dev, LIS3DH_REG_WHO_AM_I, &chip_id, 1))
return false; return false;
if (chip_id != LIS3DH_CHIP_ID) if (chip_id != LIS3DH_CHIP_ID)
@ -1048,20 +1083,20 @@ static bool lis3dh_reset (lis3dh_sensor_t* dev)
uint8_t reg[8] = { 0 }; uint8_t reg[8] = { 0 };
// initialize sensor completely including setting in power down mode // initialize sensor completely including setting in power down mode
lis3dh_write_reg (dev, LIS3DH_REG_TEMP_CFG , reg, 8); lis3dh_reg_write (dev, LIS3DH_REG_TEMP_CFG , reg, 8);
lis3dh_write_reg (dev, LIS3DH_REG_FIFO_CTRL, reg, 1); lis3dh_reg_write (dev, LIS3DH_REG_FIFO_CTRL, reg, 1);
lis3dh_write_reg (dev, LIS3DH_REG_INT1_CFG , reg, 1); lis3dh_reg_write (dev, LIS3DH_REG_INT1_CFG , reg, 1);
lis3dh_write_reg (dev, LIS3DH_REG_INT1_THS , reg, 2); lis3dh_reg_write (dev, LIS3DH_REG_INT1_THS , reg, 2);
lis3dh_write_reg (dev, LIS3DH_REG_INT2_CFG , reg, 1); lis3dh_reg_write (dev, LIS3DH_REG_INT2_CFG , reg, 1);
lis3dh_write_reg (dev, LIS3DH_REG_INT2_THS , reg, 2); lis3dh_reg_write (dev, LIS3DH_REG_INT2_THS , reg, 2);
lis3dh_write_reg (dev, LIS3DH_REG_CLICK_CFG, reg, 1); lis3dh_reg_write (dev, LIS3DH_REG_CLICK_CFG, reg, 1);
lis3dh_write_reg (dev, LIS3DH_REG_CLICK_THS, reg, 4); lis3dh_reg_write (dev, LIS3DH_REG_CLICK_THS, reg, 4);
return true; return true;
} }
bool lis3dh_read_reg(lis3dh_sensor_t* dev, uint8_t reg, uint8_t *data, uint16_t len) bool lis3dh_reg_read(lis3dh_sensor_t* dev, uint8_t reg, uint8_t *data, uint16_t len)
{ {
if (!dev || !data) return false; if (!dev || !data) return false;
@ -1070,7 +1105,7 @@ bool lis3dh_read_reg(lis3dh_sensor_t* dev, uint8_t reg, uint8_t *data, uint16_t
} }
bool lis3dh_write_reg(lis3dh_sensor_t* dev, uint8_t reg, uint8_t *data, uint16_t len) bool lis3dh_reg_write(lis3dh_sensor_t* dev, uint8_t reg, uint8_t *data, uint16_t len)
{ {
if (!dev || !data) return false; if (!dev || !data) return false;

152
extras/lis3dh/lis3dh.h
View file

@ -154,7 +154,7 @@ bool lis3dh_set_scale (lis3dh_sensor_t* dev, lis3dh_scale_t scale);
* @return true on success, false on error * @return true on success, false on error
*/ */
bool lis3dh_set_fifo_mode (lis3dh_sensor_t* dev, lis3dh_fifo_mode_t mode, bool lis3dh_set_fifo_mode (lis3dh_sensor_t* dev, lis3dh_fifo_mode_t mode,
uint8_t thresh, lis3dh_int_signals_t trigger); uint8_t thresh, lis3dh_int_signal_t trigger);
/** /**
@ -167,7 +167,7 @@ bool lis3dh_new_data (lis3dh_sensor_t* dev);
/** /**
* @brief Get one sample of sensor data as floating point values (unit 1g) * @brief Get one sample of sensor data as floating point values (unit g)
* *
* Function works only in bypass mode and fails in FIFO modes. In FIFO modes, * Function works only in bypass mode and fails in FIFO modes. In FIFO modes,
* function *lis3dh_get_float_data_fifo* has to be used instead to get data. * function *lis3dh_get_float_data_fifo* has to be used instead to get data.
@ -220,74 +220,21 @@ uint8_t lis3dh_get_raw_data_fifo (lis3dh_sensor_t* dev,
/** /**
* @brief Set configuration for activity (inertial) interrupt INT1/INT2 * @brief Enable / disable an interrupt on signal INT1 or INT2
* *
* Set the configuration for interrupts that are generated when a certain * @param dev pointer to the sensor device data structure
* acceleration is higher or lower than defined threshold and one of the * @param type interrupt to be enabled or disabled
* following activities are recognized: wake-up, free fall or 6D/4D * @param signal interrupt signal that is activated for the interrupt
* orientation detection * @param value true to enable or false to disable the interrupt
* * @return true on success, false on error
* @param dev pointer to the sensor device data structure
* @param signal specifies the interrupt signal used in function
* @param config configuration for the specified interrupt signal
* @return true on success, false on error
*/ */
bool lis3dh_set_int_activity_config (lis3dh_sensor_t* dev, bool lis3dh_enable_int (lis3dh_sensor_t* dev,
lis3dh_int_signals_t signal, lis3dh_int_type_t type,
lis3dh_int_activity_config_t* config); lis3dh_int_signal_t signal, bool value);
/**
* @brief Get cofiguration for activity (inertial) interrupt INT1/INT2
*
* Get the configuration for interrupts that are generated when a certain
* acceleration is higher or lower than defined threshold and one of the
* following activities is recognized: wake-up, free fall or 6D/4D orientation
* detection
*
* @param dev pointer to the sensor device data structure
* @param signal specifies the interrupt signal used in function
* @param config configuration for the specified interrupt signal
* @return true on success, false on error
*/
bool lis3dh_get_int_activity_config (lis3dh_sensor_t* dev,
lis3dh_int_signals_t signal,
lis3dh_int_activity_config_t* config);
/**
* @brief Get the source of the activity (inertial) interrupt INT1/INT2
*
* Returns a byte with flags that indicate the activity which triggered
* the interrupt signal (see INTx_SRC register in datasheet for details)
*
* @param dev pointer to the sensor device data structure
* @param source pointer to the interrupt source
* @param signal specifies the interrupt signal used in function
* @return true on success, false on error
*/
bool lis3dh_get_int_activity_source (lis3dh_sensor_t* dev,
lis3dh_int_activity_source_t* source,
lis3dh_int_signals_t signal);
/**
* @brief Enable/disable an data interrupt on signal INT1
*
* Enables or diables interrupts that are generated either when data are
* ready to read or FIFO activities like overrun an watermark happen.
*
* @param dev pointer to the sensor device data structure
* @param type type of interrupt to be enabled/disabled
* @param value true to enable/false to disable the interrupt
* @return true on success, false on error
*/
bool lis3dh_enable_int_data (lis3dh_sensor_t* dev,
lis3dh_int_data_t type, bool value);
/** /**
* @brief Get the source of the data interrupt on signal INT1 * @brief Get the source of data ready and FIFO interrupts on INT1
* *
* @param dev pointer to the sensor device data structure * @param dev pointer to the sensor device data structure
* @param source pointer to the interrupt source * @param source pointer to the interrupt source
@ -298,44 +245,91 @@ bool lis3dh_get_int_data_source (lis3dh_sensor_t* dev,
/** /**
* @brief Set configuration for click detection interrupt INT1/INT2 * @brief Set the configuration of an inertial event interrupt generator
*
* Inertial interrupt generators produce interrupts when certain inertial event
* occures (event interrupts), that is, the acceleration of defined axes is
* higher or lower than a defined threshold and one of the following event is
* recognized: axis movement / wake up, free fall, 6D/4D orientation detection.
*
* @param dev pointer to the sensor device data structure
* @param config pointer to the interrupt generator configuration
* @param gen interrupt generator to which the function is applied
* @return true on success, false on error
*/
bool lis3dh_set_int_event_config (lis3dh_sensor_t* dev,
lis3dh_int_event_config_t* config,
lis3dh_int_event_gen_t gen);
/**
* @brief Get the configuration of an inertial event interrupt generator
*
* Inertial interrupt generators produce interrupts when certain inertial event
* occures (event interrupts), that is, the acceleration of defined axes is
* higher or lower than a defined threshold and one of the following event is
* recognized: axis movement / wake up, free fall, 6D/4D orientation detection.
*
* @param dev pointer to the sensor device data structure
* @param config pointer to the interrupt generator configuration
* @param gen interrupt generator to which the function is applied
* @return true on success, false on error
*/
bool lis3dh_get_int_event_config (lis3dh_sensor_t* dev,
lis3dh_int_event_config_t* config,
lis3dh_int_event_gen_t gen);
/**
* @brief Get the source of an inertial event interrupt INT1/INT2
*
* Returns a byte with flags that indicate the event which triggered
* the interrupt signal (see INTx_SRC register in datasheet for details)
*
* @param dev pointer to the sensor device data structure
* @param source pointer to the interrupt source data structure
* @param gen interrupt generator to which the function is applied
* @return true on success, false on error
*/
bool lis3dh_get_int_event_source (lis3dh_sensor_t* dev,
lis3dh_int_event_source_t* source,
lis3dh_int_event_gen_t gen);
/**
* @brief Set the configuration of the click detection interrupt generator
* *
* Set the configuration for interrupts that are generated when single or * Set the configuration for interrupts that are generated when single or
* double clicks are detected. * double clicks are detected.
* *
* @param dev pointer to the sensor device data structure * @param dev pointer to the sensor device data structure
* @param signal specifies the interrupt signal used in function * @param config pointer to the interrupt generator configuration
* @param config configuration for the specified interrupt signal
* @return true on success, false on error * @return true on success, false on error
*/ */
bool lis3dh_set_int_click_config (lis3dh_sensor_t* dev, bool lis3dh_set_int_click_config (lis3dh_sensor_t* dev,
lis3dh_int_signals_t signal,
lis3dh_int_click_config_t* config); lis3dh_int_click_config_t* config);
/** /**
* @brief Set configuration for click detection interrupt INT1/INT2 * @brief Get the configuration of the click detection interrupt generator
* *
* Set the configuration for interrupts that are generated when single or * Set the configuration for interrupts that are generated when single or
* double clicks are detected. * double clicks are detected.
* *
* @param dev pointer to the sensor device data structure * @param dev pointer to the sensor device data structure
* @param signal specifies the interrupt signal used in function * @param config pointer to the interrupt generator configuration
* @param config configuration for the specified interrupt signal
* @return true on success, false on error * @return true on success, false on error
*/ */
bool lis3dh_get_int_click_config (lis3dh_sensor_t* dev, bool lis3dh_get_int_click_config (lis3dh_sensor_t* dev,
lis3dh_int_signals_t signal,
lis3dh_int_click_config_t* config); lis3dh_int_click_config_t* config);
/** /**
* @brief Get the source of the click detection interrupt INT1/INT2 * @brief Get the source of the click detection interrupt on signal INT1/INT2
* *
* Returns a byte with flags that indicate the activity which triggered * Returns a byte with flags that indicate the activity which triggered
* the interrupt signal (see CLICK_SRC register in datasheet for details) * the interrupt signal (see CLICK_SRC register in datasheet for details)
* *
* @param dev pointer to the sensor device data structure * @param dev pointer to the sensor device data structure
* @param signal specifies the interrupt signal used in function
* @param source pointer to the interrupt source * @param source pointer to the interrupt source
* @return true on success, false on error * @return true on success, false on error
*/ */
@ -395,9 +389,8 @@ bool lis3dh_set_hpf_ref (lis3dh_sensor_t* dev, int8_t ref);
*/ */
int8_t lis3dh_get_hpf_ref (lis3dh_sensor_t* dev); int8_t lis3dh_get_hpf_ref (lis3dh_sensor_t* dev);
/** /**
* @brief Enable / disable ADC or temperatury sensor * @brief Enable / disable ADC or temperature sensor
* *
* @param dev pointer to the sensor device data structure * @param dev pointer to the sensor device data structure
* @param enable if true, ADC inputs are enabled * @param enable if true, ADC inputs are enabled
@ -419,6 +412,7 @@ int8_t lis3dh_enable_adc (lis3dh_sensor_t* dev, bool enable, bool temp);
bool lis3dh_get_adc (lis3dh_sensor_t* dev, bool lis3dh_get_adc (lis3dh_sensor_t* dev,
uint16_t* adc1, uint16_t* adc2, uint16_t* adc3); uint16_t* adc1, uint16_t* adc2, uint16_t* adc3);
// ---- Low level interface functions ----------------------------- // ---- Low level interface functions -----------------------------
/** /**
@ -435,7 +429,7 @@ bool lis3dh_get_adc (lis3dh_sensor_t* dev,
* @param len number of bytes to be written to the register * @param len number of bytes to be written to the register
* @return true on success, false on error * @return true on success, false on error
*/ */
bool lis3dh_write_reg (lis3dh_sensor_t* dev, bool lis3dh_reg_write (lis3dh_sensor_t* dev,
uint8_t reg, uint8_t *data, uint16_t len); uint8_t reg, uint8_t *data, uint16_t len);
/** /**
@ -452,7 +446,7 @@ bool lis3dh_write_reg (lis3dh_sensor_t* dev,
* @param len number of bytes to be read from the register * @param len number of bytes to be read from the register
* @return true on success, false on error * @return true on success, false on error
*/ */
bool lis3dh_read_reg (lis3dh_sensor_t* dev, bool lis3dh_reg_read (lis3dh_sensor_t* dev,
uint8_t reg, uint8_t *data, uint16_t len); uint8_t reg, uint8_t *data, uint16_t len);
#ifdef __cplusplus #ifdef __cplusplus

107
extras/lis3dh/lis3dh_types.h
View file

@ -115,17 +115,59 @@ typedef enum {
lis3dh_int1_signal = 0, lis3dh_int1_signal = 0,
lis3dh_int2_signal = 1 lis3dh_int2_signal = 1
} lis3dh_int_signals_t; } lis3dh_int_signal_t;
/** /**
* @brief Activity interrupt configuration for INT1/INT2 signals * @brief Inertial event interrupt generators
* */
* Activity interrupts are: axes movement wake-up, free-fall, 6D/4D detection. typedef enum {
lis3dh_int_event1_gen = 0,
lis3dh_int_event2_gen = 1
} lis3dh_int_event_gen_t;
/**
* @brief Interrupt types for interrupt signals INT1/INT2
*/
typedef enum {
lis3dh_int_data_ready, // data ready for read interrupt (only INT1)
lis3dh_int_fifo_watermark, // FIFO exceeds the threshold (only INT1)
lis3dh_int_fifo_overrun, // FIFO is completely filled (only INT1)
lis3dh_int_event1, // inertial event interrupt 1
lis3dh_int_event2, // inertial event interrupt 2
lis3dh_int_click // click detection interrupt
} lis3dh_int_type_t;
/**
* @brief Data ready and FIFO status interrupt source for INT1
*/ */
typedef struct { typedef struct {
enum { // activity type for the interrupt bool data_ready; // true when acceleration data are ready to read
bool fifo_watermark; // true when FIFO exceeds the FIFO threshold
bool fifo_overrun; // true when FIFO is completely filled
} lis3dh_int_data_source_t;
/**
* @brief Inertial interrupt generator configuration for INT1/INT2
*
* Inertial events are: wake-up, free-fall, 6D/4D detection.
*/
typedef struct {
enum { // interrupt mode
lis3dh_wake_up, // AOI = 0, 6D = 0 lis3dh_wake_up, // AOI = 0, 6D = 0
lis3dh_free_fall, // AOI = 1, 6D = 0 lis3dh_free_fall, // AOI = 1, 6D = 0
@ -136,7 +178,7 @@ typedef struct {
lis3dh_4d_movement, // AOI = 0, 6D = 1, D4D = 1 lis3dh_4d_movement, // AOI = 0, 6D = 1, D4D = 1
lis3dh_4d_position, // AOI = 1, 6D = 1, D4D = 1 lis3dh_4d_position, // AOI = 1, 6D = 1, D4D = 1
} activity; } mode;
uint8_t threshold; // threshold used for comparison for all axes uint8_t threshold; // threshold used for comparison for all axes
@ -154,50 +196,26 @@ typedef struct {
uint8_t duration; // duration in 1/ODR an interrupt condition has uint8_t duration; // duration in 1/ODR an interrupt condition has
// to be given before the interrupt is generated // to be given before the interrupt is generated
} lis3dh_int_activity_config_t; } lis3dh_int_event_config_t;
/** /**
* @brief Activity interrupt source type for interrupt signals INT1/INT2 * @brief Inertial event source type for interrupt generator INT1/INT2
*/ */
typedef struct { typedef struct {
bool active:1; // true - one ore more activities occured bool active:1; // true - one ore more events occured
bool x_low :1; // true - x low activity occured bool x_low :1; // true - x lower than threshold event
bool x_high:1; // true - x high activity occured bool x_high:1; // true - x higher than threshold event
bool y_low :1; // true - z low activity occured bool y_low :1; // true - z lower than threshold event
bool y_high:1; // true - z high activity occured bool y_high:1; // true - z higher than threshold event
bool z_low :1; // true - z low activity occured bool z_low :1; // true - z lower than threshold event
bool z_high:1; // true - z high activity occured bool z_high:1; // true - z higher than threshold event
} lis3dh_int_activity_source_t; } lis3dh_int_event_source_t;
/**
* @brief Data interrupt types for INT1 signal
*/
typedef enum {
lis3dh_data_ready, // interrupt when data are ready to read
lis3dh_fifo_watermark, // interrupt when FIFO exceeds the FIFO threashold
lis3dh_fifo_overrun // interrupt when FIFO is completely filled
} lis3dh_int_data_t;
/**
* @brief Data interrupt source type for INT1 signal
*/
typedef struct {
bool data_ready; // true when data are ready to read
bool fifo_watermark; // true when FIFO exceeds the FIFO threashold
bool fifo_overrun; // true when FIFO is completely filled
} lis3dh_int_data_source_t;
/** /**
@ -230,7 +248,7 @@ typedef struct {
/** /**
* @brief Click interrupt configuration for interrupt signals INT1/INT2 * @brief Click interrupt source for interrupt signals INT1/INT2
*/ */
typedef struct { typedef struct {
@ -243,7 +261,7 @@ typedef struct {
bool s_click:1; // single click detected bool s_click:1; // single click detected
bool d_click:1; // double click detected bool d_click:1; // double click detected
bool active :1; // true - one ore more Activities occured bool active :1; // true - one ore more event occured
} lis3dh_int_click_source_t; } lis3dh_int_click_source_t;
@ -278,7 +296,7 @@ typedef lis3dh_raw_data_t lis3dh_raw_data_fifo_t[32];
/** /**
* @brief Floating point output value set in degree * @brief Floating point output value set in g
*/ */
typedef struct { typedef struct {
@ -321,8 +339,9 @@ typedef struct {
uint8_t cs; // ESP8266, ESP32: GPIO used as SPI CS uint8_t cs; // ESP8266, ESP32: GPIO used as SPI CS
// __linux__: device index // __linux__: device index
lis3dh_scale_t scale; // fill range scale (default 245 dps) lis3dh_scale_t scale; // full range scale (default 2 g)
lis3dh_resolution_t res; // resolution used lis3dh_resolution_t res; // resolution used
lis3dh_fifo_mode_t fifo_mode; // FIFO operation mode (default bypass) lis3dh_fifo_mode_t fifo_mode; // FIFO operation mode (default bypass)
bool fifo_first; // first FIFO access bool fifo_first; // first FIFO access