muse s anthena timestamp rework

Andrey1994 · Andrey1994 · commit 7f619fd38583 · 2026-04-27T23:16:43.000+07:00
Signed-off-by: Andrey Parfenov &lt;a1994ndrey@gmail.com&gt;
diff --git a/src/board_controller/muse/inc/muse_anthena.h b/src/board_controller/muse/inc/muse_anthena.h
@@ -42,9 +42,9 @@ class MuseAnthena : public BLELibBoard
     std::condition_variable cv;
     std::vector<std::pair<simpleble_uuid_t, simpleble_uuid_t>> notified_characteristics;
     std::pair<simpleble_uuid_t, simpleble_uuid_t> control_characteristics;
-    bool timestamp_initialized;
-    uint32_t first_device_tick;
-    double first_host_timestamp;
+    double last_eeg_timestamp;
+    double last_aux_timestamp;
+    double last_anc_timestamp;
     double last_battery;
     std::string muse_preset;
     bool enable_low_latency;
@@ -57,10 +57,12 @@ class MuseAnthena : public BLELibBoard
     std::string bytes_to_string (const uint8_t *data, size_t size);
     void handle_data_notification (const uint8_t *data, size_t size);
     void parse_sensor_payload (
-        uint8_t tag, uint8_t sequence_num, uint32_t device_tick, const uint8_t *data, size_t size);
+        uint8_t tag, uint8_t sequence_num, double host_timestamp, const uint8_t *data, size_t size);
     bool get_sensor_config (uint8_t tag, SensorConfig &config);
     int get_optics_canonical_index (uint8_t tag, int channel);
-    double get_sample_timestamp (uint32_t device_tick, int sample_index, double sampling_rate);
+    void reset_timestamps ();
+    static double get_sample_timestamp (double last_timestamp, double current_timestamp,
+        int sample_index, int n_samples, double sampling_rate);
 
 public:
     MuseAnthena (int board_id, struct BrainFlowInputParams params);
diff --git a/src/board_controller/muse/inc/muse_anthena_constants.h b/src/board_controller/muse/inc/muse_anthena_constants.h
@@ -11,6 +11,5 @@
 // info for equations
 #define MUSE_ANTHENA_ACCELEROMETER_SCALE_FACTOR 0.0000610352
 #define MUSE_ANTHENA_GYRO_SCALE_FACTOR -0.0074768
-#define MUSE_ANTHENA_DEVICE_CLOCK_HZ 256000.0
 #define MUSE_ANTHENA_EEG_SCALE_FACTOR (1450.0 / 16383.0)
 #define MUSE_ANTHENA_OPTICS_SCALE_FACTOR 1.0
diff --git a/src/board_controller/muse/muse_anthena.cpp b/src/board_controller/muse/muse_anthena.cpp
@@ -263,9 +263,7 @@ MuseAnthena::MuseAnthena (int board_id, struct BrainFlowInputParams params)
     muse_adapter = NULL;
     muse_peripheral = NULL;
     is_streaming = false;
-    timestamp_initialized = false;
-    first_device_tick = 0;
-    first_host_timestamp = 0.0;
+    reset_timestamps ();
     last_battery = 0.0;
     muse_preset = "p1041";
     enable_low_latency = true;
@@ -486,9 +484,7 @@ int MuseAnthena::start_stream (int buffer_size, const char *streamer_params)
     if (res == (int)BrainFlowExitCodes::STATUS_OK)
     {
         std::lock_guard<std::mutex> callback_guard (callback_lock);
-        timestamp_initialized = false;
-        first_device_tick = 0;
-        first_host_timestamp = 0.0;
+        reset_timestamps ();
         last_battery = 0.0;
     }
     if (res == (int)BrainFlowExitCodes::STATUS_OK)
@@ -555,7 +551,7 @@ int MuseAnthena::stop_stream ()
         res = (int)BrainFlowExitCodes::STREAM_ALREADY_RUN_ERROR;
     }
     is_streaming = false;
