@hangtime/grip-connect 0.2.1 → 0.2.6

package/src/stream.js

@@ -0,0 +1,35 @@
+import { isConnected } from "./is-connected";
+import { write } from "./write";
+import { stop } from "./stop";
+import { Motherboard, Progressor } from "./devices";
+import { MotherboardCommands, ProgressorCommands } from "./commands";
+import { CALIBRATION } from "./data";
+import { calibration } from "./calibration";
+/**
+ * stream output
+ * @param board
+ */
+export const stream = async (board, duration = 0) => {
+    if (isConnected(board)) {
+        if (board.name === "Motherboard") {
+            // read calibration (required before reading data)
+            if (!CALIBRATION[0].length) {
+                await calibration(Motherboard);
+            }
+            // start stream
+            await write(Motherboard, "uart", "tx", MotherboardCommands.START_WEIGHT_MEAS, duration);
+            // end stream if duration is set
+            if (duration !== 0) {
+                await stop(Motherboard);
+            }
+        }
+        if (board.name && board.name.startsWith("Progressor")) {
+            // start stream
+            await write(Progressor, "progressor", "tx", ProgressorCommands.START_WEIGHT_MEAS, duration);
+            // end stream if duration is set
+            if (duration !== 0) {
+                await stop(Progressor);
+            }
+        }
+    }
+};

package/src/struct/index.d.ts

@@ -0,0 +1,9 @@
+export default function struct(format: string): Readonly<{
+    unpack: (arrb: ArrayBuffer) => unknown[];
+    pack: (...values: unknown[]) => ArrayBuffer;
+    unpack_from: (arrb: ArrayBuffer, offs: number) => unknown[];
+    pack_into: (arrb: ArrayBuffer, offs: number, ...values: unknown[]) => void;
+    iter_unpack: (arrb: ArrayBuffer) => IterableIterator<unknown[]>;
+    format: string;
+    size: number;
+}>;

package/src/struct/index.js

