@robotical/raftjs 2.1.2 → 2.1.4

package/src/RaftChannelSimulated.ts

@@ -586,6 +586,34 @@ export default class RaftChannelSimulated implements RaftChannel {
 
         return true;
       }
+      case "SCD30": {
+        if (dataBlockSizeBytes < 24) {
+          return false;
+        }
+
+        const clamp = (value: number, min: number, max: number) => Math.max(min, Math.min(max, value));
+        const co2Ppm = clamp(
+          850 + 320 * Math.sin(deviceTimeMs / 6500) + 45 * Math.sin(deviceTimeMs / 1400),
+          400,
+          2000
+        );
+        const temperatureC = clamp(
+          22 + 2.2 * Math.sin(deviceTimeMs / 11000 + Math.PI / 5),
+          -40,
+          125
+        );
+        const humidityPercent = clamp(
+          48 + 14 * Math.sin(deviceTimeMs / 9000 + Math.PI / 2),
+          0,
+          100
+        );
+
+        return (
+          this._writeFloat32BytesAtOffsets(dataView, bytePos, [6, 7, 9, 10], co2Ppm) &&
+          this._writeFloat32BytesAtOffsets(dataView, bytePos, [12, 13, 15, 16], temperatureC) &&
+          this._writeFloat32BytesAtOffsets(dataView, bytePos, [18, 19, 21, 22], humidityPercent)
+        );
+      }
       case "RoboticalLEDRing": {
         if (dataBlockSizeBytes < 1) {
           return false;
@@ -665,6 +693,30 @@ export default class RaftChannelSimulated implements RaftChannel {
     }
   }
 
+  private _writeFloat32BytesAtOffsets(
+    dataView: DataView,
+    baseBytePos: number,
+    offsets: number[],
+    value: number
+  ): boolean {
+    if (offsets.length < 4) {
+      return false;
+    }
+
+    const maxOffset = Math.max(...offsets);
+    if (baseBytePos + maxOffset >= dataView.byteLength) {
+      return false;
+    }
+
+    const scratchBuffer = new ArrayBuffer(4);
+    new DataView(scratchBuffer).setFloat32(0, value, false);
+    const bytes = new Uint8Array(scratchBuffer);
+    for (let idx = 0; idx < 4; idx++) {
+      dataView.setUint8(baseBytePos + offsets[idx], bytes[idx]);
+    }
+    return true;
+  }
+
   private _getGridDimensions(attr: any, repeatCount: number): { rows: number; cols: number } {
     if (attr && typeof attr.resolution === "string") {
       const match = attr.resolution.match(/(\d+)\s*x\s*(\d+)/i);
@@ -1017,6 +1069,45 @@ export default class RaftChannelSimulated implements RaftChannel {
         "us": 100000
       }
     },
+    "SCD30": {
+      "name": "CO2 Sensor",
+      "desc": "",
+      "manu": "Sensirion",
+      "type": "SCD30",
+      "clas": ["CO2", "TEMP", "RH"],
+      "resp": {
+        "b": 24,
+        "a": [
+          {
+            "n": "CO2",
+            "t": ">f",
+            "at": [6, 7, 9, 10],
+            "u": "ppm",
+            "r": [0, 40000],
+            "f": ".1f",
+            "o": "float"
+          },
+          {
+            "n": "temperature",
+            "t": ">f",
+            "at": [12, 13, 15, 16],
+            "u": "C",
+            "r": [-40, 125],
+            "f": ".2f",
+            "o": "float"
+          },
+          {
+            "n": "humidity",
+            "t": ">f",
+            "at": [18, 19, 21, 22],
+            "u": "%RH",
+            "r": [0, 100],
+            "f": ".2f",
+            "o": "float"
+          }
+        ]
+      }
+    },
     "RoboticalServo": {
       "name": "Robotical Servo",
       "desc": "Servo",

package/src/RaftConnector.ts

@@ -14,7 +14,7 @@ import RaftChannelWebSocket from "./RaftChannelWebSocket";
 import RaftChannelWebSerial from "./RaftChannelWebSerial";
 import RaftChannelSimulated from "./RaftChannelSimulated";
 import RaftCommsStats from "./RaftCommsStats";
-import { RaftEventFn, RaftOKFail, RaftFileSendType, RaftFileDownloadResult, RaftProgressCBType, RaftStreamDataProgressCBType, RaftBridgeSetupResp, RaftFileDownloadFn, RaftReportMsg } from "./RaftTypes";
+import { RaftEventFn, RaftOKFail, RaftFileSendType, RaftFileDownloadResult, RaftProgressCBType, RaftStreamDataProgressCBType, RaftBridgeSetupResp, RaftFileDownloadFn, RaftReportMsg, RaftRtStreamDataCBType, RaftRtStreamHandle, RaftRtStreamOptions, RaftRtStreamStartResp } from "./RaftTypes";
 import RaftSystemUtils from "./RaftSystemUtils";
 import RaftFileHandler from "./RaftFileHandler";
 import RaftStreamHandler from "./RaftStreamHandler";
@@ -87,6 +87,10 @@ export default class RaftConnector {
   // Update manager
   private _raftUpdateManager: RaftUpdateManager | null = null;
 
+  // Open-ended RT stream callbacks keyed by streamID
+  private _rtStreamCallbacks = new Map<number, RaftRtStreamDataCBType>();
+  private _fallbackRtStreamCallback: { streamID: number, callback: RaftRtStreamDataCBType } | null = null;
+
   /**
    * RaftConnector constructor
    * @param getSystemTypeCB - callback to get system type
@@ -193,6 +197,22 @@ export default class RaftConnector {
     return this._commsStats;
   }
 
+  /**
+   * getOperationQueueDepth
+   * @returns number of high-level device operations queued or running
+   */
+  getOperationQueueDepth(): number {
+    return 0;
+  }
+
+  /**
+   * isOperationBusy
+   * @returns true when a high-level device operation is queued or running
+   */
+  isOperationBusy(): boolean {
+    return false;
+  }
+
   /**
    * Get Raft message handler (to allow message sending and receiving)
    * @returns RaftMsgHandler - Raft message handler
@@ -408,6 +428,11 @@ export default class RaftConnector {
    *
    */
   async sendRICRESTMsg(commandName: string, params: object,
+    bridgeID: number | undefined = undefined): Promise<RaftOKFail> {
+    return this._sendRICRESTMsg(commandName, params, bridgeID);
+  }
+
+  private async _sendRICRESTMsg(commandName: string, params: object,
     bridgeID: number | undefined = undefined): Promise<RaftOKFail> {
     try {
       // Format the paramList as query string
@@ -415,11 +440,12 @@ export default class RaftConnector {
       let paramQueryStr = '';
       for (const param of paramEntries) {
         if (paramQueryStr.length > 0) paramQueryStr += '&';
-        paramQueryStr += param[0] + '=' + param[1];
+        paramQueryStr += `${encodeURIComponent(param[0])}=${encodeURIComponent(String(param[1]))}`;
       }
       // Format the url to send
       if (paramQueryStr.length > 0) commandName += '?' + paramQueryStr;
-      return await this._raftMsgHandler.sendRICRESTURL<RaftOKFail>(commandName, bridgeID);
+      const response = await this._raftMsgHandler.sendRICRESTURL<RaftOKFail | null>(commandName, bridgeID);
+      return response ?? { rslt: 'fail' };
     } catch (error) {
       RaftLog.warn(`sendRICRESTMsg failed ${error}`);
       return { rslt: 'fail' };
@@ -473,6 +499,13 @@ export default class RaftConnector {
     fileBlockData: Uint8Array
   ): void {
     // RaftLog.info(`onRxFileBlock filePos ${filePos} fileBlockData ${RaftUtils.bufferToHex(fileBlockData)}`);
+    const streamID = (filePos >>> 24) & 0xff;
+    const streamFilePos = filePos & 0x00ffffff;
+    const streamCallback = this._rtStreamCallbacks.get(streamID);
+    if (streamID !== 0 && streamCallback) {
+      streamCallback(fileBlockData, streamFilePos, streamID);
+      return;
+    }
     this._raftFileHandler.onFileBlock(filePos, fileBlockData);
   }
 
@@ -534,6 +567,82 @@ export default class RaftConnector {
     return false;
   }
 
+  /**
+   * openRtStream - open an indefinite bidirectional RT stream.
+   * The returned handle can send byte blocks and closes with ufEnd.
+   */
+  async openRtStream(options: RaftRtStreamOptions): Promise<RaftRtStreamHandle> {
+    const cmdMsg = JSON.stringify({
+      cmdName: "ufStart",
+      reqStr: "ufStart",
+      fileType: "rtstream",
+      fileName: options.fileName,
+      endpoint: options.endpoint,
+      fileLen: 0,
+    });
+
+    const startResp = await this._raftMsgHandler.sendRICRESTCmdFrame<RaftRtStreamStartResp>(cmdMsg);
+    if (!startResp || startResp.rslt !== "ok" || startResp.streamID === undefined) {
+      throw new Error(`openRtStream failed ${startResp?.rslt ?? "no response"}`);
+    }
+
+    const streamID = startResp.streamID;
+    const maxBlockSize = startResp.maxBlockSize || this._raftStreamHandler.maxBlockSize;
+    let txFilePos = 0;
+    let sendQueue = Promise.resolve();
+    this._rtStreamCallbacks.set(streamID, options.onData);
+    this._fallbackRtStreamCallback = { streamID, callback: options.onData };
+
+    const sendBytes = async (bytes: Uint8Array): Promise<boolean> => {
+      let sentOk = false;
+      sendQueue = sendQueue
+        .catch(() => {
+          // Keep later terminal input flowing even if an earlier block failed.
+        })
+        .then(async () => {
+          sentOk = await this._raftMsgHandler.sendStreamBlock(bytes, txFilePos, streamID);
+          if (sentOk) {
+            txFilePos = (txFilePos + bytes.length) & 0x00ffffff;
+          }
+        });
+      await sendQueue;
+      return sentOk;
+    };
+
+    const close = async (): Promise<boolean> => {
+      this._rtStreamCallbacks.delete(streamID);
+      if (this._fallbackRtStreamCallback?.streamID === streamID) {
+        this._fallbackRtStreamCallback = null;
+      }
+      const endMsg = JSON.stringify({
+        cmdName: "ufEnd",
+        reqStr: "ufEnd",
+        streamID,
+      });
+      try {
+        const endResp = await this._raftMsgHandler.sendRICRESTCmdFrame<RaftOKFail>(endMsg);
+        return endResp?.rslt === "ok";
+      } catch (error) {
+        RaftLog.warn(`closeRtStream failed ${streamID}: ${error}`);
+        return false;
+      }
+    };
+
+    // Some endpoints use an initial empty block as an attach signal.
+    // Keep this opt-in because older endpoints reject zero-length ufBlock frames.
+    if (options.sendInitialEmptyBlock) {
+      await sendBytes(new Uint8Array());
+    }
+
+    return {
+      streamID,
+      maxBlockSize,
+      sendBytes,
+      sendText: (text: string) => sendBytes(new TextEncoder().encode(text)),
+      close,
+    };
+  }
+
   /**
    * streamAudio - stream audio
    * @param streamContents audio data

package/src/RaftDeviceInfo.ts

@@ -136,6 +136,7 @@ export interface DeviceTypeInfo {
     desc: string;
     manu: string;
     type: string;
+    role?: string;
     resp?: DeviceTypePollRespMetadata;
     clas?: Array<string>;
     actions?: DeviceTypeAction[];
@@ -148,5 +149,8 @@ export interface DeviceTypeInfoRecs {
 export type RaftDevTypeInfoResponse = {
     req: string;
     rslt: string;
-    devinfo: DeviceTypeInfo;
+    devinfo?: DeviceTypeInfo;
+    dtIdx?: number;
+    name?: string;
+    role?: string;
   };

package/src/RaftDeviceManager.test.ts

@@ -2,7 +2,7 @@ import { DeviceManager } from "./RaftDeviceManager";
 import { DeviceTypeInfo } from "./RaftDeviceInfo";
 import RaftSystemUtils from "./RaftSystemUtils";
 
-function makeTypeInfo(name: string, respBytes: number, attrs: Array<{ n: string; t: string }>): DeviceTypeInfo {
+function makeTypeInfo(name: string, respBytes: number, attrs: Array<{ n: string; t: string; at?: number | number[] }>): DeviceTypeInfo {
     return {
         name,
         desc: name,
@@ -123,6 +123,40 @@ describe("DeviceManager binary devbin parsing", () => {
         expect(deviceState.deviceAttributes.status.values).toEqual([4]);
     });
 
+    it("decodes current length-prefixed records with sparse absolute attribute offsets", async () => {
+        const scd30Info = makeTypeInfo("SCD30", 24, [
+            { n: "CO2", t: ">f", at: [6, 7, 9, 10] },
+            { n: "temperature", t: ">f", at: [12, 13, 15, 16] },
+            { n: "humidity", t: ">f", at: [18, 19, 21, 22] }
+        ]);
+        const deviceManager = await makeDeviceManager({ "42": scd30Info });
+        const rxMsg = Uint8Array.from([
+            0x00, 0x80,
+            0xDB, 0xFF, 0x00,
+            0x00, 0x23,
+            0x81,
+            0x00, 0x00, 0x02, 0x61,
+            0x00, 0x2a,
+            0x07,
+            0x1a,
+            0x00, 0x01,
+            0x00, 0x01, 0xb0,
+            0x00, 0x01, 0xb0,
+            0x43, 0xfa, 0x00, 0x00, 0x00, 0x00,
+            0x41, 0xc8, 0x00, 0x00, 0x00, 0x00,
+            0x42, 0x5e, 0x00, 0x00, 0x00, 0x00
+        ]);
+
+        await deviceManager.handleClientMsgBinary(rxMsg);
+
+        const deviceState = deviceManager.getDeviceState("1_261");
+        expect(deviceState.deviceType).toBe("SCD30");
+        expect(deviceState.deviceTimeline.totalSamplesAdded).toBe(1);
+        expect(deviceState.deviceAttributes.CO2.values).toEqual([500]);
+        expect(deviceState.deviceAttributes.temperature.values).toEqual([25]);
+        expect(deviceState.deviceAttributes.humidity.values).toEqual([55.5]);
+    });
+
     it("keeps Cog v1.9.5 direct device records distinct when bus and address are both zero", async () => {
         const lightInfo = makeTypeInfo("LightSensors", 16, [
             { n: "ch0", t: ">H" },

package/src/RaftDeviceManager.ts

@@ -403,8 +403,14 @@ export class DeviceManager implements RaftDeviceMgrIF{
             // Check if a device state already exists
             if (!(deviceKey in this._devicesState) || (this._devicesState[deviceKey].deviceTypeInfo === undefined)) {
 
-                // Get the device type info
-                const deviceTypeInfo = resolvedDeviceTypeInfo ?? await this.getDeviceTypeInfo(busNum.toString(), devTypeIdx.toString());
+                // Merge rationale: upstream's deviceid lookup carries
+                // per-instance name/role fields, while Robotical's simulator
+                // and older firmware still expose bus/type lookup. Try the
+                // richer endpoint first and fall back to the type record that
+                // was already loaded for payload-format detection.
+                const deviceTypeInfo = await this.getDeviceTypeInfo(deviceKey)
+                    ?? resolvedDeviceTypeInfo
+                    ?? await this.getDeviceTypeInfo(busNum.toString(), devTypeIdx.toString());
                 
                 // Debug
                 // console.log(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} pollDataPos ${pollDataPos} busNum ${busNum} devAddr 0x${devAddr.toString(16)} devTypeIdx ${devTypeIdx} deviceTypeInfo ${JSON.stringify(deviceTypeInfo)}`);
@@ -482,11 +488,21 @@ export class DeviceManager implements RaftDeviceMgrIF{
 
                         const sampleStartPos = pollDataPos;
                         const sampleEndPos = pollDataPos + sampleLen;
+                        // Merge rationale: keep Robotical's explicit sample
+                        // boundary and add upstream diagnostics so malformed
+                        // samples can be skipped with useful context.
                         const newMsgBufIdx = this._attributeHandler.processMsgAttrGroup(rxMsg, sampleStartPos,
                             deviceState.deviceTimeline, pollRespMetadata,
                             deviceState.deviceAttributes,
                             this._maxDatapointsToStore,
-                            sampleEndPos);
+                            sampleEndPos,
+                            {
+                                deviceKey,
+                                deviceType: deviceState.deviceType,
+                                debugMsgIndex,
+                                sampleStartIdx: sampleStartPos,
+                                sampleEndIdx: sampleEndPos,
+                            });
 
                         if (newMsgBufIdx < 0)
                         {
@@ -515,11 +531,21 @@ export class DeviceManager implements RaftDeviceMgrIF{
                         while (pollDataPos + legacySampleLen <= samplesEndPos) {
                             const sampleStartPos = pollDataPos;
                             const sampleEndPos = pollDataPos + legacySampleLen;
+                            // Legacy raw records are not length-prefixed, but
+                            // the fixed sample span gives the same bound and
+                            // diagnostic context to the attribute handler.
                             const newMsgBufIdx = this._attributeHandler.processMsgAttrGroup(rxMsg, sampleStartPos,
                                 deviceState.deviceTimeline, pollRespMetadata,
                                 deviceState.deviceAttributes,
                                 this._maxDatapointsToStore,
-                                sampleEndPos);
+                                sampleEndPos,
+                                {
+                                    deviceKey,
+                                    deviceType: deviceState.deviceType,
+                                    debugMsgIndex,
+                                    sampleStartIdx: sampleStartPos,
+                                    sampleEndIdx: sampleEndPos,
+                                });
 
                             if (newMsgBufIdx < 0)
                             {
@@ -632,8 +658,11 @@ export class DeviceManager implements RaftDeviceMgrIF{
                 // Check if a device state already exists
                 if (!(deviceKey in this._devicesState) || (this._devicesState[deviceKey].deviceTypeInfo === undefined)) {
 
-                    // Get the device type info
-                    const deviceTypeInfo = await this.getDeviceTypeInfo(busName, deviceTypeName);
+                    // Prefer upstream's per-instance deviceid endpoint, but
+                    // keep Robotical's bus/type fallback for simulated and
+                    // older JSON publishers.
+                    const deviceTypeInfo = await this.getDeviceTypeInfo(deviceKey)
+                        ?? await this.getDeviceTypeInfo(busName, deviceTypeName);
 
                     // Check if device record exists
                     if (deviceKey in this._devicesState) {
@@ -802,71 +831,87 @@ export class DeviceManager implements RaftDeviceMgrIF{
     // Get device type info
     ////////////////////////////////////////////////////////////////////////////
 
-    private async getDeviceTypeInfo(busName: string, deviceType: string): Promise<DeviceTypeInfo | undefined> {
+    private async getDeviceTypeInfo(deviceKey: string): Promise<DeviceTypeInfo | undefined>;
+    private async getDeviceTypeInfo(busName: string, deviceType: string): Promise<DeviceTypeInfo | undefined>;
+    private async getDeviceTypeInfo(deviceKeyOrBusName: string, deviceType?: string): Promise<DeviceTypeInfo | undefined> {
+        const cacheKey = deviceType === undefined ? deviceKeyOrBusName : deviceType;
+        const requestLabel = deviceType === undefined ? `deviceKey ${deviceKeyOrBusName}` : `deviceType ${deviceType}`;
+
         // Check if already in cache
-        if (deviceType in this._cachedDeviceTypeRecs) {
-            return this._cachedDeviceTypeRecs[deviceType];
+        if (cacheKey in this._cachedDeviceTypeRecs) {
+            return this._cachedDeviceTypeRecs[cacheKey];
         }
 
-        // Check if there's already a pending request for this device type
-        if (deviceType in this._pendingDeviceTypeRequests) {
-            // console.log(`DevMan.getDeviceTypeInfo joining existing request queue for deviceType ${deviceType}`);
-            
+        // Check if there's already a pending request for this device/type
+        if (cacheKey in this._pendingDeviceTypeRequests) {
             // Add this request to the waiting queue
             return new Promise<DeviceTypeInfo | undefined>((resolve, reject) => {
-                this._pendingDeviceTypeRequests[deviceType].waitingQueue.push({ resolve, reject });
+                this._pendingDeviceTypeRequests[cacheKey].waitingQueue.push({ resolve, reject });
             });
         }
 
         // Check rate limiting for new requests
-        if (deviceType in this._cachedDeviceTypePreviousAttemptTimes) {
-            const timeSinceLastAttempt = Date.now() - this._cachedDeviceTypePreviousAttemptTimes[deviceType];
+        if (cacheKey in this._cachedDeviceTypePreviousAttemptTimes) {
+            const timeSinceLastAttempt = Date.now() - this._cachedDeviceTypePreviousAttemptTimes[cacheKey];
             if (timeSinceLastAttempt < this._minTimeBetweenDeviceTypeInfoRetrievalMs) {
-                console.log(`DevMan.getDeviceTypeInfo rate limited for deviceType ${deviceType}`);
+                console.log(`DevMan.getDeviceTypeInfo rate limited for ${requestLabel}`);
                 return undefined;
             }
         }
 
         // Create and cache the promise with an empty waiting queue
-        const requestPromise = this.executeDeviceTypeInfoRequest(busName, deviceType);
-        this._pendingDeviceTypeRequests[deviceType] = {
+        const requestPromise = this.executeDeviceTypeInfoRequest(deviceKeyOrBusName, deviceType);
+        this._pendingDeviceTypeRequests[cacheKey] = {
             promise: requestPromise,
             waitingQueue: []
         };
 
         try {
             const result = await requestPromise;
-            
+
             // Resolve all waiting requests with the same result
-            const waitingQueue = this._pendingDeviceTypeRequests[deviceType].waitingQueue;
+            const waitingQueue = this._pendingDeviceTypeRequests[cacheKey].waitingQueue;
             waitingQueue.forEach(({ resolve }) => resolve(result));
-            
+
             return result;
         } catch (error) {
             // Reject all waiting requests with the same error
-            const waitingQueue = this._pendingDeviceTypeRequests[deviceType].waitingQueue;
+            const waitingQueue = this._pendingDeviceTypeRequests[cacheKey].waitingQueue;
             waitingQueue.forEach(({ reject }) => reject(error));
-            
-            console.warn(`DevMan.getDeviceTypeInfo failed for ${deviceType}: ${error}`);
+
+            console.warn(`DevMan.getDeviceTypeInfo failed for ${requestLabel}: ${error}`);
             return undefined;
         } finally {
             // Clean up the pending request
-            delete this._pendingDeviceTypeRequests[deviceType];
+            delete this._pendingDeviceTypeRequests[cacheKey];
         }
     }
 
-    private async executeDeviceTypeInfoRequest(busName: string, deviceType: string): Promise<DeviceTypeInfo | undefined> {
-        this._cachedDeviceTypePreviousAttemptTimes[deviceType] = Date.now();
-        
+    private async executeDeviceTypeInfoRequest(deviceKeyOrBusName: string, deviceType?: string): Promise<DeviceTypeInfo | undefined> {
+        const cacheKey = deviceType === undefined ? deviceKeyOrBusName : deviceType;
+        this._cachedDeviceTypePreviousAttemptTimes[cacheKey] = Date.now();
+
         try {
-            const cmd = "devman/typeinfo?bus=" + busName + "&type=" + deviceType;
+            // Merge rationale: support both upstream's per-device endpoint and
+            // Robotical's older bus/type endpoint. The deviceid response may
+            // include instance-specific name/role; the bus/type response keeps
+            // simulators and older firmware working.
+            const cmd = deviceType === undefined
+                ? "devman/typeinfo?deviceid=" + deviceKeyOrBusName
+                : "devman/typeinfo?bus=" + deviceKeyOrBusName + "&type=" + deviceType;
             const msgHandler = this._systemUtils?.getMsgHandler();
-            
+
             if (msgHandler) {
                 const msgRslt = await msgHandler.sendRICRESTURL<RaftDevTypeInfoResponse>(cmd);
                 if (msgRslt && msgRslt.rslt === "ok") {
-                    this._cachedDeviceTypeRecs[deviceType] = msgRslt.devinfo;
-                    return msgRslt.devinfo;
+                    // Merge devinfo (type-level) with top-level per-instance overrides (name, role)
+                    const base: DeviceTypeInfo = msgRslt.devinfo
+                        ? { ...msgRslt.devinfo }
+                        : { name: "", desc: "", manu: "", type: "" };
+                    if (msgRslt.name !== undefined) base.name = msgRslt.name;
+                    if (msgRslt.role !== undefined) base.role = msgRslt.role;
+                    this._cachedDeviceTypeRecs[cacheKey] = base;
+                    return base;
                 }
             }
             return undefined;
@@ -964,10 +1009,14 @@ export class DeviceManager implements RaftDeviceMgrIF{
         }
 
         let attrPayloadLen = 0;
+        let usesAbsolutePositions = false;
         for (const attrDef of pollRespMetadata.a) {
             if (!attrDef.t) {
                 return pollRespMetadata.b;
             }
+            if (attrDef.at !== undefined) {
+                usesAbsolutePositions = true;
+            }
             try {
                 attrPayloadLen += structSizeOf(attrDef.t);
             } catch {
@@ -975,6 +1024,10 @@ export class DeviceManager implements RaftDeviceMgrIF{
             }
         }
 
+        if (usesAbsolutePositions && pollRespMetadata.b > 0) {
+            return pollRespMetadata.b;
+        }
+
         // Cog v1.9.5 light metadata reports the direct-sensor payload size doubled,
         // but the legacy raw record contains one fixed payload matching the attribute schema.
         if ((attrPayloadLen > 0) && (pollRespMetadata.b > 0) && (attrPayloadLen <= pollRespMetadata.b)) {