-    timestamp_initialized = false;
+    reset_timestamps ();
     return res;
 }
 
@@ -744,8 +740,7 @@ void MuseAnthena::handle_data_notification (const uint8_t *data, size_t size)
 
         const uint8_t *packet = data + offset;
         uint8_t packet_index = packet[1];
-        uint32_t device_tick =
-            cast_32bit_to_uint32_little_endian ((const unsigned char *)(packet + 2));
+        double packet_host_timestamp = get_timestamp ();
         uint8_t primary_tag = packet[9];
         const uint8_t *packet_data = packet + PACKET_HEADER_SIZE;
         size_t packet_data_size = packet_len - PACKET_HEADER_SIZE;
@@ -758,8 +753,8 @@ void MuseAnthena::handle_data_notification (const uint8_t *data, size_t size)
                 primary_config.variable_length ? packet_data_size : primary_config.data_len;
             if ((primary_data_len > 0) && (primary_data_len <= packet_data_size))
             {
-                parse_sensor_payload (
-                    primary_tag, packet_index, device_tick, packet_data, primary_data_len);
+                parse_sensor_payload (primary_tag, packet_index, packet_host_timestamp, packet_data,
+                    primary_data_len);
                 packet_data_offset = primary_data_len;
             }
             else
@@ -799,7 +794,7 @@ void MuseAnthena::handle_data_notification (const uint8_t *data, size_t size)
                 break;
             }
 
-            parse_sensor_payload (tag, subpacket_index, device_tick,
+            parse_sensor_payload (tag, subpacket_index, packet_host_timestamp,
                 packet_data + packet_data_offset + SUBPACKET_HEADER_SIZE, sensor_data_len);
             packet_data_offset += SUBPACKET_HEADER_SIZE + sensor_data_len;
         }
@@ -809,7 +804,7 @@ void MuseAnthena::handle_data_notification (const uint8_t *data, size_t size)
 }
 
 void MuseAnthena::parse_sensor_payload (
-    uint8_t tag, uint8_t sequence_num, uint32_t device_tick, const uint8_t *data, size_t size)
+    uint8_t tag, uint8_t sequence_num, double host_timestamp, const uint8_t *data, size_t size)
 {
     SensorConfig config;
     if (!get_sensor_config (tag, config))
@@ -872,10 +867,11 @@ void MuseAnthena::parse_sensor_payload (
                     }
                 }
             }
-            package[(size_t)timestamp_channel] =
-                get_sample_timestamp (device_tick, sample, config.sampling_rate);
+            package[(size_t)timestamp_channel] = get_sample_timestamp (
+                last_eeg_timestamp, host_timestamp, sample, config.n_samples, config.sampling_rate);
             push_package (package.data (), (int)BrainFlowPresets::DEFAULT_PRESET);
         }
+        last_eeg_timestamp = host_timestamp;
         return;
     }
 
@@ -911,10 +907,11 @@ void MuseAnthena::parse_sensor_payload (
                         (double)raw * MUSE_ANTHENA_GYRO_SCALE_FACTOR;
                 }
             }
-            package[(size_t)timestamp_channel] =
-                get_sample_timestamp (device_tick, sample, config.sampling_rate);
+            package[(size_t)timestamp_channel] = get_sample_timestamp (
+                last_aux_timestamp, host_timestamp, sample, config.n_samples, config.sampling_rate);
             push_package (package.data (), (int)BrainFlowPresets::AUXILIARY_PRESET);
         }
+        last_aux_timestamp = host_timestamp;
         return;
     }
 
@@ -947,26 +944,47 @@ void MuseAnthena::parse_sensor_payload (
                 }
             }
 
-            package[(size_t)timestamp_channel] =
-                get_sample_timestamp (device_tick, sample, config.sampling_rate);
+            package[(size_t)timestamp_channel] = get_sample_timestamp (
+                last_anc_timestamp, host_timestamp, sample, config.n_samples, config.sampling_rate);
             push_package (package.data (), (int)BrainFlowPresets::ANCILLARY_PRESET);
         }
