@hangtime/grip-connect 0.4.2 → 0.5.1

package/dist/models/device/forceboard.model.js

@@ -0,0 +1,201 @@
+import { Device } from "../device.model";
+import { read } from "../../read";
+/**
+ * Represents a PitchSix Force Board device
+ */
+export class ForceBoard extends Device {
+    constructor() {
+        super({
+            filters: [{ name: "Force Board" }],
+            services: [
+                {
+                    name: "Device Information",
+                    id: "device",
+                    uuid: "0000180a-0000-1000-8000-00805f9b34fb",
+                    characteristics: [
+                        // {
+                        //   name: "Serial Number String (Blocked)",
+                        //   id: "serial",
+                        //   uuid: "00002a25-0000-1000-8000-00805f9b34fb",
+                        // },
+                        // {
+                        //   name: "Firmware Revision String (Blocked)",
+                        //   id: "firmware",
+                        //   uuid: "00002a26-0000-1000-8000-00805f9b34f",
+                        // },
+                        {
+                            name: "Manufacturer Name String",
+                            id: "manufacturer",
+                            uuid: "00002a29-0000-1000-8000-00805f9b34fb",
+                        },
+                    ],
+                },
+                {
+                    name: "Battery Service",
+                    id: "battery",
+                    uuid: "0000180f-0000-1000-8000-00805f9b34fb",
+                    characteristics: [
+                        {
+                            name: "Battery Level",
+                            id: "level",
+                            uuid: "00002a19-0000-1000-8000-00805f9b34fb",
+                        },
+                    ],
+                },
+                {
+                    name: "Nordic Device Firmware Update (DFU) Service",
+                    id: "dfu",
+                    uuid: "0000fe59-0000-1000-8000-00805f9b34fb",
+                    characteristics: [
+                        {
+                            name: "Buttonless DFU",
+                            id: "dfu",
+                            uuid: "8ec90003-f315-4f60-9fb8-838830daea50",
+                        },
+                    ],
+                },
+                {
+                    name: "",
+                    id: "",
+                    uuid: "f3641400-00b0-4240-ba50-05ca45bf8abc",
+                    characteristics: [
+                        {
+                            name: "Read + Indicate",
+                            id: "",
+                            uuid: "f3641401-00b0-4240-ba50-05ca45bf8abc",
+                        },
+                    ],
+                },
+                {
+                    name: "Humidity Service",
+                    id: "humidity",
+                    uuid: "cf194c6f-d0c1-47b2-aeff-dc610f09bd18",
+                    characteristics: [
+                        {
+                            name: "Humidity Level",
+                            id: "level",
+                            uuid: "cf194c70-d0c1-47b2-aeff-dc610f09bd18",
+                        },
+                    ],
+                },
+                {
+                    name: "",
+                    id: "",
+                    uuid: "3a90328c-c266-4c76-b05a-6af6104a0b13",
+                    characteristics: [
+                        {
+                            name: "Read",
+                            id: "",
+                            uuid: "3a90328d-c266-4c76-b05a-6af6104a0b13",
+                        },
+                    ],
+                },
+                {
+                    name: "",
+                    id: "forceboard",
+                    uuid: "9a88d67f-8df2-4afe-9e0d-c2bbbe773dd0",
+                    characteristics: [
+                        {
+                            name: "Write",
+                            id: "",
+                            uuid: "9a88d680-8df2-4afe-9e0d-c2bbbe773dd0",
+                        },
+                        {
+                            name: "Read + Indicate",
+                            id: "",
+                            uuid: "9a88d681-8df2-4afe-9e0d-c2bbbe773dd0",
+                        },
+                        {
+                            name: "Read + Notify",
+                            id: "rx",
+                            uuid: "9a88d682-8df2-4afe-9e0d-c2bbbe773dd0",
+                        },
+                        {
+                            name: "Write",
+                            id: "",
+                            uuid: "9a88d683-8df2-4afe-9e0d-c2bbbe773dd0",
+                        },
+                        {
+                            name: "Read",
+                            id: "",
+                            uuid: "9a88d685-8df2-4afe-9e0d-c2bbbe773dd0",
+                        },
+                        {
+                            name: "Write",
+                            id: "",
+                            uuid: "9a88d686-8df2-4afe-9e0d-c2bbbe773dd0",
+                        },
+                        {
+                            name: "Read + Write",
+                            id: "",
+                            uuid: "9a88d687-8df2-4afe-9e0d-c2bbbe773dd0",
+                        },
+                        {
+                            name: "Serial / Read + Write",
+                            id: "",
+                            uuid: "9a88d688-8df2-4afe-9e0d-c2bbbe773dd0",
+                        },
+                        {
+                            name: "Read + Write",
+                            id: "",
+                            uuid: "9a88d689-8df2-4afe-9e0d-c2bbbe773dd0",
+                        },
+                    ],
+                },
+                {
+                    name: "",
+                    id: "",
+                    uuid: "467a8516-6e39-11eb-9439-0242ac130002",
+                    characteristics: [
+                        {
+                            name: "Read + Write",
+                            id: "",
+                            uuid: "467a8517-6e39-11eb-9439-0242ac130002",
+                        },
+                        {
+                            name: "Read + Write",
+                            id: "",
+                            uuid: "467a8518-6e39-11eb-9439-0242ac130002",
+                        },
+                    ],
+                },
+            ],
+        });
+    }
+    /**
+     * Retrieves battery or voltage information from the device.
+     * @returns {Promise<string | undefined>} A Promise that resolves with the battery or voltage information,
+     */
+    battery = async () => {
+        if (this.isConnected()) {
+            return await read(this, "battery", "level", 250);
+        }
+        // If device is not found, return undefined
+        return undefined;
+    };
+    /**
+     * Retrieves humidity level from the device.
+     * @returns {Promise<string>} A Promise that resolves with the humidity level,
+     */
+    humidity = async () => {
+        // Check if the device is connected
+        if (this.isConnected()) {
+            return await read(this, "humidity", "level", 250);
+        }
+        // If device is not found, return undefined
+        return undefined;
+    };
+    /**
+     * Retrieves manufacturer information from the device.
+     * @returns {Promise<string>} A Promise that resolves with the manufacturer information,
+     */
+    manufacturer = async () => {
+        // Check if the device is connected
+        if (this.isConnected()) {
+            // Read manufacturer information from the device
+            return await read(this, "device", "manufacturer", 250);
+        }
+        // If device is not found, return undefined
+        return undefined;
+    };
+}