@@ -0,0 +1,176 @@
+const rechk = /^([<>])?(([1-9]\d*)?([xcbB?hHiIfdsp]))*$/;
+const refmt = /([1-9]\d*)?([xcbB?hHiIfdsp])/g;
+const str = (v, o, c) => String.fromCharCode(...Array.from(new Uint8Array(v.buffer, v.byteOffset + o, c)));
+const rts = (v, o, c, s) => new Uint8Array(v.buffer, v.byteOffset + o, c).set(s.split("").map((str) => str.charCodeAt(0)));
+const pst = (v, o, c) => str(v, o + 1, Math.min(v.getUint8(o), c - 1));
+const tsp = (v, o, c, s) => {
+    v.setUint8(o, s.length);
+    rts(v, o + 1, c - 1, s);
+};
+const lut = (le) => ({
+    x: (c) => [
+        1,
+        c,
+        () => ({
+            u: () => undefined,
+            p: () => undefined,
+        }),
+    ],
+    c: (c) => [
+        c,
+        1,
+        (o) => ({
+            u: (v) => str(v, o, 1),
+            p: (v, s) => rts(v, o, 1, s),
+        }),
+    ],
+    "?": (c) => [
+        c,
+        1,
+        (o) => ({
+            u: (v) => Boolean(v.getUint8(o)),
+            p: (v, B) => v.setUint8(o, B ? 1 : 0),
+        }),
+    ],
+    b: (c) => [
+        c,
+        1,
+        (o) => ({
+            u: (v) => v.getInt8(o),
+            p: (v, b) => v.setInt8(o, b),
+        }),
+    ],
+    B: (c) => [
+        c,
+        1,
+        (o) => ({
+            u: (v) => v.getUint8(o),
+            p: (v, B) => v.setUint8(o, B),
+        }),
+    ],
+    h: (c) => [
+        c,
+        2,
+        (o) => ({
+            u: (v) => v.getInt16(o, le),
+            p: (v, h) => v.setInt16(o, h, le),
+        }),
+    ],
+    H: (c) => [
+        c,
+        2,
+        (o) => ({
+            u: (v) => v.getUint16(o, le),
+            p: (v, H) => v.setUint16(o, H, le),
+        }),
+    ],
+    i: (c) => [
+        c,
+        4,
+        (o) => ({
+            u: (v) => v.getInt32(o, le),
+            p: (v, i) => v.setInt32(o, i, le),
+        }),
+    ],
+    I: (c) => [
+        c,
+        4,
+        (o) => ({
+            u: (v) => v.getUint32(o, le),
+            p: (v, I) => v.setUint32(o, I, le),
+        }),
+    ],
+    f: (c) => [
+        c,
+        4,
+        (o) => ({
+            u: (v) => v.getFloat32(o, le),
+            p: (v, f) => v.setFloat32(o, f, le),
+        }),
+    ],
+    d: (c) => [
+        c,
+        8,
+        (o) => ({
+            u: (v) => v.getFloat64(o, le),
+            p: (v, d) => v.setFloat64(o, d, le),
+        }),
+    ],
+    s: (c) => [
+        1,
+        c,
+        (o) => ({
+            u: (v) => str(v, o, c),
+            p: (v, s) => rts(v, o, c, s.slice(0, c)),
+        }),
+    ],
+    p: (c) => [
+        1,
+        c,
+        (o) => ({
+            u: (v) => pst(v, o, c),
+            p: (v, s) => tsp(v, o, c, s.slice(0, c - 1)),
+        }),
+    ],
+});
+const errbuf = new RangeError("Structure larger than remaining buffer");
+const errval = new RangeError("Not enough values for structure");
+export default function struct(format) {
+    const fns = [];
+    let size = 0;
+    let m = rechk.exec(format);
+    if (!m) {
+        throw new RangeError("Invalid format string");
+    }
+    const t = lut("<" === m[1]);
+    const lu = (n, c) => t[c](n ? parseInt(n, 10) : 1);
+    while ((m = refmt.exec(format))) {
+        // eslint-disable-next-line no-extra-semi
+        ;
+        ((r, s, f) => {
+            for (let i = 0; i < r; ++i, size += s) {
+                if (f) {
+                    fns.push(f(size));
+                }
+            }
+        })(...lu(...m.slice(1)));
+    }
+    const unpack_from = (arrb, offs) => {
+        if (arrb.byteLength < (offs | 0) + size) {
+            throw errbuf;
+        }
+        const v = new DataView(arrb, offs | 0);
+        return fns.map((f) => f.u(v));
+    };
+    const pack_into = (arrb, offs, ...values) => {
+        if (values.length < fns.length) {
+            throw errval;
+        }
+        if (arrb.byteLength < offs + size) {
+            throw errbuf;
+        }
+        const v = new DataView(arrb, offs);
+        new Uint8Array(arrb, offs, size).fill(0);
+        fns.forEach((f, i) => f.p(v, values[i]));
+    };
+    const pack = (...values) => {
+        const b = new ArrayBuffer(size);
+        pack_into(b, 0, ...values);
+        return b;
+    };
+    const unpack = (arrb) => unpack_from(arrb, 0);
+    function* iter_unpack(arrb) {
+        for (let offs = 0; offs + size <= arrb.byteLength; offs += size) {
+            yield unpack_from(arrb, offs);
+        }
+    }
+    return Object.freeze({
+        unpack,
+        pack,
+        unpack_from,
+        pack_into,
+        iter_unpack,
+        format,
+        size,
+    });
+}

package/src/struct/index.ts

