Support for timestamps in FIFO

[ScottMit]

Hi,

Thanks for supporting this library on Seeed devices.
I have a Xiao Sense board that is recording IMU data and I would like to record timestamps from the FIFO.
Could this functionality be added to the library?

Thanks.
Scott

[baorepo]

@ScottMit Good idea. Could you please elaborate on your thoughts regarding this FIFO? We will add this function for you.

[baorepo]

@Yuan-AZKKXL

Background

• The LSM6DS3 sensor does support FIFO timestamping, which records hardware timestamps alongside sensor data if enabled.
• This typically involves configuring the TIMESTAMP and FIFO registers so that timestamp values are included in the FIFO stream.

To Implement This:

1. Enable timestamp storage in FIFO by setting the appropriate registers (e.g., TIMESTAMP_CTRL and FIFO_CTRLx).
2. Update the library’s FIFO reading logic to recognize and parse timestamp tags and values from the FIFO stream.
3. Extend the library’s API so that timestamps can be accessed by users, along with accelerometer and gyroscope data.

Reference:

• LSM6DS3 Datasheet (see FIFO and TIMESTAMP_CTRL sections).

Example (Pseudo-Arduino code):

// Enable timestamp in FIFO
imu.writeRegister(LSM6DS3_REG_TIMESTAMP_CTRL, 0x80); // Enable timestamp
imu.writeRegister(LSM6DS3_REG_FIFO_CTRL4, 0x08); // Enable timestamp batching

// Read FIFO and decode timestamp pattern
while (fifoHasData()) {
    uint8_t tag = readFifoTag();
    if (tag == LSM6DS3_TAG_TIMESTAMP) {
        uint32_t ts = readTimestamp();
        Serial.println(ts);
    }
    // ... handle other tags (accel, gyro, etc)
}

Next Steps:

• Check if the current library already parses FIFO tags and timestamp registers.
• If not, we could propose or submit a PR to enable timestamping, parse the FIFO timestamps, and document the new API.

[ScottMit]

@baorepo thanks for the quick response.
Currently we are following the SparkFun FIFO example that reads the buffer until it is empty with myIMU.fifoRead(). It makes assumptions about what that data contains, e.g. gx = myIMU.calcGyro(myIMU.fifoRead())
This is working for us collecting gyro x, y, z and accel x, y, z. What we would like is to be able to read a timestamp also - from my understanding of the data sheet that would require two more fifpoRead().
However, if you want to wrap it in a readTimestamp() function, that could also work
And, maybe we need a SensorSetting that can activate/deactivate the timestamp for FIFO?
: )

[AZKKXL]

@ScottMit
hello,Do you want us to provide an interface implementation to activate the pedometer and timestamp data in the FIFO according to the steps in the picture?

[ScottMit]

@Yuan-AZKKXL
Hello. and thanks for the message.
We would like option 1, where data is written to the FIFO at the ODR_FIFO rate, but I imagine other people would be interested in option 2, where data is written for every new step count. So, an interface for either of these implementations would be good.
It looks like some of the steps already have an interface in the library: 1. turn on the accelerometer, 3. set fifo decimation, 7. configure the FIFO mode. maybe others.

[AZKKXL]

So you want us to provide a separate interface for each step when enabling the FIFO timestamp function, allowing users to combine them into a complete feature?

[ScottMit]

Yes, I think that would make the most sense in the existing library interface. This is what the original SparkFun Library example for FIFO sets:

  myIMU.settings.gyroEnabled = 1;  //Can be 0 or 1
  myIMU.settings.gyroRange = 2000;   //Max deg/s.  Can be: 125, 245, 500, 1000, 2000
  myIMU.settings.gyroSampleRate = 833;   //Hz.  Can be: 13, 26, 52, 104, 208, 416, 833, 1666
  myIMU.settings.gyroBandWidth = 200;  //Hz.  Can be: 50, 100, 200, 400;
  myIMU.settings.gyroFifoEnabled = 1;  //Set to include gyro in FIFO
  myIMU.settings.gyroFifoDecimation = 1;  //set 1 for on /1

  myIMU.settings.accelEnabled = 1;
  myIMU.settings.accelRange = 16;      //Max G force readable.  Can be: 2, 4, 8, 16
  myIMU.settings.accelSampleRate = 833;  //Hz.  Can be: 13, 26, 52, 104, 208, 416, 833, 1666, 3332, 6664, 13330
  myIMU.settings.accelBandWidth = 200;  //Hz.  Can be: 50, 100, 200, 400;
  myIMU.settings.accelFifoEnabled = 1;  //Set to include accelerometer in the FIFO
  myIMU.settings.accelFifoDecimation = 1;  //set 1 for on /1
  myIMU.settings.tempEnabled = 1;
  
    //Non-basic mode settings
  myIMU.settings.commMode = 1;

  //FIFO control settings
  myIMU.settings.fifoThreshold = 100;  //Can be 0 to 4096 (16 bit bytes)
  myIMU.settings.fifoSampleRate = 50;  //Hz.  Can be: 10, 25, 50, 100, 200, 400, 800, 1600, 3300, 6600
  myIMU.settings.fifoModeWord = 6;  //FIFO mode.