package/dist/models/device/kilterboard.model.d.ts

@@ -0,0 +1,85 @@
+import { Device } from "../device.model";
+import type { IKilterBoard } from "../../interfaces/device/kilterboard.interface";
+/**
+ * Aurora Climbing Advertising service
+ */
+export declare const AuroraUUID = "4488b571-7806-4df6-bcff-a2897e4953ff";
+declare class ClimbPlacement {
+    position: number;
+    role_id: number;
+    constructor(position: number, role_id: number);
+}
+/**
+ * Represents a Aurora Climbing device
+ * Kilter Board, Tension Board, Decoy Board, Touchstone Board, Grasshopper Board, Aurora Board, So iLL Board
+ */
+export declare class KilterBoard extends Device implements IKilterBoard {
+    constructor();
+    /**
+     * 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.
+     */
+    checksum(data: number[]): number;
+    /**
+     * Wraps a byte array with header and footer bytes for transmission.
+     * @param data - The array of bytes to wrap.
+     * @returns The wrapped byte array.
+     */
+    wrapBytes(data: number[]): number[];
+    /**
+     * 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.
+     */
+    encodePosition(position: number): number[];
+    /**
+     * 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.
+     */
+    encodeColor(color: string): number;
+    /**
+     * 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.
+     */
+    encodePlacement(position: number, ledColor: string): number[];
+    /**
+     * 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.
+     */
+    prepBytesV3(climbPlacementList: ClimbPlacement[]): number[];
+    /**
+     * 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}
+     */
+    splitEvery(n: number, list: number[]): number[][];
+    /**
+     * 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
+     */
+    splitMessages: (buffer: number[]) => Uint8Array[];
+    /**
+     * Sends a series of messages to a device.
+     */
+    writeMessageSeries(messages: Uint8Array[]): Promise<void>;
+    /**
+     * Configures the LEDs based on an array of climb placements. If a configuration is provided, it prepares and sends a payload to the device.
+     * @param {ClimbPlacement[]} [config] - Optional color or array of climb placements for the LEDs. Ignored if placements are provided.
+     * @returns {Promise<number[] | undefined>} A promise that resolves with the payload array for the Kilter Board if LED settings were applied, or `undefined` if no action was taken or for the Motherboard.
+     */
+    led: (config?: ClimbPlacement[]) => Promise<number[] | undefined>;
+}
+export {};

