@hangtime/grip-connect 0.3.5 → 0.3.7

package/dist/led.js

@@ -0,0 +1,192 @@
+import { write } from "./write";
+import { isConnected } from "./is-connected";
+import { KilterBoard, Motherboard } from "./devices";
+import { KilterBoardPacket } from "./commands/kilterboard";
+/**
+ * Maximum length of the message body for byte wrapping.
+ */
+const MESSAGE_BODY_MAX_LENGTH = 255;
+/**
+ * Maximum length of the the bluetooth chunk.
+ */
+const MAX_BLUETOOTH_MESSAGE_SIZE = 20;
+/**
+ * Calculates the checksum for a byte array by summing up all bytes ot hre packet in a single-byte variable.
+ * @param data - The array of bytes to calculate the checksum for.
+ * @returns The calculated checksum value.
+ */
+function checksum(data) {
+    let i = 0;
+    for (const value of data) {
+        i = (i + value) & 255;
+    }
+    return ~i & 255;
+}
+/**
+ * Wraps a byte array with header and footer bytes for transmission.
+ * @param data - The array of bytes to wrap.
+ * @returns The wrapped byte array.
+ */
+function wrapBytes(data) {
+    if (data.length > MESSAGE_BODY_MAX_LENGTH) {
+        return [];
+    }
+    /**
+    - 0x1
+    - len(packets)
+    - checksum(packets)
+    - 0x2
+    - *packets
+    - 0x3
+    
+    First byte is always 1, the second is a number of packets, then checksum, then 2, packets themselves, and finally 3.
+     */
+    return [1, data.length, checksum(data), 2, ...data, 3];
+}
+class ClimbPlacement {
+    position;
+    role_id;
+    constructor(position, role_id) {
+        this.position = position;
+        this.role_id = role_id;
+    }
+}
+/**
+ * Encodes a position into a byte array.
+ * The lowest 8 bits of the position get put in the first byte of the group.
+ * The highest 8 bits of the position get put in the second byte of the group.
+ * @param position - The position to encode.
+ * @returns The encoded byte array representing the position.
+ */
+function encodePosition(position) {
+    const position1 = position & 255;
+    const position2 = (position & 65280) >> 8;
+    return [position1, position2];
+}
+/**
+ * Encodes a color string into a numeric representation.
+ * The rgb color, 3 bits for the R and G components, 2 bits for the B component, with the 3 R bits occupying the high end of the byte and the 2 B bits in the low end (hence 3 G bits in the middle).
+ * @param color - The color string in hexadecimal format (e.g., 'FFFFFF').
+ * @returns The encoded /compressed color value.
+ */
+function encodeColor(color) {
+    const substring = color.substring(0, 2);
+    const substring2 = color.substring(2, 4);
+    const parsedSubstring = parseInt(substring, 16) / 32;
+    const parsedSubstring2 = parseInt(substring2, 16) / 32;
+    const parsedResult = (parsedSubstring << 5) | (parsedSubstring2 << 2);
+    const substring3 = color.substring(4, 6);
+    const parsedSubstring3 = parseInt(substring3, 16) / 64;
+    const finalParsedResult = parsedResult | parsedSubstring3;
+    return finalParsedResult;
+}
+/**
+ * Encodes a placement (requires a 16-bit position and a 24-bit rgb color. ) into a byte array.
+ * @param position - The position to encode.
+ * @param ledColor - The color of the LED in hexadecimal format (e.g., 'FFFFFF').
+ * @returns The encoded byte array representing the placement.
+ */
+function encodePlacement(position, ledColor) {
+    return [...encodePosition(position), encodeColor(ledColor)];
+}
+/**
+ * Prepares byte arrays for transmission based on a list of climb placements.
+ * @param climbPlacementList - The list of climb placements containing position and role ID.
+ * @returns The final byte array ready for transmission.
+ */
+export function prepBytesV3(climbPlacementList) {
+    const resultArray = [];
+    let tempArray = [KilterBoardPacket.V3_MIDDLE];
+    for (const climbPlacement of climbPlacementList) {
+        if (tempArray.length + 3 > MESSAGE_BODY_MAX_LENGTH) {
+            resultArray.push(tempArray);
+            tempArray = [KilterBoardPacket.V3_MIDDLE];
+        }
+        const ledColor = climbPlacement.role_id;
+        const encodedPlacement = encodePlacement(climbPlacement.position, ledColor);
+        tempArray.push(...encodedPlacement);
+    }
+    resultArray.push(tempArray);
+    if (resultArray.length === 1) {
+        resultArray[0][0] = KilterBoardPacket.V3_ONLY;
+    }
+    else if (resultArray.length > 1) {
+        resultArray[0][0] = KilterBoardPacket.V3_FIRST;
+        resultArray[resultArray.length - 1][0] = KilterBoardPacket.V3_LAST;
+    }
+    const finalResultArray = [];
+    for (const currentArray of resultArray) {
+        finalResultArray.push(...wrapBytes(currentArray));
+    }
+    return finalResultArray;
+}
+/**
+ * Splits a collection into slices of the specified length.
+ * https://github.com/ramda/ramda/blob/master/source/splitEvery.js
+ * @param {Number} n
+ * @param {Array} list
+ * @return {Array}
+ */
+function splitEvery(n, list) {
+    if (n <= 0) {
+        throw new Error("First argument to splitEvery must be a positive integer");
+    }
+    const result = [];
+    let idx = 0;
+    while (idx < list.length) {
+        result.push(list.slice(idx, (idx += n)));
+    }
+    return result;
+}
+/**
+ * The kilter board only supports messages of 20 bytes
+ * at a time. This method splits a full message into parts
+ * of 20 bytes
+ *
+ * @param buffer
+ */
+const splitMessages = (buffer) => splitEvery(MAX_BLUETOOTH_MESSAGE_SIZE, buffer).map((arr) => new Uint8Array(arr));
+/**
+ * Sends a series of messages to a device.
+ */
+async function writeMessageSeries(messages) {
+    for (const message of messages) {
+        await write(KilterBoard, "uart", "tx", message);
+    }
+}
+/**
+ * Sets the LEDs on the specified device.
+ * @param {Device} board - The device on which to set the LEDs.
+ * @param {ClimbPlacement[]} [placement] - An optional array of climb placements for LED positioning.
+ * @returns {Promise<number[] | undefined>} A promise that resolves with the payload array if LED settings were applied, or `undefined` if no action was taken.
+ */
+export const led = async (board, placement) => {
+    // Check if the filter contains the Aurora Climbing Advertising service
+    const AuroraUUID = "4488b571-7806-4df6-bcff-a2897e4953ff";
+    if (board.filters.some((filter) => filter.services?.includes(AuroraUUID))) {
+        // The Aurora Boards needs a LED / Postion Placememnet Array
+        if (placement) {
+            // Prepares byte arrays for transmission based on a list of climb placements.
+            const payload = prepBytesV3(placement);
+            // Sends the payload to the device by splitting it into messages and writing each message.
+            if (isConnected(board)) {
+                writeMessageSeries(splitMessages(payload));
+            }
+            return payload;
+        }
+    }
+    if (board.filters.some((filter) => filter.name === "Motherboard")) {
+        console.log("Green");
+        await write(Motherboard, "led", "red", new Uint8Array([0x00]));
+        await write(Motherboard, "led", "green", new Uint8Array([0x01]), 2500);
+        console.log("Red");
+        await write(Motherboard, "led", "red", new Uint8Array([0x01]));
+        await write(Motherboard, "led", "green", new Uint8Array([0x00]), 2500);
+        console.log("Orage");
+        await write(Motherboard, "led", "red", new Uint8Array([0x01]));
+        await write(Motherboard, "led", "green", new Uint8Array([0x01]), 2500);
+        console.log("Off");
+        await write(Motherboard, "led", "red", new Uint8Array([0x00]));
+        await write(Motherboard, "led", "green", new Uint8Array([0x00]), 2500);
+    }
+};

