@robotical/raftjs 1.4.6 → 2.0.3

package/dist/web/main.js

@@ -9,7 +9,7 @@
 //
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RaftDeviceManager = exports.RaftSysTypeManager = exports.RaftUtils = exports.RaftSystemUtils = exports.RaftStreamHandler = exports.RaftMsgHandler = exports.RaftMiniHDLC = exports.RaftLog = exports.RaftFileHandler = exports.RaftChannelWebSocket = exports.RaftConnector = exports.RaftCommsStats = exports.RaftChannelBLE = void 0;
+exports.RaftDeviceManager = exports.RaftSysTypeManager = exports.RaftUtils = exports.RaftSystemUtils = exports.RaftStreamHandler = exports.RaftMsgHandler = exports.RaftMiniHDLC = exports.RaftLog = exports.RaftFileHandler = exports.RaftChannelSimulated = exports.RaftChannelWebSocket = exports.RaftConnector = exports.RaftCommsStats = exports.RaftChannelBLE = void 0;
 const tslib_1 = require("tslib");
 const RaftChannelBLEFactory_1 = require("./RaftChannelBLEFactory");
 const raftChannel = (0, RaftChannelBLEFactory_1.createBLEChannel)();
@@ -20,6 +20,8 @@ var RaftConnector_1 = require("./RaftConnector");
 Object.defineProperty(exports, "RaftConnector", { enumerable: true, get: function () { return tslib_1.__importDefault(RaftConnector_1).default; } });
 var RaftChannelWebSocket_1 = require("./RaftChannelWebSocket");
 Object.defineProperty(exports, "RaftChannelWebSocket", { enumerable: true, get: function () { return tslib_1.__importDefault(RaftChannelWebSocket_1).default; } });
+var RaftChannelSimulated_1 = require("./RaftChannelSimulated");
+Object.defineProperty(exports, "RaftChannelSimulated", { enumerable: true, get: function () { return tslib_1.__importDefault(RaftChannelSimulated_1).default; } });
 var RaftFileHandler_1 = require("./RaftFileHandler");
 Object.defineProperty(exports, "RaftFileHandler", { enumerable: true, get: function () { return tslib_1.__importDefault(RaftFileHandler_1).default; } });
 var RaftLog_1 = require("./RaftLog");
@@ -45,4 +47,5 @@ tslib_1.__exportStar(require("./RaftConnEvents"), exports);
 tslib_1.__exportStar(require("./RaftUpdateEvents"), exports);
 tslib_1.__exportStar(require("./RaftProtocolDefs"), exports);
 tslib_1.__exportStar(require("./RaftDeviceStates"), exports);
+tslib_1.__exportStar(require("./RaftDeviceInfo"), exports);
 //# sourceMappingURL=main.js.map

package/dist/web/main.js.map

