@robotical/raftjs 2.0.5 → 2.0.7

package/src/RaftChannelSimulated.ts

@@ -296,49 +296,62 @@ export default class RaftChannelSimulated implements RaftChannel {
     dataView.setUint16(bytePos, deviceTimeMs % 65536, false);
     bytePos += 2;
 
-    const numAttributes = attributes.length;
-    const numSamplesPerCycle = 10;
-    const frequencyHz = (deviceIntervalMs > 0)
-      ? (1000 / deviceIntervalMs) / numSamplesPerCycle
-      : 0.1;
-    const timeRadians = deviceTimeMs * frequencyHz * (2 * Math.PI) / 1000;
-
-    // Iterate through attributes and fill the payload
-    for (let attrIdx = 0; attrIdx < numAttributes; attrIdx++) {
-      const attr = attributes[attrIdx];
-      const { typeCode, repeatCount, littleEndian } = this._parseAttrType(attr.t);
-      const scaledValues = this._generateAttributeScaledValues(
-        attr,
-        attrIdx,
-        repeatCount,
-        numAttributes,
-        timeRadians,
-        deviceTimeMs
-      );
-
-      if (scaledValues.length !== repeatCount) {
-        RaftLog.warn(`RaftChannelSimulated._createSimulatedDeviceInfoMsg - value count mismatch for ${attr.n}`);
-        continue;
-      }
-
-      for (let elemIdx = 0; elemIdx < repeatCount; elemIdx++) {
-        const scaledValue = scaledValues[elemIdx];
-        const rawValue = this._prepareRawValue(attr, typeCode, scaledValue);
-        const nextBytePos = this._writeRawValueToBuffer(
-          dataView,
-          bytePos,
-          typeCode,
-          littleEndian,
-          rawValue
+    const handledByCustomGenerator = this._fillCustomRawData(
+      deviceTypeInfo,
+      dataView,
+      bytePos,
+      dataBlockSizeBytes,
+      deviceIntervalMs,
+      deviceTimeMs
+    );
+
+    if (!handledByCustomGenerator) {
+      const numAttributes = attributes.length;
+      const numSamplesPerCycle = 10;
+      const frequencyHz = (deviceIntervalMs > 0)
+        ? (1000 / deviceIntervalMs) / numSamplesPerCycle
+        : 0.1;
+      const timeRadians = deviceTimeMs * frequencyHz * (2 * Math.PI) / 1000;
+
+      // Iterate through attributes and fill the payload
+      for (let attrIdx = 0; attrIdx < numAttributes; attrIdx++) {
+        const attr = attributes[attrIdx];
+        const { typeCode, repeatCount, littleEndian } = this._parseAttrType(attr.t);
+        const scaledValues = this._generateAttributeScaledValues(
+          attr,
+          attrIdx,
+          repeatCount,
+          numAttributes,
+          timeRadians,
+          deviceTimeMs
         );
 
-        if (nextBytePos < 0) {
-          RaftLog.warn(`RaftChannelSimulated._createSimulatedDeviceInfoMsg - buffer overflow writing ${attr.n}`);
-          break;
+        if (scaledValues.length !== repeatCount) {
+          RaftLog.warn(`RaftChannelSimulated._createSimulatedDeviceInfoMsg - value count mismatch for ${attr.n}`);
+          continue;
         }
 
-        bytePos = nextBytePos;
+        for (let elemIdx = 0; elemIdx < repeatCount; elemIdx++) {
+          const scaledValue = scaledValues[elemIdx];
+          const rawValue = this._prepareRawValue(attr, typeCode, scaledValue);
+          const nextBytePos = this._writeRawValueToBuffer(
+            dataView,
+            bytePos,
+            typeCode,
+            littleEndian,
+            rawValue
+          );
+
+          if (nextBytePos < 0) {
+            RaftLog.warn(`RaftChannelSimulated._createSimulatedDeviceInfoMsg - buffer overflow writing ${attr.n}`);
+            break;
+          }
+
+          bytePos = nextBytePos;
+        }
       }
+    } else {
+      bytePos += dataBlockSizeBytes;
     }
 
     // Convert the buffer to a byte array
@@ -471,6 +484,80 @@ export default class RaftChannelSimulated implements RaftChannel {
     return values;
   }
 
+  private _fillCustomRawData(
+    deviceTypeInfo: DeviceTypeInfo,
+    dataView: DataView,
+    bytePos: number,
+    dataBlockSizeBytes: number,
+    deviceIntervalMs: number,
+    deviceTimeMs: number
+  ): boolean {
+    switch (deviceTypeInfo.type) {
+      case "LTR-329": {
+        if (dataBlockSizeBytes < 4) {
+          return false;
+        }
+
+        const frequencyHz = (deviceIntervalMs > 0)
+          ? (1000 / deviceIntervalMs) / 10
+          : 0.1;
+        const timeRadians = deviceTimeMs * frequencyHz * (2 * Math.PI) / 1000;
+
+        const range = deviceTypeInfo.resp?.a?.[0]?.r ?? [0, 64000];
+        const minLux = range[0] ?? 0;
+        const maxLux = range[1] ?? 64000;
+
+        const baseLux = (maxLux + minLux) / 4;
+        const amplitudeLux = (maxLux - minLux) / 6;
+        let combined = Math.round(baseLux + amplitudeLux * Math.sin(timeRadians));
+        combined = Math.max(minLux, Math.min(maxLux, combined));
+
+        const irBase = combined * 0.35;
+        const irVariance = (combined * 0.15) * Math.sin(timeRadians + Math.PI / 4);
+        let ir = Math.round(irBase + irVariance);
+        ir = Math.max(minLux, Math.min(combined, ir));
+
+        dataView.setUint16(bytePos, combined, true);
+        dataView.setUint16(bytePos + 2, ir, true);
+
+        return true;
+      }
+      case "RoboticalServo": {
+        if (dataBlockSizeBytes < 6) {
+          return false;
+        }
+
+        const swingAmplitudeDeg = 90;
+        const cycleMs = 4000;
+        const angularSpeedRadPerMs = (2 * Math.PI) / cycleMs;
+        const phaseRadians = (deviceTimeMs % cycleMs) * angularSpeedRadPerMs;
+
+        const angleDegrees = swingAmplitudeDeg * Math.sin(phaseRadians);
+        const velocityDegPerSec = swingAmplitudeDeg * angularSpeedRadPerMs * 1000 * Math.cos(phaseRadians);
+        const clamp = (value: number, min: number, max: number) => Math.max(min, Math.min(max, value));
+
+        const angleRaw = clamp(Math.round(angleDegrees * 10), -1800, 1800);
+        let velocityRaw = Math.round(velocityDegPerSec);
+        velocityRaw = clamp(velocityRaw, -32768, 32767);
+
+        let currentRaw = Math.round(20 + 0.08 * Math.abs(velocityDegPerSec));
+        currentRaw = clamp(currentRaw, 0, 127);
+
+        const isMoving = Math.abs(velocityDegPerSec) > 5;
+        const stateRaw = (0x02) | (isMoving ? 0x01 : 0);
+
+        dataView.setInt16(bytePos, angleRaw, false);
+        dataView.setInt8(bytePos + 2, currentRaw);
+        dataView.setUint8(bytePos + 3, stateRaw);
+        dataView.setInt16(bytePos + 4, velocityRaw, false);
+
+        return true;
+      }
+      default:
+        return false;
+    }
+  }
+
   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);
@@ -723,6 +810,102 @@ export default class RaftChannelSimulated implements RaftChannel {
               }
           ]
        }
+    },
+    "LTR-329": {
+      "name": "LTR-329",
+      "desc": "Visible light and IR Sensor",
+      "manu": "Lite On",
+      "type": "LTR-329",
+      "clas": ["LGHT"],
+      "resp": {
+        "b": 4,
+        "a": [
+          {
+            "n": "ir",
+            "t": "<h",
+            "u": "lux",
+            "r": [0, 64000],
+            "f": "d",
+            "o": "uint16"
+          },
+          {
+            "n": "visible",
+            "t": "<h",
+            "u": "lux",
+            "r": [0, 64000],
+            "f": "d",
+            "o": "uint16"
+          }
+        ],
+        "c": {
+          "n": "ltr329_light_calc",
+          "c": "int combined = buf[0] + (((uint16_t)buf[1])<<8); out.ir = buf[2] + (((uint16_t)buf[3])<<8); out.visible = combined - out.ir;",
+          "j": "let combined = buf[0] + (buf[1] << 8); let ir = buf[2] + (buf[3] << 8); attrValues['ir'].push(ir); attrValues['visible'].push(Math.max(0, combined - ir));"
+        }
+      }
+    },
+    "RoboticalServo": {
+      "name": "Robotical Servo",
+      "desc": "Servo",
+      "manu": "Robotical",
+      "type": "RoboticalServo",
+      "clas": ["SRVO"],
+      "resp": {
+        "b": 6,
+        "a": [
+          {
+            "n": "angle",
+            "t": ">h",
+            "r": [-180.0, 180.0],
+            "f": ".1f",
+            "d": 10,
+            "o": "int16",
+            "u": "degrees"
+          },
+          {
+            "n": "current",
+            "t": "b",
+            "r": [-128, 127],
+            "f": "d",
+            "o": "int8"
+          },
+          {
+            "n": "state",
+            "t": "B",
+            "r": [0, 255],
+            "f": "02x",
+            "o": "uint8"
+          },
+          {
+            "n": "velocity",
+            "t": ">h",
+            "r": [-32768, 32767],
+            "f": "d",
+            "o": "int16"
+          }
+        ]
+      },
+      "actions": [
+        {
+          "n": "angle",
+          "t": ">h",
+          "w": "0001",
+          "wz": "0064",
+          "f": ".1f",
+          "mul": 10,
+          "sub": 0,
+          "r": [-180.0, 180.0],
+          "d": 0
+        },
+        {
+          "n": "enable",
+          "t": "B",
+          "w": "20",
+          "f": "b",
+          "r": [0, 1],
+          "d": 1
+        }
+      ]
     }
   };
  

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

@@ -79,6 +79,7 @@ export interface DeviceTypeAttribute {
 export interface CustomFunctionDefinition {
     n: string;                      // Function name
     c: string;                      // Function pseudo-code
+    j?: string;                     // Optional JavaScript implementation
 }
 
 export interface DeviceTypePollRespMetadata {