package/dist/notify.d.ts

@@ -0,0 +1,16 @@
+import type { massObject } from "./types/notify";
+/** Define the type for the callback function */
+type NotifyCallback = (data: massObject) => void;
+/**
+ * Defines the type for the callback function.
+ * @callback NotifyCallback
+ * @param {massObject} data - The data passed to the callback.
+ */
+export declare let notifyCallback: NotifyCallback;
+/**
+ * Sets the callback function to be called when notifications are received.
+ * @param {NotifyCallback} callback - The callback function to be set.
+ * @returns {void}
+ */
+export declare const notify: (callback: NotifyCallback) => void;
+export {};

package/dist/notify.js

@@ -0,0 +1,14 @@
+/**
+ * Defines the type for the callback function.
+ * @callback NotifyCallback
+ * @param {massObject} data - The data passed to the callback.
+ */
+export let notifyCallback;
+/**
+ * Sets the callback function to be called when notifications are received.
+ * @param {NotifyCallback} callback - The callback function to be set.
+ * @returns {void}
+ */
+export const notify = (callback) => {
+    notifyCallback = callback;
+};

package/dist/read.d.ts

@@ -0,0 +1,10 @@
+import type { Device } from "./types/devices";
+/**
+ * Reads the value of the specified characteristic from the device.
+ * @param {Device} board - The device to read from.
+ * @param {string} serviceId - The service ID where the characteristic belongs.
+ * @param {string} characteristicId - The characteristic ID to read from.
+ * @param {number} [duration=0] - The duration to wait before resolving the promise, in milliseconds.
+ * @returns {Promise<void>} A promise that resolves when the read operation is completed.
+ */
+export declare const read: (board: Device, serviceId: string, characteristicId: string, duration?: number) => Promise<void>;