@@ -0,0 +1,215 @@
+const rechk: RegExp = /^([<>])?(([1-9]\d*)?([xcbB?hHiIfdsp]))*$/
+const refmt: RegExp = /([1-9]\d*)?([xcbB?hHiIfdsp])/g
+
+const str = (v: DataView, o: number, c: number): string =>
+  String.fromCharCode(...Array.from(new Uint8Array(v.buffer, v.byteOffset + o, c)))
+
+const rts = (v: DataView, o: number, c: number, s: string): void =>
+  new Uint8Array(v.buffer, v.byteOffset + o, c).set(s.split("").map((str) => str.charCodeAt(0)))
+
+const pst = (v: DataView, o: number, c: number): string => str(v, o + 1, Math.min(v.getUint8(o), c - 1))
+
+const tsp = (v: DataView, o: number, c: number, s: string): void => {
+  v.setUint8(o, s.length)
+  rts(v, o + 1, c - 1, s)
+}
+
+interface FormatFn {
+  u: (v: DataView) => unknown
+  p: (v: DataView, value: unknown) => void
+}
+
+interface LUT {
+  [key: string]: (c: number) => [number, number, (o: number) => FormatFn]
+}
+
+const lut = (le: boolean): LUT => ({
+  x: (c: number) =>
+    [
+      1,
+      c,
+      () => ({
+        u: () => undefined,
+        p: () => undefined,
+      }),
+    ] as [number, number, (o: number) => FormatFn],
+  c: (c: number) =>
+    [
+      c,
+      1,
+      (o: number) => ({
+        u: (v: DataView) => str(v, o, 1),
+        p: (v: DataView, s: string) => rts(v, o, 1, s),
+      }),
+    ] as [number, number, (o: number) => FormatFn],
+  "?": (c: number) =>
+    [
+      c,
+      1,
+      (o: number) => ({
+        u: (v: DataView) => Boolean(v.getUint8(o)),
+        p: (v: DataView, B: boolean) => v.setUint8(o, B ? 1 : 0),
+      }),
+    ] as [number, number, (o: number) => FormatFn],
+  b: (c: number) =>
+    [
+      c,
+      1,
+      (o: number) => ({
+        u: (v: DataView) => v.getInt8(o),
+        p: (v: DataView, b: number) => v.setInt8(o, b),
+      }),
+    ] as [number, number, (o: number) => FormatFn],
+  B: (c: number) =>
+    [
+      c,
+      1,
+      (o: number) => ({
+        u: (v: DataView) => v.getUint8(o),
+        p: (v: DataView, B: number) => v.setUint8(o, B),
+      }),
+    ] as [number, number, (o: number) => FormatFn],
+  h: (c: number) =>
+    [
+      c,
+      2,
+      (o: number) => ({
+        u: (v: DataView) => v.getInt16(o, le),
+        p: (v: DataView, h: number) => v.setInt16(o, h, le),
+      }),
+    ] as [number, number, (o: number) => FormatFn],
+  H: (c: number) =>
+    [
+      c,
+      2,
+      (o: number) => ({
+        u: (v: DataView) => v.getUint16(o, le),
+        p: (v: DataView, H: number) => v.setUint16(o, H, le),
+      }),
+    ] as [number, number, (o: number) => FormatFn],
+  i: (c: number) =>
+    [
+      c,
+      4,
+      (o: number) => ({
+        u: (v: DataView) => v.getInt32(o, le),
+        p: (v: DataView, i: number) => v.setInt32(o, i, le),
+      }),
+    ] as [number, number, (o: number) => FormatFn],
+  I: (c: number) =>
+    [
+      c,
+      4,
+      (o: number) => ({
+        u: (v: DataView) => v.getUint32(o, le),
+        p: (v: DataView, I: number) => v.setUint32(o, I, le),
+      }),
+    ] as [number, number, (o: number) => FormatFn],
+  f: (c: number) =>
+    [
+      c,
+      4,
+      (o: number) => ({
+        u: (v: DataView) => v.getFloat32(o, le),
+        p: (v: DataView, f: number) => v.setFloat32(o, f, le),
+      }),
+    ] as [number, number, (o: number) => FormatFn],
+  d: (c: number) =>
+    [
+      c,
+      8,
+      (o: number) => ({
+        u: (v: DataView) => v.getFloat64(o, le),
+        p: (v: DataView, d: number) => v.setFloat64(o, d, le),
+      }),
+    ] as [number, number, (o: number) => FormatFn],
+  s: (c: number) =>
+    [
+      1,
+      c,
+      (o: number) => ({
+        u: (v: DataView) => str(v, o, c),
+        p: (v: DataView, s: string) => rts(v, o, c, s.slice(0, c)),
+      }),
+    ] as [number, number, (o: number) => FormatFn],
+  p: (c: number) =>
+    [
+      1,
+      c,
+      (o: number) => ({
+        u: (v: DataView) => pst(v, o, c),
+        p: (v: DataView, s: string) => tsp(v, o, c, s.slice(0, c - 1)),
+      }),
+    ] as [number, number, (o: number) => FormatFn],
+})
+
+const errbuf: RangeError = new RangeError("Structure larger than remaining buffer")
+const errval: RangeError = new RangeError("Not enough values for structure")
+
+export default function struct(format: string) {
+  const fns: FormatFn[] = []
+  let size: number = 0
+  let m: RegExpExecArray | null = rechk.exec(format)
+
+  if (!m) {
+    throw new RangeError("Invalid format string")
+  }
+
+  const t: LUT = lut("<" === m[1])
+  const lu = (n: string, c: string): [number, number, (o: number) => FormatFn] => t[c](n ? parseInt(n, 10) : 1)
+
+  while ((m = refmt.exec(format))) {
+    // eslint-disable-next-line no-extra-semi
+    ;((r: number, s: number, f: (o: number) => FormatFn) => {
+      for (let i = 0; i < r; ++i, size += s) {
+        if (f) {
+          fns.push(f(size))
+        }
+      }
+    })(...lu(...(m.slice(1) as [string, string])))
+  }
+
+  const unpack_from = (arrb: ArrayBuffer, offs: number): unknown[] => {
+    if (arrb.byteLength < (offs | 0) + size) {
+      throw errbuf
+    }
+    const v = new DataView(arrb, offs | 0)
+    return fns.map((f) => f.u(v))
+  }
+
+  const pack_into = (arrb: ArrayBuffer, offs: number, ...values: unknown[]): void => {
+    if (values.length < fns.length) {
+      throw errval
+    }
+    if (arrb.byteLength < offs + size) {
+      throw errbuf
+    }
+    const v = new DataView(arrb, offs)
+    new Uint8Array(arrb, offs, size).fill(0)
+    fns.forEach((f, i) => f.p(v, values[i]))
+  }
+
+  const pack = (...values: unknown[]): ArrayBuffer => {
+    const b = new ArrayBuffer(size)
+    pack_into(b, 0, ...values)
+    return b
+  }
+
+  const unpack = (arrb: ArrayBuffer): unknown[] => unpack_from(arrb, 0)
+
+  function* iter_unpack(arrb: ArrayBuffer): IterableIterator<unknown[]> {
+    for (let offs = 0; offs + size <= arrb.byteLength; offs += size) {
+      yield unpack_from(arrb, offs)
+    }
+  }
+
+  return Object.freeze({
+    unpack,
+    pack,
+    unpack_from,
+    pack_into,
+    iter_unpack,
+    format,
+    size,
+  })
+}

