@robotical/raftjs 1.4.7 → 2.0.4

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.7",
+  "version": "2.0.4",
   "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;

package/src/RaftChannelBLE.native.ts

@@ -125,7 +125,7 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
 
   async discoveryStart(uuids: string[], tries = 10): Promise<boolean> {
     if (tries <= 0) {
-      RaftLog.debug(`BLEChannel discoveryStart failed after 5 tries`);
+      RaftLog.debug(`BLEChannel discoveryStart failed`);
       return false;
     }
     // Disconnect any existing connection
@@ -363,7 +363,7 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
     try {
       if (this._bleDevice) {
         if (!this._connectedDeviceServiceUUID) {
-          RaftLog.error('BLEChannel _configDeviceConnection - no connected device service UUID');
+          RaftLog.warn('BLEChannel _configDeviceConnection - no connected device service UUID');
           return false;
         }
         this._bleSubscrOnRx = this._bleDevice.monitorCharacteristicForService(
@@ -535,7 +535,7 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
 
       try {
         if (!this._connectedDeviceServiceUUID) {
-          RaftLog.error('BLEChannel sendTxMsg - no connected device service UUID');
+          RaftLog.warn('BLEChannel sendTxMsg - no connected device service UUID');
           return false;
         }
         await this._bleDevice!.writeCharacteristicWithoutResponseForService(
@@ -578,7 +578,7 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
 
       try {
         if (!this._connectedDeviceServiceUUID) {
-          RaftLog.error('BLEChannel sendTxMsgNoAwait - no connected device service UUID');
+          RaftLog.warn('BLEChannel sendTxMsgNoAwait - no connected device service UUID');
           return false;
         }
         this._bleDevice!.writeCharacteristicWithoutResponseForService(
@@ -600,9 +600,18 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
 
   // RICREST command before disconnect
   ricRestCmdBeforeDisconnect(): string | null {
-    // NT: Sending blerestart *before* disconnecting results in timeout issues as the device is no longer connected when we try to actually disconnect
-    // suggested fix: allow callaback command to be sent after disconnect on the fw side 
-    // return "blerestart";
-    return null;
+    return "bledisconnect";
+  }
+
+  // Method used for testing and simulation should never be called
+  sendTxMsgRaw(): boolean {
+    RaftLog.debug(`sendTxMsgRaw - not implemented`);
+    return false;
+  }
+
+  // Method used for testing and simulation should never be called
+  sendTxMsgRawAndWaitForReply<T>(): T {
+    RaftLog.debug(`sendTxMsgRawAndWaitForReply - not implemented`);
+    return null as T;
   }
 }

package/src/RaftChannelBLE.web.ts

@@ -21,7 +21,7 @@ export default class RaftChannelBLE implements RaftChannel {
   _cmdUUID = 'aa76677e-9cfd-4626-a510-0d305be57c8e';
   _respUUID = 'aa76677e-9cfd-4626-a510-0d305be57c8f';
   _serviceUUIDs = ['aa76677e-9cfd-4626-a510-0d305be57c8d', 'da903f65-d5c2-4f4d-a065-d1aade7af874'];
-  
+
   // Device and characteristics
   private _bleDevice: BluetoothDevice | null = null;
   private _characteristicTx: BluetoothRemoteGATTCharacteristic | null = null;
@@ -67,16 +67,13 @@ export default class RaftChannelBLE implements RaftChannel {
 
   // RICREST command before disconnect
   ricRestCmdBeforeDisconnect(): string | null {
-    // NT: Sending blerestart *before* disconnecting results in timeout issues as the device is no longer connected when we try to actually disconnect
-    // suggested fix: allow callaback command to be sent after disconnect on the fw side 
-    // return "blerestart";
-    return null;
+    return "bledisconnect";
   }
 
   // isEnabled
   isEnabled() {
     if (navigator.bluetooth) {
-      RaftLog.error("Web Bluetooth is supported in your browser.");
+      RaftLog.warn("Web Bluetooth is supported in your browser.");
       return true;
     } else {
       window.alert(
@@ -101,7 +98,7 @@ export default class RaftChannelBLE implements RaftChannel {
   onDisconnected(event: Event): void {
     const device = event.target as BluetoothDevice;
     RaftLog.debug(`RaftChannelBLE.onDisconnected ${device.name}`);
-    if (this._bleDevice) {
+    if (this._bleDevice && this._eventListenerFn) {
       this._bleDevice.removeEventListener(
         "gattserverdisconnected",
         this._eventListenerFn
@@ -157,7 +154,7 @@ export default class RaftChannelBLE implements RaftChannel {
               }
 
               if (!service) {
-                RaftLog.error(
+                RaftLog.warn(
                   `RaftChannelBLE.connect - cannot get primary service - giving up`
                 );
                 return false;
@@ -211,13 +208,13 @@ export default class RaftChannelBLE implements RaftChannel {
                 this._isConnected = true;
                 return true;
               } catch (error) {
-                RaftLog.error(
+                RaftLog.warn(
                   `RaftChannelBLE.connect - cannot find characteristic: ${error}`
                 );
               }
             } catch (error) {
               if (connRetry === this._maxConnRetries - 1) {
-                RaftLog.error(
+                RaftLog.warn(
                   `RaftChannelBLE.connect - cannot get primary service ${error} - attempt #${connRetry + 1} - giving up`
                 );
               } else {
@@ -310,12 +307,13 @@ export default class RaftChannelBLE implements RaftChannel {
       // Write to the characteristic
       try {
         if (this._characteristicTx) {
+          const bs = RaftUtils.toBufferSource(msg);
           if (this._characteristicTx.writeValueWithoutResponse) {
-            await this._characteristicTx.writeValueWithoutResponse(msg);
+            await this._characteristicTx.writeValueWithoutResponse(bs);
           } else if (this._characteristicTx.writeValue) {
-            await this._characteristicTx.writeValue(msg);
+            await this._characteristicTx.writeValue(bs);
           } else if (this._characteristicTx.writeValueWithResponse) {
-            await this._characteristicTx.writeValueWithResponse(msg);
+            await this._characteristicTx.writeValueWithResponse(bs);
           }
         }
         break;
@@ -348,15 +346,29 @@ export default class RaftChannelBLE implements RaftChannel {
 
     // Write to the characteristic
     if (this._characteristicTx) {
+      const bs = RaftUtils.toBufferSource(msg);
       if (this._characteristicTx.writeValueWithoutResponse) {
-        this._characteristicTx.writeValueWithoutResponse(msg);
+        this._characteristicTx.writeValueWithoutResponse(bs);
       } else if (this._characteristicTx.writeValue) {
-        this._characteristicTx.writeValue(msg);
+        this._characteristicTx.writeValue(bs);
       } else if (this._characteristicTx.writeValueWithResponse) {
-        this._characteristicTx.writeValueWithResponse(msg);
+        this._characteristicTx.writeValueWithResponse(bs);
       }
       return true;
     }
     return false;
   }
+
+  // Method used for testing and simulation should never be called
+  sendTxMsgRaw(): boolean {
+    RaftLog.debug(`sendTxMsgRaw - not implemented`);
+    return false;
+  }
+
+  // Method used for testing and simulation should never be called
+  sendTxMsgRawAndWaitForReply<T>(): T {
+    RaftLog.debug(`sendTxMsgRawAndWaitForReply - not implemented`);
+    return null as T;
+  }
+
 }