package/dist/read.js

@@ -0,0 +1,49 @@
+import { getCharacteristic } from "./characteristic";
+import { isConnected } from "./is-connected";
+/**
+ * Reads the value of the specified characteristic from the device.
+ * @param {Device} board - The device to read from.
+ * @param {string} serviceId - The service ID where the characteristic belongs.
+ * @param {string} characteristicId - The characteristic ID to read from.
+ * @param {number} [duration=0] - The duration to wait before resolving the promise, in milliseconds.
+ * @returns {Promise<void>} A promise that resolves when the read operation is completed.
+ */
+export const read = (board, serviceId, characteristicId, duration = 0) => {
+    return new Promise((resolve, reject) => {
+        if (isConnected(board)) {
+            const characteristic = getCharacteristic(board, serviceId, characteristicId);
+            if (characteristic) {
+                characteristic
+                    .readValue()
+                    .then((value) => {
+                    let decodedValue;
+                    const decoder = new TextDecoder("utf-8");
+                    switch (characteristicId) {
+                        case "level":
+                            // TODO: This is Motherboard specific.
+                            decodedValue = value.getUint8(0);
+                            break;
+                        default:
+                            decodedValue = decoder.decode(value);
+                            break;
+                    }
+                    // TODO: Create Read callback
+                    console.log(decodedValue);
+                    // Resolve after specified duration
+                    setTimeout(() => {
+                        resolve();
+                    }, duration);
+                })
+                    .catch((error) => {
+                    reject(error);
+                });
+            }
+            else {
+                reject(new Error("Characteristic is undefined"));
+            }
+        }
+        else {
+            reject(new Error("Device is not connected"));
+        }
+    });
+};

package/dist/stop.d.ts

@@ -0,0 +1,7 @@
+import type { Device } from "./types/devices";
+/**
+ * Stops the data stream on the specified device.
+ * @param {Device} board - The device to stop the stream on.
+ * @returns {Promise<void>} A promise that resolves when the stream is stopped.
+ */
+export declare const stop: (board: Device) => Promise<void>;

package/dist/stop.js

@@ -0,0 +1,21 @@
+import { write } from "./write";
+import { isConnected } from "./is-connected";
+import { Motherboard, Progressor } from "./devices";
+import { MotherboardCommands, ProgressorCommands } from "./commands";
+/**
+ * Stops the data stream on the specified device.
+ * @param {Device} board - The device to stop the stream on.
+ * @returns {Promise<void>} A promise that resolves when the stream is stopped.
+ */
+export const stop = async (board) => {
+    if (isConnected(board)) {
+        if (board.filters.some((filter) => filter.name === "Motherboard")) {
+            // Stop stream on Motherboard
+            await write(Motherboard, "uart", "tx", MotherboardCommands.STOP_WEIGHT_MEAS, 0);
+        }
+        if (board.filters.some((filter) => filter.namePrefix === "Progressor")) {
+            // Stop stream on Progressor
+            await write(Progressor, "progressor", "tx", ProgressorCommands.STOP_WEIGHT_MEAS, 0);
+        }
+    }
+};

package/dist/stream.d.ts

@@ -0,0 +1,8 @@
+import type { Device } from "./types/devices";
+/**
+ * Starts streaming data from the specified device.
+ * @param {Device} board - The device to stream data from.
+ * @param {number} [duration=0] - The duration of the stream in milliseconds. If set to 0, stream will continue indefinitely.
+ * @returns {Promise<void>} A promise that resolves when the streaming operation is completed.
+ */
+export declare const stream: (board: Device, duration?: number) => Promise<void>;

package/dist/stream.js