@@ -1 +1 @@
-{"version":3,"file":"main.js","sourceRoot":"","sources":["../../src/main.ts"],"names":[],"mappings":";AAAA,iHAAiH;AACjH,EAAE;AACF,SAAS;AACT,gGAAgG;AAChG,EAAE;AACF,wCAAwC;AACxC,oCAAoC;AACpC,EAAE;AACF,iHAAiH;;;;AAEjH,mEAA2D;AAC3D,MAAM,WAAW,GAAG,IAAA,wCAAgB,GAAE,CAAC;AACf,qCAAc;AAEtC,mDAA6D;AAApD,yIAAA,OAAO,OAAkB;AAClC,iDAA2D;AAAlD,uIAAA,OAAO,OAAiB;AAEjC,+DAAyE;AAAhE,qJAAA,OAAO,OAAwB;AACxC,qDAA+D;AAAtD,2IAAA,OAAO,OAAmB;AACnC,qCAA+C;AAAtC,2HAAA,OAAO,OAAW;AAC3B,+CAAyD;AAAhD,qIAAA,OAAO,OAAgB;AAChC,mDAA4D;AAAnD,yIAAA,OAAO,OAAkB;AAClC,yDAAmE;AAA1D,+IAAA,OAAO,OAAqB;AACrC,qDAA+D;AAAtD,2IAAA,OAAO,OAAmB;AACnC,yCAAmD;AAA1C,+HAAA,OAAO,OAAa;AAC7B,2DAAqE;AAA5D,iJAAA,OAAO,OAAsB;AAEtC,yDAAyE;AAAhE,sHAAA,aAAa,OAAqB;AAE3C,sDAA4B;AAC5B,2DAAiC;AACjC,0DAAgC;AAChC,2DAAiC;AACjC,6DAAmC;AACnC,6DAAmC;AACnC,6DAAmC"}
+{"version":3,"file":"main.js","sourceRoot":"","sources":["../../src/main.ts"],"names":[],"mappings":";AAAA,iHAAiH;AACjH,EAAE;AACF,SAAS;AACT,gGAAgG;AAChG,EAAE;AACF,wCAAwC;AACxC,oCAAoC;AACpC,EAAE;AACF,iHAAiH;;;;AAEjH,mEAA2D;AAC3D,MAAM,WAAW,GAAG,IAAA,wCAAgB,GAAE,CAAC;AACf,qCAAc;AAEtC,mDAA6D;AAApD,yIAAA,OAAO,OAAkB;AAClC,iDAA2D;AAAlD,uIAAA,OAAO,OAAiB;AAEjC,+DAAyE;AAAhE,qJAAA,OAAO,OAAwB;AACxC,+DAAyE;AAAhE,qJAAA,OAAO,OAAwB;AACxC,qDAA+D;AAAtD,2IAAA,OAAO,OAAmB;AACnC,qCAA+C;AAAtC,2HAAA,OAAO,OAAW;AAC3B,+CAAyD;AAAhD,qIAAA,OAAO,OAAgB;AAChC,mDAA4D;AAAnD,yIAAA,OAAO,OAAkB;AAClC,yDAAmE;AAA1D,+IAAA,OAAO,OAAqB;AACrC,qDAA+D;AAAtD,2IAAA,OAAO,OAAmB;AACnC,yCAAmD;AAA1C,+HAAA,OAAO,OAAa;AAC7B,2DAAqE;AAA5D,iJAAA,OAAO,OAAsB;AAEtC,yDAAyE;AAAhE,sHAAA,aAAa,OAAqB;AAE3C,sDAA4B;AAC5B,2DAAiC;AACjC,0DAAgC;AAChC,2DAAiC;AACjC,6DAAmC;AACnC,6DAAmC;AACnC,6DAAmC;AACnC,2DAAiC"}

package/examples/dashboard/package.json

@@ -1,6 +1,6 @@
 {
   "name": "raftjs-example-dashboard",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "",
   "scripts": {
     "start": "npm run clean && parcel build src/index.html && parcel src/index.html",

package/examples/dashboard/src/CommandPanel.tsx

@@ -38,17 +38,17 @@ export default function CommandPanel() {
 
         // Update history only if the command is not the same as the last one
         if (commandHistory.length === 0 || commandHistory[commandHistory.length - 1] !== cmd) {
-          setCommandHistory((prevHistory) => [...prevHistory, cmd]);
+          setCommandHistory((prevHistory: any) => [...prevHistory, cmd]);
         }
 
         // Reset the history index and clear the command
         setHistoryIndex(-1);
         setCommand('');
       }).catch(error => {
-        console.error(`Error sending command: ${cmd}`, error);
+        console.warn(`Error sending command: ${cmd}`, error);
       });
     } else {
-      console.error("Command is empty.");
+      console.warn("Command is empty.");
     }
   };
 

package/examples/dashboard/src/ConnManager.ts