+        last_anc_timestamp = host_timestamp;
     }
 }
 
-double MuseAnthena::get_sample_timestamp (
-    uint32_t device_tick, int sample_index, double sampling_rate)
+void MuseAnthena::reset_timestamps ()
 {
-    if (!timestamp_initialized)
+    last_eeg_timestamp = -1.0;
+    last_aux_timestamp = -1.0;
+    last_anc_timestamp = -1.0;
+}
+
+double MuseAnthena::get_sample_timestamp (double last_timestamp, double current_timestamp,
+    int sample_index, int n_samples, double sampling_rate)
+{
+    if ((n_samples <= 0) || (sampling_rate <= 0.0))
+    {
+        return current_timestamp;
+    }
+
+    if (last_timestamp <= 0.0)
+    {
+        return current_timestamp - (double)(n_samples - sample_index - 1) / sampling_rate;
+    }
+
+    if (current_timestamp <= last_timestamp)
+    {
+        return current_timestamp;
+    }
+
+    double sample_timestamp = last_timestamp + (double)(sample_index + 1) / sampling_rate;
+    if (sample_timestamp <= current_timestamp)
     {
-        timestamp_initialized = true;
-        first_device_tick = device_tick;
-        first_host_timestamp = get_timestamp ();
+        return sample_timestamp;
     }
 
-    uint32_t elapsed_ticks = device_tick - first_device_tick;
-    return first_host_timestamp + (double)elapsed_ticks / MUSE_ANTHENA_DEVICE_CLOCK_HZ +
-        (double)sample_index / sampling_rate;
+    double step = (current_timestamp - last_timestamp) / (double)n_samples;
+    return last_timestamp + step * (double)(sample_index + 1);
 }
 
 std::string MuseAnthena::bytes_to_string (const uint8_t *data, size_t size)

Original file line number	Diff line number	Diff line change
`@@ -263,9 +263,7 @@ MuseAnthena::MuseAnthena (int board_id, struct BrainFlowInputParams params)`
`263`	`263`	`muse_adapter = NULL;`
`264`	`264`	`muse_peripheral = NULL;`
`265`	`265`	`is_streaming = false;`
`266`		`- timestamp_initialized = false;`
`267`		`- first_device_tick = 0;`
`268`		`- first_host_timestamp = 0.0;`
	`266`	`+ reset_timestamps ();`
`269`	`267`	`last_battery = 0.0;`
`270`	`268`	`muse_preset = "p1041";`
`271`	`269`	`enable_low_latency = true;`
`@@ -486,9 +484,7 @@ int MuseAnthena::start_stream (int buffer_size, const char *streamer_params)`
`486`	`484`	`if (res == (int)BrainFlowExitCodes::STATUS_OK)`
`487`	`485`	`{`
`488`	`486`	`std::lock_guard<std::mutex> callback_guard (callback_lock);`
`489`		`- timestamp_initialized = false;`
`490`		`- first_device_tick = 0;`
`491`		`- first_host_timestamp = 0.0;`
	`487`	`+ reset_timestamps ();`
`492`	`488`	`last_battery = 0.0;`
`493`	`489`	`}`
`494`	`490`	`if (res == (int)BrainFlowExitCodes::STATUS_OK)`
`@@ -555,7 +551,7 @@ int MuseAnthena::stop_stream ()`
`555`	`551`	`res = (int)BrainFlowExitCodes::STREAM_ALREADY_RUN_ERROR;`
`556`	`552`	`}`
`557`	`553`	`is_streaming = false;`
`558`		`- timestamp_initialized = false;`
	`554`	`+ reset_timestamps ();`
