What is the correct way to enable the FIFO interrupt in LIS2DH12?

jeranio · August 30, 2021, 11:06am

Hi there,
I’m facing an issue in enabling the FIFO interrupt functionality in LIS2DH12. Here’s the details.

First, I forked the Ruuvitag firmware repository (here) and I’ve added a new function in app_sensor.c to enable the FIFO interrupt (similarly to this one)

github.com

jermathew/ruuvi.firmware.c/blob/a90c4c9d97f8132a68f9129c126b61ef0b24a40d/src/app_sensor.c#L522

    
      
                  err_code |= ri_gpio_interrupt_enable (RB_INT_LEVEL_PIN,
                                                        RI_GPIO_SLOPE_TOGGLE,
                                                        RI_GPIO_MODE_INPUT_NOPULL,
                                                        &on_accelerometer_isr);
                  err_code |= provider->level_interrupt_set (true, threshold_g);
              }
          
          
    return err_code;
          }
          
          
rd_status_t app_sensor_acc_fifo_set (bool enable)
          {
              rd_status_t err_code = RD_SUCCESS;
              const rd_sensor_data_fields_t acceleration =
              {
                  .datas.acceleration_x_g = 1,
                  .datas.acceleration_y_g = 1,
                  .datas.acceleration_z_g = 1
              };
              const rd_sensor_t * const provider = app_sensor_find_provider (acceleration);

At this point, I defined a handler function for FIFO interrupts:

github.com

jermathew/ruuvi.firmware.c/blob/a90c4c9d97f8132a68f9129c126b61ef0b24a40d/src/app_sensor.c#L474

    
      
          }
          
          
static void fifo_task(void * p_data, uint16_t data_len){
            // here the FIFO buffer should be read
            // for now, just print a log statement
            char msg[128];
            snprintf (msg, sizeof (msg), "%lu: FIFO called\r\n", (uint32_t) ri_rtc_millis());
            LOG (msg);
          }
          
          
static void on_fifo_isr (const ri_gpio_evt_t event)
          {   
              rd_status_t err_code = RD_SUCCESS;
              err_code |= ri_scheduler_event_put (NULL, 0u, &fifo_task);
              RD_ERROR_CHECK (err_code, RD_SUCCESS);
          
          
}
          
          
rd_status_t app_sensor_acc_thr_set (float * const threshold_g)
          {
              rd_status_t err_code = RD_SUCCESS;

At the moment, the fifo_task function prints a log with a timestamp (ms) followed by a string (“FIFO called”)

Then, I edited app_main.c in order to call the app_sensor_acc_fifo_set function from above.

github.com

jermathew/ruuvi.firmware.c/blob/a90c4c9d97f8132a68f9129c126b61ef0b24a40d/src/main.c#L86

    
      
          err_code |= rt_flash_init();
          err_code |= app_led_init();
          app_led_error_signal (true);
          err_code |= app_button_init();
          err_code |= app_dc_dc_init();
          err_code |= app_sensor_init();
          err_code |= app_log_init();
          // Allow fail on boards which do not have accelerometer.
          (void) app_sensor_acc_thr_set (&motion_threshold);
          // Enable FIFO
          (void) app_sensor_acc_fifo_set(true);
          err_code |= app_comms_init (APP_LOCKED_AT_BOOT);
          err_code |= app_sensor_vdd_sample();
          err_code |= app_heartbeat_init();
          err_code |= app_heartbeat_start();
          
          
if (RD_SUCCESS == err_code)
          {
              app_led_error_signal (false);
              app_led_activity_signal (true);
              err_code |= ri_delay_ms (APP_SELFTEST_OK_DELAY_MS);

I’ve also set APP_SENSOR_LIS2DH12_SAMPLERATE to 50Hz, increased the advertising frequency (i.e APP_BLE_INTERVAL_MS) to 3 seconds and set APP_NUM_REPEATS to 1. In this way, the Ruuvitag should send a BLE advertisement packet every 3 seconds (since APP_NUM_REPEATS is set to 1).

Additionally, I’ve enabled logging (RI_LOG_ENABLED) and set the log level (APP_LOG_LEVEL) to “INFO” (RI_LOG_LEVEL_INFO).

Finally, I erased the chip and flashed the firmware using SEGGER Embedded Studio (project “ruuvitag_b”) and the Ruuvitag development kit. The application mode was set to “Release”.

Here’s a screenshot:

In general, it seems that FIFO interrupts are triggered approximately every 3 seconds. For instance, the third “FIFO called” log (6491: FIFO called) is printed after (6491 - 3482)/1000=3.009 seconds from the second one (“3482: FIFO called”).

From my understading, FIFO interrupts should be fired roughly every 32/APP_SENSOR_LIS2DH12_SAMPLERATE since the LIS2DH12 FIFO buffer can hold up to 32 samples. Given that APP_SENSOR_LIS2DH12_SAMPLERATE is 50, we should expect the “FIFO interrupt” log to be printed every 32/50=0.64 seconds. However, it seems that interrupts are triggered every APP_HEARTBEAT_INTERVAL_MS*1000 seconds.

Indeed, by printing additional logs, I found out that FIFO interrupts are triggered almost every time the app_sensor_get function in app_sensor.c is called, that is, every APP_HEARTBEAT_INTERVAL_MS milliseconds:

Perhaps, FIFO interrupts are triggered when the ri_lis2dh12_data_get function in ruuvi_interface_lis2dh12.c gets called from app_sensor_get.

I’ve also tried setting APP_SENSOR_LIS2DH12_SAMPLERATE to a different value (100Hz), but FIFO interrupts are still fired every 3 seconds.

Given that I’m a beginner, it is very likely that I didn’t properly enabled the FIFO functionality at all.

Any hints on what I should do to enable FIFO interrupts would be greatly appreciated.
Thanks

otso · September 1, 2021, 11:29am

Hello,

Perhaps, FIFO interrupts are triggered when the ri_lis2dh12_data_get function in ruuvi_interface_lis2dh12.c gets called from app_sensor_get.

On a quick look, it seems to me that this is the case. Do you read the FIFO completely when the interrupt is triggered? If not, here’s what would happen:

FIFO gets full → interrupt
data_get is called → 1 element is read → FIFO has space for new element
FIFO gets full → interrupt
Back to 2.

This would explain the behavior you’re seeing. As a fix, you should read the FIFO when the FIFO interrupt comes. Please also note that nRF52 is configured to use port-level GPIO interrupts to save power. This means that if you’re using both threshold and FIFO interrupt at the same time, one interrupt will be missed when threshold and FIFO full interrupt fire on same accelerometer sample.

I hope this helps, driver/integration_tests folder also has test for FIFO interrupts which provides a sample on how the FIFO can be read.

jeranio · September 5, 2021, 6:25am

Hi @otso ,
sorry for the late response and thanks for your reply.

Yes, I was just logging instead of reading the FIFO buffer, and your explanation makes perfect sense. I should’ve tried to read the FIFO buffer before asking you this question about FIFO interrupts.

By the way, I followed your advice and edited my code according to this and, indeed, by reading the FIFO buffer every time an interrupt occurs, the buffer is cleared and this, in turn, let the interrupt timings to be the expected one.

Thanks again for your response