@@ -20,7 +20,9 @@ export default class ConnManager {
   private _connector = new RaftConnector(async (systemUtils: RaftSystemUtils) => {
     const systemInfo = await systemUtils.getSystemInfo();
     const sysType = sysTypeManager.createSystemType(systemInfo.SystemName) || sysTypeManager.createDefaultSystemType();
-    sysType?.deviceMgrIF.setMaxDataPointsToStore(settingsManager.getSetting("maxDatapointsToStore"));
+    if (sysType && sysType.deviceMgrIF) {
+      sysType.deviceMgrIF.setMaxDataPointsToStore(settingsManager.getSetting("maxDatapointsToStore"));
+    }
     return sysType;
   });
 
@@ -49,8 +51,22 @@ export default class ConnManager {
     return this._connector;
   }
 
-  private async getBleDevice(uuids: string[]): Promise<BluetoothDevice | null> {
-    const filtersArray = uuids.map((uuid) => ({ services: [uuid] }));
+  private async getBleDevice(uuids: string[], serialNo: string | null = null): Promise<BluetoothDevice | null> {
+
+    // Filter by main service UUID if no serial number provided
+    let filtersArray = uuids.map((uuid) => ({ services: [ uuid] }));
+
+    // Check if a serial number is provided
+    if ((serialNo !== null) && (serialNo !== "")) {
+      
+      // Generate a UUID from the base UUID xored with serial number in BCD form
+      const baseUUID = "aa76677e-9cfd-4626-0000-000000000000";
+      const modifiedUUID = this.generateServiceFilterUUID(baseUUID, serialNo);
+      filtersArray = [{ services: [modifiedUUID] }];
+
+      // console.log(`getBleDevice - modified UUID: ${modifiedUUID}`);
+    }
+
     try {
       const dev = await navigator.bluetooth.requestDevice({
         filters: filtersArray,
@@ -58,13 +74,13 @@ export default class ConnManager {
       });
       return dev;
     } catch (e) {
-      RaftLog.error(`getBleDevice - failed to get device ${e}`);
+      RaftLog.warn(`getBleDevice - failed to get device ${e}`);
       return null;
     }
   }
 
   // Connect
-  public async connect(method: string, locator: string | object, uuids: string[]): Promise<boolean> {
+  public async connect(method: string, locator: string | object, uuids: string[], serialNo: string | null = null): Promise<boolean> {
 
     // Hook up the connector
     this._connector.setEventListener((evtType, eventEnum, eventName, eventData) => {
@@ -76,7 +92,7 @@ export default class ConnManager {
     await this._connector.initializeChannel(method);
     // Set the connector websocket suffix
     if (method === "WebBLE") {
-      const dev = await this.getBleDevice(uuids);
+      const dev = await this.getBleDevice(uuids, serialNo);
       return this._connector.connect(dev as object);
     }
     return this._connector.connect(locator);
@@ -86,4 +102,65 @@ export default class ConnManager {
   public disconnect(): Promise<void> {
     return this._connector.disconnect();
   }
+
+  ///////////////////////////////////////////////////////////////////////////////////
+  /// @brief Generate a UUID for service filtering based on device serial number
+  /// @param baseUUID Base UUID string (e.g., "aa76677e-9cfd-4626-0000-000000000000")
+  /// @param serialNo Serial number as an ASCII string (e.g., "1234567890123456")
+  /// @returns Modified UUID string
+  public generateServiceFilterUUID(baseUUID: string, serialNo: string): string {
+    const UUID_128_BYTES = 16;
+
+    // Convert UUID string to byte array
+    let uuidBytes = this.uuidToByteArray(baseUUID);
+
+    // Convert serial number assuming it is decimal (or hex) digits to bytes
+    let serialBytes = this.hexStringToBytes(serialNo);
+
+    // Limit to 16 bytes (UUID size)
+    const bytesToProc = Math.min(serialBytes.length, UUID_128_BYTES);
+
+    // console.log(`generateServiceFilterUUID - serialBCD: ${serialBCD} bytesToProc: ${bytesToProc}`);
+
+    // XOR the serial BCD bytes with the UUID bytes
+    for (let i = 0; i < bytesToProc; i++) {
+        uuidBytes[15 - i] ^= serialBytes[bytesToProc - 1 - i];
+    }
+
+    // Convert back to UUID string format
+    return this.byteArrayToUUID(uuidBytes);
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  /// @brief Convert UUID string to byte array (Big Endian order)
+  public uuidToByteArray(uuid: string): Uint8Array {
+    return new Uint8Array(
+        uuid.replace(/-/g, "") // Remove dashes
+            .match(/.{1,2}/g)!.map(byte => parseInt(byte, 16)) // Convert hex pairs to bytes
+    );
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  /// @brief Convert byte array back to UUID string
+  public byteArrayToUUID(bytes: Uint8Array): string {
+    return [...bytes]
+        .map(b => b.toString(16).padStart(2, "0")) // Convert to hex
+        .join("")
+        .replace(/^(.{8})(.{4})(.{4})(.{4})(.{12})$/, "$1-$2-$3-$4-$5"); // Format as UUID
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  /// @brief Convert an hex string to bytes
+  /// @param hex string - e.g. "1234567890123456" -> [0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]
+  /// @returns byte array
+  public hexStringToBytes(hex: string): Uint8Array {
+    // Pad to ensure even number of characters
+    if (hex.length % 2 !== 0) {
+        hex = "0" + hex;
+    }
+
+    return new Uint8Array(
+        hex.match(/.{1,2}/g)?.map(byte => parseInt(byte, 16)) || []
+    );
+}
 }

package/examples/dashboard/src/DeviceActionsForm.tsx

@@ -13,7 +13,7 @@ interface InputValues {
     [key: string]: number;
 }
 
-const DeviceActionsForm: React.FC<DeviceActionsTableProps> = ({ deviceKey }) => {
+const DeviceActionsForm: React.FC<DeviceActionsTableProps> = ({ deviceKey }: DeviceActionsTableProps) => {
     const deviceManager = connManager.getConnector().getSystemType()?.deviceMgrIF;
     const [deviceActions, setDeviceActions] = useState<DeviceTypeAction[]>([]);
     const [inputValues, setInputValues] = useState<InputValues>({});
@@ -44,7 +44,7 @@ const DeviceActionsForm: React.FC<DeviceActionsTableProps> = ({ deviceKey }) =>
     }, [deviceKey]);
 
     const handleInputChange = (name: string, value: number) => {
-        setInputValues((prevValues) => ({
+        setInputValues((prevValues: any) => ({
             ...prevValues,
             [name]: value,
         }));

package/examples/dashboard/src/DevicePanel.tsx

@@ -83,7 +83,7 @@ const DevicePanel = ({ deviceKey, lastUpdated }: DevicePanelProps) => {
             navigator.clipboard.writeText(csvContent).then(() => {
                 console.log("Device values copied to clipboard");
             }).catch(err => {
-                console.error('Failed to copy: ', err);
+                console.warn('Failed to copy: ', err);
                 fallbackCopyTextToClipboard(csvContent);
             });
         } else {
@@ -109,7 +109,7 @@ const DevicePanel = ({ deviceKey, lastUpdated }: DevicePanelProps) => {
             document.execCommand("copy");
             // alert("Device values copied to clipboard!");
         } catch (err) {
-            console.error('Fallback: Oops, unable to copy', err);
+            console.warn('Fallback: Oops, unable to copy', err);
             alert("Failed to copy device values to clipboard");
         }
     

package/examples/dashboard/src/Main.tsx

@@ -35,12 +35,14 @@ export default function Main() {
     localStorage.getItem('lastIpAddress') || ''
   );
 
+  const [serialNo, setSerialNo] = useState<string>('');
+
   const handleConnect = () => {
     if (ipAddress.trim() === '') {
-      console.error('No IP address entered');
+      console.warn('No IP address entered');
       return;
     }
-    connManager.connect('WebSocket', ipAddress, []);
+    connManager.connect('WebSocket', ipAddress, [], null);
     localStorage.setItem('lastIpAddress', ipAddress);
   };
 
@@ -193,10 +195,18 @@ export default function Main() {
                   </div>
                   <div className="info-box">
                     <h3>WebBLE</h3>
+                    <input
+                      className="serial-no-input"
+                      id="serial-no"
+                      type="text"
+                      placeholder="Serial No (ignored if empty)"
+                      value={serialNo}
+                      onChange={(e) => setSerialNo(e.target.value)}
+                    />
                     <button
                       className="action-button"
                       onClick={() => {
-                        connManager.connect('WebBLE', '', sysTypeManager.getAllServiceUUIDs());
+                        connManager.connect('WebBLE', '', sysTypeManager.getAllServiceUUIDs(), serialNo);
                       }}
                     >
                       Connect
@@ -207,7 +217,7 @@ export default function Main() {
                     <button
                       className="action-button"
                       onClick={() => {
-                        connManager.connect('WebSerial', '', []);
+                        connManager.connect('WebSerial', '', [], null);
                       }}
                     >
                       Connect

package/examples/dashboard/src/SystemTypeMarty/RICSystemUtils.ts

@@ -98,7 +98,7 @@ export default class RICSystemUtils {
       const retrieveResult = await this.retrieveInfo();
       return retrieveResult;
     } catch (err) {
-      RaftLog.error(`retrieveMartySystemInfo: error ${err}`);
+      RaftLog.warn(`retrieveMartySystemInfo: error ${err}`);
     }
     return false;
   }
@@ -260,7 +260,7 @@ export default class RICSystemUtils {
             // Debug
             RaftLog.debug(
               `getHWElemList: found ${hwElemList.hw.length} addons/buspixels`
-            
+            );
           } else if (addToNonAddOnsList) {
             this._hwElemsExcludingAddOns.push(...hwElemList.hw);
             // Debug
@@ -279,9 +279,9 @@ export default class RICSystemUtils {
     try {
       const reports: Array<RaftReportMsg> = [];
       // add callback to subscribe to report messages
-      this._msgHandler.reportMsgCallbacksSet("getHWElemCB", function (
+      this._msgHandler.reportMsgCallbacksSet("getHWElemCB", async function (
         report: RaftReportMsg
-      ) {
+      ): Promise<void> {
         reports.push(report);
         RaftLog.debug(`getHWElemCB Report callback ${JSON.stringify(report)}`);
       });

package/examples/dashboard/src/styles.css

@@ -121,6 +121,14 @@ h1 {
     width: 100%;
 }
 
+.serial-no-input {
+    border: 1px solid #ccc;
+    border-radius: 4px;
+    margin-bottom: 10px;
+    padding: 10px;
+    width: 100%;
+}
+
 .command-input {
     padding: 10px;
     margin-bottom: 10px;

package/examples/dashboard/tsconfig.json

@@ -4,7 +4,7 @@
     "esModuleInterop": true,
     "resolveJsonModule": true,
     "module": "esnext",
-    "target": "es5",
+    "target": "es2017",
     "strict": true,
     "moduleResolution": "node",
     "lib": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robotical/raftjs",
-  "version": "1.4.6",
+  "version": "2.0.3",
   "description": "Javascript/TS library for Raft library",
   "main": "dist/web/main.js",
   "types": "dist/web/main.d.ts",
@@ -31,19 +31,18 @@
     "watch-all": "tsc -p tsconfig.json --watch & tsc -p tsconfig.react-native.json --watch"
   },
   "devDependencies": {
-    "@types/node": "^20.14.0",
-    "@types/web-bluetooth": "^0.0.20",
-    "@typescript-eslint/eslint-plugin": "^8.6.0",
-    "eslint": "^9.4.0",
-    "react-native-ble-plx": "^3.2.0",
-    "typescript": "^5.4.5",
-    "@types/text-encoding": "^0.0.39",
-    "rimraf": "^6.0.1"
+    "@types/node": "^22.13.11",
+    "@types/web-bluetooth": "^0.0.21",
+    "@typescript-eslint/eslint-plugin": "^8.27.0",
+    "eslint": "^9.23.0",
+    "react-native-ble-plx": "^3.5.0",
+    "typescript": "^5.8.2",
+    "rimraf": "^6.0.1",
+    "@types/text-encoding": "^0.0.40"
   },
   "dependencies": {
-    "text-encoding": "^0.7.0",
     "isomorphic-ws": "^5.0.0",
-    "tslib": "^2.6.2"
+    "tslib": "^2.8.1"
   },
   "peerDependencies": {
     "react-native-ble-plx": "*",

package/src/RaftAttributeHandler.ts

@@ -45,6 +45,8 @@ export default class AttributeHandler {
 
         } else {
 
+            // console.log(`RaftAttrHdlr.processMsgAttrGroup ${JSON.stringify(pollRespMetadata)} msgBufIdx ${msgBufIdx} timestampUs ${timestampUs}`);
+
             // Iterate over attributes
             for (let attrIdx = 0; attrIdx < pollRespMetadata.a.length; attrIdx++) {
 
@@ -56,6 +58,8 @@ export default class AttributeHandler {
                     continue;
                 }
 
+                // 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);
                 if (newMsgBufIdx < 0) {
@@ -65,7 +69,6 @@ export default class AttributeHandler {
                 msgBufIdx = newMsgBufIdx;
                 newAttrValues.push(values);
             }
-
         }
         
         // Number of bytes in group
@@ -142,19 +145,94 @@ export default class AttributeHandler {
         // Add the new timestamps
         deviceTimeline.timestampsUs.push(...timestampsUs);
 
+        // Validate attributes based on the vft field
+        this.validateAttributes(pollRespMetadata, devAttrsState, numNewDataPoints);
+
         // Return the next message buffer index
         return msgDataStartIdx+pollRespSizeBytes;
     }
 
+    private validateAttributes(pollRespMetadata: DeviceTypePollRespMetadata, devAttrsState: DeviceAttributesState, numNewDataPoints: number): void {
+        // 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;
+            }
+
+            // Get the name of the validating attribute
+            const validatingAttrName = attrDef.vft;
+
+            // Check if the validating attribute exists in the state
+            if (!(validatingAttrName in devAttrsState)) {
+                console.debug(`Cannot validate attribute ${attrDef.n} as validating attribute ${validatingAttrName} doesn't exist`);
+                continue;
+            }
+
+            // Get the current attribute state
+            const currentAttr = devAttrsState[attrDef.n];
+            const validatingAttr = devAttrsState[validatingAttrName];
+
+            // Check if both attributes have values
+            if (!currentAttr.values.length || !validatingAttr.values.length) {
+                continue;
+            }
+
+            // 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;
+                if (valueIdx >= 0 && valueIdx < numValues) {
+                    // Check if the validating attribute's value is 0/false at the same index
+                    const validatingValueIdx = validatingAttr.values.length - numNewDataPoints + i;
+                    if (validatingValueIdx >= 0 && validatingValueIdx < validatingAttr.values.length) {
+                        // If the validating attribute's value is 0 or false, mark the current value as invalid
+                        if (!validatingAttr.values[validatingValueIdx]) {
+                            currentAttr.values[valueIdx] = NaN; // Using NaN to represent invalid values
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     private processMsgAttribute(attrDef: DeviceTypeAttribute, msgBuffer: Uint8Array, msgBufIdx: number, msgDataStartIdx: number): { values: number[], newMsgBufIdx: number} {
 
         // Current field message string index
         let curFieldBufIdx = msgBufIdx;
         let attrUsesAbsPos = false;
 
-        // Check for "at": N which means start reading from byte N of the message (after the timestamp bytes)
+        // Check for "at" field which means absolute position in the buffer
         if (attrDef.at !== undefined) {
-            curFieldBufIdx = msgDataStartIdx + attrDef.at;
+            // 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 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];
+                    }
+                }
+                
+                // Use this buffer for attribute extraction
+                msgBuffer = bytesForType;
+                curFieldBufIdx = 0;
+            } else {
+                // Standard absolute position in the buffer
+                curFieldBufIdx = msgDataStartIdx + attrDef.at;
+            }
             attrUsesAbsPos = true;
         }
 
@@ -194,13 +272,13 @@ export default class AttributeHandler {
         // Check for XOR mask
         if ("x" in attrDef) {
             const mask = typeof attrDef.x === "string" ? parseInt(attrDef.x, 16) : attrDef.x as number;
-            attrValues = attrValues.map((value) => value ^ mask);
+            attrValues = attrValues.map((value) => (value >>> 0) ^ mask);
         }
         
         // Check for AND mask
         if ("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 & mask));
+            attrValues = attrValues.map((value) => (maskOnSignedValue ? this.signExtend(value, mask) : (value >>> 0) & mask));
         }
 
         // Check for a sign-bit
@@ -219,9 +297,9 @@ export default class AttributeHandler {
         if ("s" in attrDef && attrDef.s) {
             const bitshift = attrDef.s as number;
             if (bitshift > 0) {
-                attrValues = attrValues.map((value) => (value) >> bitshift);
+                attrValues = attrValues.map((value) => (value >>> 0) >>> bitshift);
             } else if (bitshift < 0) {
-                attrValues = attrValues.map((value) => (value) << -bitshift);
+                attrValues = attrValues.map((value) => (value >>> 0) << -bitshift);
             }
         }
 
@@ -237,10 +315,47 @@ export default class AttributeHandler {
             attrValues = attrValues.map((value) => (value) + addValue);
         }
 
-        // console.log(`DeviceManager msg attrGroup ${attrGroup} devkey ${deviceKey} valueHexChars ${valueHexChars} msgHexStr ${msgHexStr} ts ${timestamp} attrName ${attrDef.n} type ${attrDef.t} value ${value} signExtendableMaskSignPos ${signExtendableMaskSignPos} attrTypeDefForStruct ${attrTypeDefForStruct} attrDef ${attrDef}`);
+        // Apply lookup table if defined
+        if ("lut" in attrDef && attrDef.lut !== undefined) {
+            attrValues = attrValues.map((value): number => {
+                // Skip NaN values
+                if (isNaN(value)) {
+                    return value;
+                }
+
+                // 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)) {
+                        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;
+            });
+        }
+
+        // const msgBufIdxIn = msgBufIdx;
+
         // Move buffer position if using relative positioning
         msgBufIdx += attrUsesAbsPos ? 0 : numBytesConsumed;
 
+        // console.log(`RaftAttrHdlr.processMsgAttr attr ${attrDef.n} msgBufIdx ${msgBufIdxIn} msgBufIdx ${msgBufIdx} attrUsesAbsPos ${attrUsesAbsPos} numBytesConsumed ${numBytesConsumed} attrValues ${attrValues}`);
+
         // if (attrDef.n === "amb0") {
         //     console.log(`${new Date().toISOString()} ${attrDef.n} ${attrValues}`);
         // }
@@ -264,7 +379,7 @@ export default class AttributeHandler {
     private extractTimestampAndAdvanceIdx(msgBuffer: Uint8Array, msgBufIdx: number, timestampWrapHandler: DeviceTimeline): 
                     { newBufIdx: number, timestampUs: number } {
 
-        // Check there are enough characters for the timestamp
+        // Check there are enough bytes for the timestamp
         if (msgBufIdx + this.POLL_RESULT_TIMESTAMP_SIZE > msgBuffer.length) {
             return { newBufIdx: -1, timestampUs: 0 };
         }
@@ -278,8 +393,8 @@ export default class AttributeHandler {
             timestampUs = structUnpack(">I", tsBuffer)[0] as number * this.POLL_RESULT_RESOLUTION_US;
         }
 
-        // Check if time is before lastReportTimeMs - in which case a wrap around occurred to add on the max value
-        if (timestampUs < timestampWrapHandler.lastReportTimestampUs) {
+        // 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 ) {
             timestampWrapHandler.reportTimestampOffsetUs += this.POLL_RESULT_WRAP_VALUE * this.POLL_RESULT_RESOLUTION_US;
         }
         timestampWrapHandler.lastReportTimestampUs = timestampUs;
@@ -294,5 +409,42 @@ export default class AttributeHandler {
         return { newBufIdx: msgBufIdx, timestampUs: timestampUs };
     }
 
+    // Helper method to check if a value is in a range string like "42,43,44-45,47"
+    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') ? 
+                    parseInt(startStr, 16) : parseInt(startStr, 10);
+                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') ? 
+                    parseInt(part, 16) : parseInt(part, 10);
+                
+                if (!isNaN(partValue) && roundedValue === partValue) {
+                    return true;
+                }
+            }
+        }
+        
+        return false;
+    }
 
 }

package/src/RaftChannel.ts

@@ -22,6 +22,8 @@ export default interface RaftChannel
     setMsgHandler(raftMsgHandler: RaftMsgHandler): void;
     sendTxMsg(msg: Uint8Array, sendWithResponse: boolean): Promise<boolean>;
     sendTxMsgNoAwait(msg: Uint8Array, sendWithResponse: boolean): Promise<boolean>;
+    sendTxMsgRaw(msg: string): boolean;
+    sendTxMsgRawAndWaitForReply<T>(msgPayload: Uint8Array): T;
     requiresSubscription(): boolean;
     ricRestCmdBeforeDisconnect(): string | null;
     fhBatchAckSize(): number;