@@ -0,0 +1,41 @@
+import { isConnected } from "./is-connected";
+import { write } from "./write";
+import { stop } from "./stop";
+import { Motherboard, Progressor } from "./devices";
+import { MotherboardCommands, ProgressorCommands } from "./commands";
+import { emptyDownloadPackets } from "./download";
+import { CALIBRATION } from "./data/motherboard";
+import { calibration } from "./calibration";
+/**
+ * Starts streaming data from the specified device.
+ * @param {Device} board - The device to stream data from.
+ * @param {number} [duration=0] - The duration of the stream in milliseconds. If set to 0, stream will continue indefinitely.
+ * @returns {Promise<void>} A promise that resolves when the streaming operation is completed.
+ */
+export const stream = async (board, duration = 0) => {
+    if (isConnected(board)) {
+        // Reset download packets
+        emptyDownloadPackets();
+        // Device specific logic
+        if (board.filters.some((filter) => filter.name === "Motherboard")) {
+            // Read calibration data if not already available
+            if (!CALIBRATION[0].length) {
+                await calibration(Motherboard);
+            }
+            // Start streaming data
+            await write(Motherboard, "uart", "tx", MotherboardCommands.START_WEIGHT_MEAS, duration);
+            // Stop streaming if duration is set
+            if (duration !== 0) {
+                await stop(Motherboard);
+            }
+        }
+        if (board.filters.some((filter) => filter.namePrefix === "Progressor")) {
+            // Start streaming data
+            await write(Progressor, "progressor", "tx", ProgressorCommands.START_WEIGHT_MEAS, duration);
+            // Stop streaming if duration is set
+            if (duration !== 0) {
+                await stop(Progressor);
+            }
+        }
+    }
+};

package/dist/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/dist/struct/index.js

@@ -0,0 +1,203 @@
+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))) {
+        ;
+        ((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/dist/tare.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Initiates the tare calibration process.
+ * @param {number} time - The duration time for tare calibration process.
+ * @returns {void} A Promise that resolves when tare calibration is initiated.
+ */
+export declare const tare: (time?: number) => void;
+/**
+ * Apply tare calibration to the provided sample.
+ * @param {number} sample - The sample to calibrate.
+ * @returns {number} The calibrated tare value.
+ */
+export declare const applyTare: (sample: number) => number;

package/dist/tare.js

@@ -0,0 +1,70 @@
+/**
+ * Represents the current tare value for calibration.
+ * @type {number}
+ */
+let currentTare = 0;
+/**
+ * Represents the state of tare calibration.
+ * - If `false`, tare calibration is not active.
+ * - If `true`, tare calibration process is initiated.
+ * - If `Date` object, tare calibration process is ongoing and started at this date.
+ * @type {boolean | Date}
+ */
+let runTare = false;
+/**
+ * Array holding the samples collected during tare calibration.
+ * @type {number[]}
+ */
+let tareSamples = [];
+/**
+ * Array holding the sum of samples collected during tare calibration.
+ * @type {number}
+ */
+let newTares = 0;
+/**
+ * Duration time for tare calibration process.
+ * @type {number}
+ */
+let timeTare = 5000;
+/**
+ * Initiates the tare calibration process.
+ * @param {number} time - The duration time for tare calibration process.
+ * @returns {void} A Promise that resolves when tare calibration is initiated.
+ */
+export const tare = (time = 5000) => {
+    runTare = true;
+    timeTare = time;
+    tareSamples = [];
+};
+/**
+ * Apply tare calibration to the provided sample.
+ * @param {number} sample - The sample to calibrate.
+ * @returns {number} The calibrated tare value.
+ */
+export const applyTare = (sample) => {
+    if (runTare) {
+        // If taring process is initiated
+        if (typeof runTare === "boolean" && runTare) {
+            // If tare flag is true (first time), set it to the current date
+            runTare = new Date();
+            // Initialize the sum of new tare values
+            newTares = 0;
+        }
+        // Push current sample to tareSamples array
+        tareSamples.push(sample);
+        // Check if taring process duration has passed (defaults to 5 seconds)
+        if (typeof runTare !== "boolean" && new Date().getTime() - runTare.getTime() > timeTare) {
+            // Calculate the sum of tare samples
+            for (const tareSample of tareSamples) {
+                newTares += tareSample;
+            }
+            // Calculate the average by dividing the sum by the number of samples and update the tare value with the calculated average
+            currentTare = newTares / tareSamples.length;
+            // Reset tare related variables
+            runTare = false;
+            tareSamples = [];
+        }
+    }
+    // Apply tare correction to the sample and return the calibrated value
+    return currentTare;
+};

package/dist/types/commands.d.ts

@@ -0,0 +1,18 @@
+export interface Commands {
+    START_WEIGHT_MEAS?: string;
+    STOP_WEIGHT_MEAS?: string;
+    SLEEP?: number | string;
+    GET_SERIAL?: string;
+    GET_TEXT?: string;
+    DEBUG_STREAM?: string;
+    GET_CALIBRATION?: string;
+    TARE_SCALE?: string;
+    START_PEAK_RFD_MEAS?: string;
+    START_PEAK_RFD_MEAS_SERIES?: string;
+    ADD_CALIB_POINT?: string;
+    SAVE_CALIB?: string;
+    GET_FW_VERSION?: string;
+    GET_ERR_INFO?: string;
+    CLR_ERR_INFO?: string;
+    GET_BATT_VLTG?: string;
+}

package/dist/types/commands.js

@@ -0,0 +1 @@
+export {};