`559`	`555`	`return res;`
`560`	`556`	`}`
`561`	`557`
`@@ -744,8 +740,7 @@ void MuseAnthena::handle_data_notification (const uint8_t *data, size_t size)`
`744`	`740`
`745`	`741`	`const uint8_t *packet = data + offset;`
`746`	`742`	`uint8_t packet_index = packet[1];`
`747`		`- uint32_t device_tick =`
`748`		`- cast_32bit_to_uint32_little_endian ((const unsigned char *)(packet + 2));`
	`743`	`+ double packet_host_timestamp = get_timestamp ();`
`749`	`744`	`uint8_t primary_tag = packet[9];`
`750`	`745`	`const uint8_t *packet_data = packet + PACKET_HEADER_SIZE;`
`751`	`746`	`size_t packet_data_size = packet_len - PACKET_HEADER_SIZE;`
`@@ -758,8 +753,8 @@ void MuseAnthena::handle_data_notification (const uint8_t *data, size_t size)`
`758`	`753`	`primary_config.variable_length ? packet_data_size : primary_config.data_len;`
`759`	`754`	`if ((primary_data_len > 0) && (primary_data_len <= packet_data_size))`
`760`	`755`	`{`
`761`		`- parse_sensor_payload (`
`762`		`- primary_tag, packet_index, device_tick, packet_data, primary_data_len);`
	`756`	`+ parse_sensor_payload (primary_tag, packet_index, packet_host_timestamp, packet_data,`
	`757`	`+ primary_data_len);`
`763`	`758`	`packet_data_offset = primary_data_len;`
`764`	`759`	`}`
`765`	`760`	`else`
`@@ -799,7 +794,7 @@ void MuseAnthena::handle_data_notification (const uint8_t *data, size_t size)`
`799`	`794`	`break;`
`800`	`795`	`}`
`801`	`796`
`802`		`- parse_sensor_payload (tag, subpacket_index, device_tick,`
	`797`	`+ parse_sensor_payload (tag, subpacket_index, packet_host_timestamp,`
`803`	`798`	`packet_data + packet_data_offset + SUBPACKET_HEADER_SIZE, sensor_data_len);`
`804`	`799`	`packet_data_offset += SUBPACKET_HEADER_SIZE + sensor_data_len;`
`805`	`800`	`}`
`@@ -809,7 +804,7 @@ void MuseAnthena::handle_data_notification (const uint8_t *data, size_t size)`
`809`	`804`	`}`
`810`	`805`
`811`	`806`	`void MuseAnthena::parse_sensor_payload (`
`812`		`- uint8_t tag, uint8_t sequence_num, uint32_t device_tick, const uint8_t *data, size_t size)`
	`807`	`+ uint8_t tag, uint8_t sequence_num, double host_timestamp, const uint8_t *data, size_t size)`
`813`	`808`	`{`
`814`	`809`	`SensorConfig config;`
`815`	`810`	`if (!get_sensor_config (tag, config))`
`@@ -872,10 +867,11 @@ void MuseAnthena::parse_sensor_payload (`
`872`	`867`	`}`
`873`	`868`	`}`
`874`	`869`	`}`
`875`		`- package[(size_t)timestamp_channel] =`
`876`		`- get_sample_timestamp (device_tick, sample, config.sampling_rate);`
	`870`	`+ package[(size_t)timestamp_channel] = get_sample_timestamp (`
	`871`	`+ last_eeg_timestamp, host_timestamp, sample, config.n_samples, config.sampling_rate);`
`877`	`872`	`push_package (package.data (), (int)BrainFlowPresets::DEFAULT_PRESET);`
`878`	`873`	`}`
	`874`	`+ last_eeg_timestamp = host_timestamp;`
`879`	`875`	`return;`
`880`	`876`	`}`
`881`	`877`
`@@ -911,10 +907,11 @@ void MuseAnthena::parse_sensor_payload (`
`911`	`907`	`(double)raw * MUSE_ANTHENA_GYRO_SCALE_FACTOR;`
`912`	`908`	`}`
`913`	`909`	`}`
`914`		`- package[(size_t)timestamp_channel] =`
`915`		`- get_sample_timestamp (device_tick, sample, config.sampling_rate);`
	`910`	`+ package[(size_t)timestamp_channel] = get_sample_timestamp (`
	`911`	`+ last_aux_timestamp, host_timestamp, sample, config.n_samples, config.sampling_rate);`
