@hangtime/grip-connect 0.4.2 → 0.5.0

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

@@ -0,0 +1,246 @@
+import { Device } from "../device.model";
+import { notifyCallback } from "../../notify";
+import { applyTare } from "../../tare";
+import { checkActivity } from "../../is-active";
+import { read } from "../../read";
+// Constants
+let MASS_MAX = "0";
+let MASS_AVERAGE = "0";
+let MASS_TOTAL_SUM = 0;
+let DATAPOINT_COUNT = 0;
+export class Entralpi extends Device {
+    constructor() {
+        super({
+            filters: [
+                {
+                    name: "ENTRALPI",
+                },
+            ],
+            services: [
+                {
+                    name: "Device Information",
+                    id: "device",
+                    uuid: "0000180a-0000-1000-8000-00805f9b34fb",
+                    characteristics: [
+                        {
+                            name: "System ID",
+                            id: "id",
+                            uuid: "00002a23-0000-1000-8000-00805f9b34fb",
+                        },
+                        {
+                            name: "Model Number String",
+                            id: "model",
+                            uuid: "00002a24-0000-1000-8000-00805f9b34fb",
+                        },
+                        // {
+                        //   name: "Serial Number String (Blocked)",
+                        //   id: "serial",
+                        //   uuid: "00002a25-0000-1000-8000-00805f9b34fb",
+                        // },
+                        {
+                            name: "Firmware Revision String",
+                            id: "firmware",
+                            uuid: "00002a26-0000-1000-8000-00805f9b34fb",
+                        },
+                        {
+                            name: "Hardware Revision String",
+                            id: "hardware",
+                            uuid: "00002a27-0000-1000-8000-00805f9b34fb",
+                        },
+                        {
+                            name: "Software Revision String",
+                            id: "software",
+                            uuid: "00002a28-0000-1000-8000-00805f9b34fb",
+                        },
+                        {
+                            name: "Manufacturer Name String",
+                            id: "manufacturer",
+                            uuid: "00002a29-0000-1000-8000-00805f9b34fb",
+                        },
+                        {
+                            name: "IEEE 11073-20601 Regulatory Certification Data List",
+                            id: "certification",
+                            uuid: "00002a2a-0000-1000-8000-00805f9b34fb",
+                        },
+                        {
+                            name: "PnP ID",
+                            id: "pnp",
+                            uuid: "00002a50-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: "Generic Attribute",
+                    id: "attribute",
+                    uuid: "f000ffc0-0451-4000-b000-000000000000",
+                    characteristics: [
+                        {
+                            name: "",
+                            id: "",
+                            uuid: "f000ffc1-0451-4000-b000-000000000000",
+                        },
+                        {
+                            name: "",
+                            id: "",
+                            uuid: "f000ffc2-0451-4000-b000-000000000000",
+                        },
+                    ],
+                },
+                {
+                    name: "UART ISSC Transparent Service",
+                    id: "uart",
+                    uuid: "0000fff0-0000-1000-8000-00805f9b34fb",
+                    characteristics: [
+                        {
+                            name: "TX",
+                            id: "tx",
+                            uuid: "0000fff1-0000-1000-8000-00805f9b34fb",
+                        },
+                        {
+                            name: "RX",
+                            id: "rx",
+                            uuid: "0000fff4-0000-1000-8000-00805f9b34fb",
+                        },
+                    ],
+                },
+                {
+                    name: "Weight Scale",
+                    id: "weight",
+                    uuid: "0000181d-0000-1000-8000-00805f9b34fb",
+                    characteristics: [
+                        {
+                            name: "notify",
+                            id: "rx",
+                            uuid: "0000fff1-0000-1000-8000-00805f9b34fb",
+                        },
+                    ],
+                },
+            ],
+        });
+    }
+    /**
+     * 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 firmware version from the device.
+     * @returns {Promise<string>} A Promise that resolves with the firmware version,
+     */
+    firmware = async () => {
+        // Check if the device is connected
+        if (this.isConnected()) {
+            // Read firmware version from the Motherboard
+            return await read(this, "device", "firmware", 250);
+        }
+        // If device is not found, return undefined
+        return undefined;
+    };
+    /**
+     * Handles data received from the Progressor device, processes weight measurements,
+     * and updates mass data including maximum and average values.
+     * It also handles command responses for retrieving device information.
+     *
+     * @param {Event} event - The notification event.
+     */
+    handleNotifications = (event) => {
+        const characteristic = event.target;
+        const value = characteristic.value;
+        if (value) {
+            if (value.buffer) {
+                const buffer = value.buffer;
+                const rawData = new DataView(buffer);
+                const receivedData = (rawData.getUint16(0) / 100).toFixed(1);
+                let numericData = Number(receivedData);
+                // Tare correction
+                numericData -= applyTare(numericData);
+                // Update MASS_MAX
+                MASS_MAX = Math.max(Number(MASS_MAX), numericData).toFixed(1);
+                // Update running sum and count
+                const currentMassTotal = Math.max(-1000, numericData);
+                MASS_TOTAL_SUM += currentMassTotal;
+                DATAPOINT_COUNT++;
+                // Calculate the average dynamically
+                MASS_AVERAGE = (MASS_TOTAL_SUM / DATAPOINT_COUNT).toFixed(1);
+                // Check if device is being used
+                checkActivity(numericData);
+                // Notify with weight data
+                notifyCallback({
+                    massMax: MASS_MAX,
+                    massAverage: MASS_AVERAGE,
+                    massTotal: Math.max(-1000, numericData).toFixed(1),
+                });
+            }
+        }
+    };
+    /**
+     * Retrieves hardware version from the device.
+     * @returns {Promise<string>} A Promise that resolves with the hardware version,
+     */
+    hardware = async () => {
+        // Check if the device is connected
+        if (this.isConnected()) {
+            // Read hardware version from the device
+            return await read(this, "device", "hardware", 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;
+    };
+    /**
+     * Retrieves model number from the device.
+     * @returns {Promise<string>} A Promise that resolves with the model number,
+     */
+    model = async () => {
+        // Check if the device is connected
+        if (this.isConnected()) {
+            // Read model number from the Entralpi
+            return await read(this, "device", "model", 250);
+        }
+        // If device is not found, return undefined
+        return undefined;
+    };
+    /**
+     * Retrieves software version from the device.
+     * @returns {Promise<string>} A Promise that resolves with the software version,
+     */
+    software = async () => {
+        // Check if the device is connected
+        if (this.isConnected()) {
+            // Read software version from the Entralpi
+            return await read(this, "device", "software", 250);
+        }
+        // If device is not found, return undefined
+        return undefined;
+    };
+}

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

@@ -0,0 +1,23 @@
+import { Device } from "../device.model";
+import type { IForceBoard } from "../../interfaces/device/forceboard.interface";
+/**
+ * Represents a PitchSix Force Board device
+ */
+export declare class ForceBoard extends Device implements IForceBoard {
+    constructor();
+    /**
+     * 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>;
+    /**
+     * Retrieves humidity level from the device.
+     * @returns {Promise<string>} A Promise that resolves with the humidity level,
+     */
+    humidity: () => Promise<string | undefined>;
+    /**
+     * Retrieves manufacturer information from the device.
+     * @returns {Promise<string>} A Promise that resolves with the manufacturer information,
+     */
+    manufacturer: () => Promise<string | undefined>;
+}

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?: "green" | "red" | "orange" | ClimbPlacement[]) => Promise<number[] | undefined>;
+}
+export {};