How to handle multi-rate messages with per-record timestamps

[MrMati]

My problem is easiest to explain with the IMU example.

I want to send frames containing multiple accelerometer samples, where each sample has its own timestamp:

{
  "records": [
    {
      "timestamp": 2.806,
      "accel_x": 0.2,
      "accel_y": 0.231,
      "accel_z": 10.286
    },
    {
      "timestamp": 2.826,
      "accel_x": 0.229,
      "accel_y": 0.229,
      "accel_z": 10.335
    }
  ]
}

At a much lower rate, I send battery and temperature data:

{
  "records": [
    {
      "timestamp": 3.006,
      "temperature": 26.5,
      "battery": 3.7
    }
  ]
}

I was able to get the low-rate battery/temperature messages working using tableSet with registers and virtual datasets.

However, I can't figure out how to display the accelerometer samples using their individual timestamps. Since each frame contains multiple timestamped records, how should these be mapped so they appear correctly on the time axis?

AI assistant didn't help.

[alex-spataru]

Hi,

This should be possible. The attached imu_records_example.zip (project + Python simulator) reproduces your exact payload shape. Two building blocks:

1. Multi-frame parsing: parse() can return an array of rows; Serial Studio publishes one sample per row, so every entry in "records" becomes its own point.
2. Timestamp as X axis: map timestamp as its own dataset, then set it as the plot's X-Axis source in the Project Editor. Samples then land exactly at their transmitted device time.

The example uses no data tables: everything is sent as plain arrays from the frame parser, with the low-rate battery/temperature values cached and repeated into each row. Channel order is [timestamp, accel_x, accel_y, accel_z, temperature, battery]:

var lastTemperature = 0;
var lastBattery = 0;

function parse(frame) {
  if (frame.length === 0)
    return [];

  var packet = JSON.parse(frame);
  if (!packet.records)
    return [];

  var rows = [];
  for (var i = 0; i < packet.records.length; ++i) {
    var r = packet.records[i];

    if (r.temperature !== undefined)
      lastTemperature = r.temperature;
    if (r.battery !== undefined)
      lastBattery = r.battery;

    if (r.accel_x !== undefined) {
      rows.push([r.timestamp, r.accel_x, r.accel_y, r.accel_z,
                 lastTemperature, lastBattery]);
    }
  }

  return rows;
}

This should also work with your existing table-driven setup: add a dataset that carries the timestamp, point the X-axis source of your plots at it, and your tableSet-fed virtual datasets will plot against it the same way.

Note: This works fine with monotonic timestamps. Non-monotonic data should probably still work with the X-axis configuration, but it might create artifacts from the interpolation (the curve is drawn in sample order).

To run: extract the zip (keep both files in the same folder), open imu_records.ssproj, and click Connect, the project's control script auto-launches the simulator (needs python3/python on your PATH).

Let me know if this solves it for you! Also, I'd love to hear where the AI assistant fell short...I'm still building out its training data and skill files, and user feedback like yours is the best signal for where it needs reinforcing.

Best,
Alex Spataru

[MrMati]

Thanks for quick response. Unfortunately this solution doesn't meet my needs.

1. Multiplot composite is not used (not very important)
2. Sending only the low-rate frames doesn't update anything

In AI issistant I used Haiku 4.5 and GPT 5.2 through OpenRouter.
Haiku went into loop of removing a wrong group and restoring it (complained about some off by one error in indexing).
GPT created a solution that kinda works with low-rate frames, but it erases accel data while receiving them. I've attached it.
imu_gpt52.zip

In my opinion the design of Frame Parser is very limiting as it requires returning all the data every time.
While what I need is appending/setting data to only the selected plots/indicators.

Also the Frame Index being a integer instead of a string is a weird choice.
With string indexing, the parser could return an object with only the keys it wants to update set.