@robotical/raftjs 2.0.4 → 2.0.6

package/src/RaftCustomAttrHandler.ts

@@ -7,23 +7,32 @@
 //
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-import { DeviceTypePollRespMetadata } from "./RaftDeviceInfo";
+import { CustomFunctionDefinition, DeviceTypePollRespMetadata } from "./RaftDeviceInfo";
+
+type CustomAttrJsFn = (
+    buf: Uint8Array,
+    attrValues: Record<string, number[]>,
+    attrValueVecs: number[][],
+    pollRespMetadata: DeviceTypePollRespMetadata,
+    msgBuffer: Uint8Array,
+    msgBufIdx: number,
+    numMsgBytes: number
+) => void;
 
 export default class CustomAttrHandler {
+
+    private _jsFunctionCache = new Map<string, CustomAttrJsFn>();
     
     public handleAttr(pollRespMetadata: DeviceTypePollRespMetadata, msgBuffer: Uint8Array, msgBufIdx: number): number[][] {
 
-        // Implement the pseudo-code:
-        // int N=(buf[0]+32-buf[2])%32;int k=3;int i=0;while(i<N){out.Red=(buf[k]<<16)|(buf[k+1]<<8)|buf[k+2];out.IR=(buf[k+3]<<16)|(buf[k+4]<<8)|buf[k+5];k+=6;i++;next;}
-        
-        // Number of bytes in the each message
+        // Number of bytes in each message
         const numMsgBytes = pollRespMetadata.b;
 
         // Create a vector for each attribute in the metadata
-        const attrValueVecs: [][] = [];
+        const attrValueVecs: number[][] = [];
 
         // Reference to each vector by attribute name
-        const attrValues: { [key: string]: number[] } = {};
+        const attrValues: Record<string, number[]> = {};
 
         // Add attributes to the vector
         for (let attrIdx = 0; attrIdx < pollRespMetadata.a.length; attrIdx++) {
@@ -31,41 +40,78 @@ export default class CustomAttrHandler {
             attrValues[pollRespMetadata.a[attrIdx].n] = attrValueVecs[attrIdx];
         }
 
-        // Custom code for each device type
-        if (pollRespMetadata.c!.n === "max30101_fifo") {
-            // Hex dump msgBuffer
-            // console.log(`CustomAttrHandler handleAttr ${pollRespMetadata.c!.n} msgBuffer: ${msgBuffer.toString('hex')}`); 
-            const buf = msgBuffer.slice(msgBufIdx);
-            if (buf.length < numMsgBytes) {
-                return [];
+        const customFnDef = pollRespMetadata.c;
+        if (!customFnDef) {
+            return attrValueVecs;
+        }
+
+        // Provide the message buffer sliced to the data portion
+        const buf = msgBuffer.slice(msgBufIdx);
+        if (buf.length < numMsgBytes) {
+            return [];
+        }
+
+        // Execute supplied JS implementation if provided
+        if (customFnDef.j && customFnDef.j.trim().length > 0) {
+            const jsFn = this.getOrCompileJsFunction(customFnDef);
+            if (!jsFn) {
+                return attrValueVecs;
+            }
+            try {
+                jsFn(buf, attrValues, attrValueVecs, pollRespMetadata, msgBuffer, msgBufIdx, numMsgBytes);
+            } catch (err) {
+                console.error(`CustomAttrHandler JS function ${customFnDef.n} execution failed`, err);
             }
+            return attrValueVecs;
+        }
 
+        // Custom code for each device type handled natively
+        if (customFnDef.n === "max30101_fifo") {
             // Generated code ...
-            const N=(buf[0]+32-buf[2])%32;
-            let k=3;
-            let i=0;
-            while (i<N) {
-                attrValues['Red'].push(0); attrValues['Red'][attrValues['Red'].length-1] =(buf[k]<<16)|(buf[k+1]<<8)|buf[k+2];
-                attrValues['IR'].push(0); attrValues['IR'][attrValues['IR'].length-1] =(buf[k+3]<<16)|(buf[k+4]<<8)|buf[k+5];
-                k+=6;
+            const N = (buf[0] + 32 - buf[2]) % 32;
+            let k = 3;
+            let i = 0;
+            while (i < N) {
+                attrValues["Red"].push(0);
+                attrValues["Red"][attrValues["Red"].length - 1] = (buf[k] << 16) | (buf[k + 1] << 8) | buf[k + 2];
+                attrValues["IR"].push(0);
+                attrValues["IR"][attrValues["IR"].length - 1] = (buf[k + 3] << 16) | (buf[k + 4] << 8) | buf[k + 5];
+                k += 6;
                 i++;
-                ;
-            }            
-        } else if (pollRespMetadata.c!.n === "gravity_o2_calc") {
-            // Get the buffer
-            const buf = msgBuffer.slice(msgBufIdx);
-            if (buf.length < numMsgBytes) {
-                return [];
             }
-
-            // Implement the pseudo-code:
-            // float key = 20.9/120.0; float val = key * (buf[0] + (buf[1]/10.0) + (buf[2]/100.0)); out.oxygen = val;
+        } else if (customFnDef.n === "gravity_o2_calc") {
             const key = 20.9 / 120.0;
-            const val = key * (buf[0] + (buf[1] / 10.0) + (buf[2] / 100.0));
-            
-            // Add the value to the oxygen attribute
-            attrValues['oxygen'].push(val);
+            const val = key * (buf[0] + buf[1] / 10.0 + buf[2] / 100.0);
+            attrValues["oxygen"].push(val);
         }
         return attrValueVecs;
     }
+
+    private getOrCompileJsFunction(customFnDef: CustomFunctionDefinition): CustomAttrJsFn | null {
+        if (!customFnDef.j) {
+            return null;
+        }
+        const cacheKey = `${customFnDef.n}::${customFnDef.j}`;
+        const cachedFn = this._jsFunctionCache.get(cacheKey);
+        if (cachedFn) {
+            return cachedFn;
+        }
+        try {
+            const compiledFn = new Function(
+                "buf",
+                "attrValues",
+                "attrValueVecs",
+                "pollRespMetadata",
+                "msgBuffer",
+                "msgBufIdx",
+                "numMsgBytes",
+                customFnDef.j
+            ) as CustomAttrJsFn;
+            this._jsFunctionCache.set(cacheKey, compiledFn);
+            return compiledFn;
+        } catch (err) {
+            console.error(`CustomAttrHandler failed to compile JS function ${customFnDef.n}`, err);
+            return null;
+        }
+    }
 }

package/src/RaftDeviceInfo.ts

@@ -73,11 +73,13 @@ export interface DeviceTypeAttribute {
     vf?: boolean | number;          // Display attribute value in the device info panel
     vft?: string;                   // Attribute validity based on the value of another named attribute
     lut?: Array<LUTRow>;            // Lookup table for the attribute value - each row is a lookup table for a range of values e.g. [{"r":"0x20-0x30","v":0},{"r":"1,2,3","v":42},{r:"","v":1}]
+    resolution?: string;            
 }
 
 export interface CustomFunctionDefinition {
     n: string;                      // Function name
     c: string;                      // Function pseudo-code
+    j?: string;                     // Optional JavaScript implementation
 }
 
 export interface DeviceTypePollRespMetadata {