@robotical/raftjs 2.1.0 → 2.1.3

package/src/RaftAttributeHandler.ts

@@ -20,15 +20,16 @@ export default class AttributeHandler {
     // Message timestamp size
     private POLL_RESULT_TIMESTAMP_SIZE = 2;
     private POLL_RESULT_WRAP_VALUE = this.POLL_RESULT_TIMESTAMP_SIZE === 2 ? 65536 : 4294967296;
-    private POLL_RESULT_RESOLUTION_US = 1000;
-    
-    public processMsgAttrGroup(msgBuffer: Uint8Array, msgBufIdx: number, deviceTimeline: DeviceTimeline, pollRespMetadata: DeviceTypePollRespMetadata, 
-                        devAttrsState: DeviceAttributesState, maxDataPoints: number): number {
-        
+    private POLL_RESULT_RESOLUTION_US = 100;
+
+    public processMsgAttrGroup(msgBuffer: Uint8Array, msgBufIdx: number, deviceTimeline: DeviceTimeline, pollRespMetadata: DeviceTypePollRespMetadata,
+                        devAttrsState: DeviceAttributesState, maxDataPoints: number, msgEndIdx = msgBuffer.length): number {
+
         // console.log(`processMsgAttrGroup msg ${msgHexStr} timestamp ${timestamp} origTimestamp ${origTimestamp} msgBufIdx ${msgBufIdx}`)
+        const boundedMsgEndIdx = Math.min(Math.max(msgEndIdx, msgBufIdx), msgBuffer.length);
 
         // Extract msg timestamp
-        const { newBufIdx, timestampUs } = this.extractTimestampAndAdvanceIdx(msgBuffer, msgBufIdx, deviceTimeline);
+        const { newBufIdx, timestampUs } = this.extractTimestampAndAdvanceIdx(msgBuffer, msgBufIdx, deviceTimeline, boundedMsgEndIdx);
         if (newBufIdx < 0)
             return -1;
         msgBufIdx = newBufIdx;
@@ -37,11 +38,38 @@ export default class AttributeHandler {
         const msgDataStartIdx = msgBufIdx;
 
         // New attribute values (in order as they appear in the attributes JSON)
-        let newAttrValues: number[][] = [];
+        let newAttrValues: (number | string)[][] = [];
         if ("c" in pollRespMetadata) {
 
             // Extract attribute values using custom handler
-            newAttrValues = this._customAttrHandler.handleAttr(pollRespMetadata, msgBuffer, msgBufIdx);
+            newAttrValues = this._customAttrHandler.handleAttr(pollRespMetadata, msgBuffer, msgBufIdx, boundedMsgEndIdx);
+
+            // Apply per-attribute transforms that the custom handler doesn't handle
+            for (let attrIdx = 0; attrIdx < pollRespMetadata.a.length && attrIdx < newAttrValues.length; attrIdx++) {
+                const attrDef = pollRespMetadata.a[attrIdx];
+                if (newAttrValues[attrIdx].length === 0) continue;
+
+                // Sign-extend values for signed types — the pseudocode produces unsigned
+                // values from bitwise operations, but the attribute type declares signedness
+                if (attrDef.t && isAttrTypeSigned(attrDef.t)) {
+                    const byteWidth = structSizeOf(attrDef.t);
+                    const signBit = 1 << (byteWidth * 8 - 1);
+                    const range = signBit * 2;
+                    newAttrValues[attrIdx] = newAttrValues[attrIdx].map(v => {
+                        const n = v as number;
+                        return (n & signBit) ? n - range : n;
+                    });
+                }
+
+                if ("d" in attrDef && attrDef.d) {
+                    const divisor = attrDef.d as number;
+                    newAttrValues[attrIdx] = newAttrValues[attrIdx].map(v => (v as number) / divisor);
+                }
+                if ("a" in attrDef && attrDef.a !== undefined) {
+                    const addend = attrDef.a as number;
+                    newAttrValues[attrIdx] = newAttrValues[attrIdx].map(v => (v as number) + addend);
+                }
+            }
 
         } else {
 
@@ -61,16 +89,15 @@ export default class AttributeHandler {
                 // console.log(`RaftAttrHdlr.processMsgAttrGroup attr ${attrDef.n} msgBufIdx ${msgBufIdx} timestampUs ${timestampUs} attrDef ${JSON.stringify(attrDef)}`);
 
                 // Process the attribute
-                const { values, newMsgBufIdx } = this.processMsgAttribute(attrDef, msgBuffer, msgBufIdx, msgDataStartIdx);
+                const { values, newMsgBufIdx } = this.processMsgAttribute(attrDef, msgBuffer, msgBufIdx, msgDataStartIdx, boundedMsgEndIdx);
                 if (newMsgBufIdx < 0) {
-                    newAttrValues.push([]);
-                    continue;
+                    return -1;
                 }
                 msgBufIdx = newMsgBufIdx;
                 newAttrValues.push(values);
             }
         }
-        
+
         // Number of bytes in group
         let pollRespSizeBytes = msgBufIdx - msgDataStartIdx;
         if (pollRespSizeBytes < pollRespMetadata.b) {
@@ -80,7 +107,7 @@ export default class AttributeHandler {
         // Check if any attributes were added (in addition to timestamp)
         if (newAttrValues.length === 0) {
             console.warn(`DeviceManager msg attrGroup ${JSON.stringify(pollRespMetadata)} newAttrValues ${newAttrValues} is empty`);
-            return msgDataStartIdx+pollRespSizeBytes;
+            return -1;
         }
 
         // All attributes must have the same number of new values
@@ -129,13 +156,56 @@ export default class AttributeHandler {
             devAttrsState[attrDef.n].numNewValues = newAttrValues[attrIdx].length;
         }
 
-        // Handle the timestamps with increments if specified
+        // --- Piecewise EMA timestamp reconstruction ---
+        // Track the last assigned sample timestamp and step forward by emaIntervalUs
+        // per sample. No T0 recomputation — avoids amplified batch-boundary jitter.
         const timeIncUs: number = pollRespMetadata.us ? pollRespMetadata.us : 1000;
+
+        if (!deviceTimeline.emaCalibrated) {
+            // Cold start: anchor so that sample 0 gets the poll timestamp
+            deviceTimeline.emaIntervalUs = timeIncUs;
+            deviceTimeline.emaLastSampleTimeUs = timestampUs - deviceTimeline.emaIntervalUs;
+            deviceTimeline.emaPrevPollTimeUs = timestampUs;
+            deviceTimeline.emaCalibrated = true;
+            deviceTimeline.emaCalibrationPolls = 1;
+        } else {
+            // EMA interval update from poll-to-poll gap
+            if (numNewDataPoints > 1) {
+                const instantIntervalUs = (timestampUs - deviceTimeline.emaPrevPollTimeUs) / numNewDataPoints;
+                const alpha = deviceTimeline.emaCalibrationPolls < 20 ? 0.3 : 0.05;
+                deviceTimeline.emaIntervalUs = alpha * instantIntervalUs
+                                              + (1.0 - alpha) * deviceTimeline.emaIntervalUs;
+            } else if (numNewDataPoints === 1) {
+                const instantIntervalUs = timestampUs - deviceTimeline.emaPrevPollTimeUs;
+                if (Number.isFinite(instantIntervalUs) && instantIntervalUs > 0) {
+                    deviceTimeline.emaIntervalUs = instantIntervalUs;
+                }
+            }
+            deviceTimeline.emaPrevPollTimeUs = timestampUs;
+            deviceTimeline.emaCalibrationPolls++;
+        }
+
+        // Assign timestamps: each sample steps forward by emaIntervalUs
         const timestampsUs = Array(numNewDataPoints).fill(0);
+        const lastTimeUs = deviceTimeline.timestampsUs.length > 0
+            ? deviceTimeline.timestampsUs[deviceTimeline.timestampsUs.length - 1]
+            : -Infinity;
         for (let i = 0; i < numNewDataPoints; i++) {
-            timestampsUs[i] =  timestampUs + i * timeIncUs;
+            timestampsUs[i] = numNewDataPoints === 1
+                ? timestampUs
+                : deviceTimeline.emaLastSampleTimeUs + (i + 1) * deviceTimeline.emaIntervalUs;
+            // Ensure monotonically increasing timestamps
+            if (i === 0 && timestampsUs[0] <= lastTimeUs) {
+                timestampsUs[0] = lastTimeUs + 1;
+            } else if (i > 0 && timestampsUs[i] <= timestampsUs[i - 1]) {
+                timestampsUs[i] = timestampsUs[i - 1] + 1;
+            }
+        }
+        // Advance the piecewise model cursor past all samples in this batch
+        if (deviceTimeline.emaCalibrated && numNewDataPoints > 0) {
+            deviceTimeline.emaLastSampleTimeUs = timestampsUs[timestampsUs.length - 1];
         }
-        
+
         // Check if timeline points need to be discarded
         const discardCount = Math.max(0, deviceTimeline.timestampsUs.length + timestampsUs.length - maxDataPoints);
         if (discardCount > 0) {
@@ -144,6 +214,7 @@ export default class AttributeHandler {
 
         // Add the new timestamps
         deviceTimeline.timestampsUs.push(...timestampsUs);
+        deviceTimeline.totalSamplesAdded += numNewDataPoints;
 
         // Validate attributes based on the vft field
         this.validateAttributes(pollRespMetadata, devAttrsState, numNewDataPoints);
@@ -156,7 +227,7 @@ export default class AttributeHandler {
         // Iterate through all attributes to find those with a vft field
         for (let attrIdx = 0; attrIdx < pollRespMetadata.a.length; attrIdx++) {
             const attrDef: DeviceTypeAttribute = pollRespMetadata.a[attrIdx];
-            
+
             // Check if this attribute has a vft field
             if (!("vft" in attrDef) || !attrDef.vft) {
                 continue;
@@ -183,7 +254,7 @@ export default class AttributeHandler {
             // Get the most recent values from both attributes
             const numValues = currentAttr.values.length;
             const startIdx = numValues - numNewDataPoints;
-            
+
             // Process each of the new values
             for (let i = 0; i < numNewDataPoints; i++) {
                 const valueIdx = startIdx + i;
@@ -201,34 +272,39 @@ export default class AttributeHandler {
         }
     }
 
-    private processMsgAttribute(attrDef: DeviceTypeAttribute, msgBuffer: Uint8Array, msgBufIdx: number, msgDataStartIdx: number): { values: number[], newMsgBufIdx: number} {
+    private processMsgAttribute(attrDef: DeviceTypeAttribute, msgBuffer: Uint8Array, msgBufIdx: number, msgDataStartIdx: number, msgEndIdx: number): { values: (number | string)[], newMsgBufIdx: number} {
 
         // Current field message string index
         let curFieldBufIdx = msgBufIdx;
         let attrUsesAbsPos = false;
+        const boundedMsgEndIdx = Math.min(Math.max(msgEndIdx, msgDataStartIdx), msgBuffer.length);
+        const attrTypesOnly = attrDef.t;
+        const numBytesConsumed = structSizeOf(attrTypesOnly);
 
         // Check for "at" field which means absolute position in the buffer
         if (attrDef.at !== undefined) {
             // Handle both single value and array of byte positions
             if (Array.isArray(attrDef.at)) {
                 // Create a new buffer for non-contiguous data extraction
-                const elemSize = structSizeOf(attrDef.t);
+                const elemSize = numBytesConsumed;
                 const bytesForType = new Uint8Array(elemSize);
-                
+
                 // Zero out the buffer
                 bytesForType.fill(0);
-                
+
                 // Copy bytes from the specified positions
                 for (let i = 0; i < attrDef.at.length && i < elemSize; i++) {
                     const sourceIdx = msgDataStartIdx + attrDef.at[i];
-                    if (sourceIdx < msgBuffer.length) {
-                        bytesForType[i] = msgBuffer[sourceIdx];
+                    if (sourceIdx >= boundedMsgEndIdx) {
+                        return { values: [], newMsgBufIdx: -1 };
                     }
+                    bytesForType[i] = msgBuffer[sourceIdx];
                 }
-                
+
                 // Use this buffer for attribute extraction
                 msgBuffer = bytesForType;
                 curFieldBufIdx = 0;
+                msgEndIdx = bytesForType.length;
             } else {
                 // Standard absolute position in the buffer
                 curFieldBufIdx = msgDataStartIdx + attrDef.at;
@@ -237,26 +313,25 @@ export default class AttributeHandler {
         }
 
         // Check if outside bounds of message
-        if (curFieldBufIdx >= msgBuffer.length) {
+        const attrEndIdx = curFieldBufIdx + numBytesConsumed;
+        const effectiveMsgEndIdx = Math.min(Math.max(msgEndIdx, curFieldBufIdx), msgBuffer.length);
+        if (curFieldBufIdx >= effectiveMsgEndIdx || attrEndIdx > effectiveMsgEndIdx) {
             // console.warn(`DeviceManager msg outside bounds msgBuffer ${msgBuffer} attrName ${attrDef.n}`);
             return { values: [], newMsgBufIdx: -1 };
         }
 
-        // Attribute type
-        const attrTypesOnly = attrDef.t;
-
         // Slice into buffer
-        const attrBuf = msgBuffer.slice(curFieldBufIdx);
- 
+        const attrBuf = msgBuffer.slice(curFieldBufIdx, effectiveMsgEndIdx);
+
         // Check if a mask is used and the value is signed
         const maskOnSignedValue = "m" in attrDef && isAttrTypeSigned(attrTypesOnly);
 
         // Extract the value using python-struct
         const unpackValues = structUnpack(maskOnSignedValue ? attrTypesOnly.toUpperCase() : attrTypesOnly, attrBuf);
-        let attrValues = unpackValues as number[];
+        let attrValues = unpackValues as (number | string)[];
 
-        // Get number of bytes consumed
-        const numBytesConsumed = structSizeOf(attrTypesOnly);
+        // Check if any values are strings (from 's' format) — skip numeric transforms for those
+        const hasStringValues = attrValues.some(v => typeof v === 'string');
 
         // // Check if sign extendable mask specified on signed value
         // if (mmSpecifiedOnSignedValue) {
@@ -270,82 +345,82 @@ export default class AttributeHandler {
         // }
 
         // Check for XOR mask
-        if ("x" in attrDef) {
+        if (!hasStringValues && "x" in attrDef) {
             const mask = typeof attrDef.x === "string" ? parseInt(attrDef.x, 16) : attrDef.x as number;
-            attrValues = attrValues.map((value) => (value >>> 0) ^ mask);
+            attrValues = attrValues.map((value) => ((value as number) >>> 0) ^ mask);
         }
-        
+
         // Check for AND mask
-        if ("m" in attrDef) {
+        if (!hasStringValues && "m" in attrDef) {
             const mask = typeof attrDef.m === "string" ? parseInt(attrDef.m, 16) : attrDef.m as number;
-            attrValues = attrValues.map((value) => (maskOnSignedValue ? this.signExtend(value, mask) : (value >>> 0) & mask));
+            attrValues = attrValues.map((value) => (maskOnSignedValue ? this.signExtend(value as number, mask) : ((value as number) >>> 0) & mask));
         }
 
         // Check for a sign-bit
-        if ("sb" in attrDef) {
+        if (!hasStringValues && "sb" in attrDef) {
             const signBitPos = attrDef.sb as number;
             const signBitMask = 1 << signBitPos;
             if ("ss" in attrDef) {
                 const signBitSubtract = attrDef.ss as number;
-                attrValues = attrValues.map((value) => (value & signBitMask) ? signBitSubtract - value : value);
+                attrValues = attrValues.map((value) => ((value as number) & signBitMask) ? signBitSubtract - (value as number) : value);
             } else {
-                attrValues = attrValues.map((value) => (value & signBitMask) ? value - (signBitMask << 1) : value);
+                attrValues = attrValues.map((value) => ((value as number) & signBitMask) ? (value as number) - (signBitMask << 1) : value);
             }
         }
 
         // Check for bit shift required
-        if ("s" in attrDef && attrDef.s) {
+        if (!hasStringValues && "s" in attrDef && attrDef.s) {
             const bitshift = attrDef.s as number;
             if (bitshift > 0) {
-                attrValues = attrValues.map((value) => (value >>> 0) >>> bitshift);
+                attrValues = attrValues.map((value) => ((value as number) >>> 0) >>> bitshift);
             } else if (bitshift < 0) {
-                attrValues = attrValues.map((value) => (value >>> 0) << -bitshift);
+                attrValues = attrValues.map((value) => ((value as number) >>> 0) << -bitshift);
             }
         }
 
         // Check for divisor
-        if ("d" in attrDef && attrDef.d) {
+        if (!hasStringValues && "d" in attrDef && attrDef.d) {
             const divisor = attrDef.d as number;
-            attrValues = attrValues.map((value) => (value) / divisor);
+            attrValues = attrValues.map((value) => (value as number) / divisor);
         }
 
         // Check for value to add
-        if ("a" in attrDef && attrDef.a !== undefined) {
+        if (!hasStringValues && "a" in attrDef && attrDef.a !== undefined) {
             const addValue = attrDef.a as number;
-            attrValues = attrValues.map((value) => (value) + addValue);
+            attrValues = attrValues.map((value) => (value as number) + addValue);
         }
 
         // Apply lookup table if defined
-        if ("lut" in attrDef && attrDef.lut !== undefined) {
+        if (!hasStringValues && "lut" in attrDef && attrDef.lut !== undefined) {
             attrValues = attrValues.map((value): number => {
                 // Skip NaN values
-                if (isNaN(value)) {
-                    return value;
+                if (isNaN(value as number)) {
+                    return value as number;
                 }
 
                 // Search through the lookup table rows for a match
                 let defaultValue: number | null = null;
-                
+
                 for (const row of attrDef.lut || []) {
                     // Empty string means default for unmatched values
                     if (row.r === "") {
                         defaultValue = row.v;
                         continue;
                     }
-                    
+
                     // Parse the range string
-                    if (this.isValueInRangeString(value, row.r)) {
+                    if (this.isValueInRangeString(value as number, row.r)) {
                         return row.v;
                     }
                 }
-                
+
                 // If no match found but we have a default, use it
                 if (defaultValue !== null) {
                     return defaultValue;
                 }
-                
+
                 // Otherwise keep the original value
-                return value;
+                return value as number;
             });
         }
 
@@ -363,38 +438,39 @@ export default class AttributeHandler {
         // Return the value
         return { values: attrValues, newMsgBufIdx: msgBufIdx };
     }
-    
+
     private signExtend(value: number, mask: number): number {
         const signBitMask = (mask + 1) >> 1;
         const signBit = value & signBitMask;
-    
+
         if (signBit !== 0) {  // If sign bit is set
             const highBitsMask = ~mask & ~((mask + 1) >> 1);
             value |= highBitsMask;  // Apply the sign extension
         }
-    
+
         return value;
     }
 
-    private extractTimestampAndAdvanceIdx(msgBuffer: Uint8Array, msgBufIdx: number, timestampWrapHandler: DeviceTimeline): 
+    private extractTimestampAndAdvanceIdx(msgBuffer: Uint8Array, msgBufIdx: number, timestampWrapHandler: DeviceTimeline, msgEndIdx = msgBuffer.length):
                     { newBufIdx: number, timestampUs: number } {
+        const boundedMsgEndIdx = Math.min(Math.max(msgEndIdx, msgBufIdx), msgBuffer.length);
 
         // Check there are enough bytes for the timestamp
-        if (msgBufIdx + this.POLL_RESULT_TIMESTAMP_SIZE > msgBuffer.length) {
+        if (msgBufIdx + this.POLL_RESULT_TIMESTAMP_SIZE > boundedMsgEndIdx) {
             return { newBufIdx: -1, timestampUs: 0 };
         }
 
         // Use struct to extract the timestamp
         const tsBuffer = msgBuffer.slice(msgBufIdx, msgBufIdx + this.POLL_RESULT_TIMESTAMP_SIZE);
         let timestampUs: number;
-        if (this.POLL_RESULT_TIMESTAMP_SIZE === 2) { 
+        if (this.POLL_RESULT_TIMESTAMP_SIZE === 2) {
             timestampUs = structUnpack(">H", tsBuffer)[0] as number * this.POLL_RESULT_RESOLUTION_US;
         } else {
             timestampUs = structUnpack(">I", tsBuffer)[0] as number * this.POLL_RESULT_RESOLUTION_US;
         }
 
         // Check if time is before lastReportTimeMs by more than 100ms - in which case a wrap around occurred to add on the max value
-        if (timestampUs + 100000 < timestampWrapHandler.lastReportTimestampUs ) {
+        if (timestampUs + 10000 < timestampWrapHandler.lastReportTimestampUs ) {
             timestampWrapHandler.reportTimestampOffsetUs += this.POLL_RESULT_WRAP_VALUE * this.POLL_RESULT_RESOLUTION_US;
         }
         timestampWrapHandler.lastReportTimestampUs = timestampUs;
@@ -413,38 +489,38 @@ export default class AttributeHandler {
     private isValueInRangeString(value: number, rangeStr: string): boolean {
         // Round to integer for comparison
         const roundedValue = Math.round(value);
-        
+
         // Split the range string by commas
         const parts = rangeStr.split(',');
-        
+
         for (const part of parts) {
             // Check if it's a range (contains a hyphen)
             if (part.includes('-')) {
                 const [startStr, endStr] = part.split('-');
-                
+
                 // Handle hex values
-                const start = startStr.toLowerCase().startsWith('0x') ? 
+                const start = startStr.toLowerCase().startsWith('0x') ?
                     parseInt(startStr, 16) : parseInt(startStr, 10);
-                const end = endStr.toLowerCase().startsWith('0x') ? 
+                const end = endStr.toLowerCase().startsWith('0x') ?
                     parseInt(endStr, 16) : parseInt(endStr, 10);
-                
+
                 if (!isNaN(start) && !isNaN(end) && roundedValue >= start && roundedValue <= end) {
                     return true;
                 }
-            } 
+            }
             // Check if it's a single value
             else {
                 // Handle hex values
-                const partValue = part.toLowerCase().startsWith('0x') ? 
+                const partValue = part.toLowerCase().startsWith('0x') ?
                     parseInt(part, 16) : parseInt(part, 10);
-                
+
                 if (!isNaN(partValue) && roundedValue === partValue) {
                     return true;
                 }
             }
         }
-        
+
         return false;
     }
 
-}
+}

package/src/RaftChannelBLE.web.ts

@@ -41,6 +41,7 @@ export default class RaftChannelBLE implements RaftChannel {
   // Connected flag and retries
   private _isConnected = false;
   private readonly _maxConnRetries = 3;
+  private readonly _connRetryDelayMs = 500;
 
   // Event listener fn
   private _eventListenerFn: ((event: Event) => void) | null = null;
@@ -49,6 +50,11 @@ export default class RaftChannelBLE implements RaftChannel {
   private _requestedBatchAckSize = 10;
   private _requestedFileBlockSize = 500;
 
+  // Max bytes per BLE write - messages larger than this are split into chunks.
+  // Web Bluetooth doesn't expose the negotiated MTU, so use a conservative
+  // default that works with BLE 4.2+ (ATT_MTU 251 → payload 244).
+  private _maxBleWriteSize = 244;
+
   fhBatchAckSize(): number {
     return this._requestedBatchAckSize;
   }
@@ -115,6 +121,18 @@ export default class RaftChannelBLE implements RaftChannel {
     return this._bleDevice || "";
   }
 
+  private async disconnectGattBeforeRetry(): Promise<void> {
+    if (!this._bleDevice?.gatt?.connected) {
+      return;
+    }
+
+    try {
+      await this._bleDevice.gatt.disconnect();
+    } catch (error) {
+      RaftLog.warn(`RaftChannelBLE.connect - cannot disconnect before retry ${error}`);
+    }
+  }
+
   // Connect to a device
   async connect(locator: string | object, _connectorOptions: ConnectorOptions): Promise<boolean> {
     // RaftLog.debug(`Selected device: ${deviceID}`);
@@ -154,10 +172,19 @@ export default class RaftChannelBLE implements RaftChannel {
               }
 
               if (!service) {
+                if (connRetry === this._maxConnRetries - 1) {
+                  RaftLog.warn(
+                    `RaftChannelBLE.connect - cannot get primary service - attempt #${connRetry + 1} - giving up`
+                  );
+                  return false;
+                }
+
                 RaftLog.warn(
-                  `RaftChannelBLE.connect - cannot get primary service - giving up`
+                  `RaftChannelBLE.connect - cannot get primary service - attempt #${connRetry + 1} - retrying`
                 );
-                return false;
+                await this.disconnectGattBeforeRetry();
+                await new Promise(resolve => setTimeout(resolve, this._connRetryDelayMs));
+                continue;
               }
               RaftLog.debug(
                 `RaftChannelBLE.connect - found service: ${service.uuid}`
@@ -286,7 +313,20 @@ export default class RaftChannelBLE implements RaftChannel {
     }
   }
 
-  // Send a message
+  // Write a single chunk to the BLE characteristic
+  private async _writeChunk(data: Uint8Array): Promise<void> {
+    if (!this._characteristicTx) return;
+    const bs = RaftUtils.toBufferSource(data);
+    if (this._characteristicTx.writeValueWithoutResponse) {
+      await this._characteristicTx.writeValueWithoutResponse(bs);
+    } else if (this._characteristicTx.writeValue) {
+      await this._characteristicTx.writeValue(bs);
+    } else if (this._characteristicTx.writeValueWithResponse) {
+      await this._characteristicTx.writeValueWithResponse(bs);
+    }
+  }
+
+  // Send a message, chunking if it exceeds the BLE write size
   async sendTxMsg(
     msg: Uint8Array
     //    _sendWithResponse: boolean
@@ -304,16 +344,16 @@ export default class RaftChannelBLE implements RaftChannel {
       }
       this._msgTxTimeLast = Date.now();
 
-      // Write to the characteristic
+      // Write to the characteristic, chunking if necessary
       try {
         if (this._characteristicTx) {
-          const bs = RaftUtils.toBufferSource(msg);
-          if (this._characteristicTx.writeValueWithoutResponse) {
-            await this._characteristicTx.writeValueWithoutResponse(bs);
-          } else if (this._characteristicTx.writeValue) {
-            await this._characteristicTx.writeValue(bs);
-          } else if (this._characteristicTx.writeValueWithResponse) {
-            await this._characteristicTx.writeValueWithResponse(bs);
+          if (msg.length <= this._maxBleWriteSize) {
+            await this._writeChunk(msg);
+          } else {
+            for (let offset = 0; offset < msg.length; offset += this._maxBleWriteSize) {
+              const chunk = msg.subarray(offset, Math.min(offset + this._maxBleWriteSize, msg.length));
+              await this._writeChunk(chunk);
+            }
           }
         }
         break;
@@ -344,15 +384,17 @@ export default class RaftChannelBLE implements RaftChannel {
     }
     this._msgTxTimeLast = Date.now();
 
-    // Write to the characteristic
+    // Write to the characteristic, chunking if necessary
     if (this._characteristicTx) {
-      const bs = RaftUtils.toBufferSource(msg);
-      if (this._characteristicTx.writeValueWithoutResponse) {
-        this._characteristicTx.writeValueWithoutResponse(bs);
-      } else if (this._characteristicTx.writeValue) {
-        this._characteristicTx.writeValue(bs);
-      } else if (this._characteristicTx.writeValueWithResponse) {
-        this._characteristicTx.writeValueWithResponse(bs);
+      if (msg.length <= this._maxBleWriteSize) {
+        this._writeChunk(msg);
+      } else {
+        (async () => {
+          for (let offset = 0; offset < msg.length; offset += this._maxBleWriteSize) {
+            const chunk = msg.subarray(offset, Math.min(offset + this._maxBleWriteSize, msg.length));
+            await this._writeChunk(chunk);
+          }
+        })();
       }
       return true;
     }
@@ -371,4 +413,4 @@ export default class RaftChannelBLE implements RaftChannel {
     return null as T;
   }
 
-}
+}

package/src/RaftChannelSimulated.ts

@@ -23,6 +23,8 @@ interface SimulatedDeviceInfo {
 
 export default class RaftChannelSimulated implements RaftChannel {
 
+  private readonly POLL_RESULT_TIMESTAMP_RESOLUTION_US = 100;
+
   // Message handler
   private _raftMsgHandler: RaftMsgHandler | null = null;
 
@@ -292,8 +294,10 @@ export default class RaftChannelSimulated implements RaftChannel {
     const dataView = new DataView(dataBuffer);
     let bytePos = 0;
 
-    // Add 16 bit big endian deviceTimeMs mod 65536 to the buffer
-    dataView.setUint16(bytePos, deviceTimeMs % 65536, false);
+    // Add 16-bit big-endian timestamp ticks. Poll timestamps are decoded in
+    // 100us units by RaftAttributeHandler.
+    const timestampTicks = Math.floor((deviceTimeMs * 1000) / this.POLL_RESULT_TIMESTAMP_RESOLUTION_US) % 65536;
+    dataView.setUint16(bytePos, timestampTicks, false);
     bytePos += 2;
 
     const handledByCustomGenerator = this._fillCustomRawData(
@@ -357,9 +361,9 @@ export default class RaftChannelSimulated implements RaftChannel {
     // Convert the buffer to a byte array
     const dataBytes = new Uint8Array(dataBuffer);
 
-    // Create the JSON message structure
+    // Create the JSON message structure (bus key is numeric string to match firmware convention)
     const message = {
-      "BUS1": {
+      "1": {
         [deviceName]: {
           "_t": deviceTypeInfo.type,
           "_o": 1,  // Device is online
@@ -464,7 +468,8 @@ export default class RaftChannelSimulated implements RaftChannel {
     const hotspotRow = (Math.sin(hotspotPhase) + 1) * (rows - 1) / 2;
     const hotspotCol = (Math.cos(hotspotPhase) + 1) * (cols - 1) / 2;
     const hotspotAmplitude = 6;
-    const sigma = Math.max(rows, cols) / 3 || 1;
+    const rawSigma = Math.max(rows, cols) / 3;
+    const sigma = Number.isFinite(rawSigma) ? rawSigma : 1;
 
     for (let idx = 0; idx < repeatCount; idx++) {
       const row = Math.floor(idx / cols);