So, that covers many of the steps in the data sheet, but is missing steps:
2 (I'm not sure what parts of the pedometer needs to be enabled for timestamps to work), 4, 5, 6.

[AZKKXL]

Is this the result you were looking for?
ΔT(ms) = (Current timestamp - Previous timestamp) × 0.625

[ScottMit]

@Yuan-AZKKXL
No, I don't think that will work for us. We are taking FIFO data and writing it to an SD card. We need a time stamp for each recording in the FIFO, this is how it might fit in our code:

void loop() {
  // if FIFO is almost full, write to SD card
  if ((myIMU.fifoGetStatus() & 0x8000) != 0) {
    write_to_SD();
  }
}

void write_to_SD() {
  // check there is a file to write to
  if (myFile) {

    // loop until FIFO is empty.
    while ((myIMU.fifoGetStatus() & 0x1000) == 0) {

      float gx = myIMU.calcGyro(myIMU.fifoRead());
      float gy = myIMU.calcGyro(myIMU.fifoRead());
      float gz = myIMU.calcGyro(myIMU.fifoRead());
      float ax = myIMU.calcAccel(myIMU.fifoRead());
      float ay = myIMU.calcAccel(myIMU.fifoRead());
      float az = myIMU.calcAccel(myIMU.fifoRead());
      float timestamp = myIMU.calcTime(myIMU.fifoRead()); 
      // except I think the timestamp is bigger than 16 bit

      //write data
      myFile.print(ax);
      myFile.print(",");
      myFile.print(ay);
      myFile.print(",");
      myFile.print(az);
      myFile.print(",");
      myFile.print(gx);
      myFile.print(",");
      myFile.print(gy);
      myFile.print(",");
      myFile.print(gz);
      myFile.print(",");
      myFile.print(ts);
      myFile.print("\n");
    }
  }
}

[AZKKXL]

The approach you mentioned seems unfeasible because the timestamp data and the accelerometer/gyroscope data structures appear inconsistent. The current solution is to provide a separate read function for the FIFO timestamp, and you can enable or disable the timestamp functionality as done in the SparkFun_LSM6DS3_Arduino_Library.

[ScottMit]

@Yuan-AZKKXL Thanks for the explanation and clear code example.
I think reading the LSM6DS3_ACC_GYRO_TIMESTAMP0_REG gets the current timestamp, not the timestamp as recorded when data was passes to the FIFO.
You could test this by adding a small delay to the while loop and seeing if the timestamp delta changes. If it does, then it's not getting the timestamp from the FIFO.
For our use, we need timestamp data for the readings going into the FIFO because we need to check when readings are collected and if readings are being dropped.
To get FIFO timestamps the datasheet says you need to read this "as a 4th FIFO data set". I'm not exactly sure what that means, but was thinking it means the timestamp data is simply added to the FIFO data stream as a 4th option (after Acc, Gyro, & Mag) and you have to know the FIFO pattern in order to decipher it.
Let me know if my thinking is completely miss-guided.

[AZKKXL]

Yes, you're correct. The register LSM6DS3_ACC_GYRO_TIMESTAMP0_REG provides the current timestamp, not the one recorded when data was pushed into the FIFO. Regarding the timestamp being a "4th FIFO data set" as stated in the datasheet, it means the timestamp data is appended to the FIFO data stream alongside accelerometer, gyroscope, and external sensor data (note: the order here aligns with the datasheet's FIFO configuration). Thank you for the clarification—this makes the mechanism clear.

Here's the current implementation result; please verify if it meets your requirement for capturing FIFO entry timestamps to monitor data collection timing and potential drop-offs.

The difference between two FIFO timestamps: 9093440 - 9091891 = 1549.
Calculation:
1549×25μs=38725μs≈40ms

Initially, the timestamp frequency was assumed to be 25 Hz (since
1/25Hz=40ms
), but according to the datasheet, the actual frequency should be 26 Hz.

[AZKKXL]

@ScottMit I haven't encountered any issues during testing. I have updated the library and example programs. You can test it out and let me know if you encounter any problems.