2.2.3

VERSION

@@ -1,5 +1,5 @@
 VERSION_MAJOR = 2
 VERSION_MINOR = 2
-PATCHLEVEL = 2
+PATCHLEVEL = 3
 VERSION_TWEAK = 0
 EXTRAVERSION =

src/ParseInfo/DefaultSensors.h

@@ -141,11 +141,11 @@ SensorScheme defaultSensors[SENSOR_COUNT] = {
         .groupCount = MICRO_GROUP_COUNT,
         .groups = microGroups,
         .configOptions = {
-            .availableOptions = DATA_STORAGE | FREQUENCIES_DEFINED, // no streaming
+            .availableOptions = DATA_STORAGE | FREQUENCIES_DEFINED,
             .frequencyOptions = {
                 .frequencyCount = sizeof(Microphone::sample_rates.reg_vals),
-                .defaultFrequencyIndex = 1,
-                .maxBleFrequencyIndex = 1,
+                .defaultFrequencyIndex = 8,
+                .maxBleFrequencyIndex = 8,
                 .frequencies = Microphone::sample_rates.sample_rates,
             },
         },
@@ -159,7 +159,7 @@ SensorScheme defaultSensors[SENSOR_COUNT] = {
             .availableOptions = DATA_STREAMING | DATA_STORAGE | FREQUENCIES_DEFINED,
             .frequencyOptions = {
                 .frequencyCount = sizeof(PPG::sample_rates.reg_vals),
-                .defaultFrequencyIndex = 2,
+                .defaultFrequencyIndex = 1,
                 .maxBleFrequencyIndex = 12,
                 .frequencies = PPG::sample_rates.sample_rates,
             },

src/ParseInfo/README

@@ -170,4 +170,52 @@ enum SensorConfigOptions {
 - `Length`: Length of the frequency array
 - `Default Frequency Index`: Index of the default frequency
 - `Max BLE Index`: Index of the maximum frequency for BLE streaming
-- `Frequency Array`: Array of available frequencies
+- `Frequency Array`: Array of available frequencies
+
+## OE File Header
+
+`.oe` files written by `SDLogger` now embed the active parse scheme in the file header so the file stays self-describing.
+All numeric fields are written in the device's little-endian binary representation.
+
+### Header version `0x0002`
+
+Files only contain the fixed header below and rely on a hard-coded parser outside the file:
+
+| Bytes | Field     | Type   |
+|-------|-----------|--------|
+| 0-1   | Version   | uint16 |
+| 2-9   | Timestamp | uint64 |
+
+### Header version `0x0003`
+
+Files with version `0x0003` extend the fixed header and add earable identity metadata ahead of it and append a serialized ParseInfo block.
+`header_size` points to the first sensor data record in the file.
+`Parse Info Size` is the size of the `Parse Info Blob`.
+`Device ID` is the immutable Nordic chip identifier captured at boot.
+`Side` is encoded as `0` for left, `1` for right, and `255` for unknown.
+The ParseInfo blob starts immediately after `Side`.
+
+| Bytes | Field           | Type   |
+|-------|-----------------|--------|
+| 0-1   | Version         | uint16 |
+| 2-9   | Timestamp       | uint64 |
+| 10-13 | Header Size     | uint32 |
+| 14-17 | Parse Info Size | uint32 |
+| 18-25 | Device ID       | uint64 |
+| 26    | Side            | uint8  |
+| 27-X  | Parse Info Blob | byte[] |
+
+### Parse Info Blob
+
+The blob starts with the existing `Sensor List` serialization and then stores each referenced sensor scheme in the same order as the sensor IDs:
+
+| Bytes | Field              | Type   |
+|-------|--------------------|--------|
+| 0     | Sensor Count       | uint8  |
+| 1-N   | Sensor IDs         | uint8[] |
+| ...   | Sensor Scheme Size | uint16 |
+| ...   | Sensor Scheme      | byte[] |
+| ...   | Sensor Scheme Size | uint16 |
+| ...   | Sensor Scheme      | byte[] |
+
+Each `Sensor Scheme` payload uses the existing `Single Sensor Scheme` serialization already documented above.

src/ParseInfo/SensorScheme.cpp

@@ -3,6 +3,8 @@
 
 #include <string>
 #include <cstring>
+#include <errno.h>
+#include <stdint.h>
 
 #include <zephyr/kernel.h>
 #include <zephyr/bluetooth/gatt.h>
@@ -348,9 +350,77 @@ int initSensorSchemeForId(uint8_t id) {
 }
 
 struct SensorScheme* getSensorSchemeForId(uint8_t id) {
-    return sensorSchemesMap[id];
+    auto sensorSchemeIt = sensorSchemesMap.find(id);
+    if (sensorSchemeIt == sensorSchemesMap.end()) {
+        return NULL;
+    }
+
+    return sensorSchemeIt->second;
 }
 
 struct ParseInfoScheme* getParseInfoScheme() {
     return parseInfoSchemeStruct;
-}
+}
+
+size_t getParseInfoStorageSize() {
+    if ((parseInfoSchemeStruct == NULL) || (parseInfoScheme == NULL)) {
+        return 0;
+    }
+
+    size_t size = parseInfoSchemeSize;
+
+    for (size_t i = 0; i < parseInfoSchemeStruct->sensorCount; i++) {
+        SensorScheme* scheme = getSensorSchemeForId(parseInfoSchemeStruct->sensorIds[i]);
+        if (scheme == NULL) {
+            return 0;
+        }
+
+        size += sizeof(uint16_t);
+        size += getSensorSchemeSize(scheme);
+    }
+
+    return size;
+}
+
+ssize_t serializeParseInfoStorage(char* buffer, size_t bufferSize) {
+    if ((parseInfoSchemeStruct == NULL) || (parseInfoScheme == NULL) || (buffer == NULL)) {
+        return -ENODATA;
+    }
+
+    size_t size = getParseInfoStorageSize();
+    if ((size == 0) || (size > bufferSize)) {
+        return -ENOMEM;
+    }
+
+    char* bufferStart = buffer;
+    memcpy(buffer, parseInfoScheme, parseInfoSchemeSize);
+    buffer += parseInfoSchemeSize;
+
+    for (size_t i = 0; i < parseInfoSchemeStruct->sensorCount; i++) {
+        SensorScheme* scheme = getSensorSchemeForId(parseInfoSchemeStruct->sensorIds[i]);
+        if (scheme == NULL) {
+            return -ENOENT;
+        }
+
+        size_t sensorSchemeSize = getSensorSchemeSize(scheme);
+        if (sensorSchemeSize > UINT16_MAX) {
+            return -EOVERFLOW;
+        }
+
+        uint16_t encodedSchemeSize = (uint16_t)sensorSchemeSize;
+        memcpy(buffer, &encodedSchemeSize, sizeof(encodedSchemeSize));
+        buffer += sizeof(encodedSchemeSize);
+
+        ssize_t writtenSize = serializeSensorScheme(scheme, buffer, bufferSize - (buffer - bufferStart));
+        if (writtenSize < 0) {
+            return writtenSize;
+        }
+        if ((size_t)writtenSize != sensorSchemeSize) {
+            return -EIO;
+        }
+
+        buffer += writtenSize;
+    }
+
+    return buffer - bufferStart;
+}

src/ParseInfo/SensorScheme.h

@@ -65,11 +65,29 @@ int initParseInfoService(struct ParseInfoScheme* scheme, struct SensorScheme* se
 struct SensorScheme* getSensorSchemeForId(uint8_t id);
 struct ParseInfoScheme* getParseInfoScheme();
 
+/**
+ * @brief Calculate the byte length of the serialized parse-info storage blob.
+ *
+ * The storage blob contains the serialized sensor list followed by each sensor
+ * scheme prefixed with a uint16 length. Returns 0 if parse-info state is not
+ * initialized or any scheme cannot be represented in the storage format.
+ */
+size_t getParseInfoStorageSize();
+
+/**
+ * @brief Serialize parse-info state into an SD-log file header payload.
+ *
+ * @param buffer Destination buffer for the serialized parse-info storage blob.
+ * @param bufferSize Available bytes in @p buffer.
+ * @return Number of bytes written on success, or a negative errno value.
+ */
+ssize_t serializeParseInfoStorage(char* buffer, size_t bufferSize);
+
 float getSampleRateForSensorId(uint8_t id, uint8_t frequencyIndex);
 float getSampleRateForSensor(struct SensorScheme* sensorScheme, uint8_t frequencyIndex);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif // _SENSOR_SCHEME_H
+#endif // _SENSOR_SCHEME_H