package/dist/models/device/kilterboard.model.js

@@ -0,0 +1,213 @@
+import { Device } from "../device.model";
+import { KilterBoardPacket, KilterBoardPlacementRoles } from "../../commands/kilterboard";
+import { write } from "../../write";
+/**
+ * Aurora Climbing Advertising service
+ */
+export const AuroraUUID = "4488b571-7806-4df6-bcff-a2897e4953ff";
+/**
+ * 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;
+class ClimbPlacement {
+    position;
+    role_id;
+    constructor(position, role_id) {
+        this.position = position;
+        this.role_id = role_id;
+    }
+}
+/**
+ * Represents a Aurora Climbing device
+ * Kilter Board, Tension Board, Decoy Board, Touchstone Board, Grasshopper Board, Aurora Board, So iLL Board
+ */
+export class KilterBoard extends Device {
+    constructor() {
+        super({
+            filters: [
+                {
+                    services: [AuroraUUID],
+                },
+            ],
+            services: [
+                {
+                    name: "UART Nordic Service",
+                    id: "uart",
+                    uuid: "6e400001-b5a3-f393-e0a9-e50e24dcca9e",
+                    characteristics: [
+                        {
+                            name: "TX",
+                            id: "tx",
+                            uuid: "6e400002-b5a3-f393-e0a9-e50e24dcca9e",
+                        },
+                        // {
+                        //   name: "RX",
+                        //   id: "rx",
+                        //   uuid: "6e400003-b5a3-f393-e0a9-e50e24dcca9e",
+                        // },
+                    ],
+                },
+            ],
+        });
+    }
+    /**
+     * 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.
+     */
+    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.
+     */
+    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, this.checksum(data), 2, ...data, 3];
+    }
+    /**
+     * 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.
+     */
+    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.
+     */
+    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.
+     */
+    encodePlacement(position, ledColor) {
+        return [...this.encodePosition(position), this.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.
+     */
+    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 role = KilterBoardPlacementRoles.find((placement) => placement.id === climbPlacement.role_id);
+            if (!role) {
+                throw new Error(`Role with id ${climbPlacement.role_id} not found in placement_roles`);
+            }
+            const encodedPlacement = this.encodePlacement(climbPlacement.position, role.led_color);
+            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(...this.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}
+     */
+    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
+     */
+    splitMessages = (buffer) => this.splitEvery(MAX_BLUETOOTH_MESSAGE_SIZE, buffer).map((arr) => new Uint8Array(arr));
+    /**
+     * Sends a series of messages to a device.
+     */
+    async writeMessageSeries(messages) {
+        for (const message of messages) {
+            await write(this, "uart", "tx", message);
+        }
+    }
+    /**
+     * Configures the LEDs based on an array of climb placements. If a configuration is provided, it prepares and sends a payload to the device.
+     * @param {ClimbPlacement[]} [config] - Optional color or array of climb placements for the LEDs. Ignored if placements are provided.
+     * @returns {Promise<number[] | undefined>} A promise that resolves with the payload array for the Kilter Board if LED settings were applied, or `undefined` if no action was taken or for the Motherboard.
+     */
+    led = async (config) => {
+        // Handle Kilterboard logic: process placements and send payload if connected
+        if (Array.isArray(config)) {
+            // Prepares byte arrays for transmission based on a list of climb placements.
+            const payload = this.prepBytesV3(config);
+            if (this.isConnected()) {
+                await this.writeMessageSeries(this.splitMessages(payload));
+            }
+            return payload;
+        }
+        return undefined;
+    };
+}

package/dist/models/device/motherboard.model.d.ts

@@ -0,0 +1,81 @@
+import { Device } from "../device.model";
+import type { IMotherboard } from "../../interfaces/device/motherboard.interface";
+export declare const CALIBRATION: never[][];
+/**
+ * Represents a Griptonite Motherboard device
+ */
+export declare class Motherboard extends Device implements IMotherboard {
+    constructor();
+    /**
+     * Applies calibration to a sample value.
+     * @param {number} sample - The sample value to calibrate.
+     * @param {number[][]} calibration - The calibration data.
+     * @returns {number} The calibrated sample value.
+     */
+    applyCalibration: (sample: number, calibration: number[][]) => number;
+    /**
+     * Retrieves battery or voltage information from the device.
+     * @returns {Promise<string | undefined>} A Promise that resolves with the battery or voltage information,
+     */
+    battery: () => Promise<string | undefined>;
+    /**
+     * Writes a command to get calibration data from the device.
+     * @returns {Promise<void>} A Promise that resolves when the command is successfully sent.
+     */
+    calibration: () => Promise<void>;
+    /**
+     * Retrieves firmware version from the device.
+     * @returns {Promise<string>} A Promise that resolves with the firmware version,
+     */
+    firmware: () => Promise<string | undefined>;
+    /**
+     * Handles data received from the Motherboard device. Processes hex-encoded streaming packets
+     * to extract samples, calibrate masses, and update running averages of mass data.
+     * If the received data is not a valid hex packet, it returns the unprocessed data.
+     *
+     * @param {Event} event - The notification event.
+     */
+    handleNotifications: (event: Event) => void;
+    /**
+     * Retrieves hardware version from the device.
+     * @returns {Promise<string>} A Promise that resolves with the hardware version,
+     */
+    hardware: () => Promise<string | undefined>;
+    /**
+     * Sets the LED color based on a single color option. Defaults to turning the LEDs off if no configuration is provided.
+     * @param {"green" | "red" | "orange"} [config] - Optional color or array of climb placements for the LEDs. Ignored if placements are provided.
+     * @returns {Promise<number[] | undefined>} A promise that resolves with the payload array for the Kilter Board if LED settings were applied, or `undefined` if no action was taken or for the Motherboard.
+     */
+    led: (config?: "green" | "red" | "orange") => Promise<number[] | undefined>;
+    /**
+     * Retrieves manufacturer information from the device.
+     * @returns {Promise<string>} A Promise that resolves with the manufacturer information,
+     */
+    manufacturer: () => Promise<string | undefined>;
+    /**
+     * Retrieves serial number from the device.
+     * @returns {Promise<string>} A Promise that resolves with the serial number,
+     */
+    serial: () => Promise<string | undefined>;
+    /**
+     * Stops the data stream on the specified device.
+     * @returns {Promise<void>} A promise that resolves when the stream is stopped.
+     */
+    stop: () => Promise<void>;
+    /**
+     * Starts streaming data from the specified device.
+     * @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.
+     */
+    stream: (duration?: number) => Promise<void>;
+    /**
+     * Retrieves the entire 320 bytes of non-volatile memory from the device.
+     *
+     * The memory consists of 10 segments, each 32 bytes long. If any segment was previously written,
+     * the corresponding data will appear in the response. Unused portions of the memory are
+     * padded with whitespace.
+     *
+     * @returns {Promise<string>} A Promise that resolves with the 320-byte memory content as a string,
+     */
+    text: () => Promise<string | undefined>;
+}