package/src/write.d.ts

@@ -0,0 +1,8 @@
+import { Device } from "./devices/types";
+export declare let lastWrite: string | null;
+/**
+ * write
+ * @param characteristic
+ * @param message
+ */
+export declare const write: (board: Device, serviceId: string, characteristicId: string, message: string | undefined, duration?: number) => Promise<void>;

package/src/write.js

@@ -0,0 +1,41 @@
+import { isConnected } from "./is-connected";
+import { getCharacteristic } from "./characteristic";
+export let lastWrite = null;
+/**
+ * write
+ * @param characteristic
+ * @param message
+ */
+export const write = (board, serviceId, characteristicId, message, duration = 0) => {
+    return new Promise((resolve, reject) => {
+        if (isConnected(board)) {
+            if (!message)
+                return;
+            const characteristic = getCharacteristic(board, serviceId, characteristicId);
+            if (characteristic) {
+                const encoder = new TextEncoder();
+                characteristic
+                    .writeValue(encoder.encode(message))
+                    .then(() => {
+                    // update last written message
+                    lastWrite = message;
+                    // handle timeout
+                    if (duration !== 0) {
+                        setTimeout(() => {
+                            resolve();
+                        }, duration);
+                    }
+                })
+                    .catch((error) => {
+                    reject(error);
+                });
+            }
+            else {
+                reject(new Error("Characteristics is undefined"));
+            }
+        }
+        else {
+            reject(new Error("Device is not connected"));
+        }
+    });
+};