@robdobsn/raftjs 1.8.5 → 1.10.7

package/src/RaftCustomAttrHandler.ts

@@ -0,0 +1,117 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// RaftCustomAttrHandler
+// Custom attribute handler for Raft devices
+//
+// Rob Dobson (C) 2024
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+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[][] {
+
+        // Number of bytes in each message
+        const numMsgBytes = pollRespMetadata.b;
+
+        // Create a vector for each attribute in the metadata
+        const attrValueVecs: number[][] = [];
+
+        // Reference to each vector by attribute name
+        const attrValues: Record<string, number[]> = {};
+
+        // Add attributes to the vector
+        for (let attrIdx = 0; attrIdx < pollRespMetadata.a.length; attrIdx++) {
+            attrValueVecs.push([]);
+            attrValues[pollRespMetadata.a[attrIdx].n] = attrValueVecs[attrIdx];
+        }
+
+        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;
+                i++;
+            }
+        } 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);
+            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

@@ -0,0 +1,125 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// RaftDeviceInfo
+// Device information for Raft devices
+//
+// Rob Dobson (C) 2024
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+const attrTypeBits: { [key: string]: number } = {
+    "c": 8, "b": 8, "B": 8, "?": 8,
+    "h": 16, "H": 16, ">h": 16, "<h": 16, ">H": 16, "<H": 16,
+    "i": 32, "I": 32, ">i": 32, "<i": 32, ">I": 32, "<I": 32, "l": 32, "L": 32, ">l": 32, "<l": 32, ">L": 32, "<L": 32,
+    "q": 64, "Q": 64, ">q": 64, "<q": 64, ">Q": 64, "<Q": 64,
+    "f": 32, ">f": 32, "<f": 32,
+    "d": 64, ">d": 64, "<d": 64,
+    };
+
+export function getAttrTypeBits(attrType: string): number {
+    let repeat = 1;
+    let baseAttrType = attrType;
+
+    const repeatStartIdx = attrType.indexOf("[");
+    if (repeatStartIdx >= 0) {
+        const repeatEndIdx = attrType.indexOf("]", repeatStartIdx + 1);
+        if (repeatEndIdx > repeatStartIdx) {
+            const repeatStr = attrType.slice(repeatStartIdx + 1, repeatEndIdx);
+            const parsedRepeat = parseInt(repeatStr, 10);
+            if (Number.isFinite(parsedRepeat) && parsedRepeat > 0) {
+                repeat = parsedRepeat;
+            }
+            baseAttrType = attrType.slice(0, repeatStartIdx);
+        }
+    }
+
+    if (baseAttrType in attrTypeBits) {
+        return attrTypeBits[baseAttrType] * repeat;
+    }
+    return 8 * repeat;
+}
+
+export function isAttrTypeSigned(attrType: string): boolean {
+    const attrStr = attrType.charAt(0) === ">" || attrType.charAt(0) === "<" ? attrType.slice(1).charAt(0) : attrType.charAt(0);
+    return attrStr === "b" || attrStr === "h" || attrStr === "i" || attrStr === "l" || attrStr === "q";
+}
+
+export function decodeAttrUnitsEncoding(unitsEncoding: string): string {
+    // Replace instances of HTML encoded chars like &deg; with the actual char
+    return unitsEncoding.replace(/&deg;/g, "°");
+}
+
+export interface LUTRow {
+    r: string;
+    v: number;
+}
+export interface DeviceTypeAttribute {
+    n: string;                      // Name
+    t: string;                      // Type in python struct module format (e.g. 'H' uint16, 'h' int16, 'f' float etc.)
+    at?: number | number[];         // Start pos in buffer (after timestamp) if present (otherwise use relative position) or array of byte positions for non-contiguous data
+    u?: string;                     // Units (e.g. mm)
+    r?: number[];                   // Range (either min, max or min, max, step or discrete values)
+    x?: number | string;            // XOR bit mask to invert bits in the attribute value
+    m?: number | string;            // AND bit mask to extract the attribute value from the message
+    s?: number;                     // Shift value to shift the attribute value to the right (or left if negative)
+    sb?: number;                    // Sign-bit position (0-based)
+    ss?: number;                    // Sign-bit subtraction value
+    d?: number;                     // Divisor to convert the raw attribute value (after operations above) to the actual value
+    a?: number;                     // Value to add after division
+    f?: string;                     // Format string similar to C printf format string (e.g. %d, %x, %f, %04d, %08x, %08.2f etc.), %b = boolean (0 iff 0, else 1)
+    o?: string;                     // Type of output value (e.g. 'bool', 'uint8', 'float')
+    v?: boolean | number;           // Visibility of the attribute in all locations (mainly used to hide attributes that are not useful to the user)
+    vs?: boolean | number;          // Display attribute value in time-series graphs
+    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 {
+    b: number;                      // Size of polled response data block in bytes (excluding timestamp)
+    a: DeviceTypeAttribute[];       // Attributes in the polled response
+    c?: CustomFunctionDefinition;   // Custom function definition
+    us?: number;                    // Time between consecutive samples in microseconds 
+}
+
+export interface DeviceTypeAction {
+    n: string;                      // Action name
+    t?: string;                     // Action type using python struct module format (e.g. 'H' for unsigned short, 'h' for signed short, 'f' for float etc.)
+    w: string;                      // Prefix to write to cmd API
+    wz?: string;                    // Postfix to write to cmd API
+    r?: number[];                   // Range of valid values for the action
+    f?: string;                     // Custom formatting options (e.g. LEDPIX for LED pixel grid)
+    NX?: number;                    // Number of X in the LED pixel grid
+    NY?: number;                    // Number of Y in the LED pixel grid
+    concat?: boolean;               // Concatenate the all values into a single command
+    mul?: number;                   // Multiplier to apply
+    sub?: number;                   // Value to subtract before multiplying
+    d?: number;                     // Default value
+}
+
+export interface DeviceTypeInfo {
+    name: string;
+    desc: string;
+    manu: string;
+    type: string;
+    resp?: DeviceTypePollRespMetadata;
+    clas?: Array<string>;
+    actions?: DeviceTypeAction[];
+}
+
+export interface DeviceTypeInfoRecs {
+    [devType: string]: DeviceTypeInfo;
+}
+
+export type RaftDevTypeInfoResponse = {
+    req: string;
+    rslt: string;
+    devinfo: DeviceTypeInfo;
+  };