`916`	`912`	`push_package (package.data (), (int)BrainFlowPresets::AUXILIARY_PRESET);`
`917`	`913`	`}`
	`914`	`+ last_aux_timestamp = host_timestamp;`
`918`	`915`	`return;`
`919`	`916`	`}`
`920`	`917`
`@@ -947,26 +944,47 @@ void MuseAnthena::parse_sensor_payload (`
`947`	`944`	`}`
`948`	`945`	`}`
`949`	`946`
`950`		`- package[(size_t)timestamp_channel] =`
`951`		`- get_sample_timestamp (device_tick, sample, config.sampling_rate);`
	`947`	`+ package[(size_t)timestamp_channel] = get_sample_timestamp (`
	`948`	`+ last_anc_timestamp, host_timestamp, sample, config.n_samples, config.sampling_rate);`
`952`	`949`	`push_package (package.data (), (int)BrainFlowPresets::ANCILLARY_PRESET);`
`953`	`950`	`}`
	`951`	`+ last_anc_timestamp = host_timestamp;`
`954`	`952`	`}`
`955`	`953`	`}`
`956`	`954`
`957`		`-double MuseAnthena::get_sample_timestamp (`
`958`		`- uint32_t device_tick, int sample_index, double sampling_rate)`
	`955`	`+void MuseAnthena::reset_timestamps ()`
`959`	`956`	`{`
`960`		`- if (!timestamp_initialized)`
	`957`	`+ last_eeg_timestamp = -1.0;`
	`958`	`+ last_aux_timestamp = -1.0;`
	`959`	`+ last_anc_timestamp = -1.0;`
	`960`	`+}`
	`961`	`+`
	`962`	`+double MuseAnthena::get_sample_timestamp (double last_timestamp, double current_timestamp,`
	`963`	`+ int sample_index, int n_samples, double sampling_rate)`
	`964`	`+{`
	`965`	`+ if ((n_samples <= 0) \|\| (sampling_rate <= 0.0))`
	`966`	`+ {`
	`967`	`+ return current_timestamp;`
	`968`	`+ }`
	`969`	`+`
	`970`	`+ if (last_timestamp <= 0.0)`
	`971`	`+ {`
	`972`	`+ return current_timestamp - (double)(n_samples - sample_index - 1) / sampling_rate;`
	`973`	`+ }`
	`974`	`+`
	`975`	`+ if (current_timestamp <= last_timestamp)`
	`976`	`+ {`
	`977`	`+ return current_timestamp;`
	`978`	`+ }`
	`979`	`+`
	`980`	`+ double sample_timestamp = last_timestamp + (double)(sample_index + 1) / sampling_rate;`
	`981`	`+ if (sample_timestamp <= current_timestamp)`
`961`	`982`	`{`
`962`		`- timestamp_initialized = true;`
`963`		`- first_device_tick = device_tick;`
`964`		`- first_host_timestamp = get_timestamp ();`
	`983`	`+ return sample_timestamp;`
`965`	`984`	`}`
`966`	`985`
`967`		`- uint32_t elapsed_ticks = device_tick - first_device_tick;`
`968`		`- return first_host_timestamp + (double)elapsed_ticks / MUSE_ANTHENA_DEVICE_CLOCK_HZ +`
`969`		`- (double)sample_index / sampling_rate;`
	`986`	`+ double step = (current_timestamp - last_timestamp) / (double)n_samples;`
	`987`	`+ return last_timestamp + step * (double)(sample_index + 1);`
`970`	`988`	`}`
`971`	`989`
`972`	`990`	`std::string MuseAnthena::bytes_to_string (const uint8_t *data, size_t size)`