@hangtime/grip-connect 0.5.2 → 0.5.4

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

@@ -1,14 +1,79 @@
 import { BaseModel } from "./../models/base.model";
 import type { IDevice, Service } from "../interfaces/device.interface";
-import type { massObject } from "./../types/notify";
-/** Define the type for the callback function */
-type NotifyCallback = (data: massObject) => void;
-/** Define the type for the callback function */
-type WriteCallback = (data: string) => void;
-export declare class Device extends BaseModel implements IDevice {
+import type { NotifyCallback, WriteCallback } from "../interfaces/callback.interface";
+import type { Commands } from "../interfaces/command.interface";
+export declare abstract class Device extends BaseModel implements IDevice {
+    /**
+     * Filters to identify the device during Bluetooth scanning.
+     * Used to match devices that meet specific criteria such as name, service UUIDs, etc.
+     */
     filters: BluetoothLEScanFilter[];
+    /**
+     * Array of services provided by the device.
+     * Services represent functionalities that the device supports, such as weight measurement, battery information, or custom services.
+     */
     services: Service[];
+    /**
+     * Reference to the `BluetoothDevice` object representing this device.
+     * This is the actual device object obtained from the Web Bluetooth API after a successful connection.
+     */
     bluetooth?: BluetoothDevice | undefined;
+    /**
+     * Object representing the set of commands available for this device.
+     * These commands allow communication with the device to perform various operations such as starting measurements, retrieving data, or calibrating the device.
+     */
+    commands: Commands;
+    /**
+     * The BluetoothRemoteGATTServer interface of the Web Bluetooth API represents a GATT Server on a remote device.
+     */
+    private server;
+    /**
+     * Maximum mass recorded from the device, initialized to "0".
+     * @type {string}
+     * @protected
+     */
+    protected massMax: string;
+    /**
+     * Average mass calculated from the device data, initialized to "0".
+     * @type {string}
+     * @protected
+     */
+    protected massAverage: string;
+    /**
+     * Total sum of all mass data points recorded from the device.
+     * Used to calculate the average mass.
+     * @type {number}
+     * @protected
+     */
+    protected massTotalSum: number;
+    /**
+     * Number of data points received from the device.
+     * Used to calculate the average mass.
+     * @type {number}
+     * @protected
+     */
+    protected dataPointCount: number;
+    /**
+     * Optional callback for handling write operations.
+     * @callback NotifyCallback
+     * @param {massObject} data - The data passed to the callback.
+     * @type {NotifyCallback | undefined}
+     * @protected
+     */
+    protected notifyCallback: NotifyCallback;
+    /**
+     * Optional callback for handling write operations.
+     * @callback WriteCallback
+     * @param {string} data - The data passed to the callback.
+     * @type {WriteCallback | undefined}
+     * @protected
+     */
+    protected writeCallback: WriteCallback;
+    /**
+     * The last message written to the device.
+     * @type {string | Uint8Array | null}
+     */
+    protected writeLast: string | Uint8Array | null;
     constructor(device: Partial<IDevice>);
     /**
      * Connects to a Bluetooth device.
@@ -50,12 +115,6 @@ export declare class Device extends BaseModel implements IDevice {
      * @returns {void}
      */
     notify: (callback: NotifyCallback) => void;
-    /**
-     * Defines the type for the callback function.
-     * @callback NotifyCallback
-     * @param {massObject} data - The data passed to the callback.
-     */
-    notifyCallback: NotifyCallback;
     /**
      * Handles the 'connected' event.
      * @param {Function} onSuccess - Callback function to execute on successful connection.
@@ -71,9 +130,9 @@ export declare class Device extends BaseModel implements IDevice {
      * @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<string>} A promise that resolves when the read operation is completed.
+     * @returns {Promise<string | undefined>} A promise that resolves when the read operation is completed.
      */
-    read: (serviceId: string, characteristicId: string, duration?: number) => Promise<string>;
+    read: (serviceId: string, characteristicId: string, duration?: number) => Promise<string | undefined>;
     /**
      * Writes a message to the specified characteristic of a Bluetooth device and optionally provides a callback to handle responses.
      * @param {string} serviceId - The service UUID of the Bluetooth device containing the target characteristic.
@@ -93,14 +152,4 @@ export declare class Device extends BaseModel implements IDevice {
      * });
      */
     write: (serviceId: string, characteristicId: string, message: string | Uint8Array | undefined, duration?: number, callback?: WriteCallback) => Promise<void>;
-    /**
-     * A default write callback that logs the response
-     */
-    writeCallback: WriteCallback;
-    /**
-     * The last message written to the device.
-     * @type {string | Uint8Array | null}
-     */
-    writeLast: string | Uint8Array | null;
 }
-export {};

package/dist/models/device.model.js

@@ -1,14 +1,86 @@
 import { BaseModel } from "./../models/base.model";
-let server;
 export class Device extends BaseModel {
+    /**
+     * Filters to identify the device during Bluetooth scanning.
+     * Used to match devices that meet specific criteria such as name, service UUIDs, etc.
+     */
     filters;
+    /**
+     * Array of services provided by the device.
+     * Services represent functionalities that the device supports, such as weight measurement, battery information, or custom services.
+     */
     services;
+    /**
+     * Reference to the `BluetoothDevice` object representing this device.
+     * This is the actual device object obtained from the Web Bluetooth API after a successful connection.
+     */
     bluetooth;
+    /**
+     * Object representing the set of commands available for this device.
+     * These commands allow communication with the device to perform various operations such as starting measurements, retrieving data, or calibrating the device.
+     */
+    commands;
+    /**
+     * The BluetoothRemoteGATTServer interface of the Web Bluetooth API represents a GATT Server on a remote device.
+     */
+    server;
+    /**
+     * Maximum mass recorded from the device, initialized to "0".
+     * @type {string}
+     * @protected
+     */
+    massMax;
+    /**
+     * Average mass calculated from the device data, initialized to "0".
+     * @type {string}
+     * @protected
+     */
+    massAverage;
+    /**
+     * Total sum of all mass data points recorded from the device.
+     * Used to calculate the average mass.
+     * @type {number}
+     * @protected
+     */
+    massTotalSum;
+    /**
+     * Number of data points received from the device.
+     * Used to calculate the average mass.
+     * @type {number}
+     * @protected
+     */
+    dataPointCount;
+    /**
+     * Optional callback for handling write operations.
+     * @callback NotifyCallback
+     * @param {massObject} data - The data passed to the callback.
+     * @type {NotifyCallback | undefined}
+     * @protected
+     */
+    notifyCallback = (data) => console.log(data);
+    /**
+     * Optional callback for handling write operations.
+     * @callback WriteCallback
+     * @param {string} data - The data passed to the callback.
+     * @type {WriteCallback | undefined}
+     * @protected
+     */
+    writeCallback = (data) => console.log(data);
+    /**
+     * The last message written to the device.
+     * @type {string | Uint8Array | null}
+     */
+    writeLast = null;
     constructor(device) {
         super(device);
         this.filters = device.filters || [];
         this.services = device.services || [];
+        this.commands = device.commands || {};
         this.bluetooth = device.bluetooth;
+        this.massMax = "0";
+        this.massAverage = "0";
+        this.massTotalSum = 0;
+        this.dataPointCount = 0;
     }
     /**
      * Connects to a Bluetooth device.
@@ -29,8 +101,8 @@ export class Device extends BaseModel {
             this.bluetooth.addEventListener("gattserverdisconnected", (event) => {
                 this.onDisconnected(event);
             });
-            server = await this.bluetooth.gatt.connect();
-            if (server.connected) {
+            this.server = await this.bluetooth.gatt.connect();
+            if (this.server.connected) {
                 await this.onConnected(onSuccess);
             }
         }
@@ -116,19 +188,13 @@ export class Device extends BaseModel {
     notify = (callback) => {
         this.notifyCallback = callback;
     };
-    /**
-     * Defines the type for the callback function.
-     * @callback NotifyCallback
-     * @param {massObject} data - The data passed to the callback.
-     */
-    notifyCallback = (data) => console.log(data);
     /**
      * Handles the 'connected' event.
      * @param {Function} onSuccess - Callback function to execute on successful connection.
      */
     onConnected = async (onSuccess) => {
         // Connect to GATT server and set up characteristics
-        const services = await server.getPrimaryServices();
+        const services = await this.server?.getPrimaryServices();
         if (!services || services.length === 0) {
             throw new Error("No services found");
         }
@@ -176,41 +242,36 @@ export class Device extends BaseModel {
      * @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<string>} A promise that resolves when the read operation is completed.
+     * @returns {Promise<string | undefined>} A promise that resolves when the read operation is completed.
      */
-    read = (serviceId, characteristicId, duration = 0) => {
-        return new Promise((resolve, reject) => {
-            if (this.isConnected()) {
-                const characteristic = this.getCharacteristic(serviceId, characteristicId);
-                if (characteristic) {
-                    characteristic
-                        .readValue()
-                        .then((value) => {
-                        let decodedValue;
-                        const decoder = new TextDecoder("utf-8");
-                        switch (characteristicId) {
-                            case "level":
-                                // TODO: This is battery specific.
-                                decodedValue = value.getUint8(0).toString();
-                                break;
-                            default:
-                                decodedValue = decoder.decode(value);
-                                break;
-                        }
-                        // Resolve after specified duration
-                        setTimeout(() => {
-                            return resolve(decodedValue);
-                        }, duration);
-                    })
-                        .catch((error) => {
-                        reject(error);
-                    });
-                }
-                else {
-                    reject(new Error("Characteristic is undefined"));
-                }
-            }
-        });
+    read = async (serviceId, characteristicId, duration = 0) => {
+        if (!this.isConnected()) {
+            return undefined;
+        }
+        // Get the characteristic from the service
+        const characteristic = this.getCharacteristic(serviceId, characteristicId);
+        if (!characteristic) {
+            throw new Error("Characteristic is undefined");
+        }
+        // Decode the value based on characteristicId and serviceId
+        let decodedValue;
+        const decoder = new TextDecoder("utf-8");
+        // Read the value from the characteristic
+        const value = await characteristic.readValue();
+        if ((serviceId === "battery" || serviceId === "humidity" || serviceId === "temperature") &&
+            characteristicId === "level") {
+            // This is battery-specific; return the first byte as the level
+            decodedValue = value.getUint8(0).toString();
+        }
+        else {
+            // Otherwise use a UTF-8 decoder
+            decodedValue = decoder.decode(value);
+        }
+        // Wait for the specified duration before returning the result
+        if (duration > 0) {
+            await new Promise((resolve) => setTimeout(resolve, duration));
+        }
+        return decodedValue;
     };
     /**
      * Writes a message to the specified characteristic of a Bluetooth device and optionally provides a callback to handle responses.
@@ -231,40 +292,26 @@ export class Device extends BaseModel {
      * });
      */
     write = async (serviceId, characteristicId, message, duration = 0, callback = this.writeCallback) => {
-        if (this.isConnected()) {
-            // Check if message is provided
-            if (message === undefined) {
-                // If not provided, return without performing write operation
-                return;
-            }
-            // Get the characteristic from the device using serviceId and characteristicId
-            const characteristic = this.getCharacteristic(serviceId, characteristicId);
-            if (!characteristic) {
-                throw new Error("Characteristic is undefined");
-            }
-            // Convert the message to Uint8Array if it's a string
-            const valueToWrite = typeof message === "string" ? new TextEncoder().encode(message) : message;
-            // Write the value to the characteristic
-            await characteristic.writeValue(valueToWrite);
-            // Update the last written message
-            this.writeLast = message;
-            // Assign the provided callback to `writeCallback`
-            this.writeCallback = callback;
-            // If a duration is specified, resolve the promise after the duration
-            if (duration > 0) {
-                await new Promise((resolve) => setTimeout(resolve, duration));
-            }
+        // Check if not connected or no message is provided
+        if (!this.isConnected() || message === undefined) {
+            return undefined;
+        }
+        // Get the characteristic from the service
+        const characteristic = this.getCharacteristic(serviceId, characteristicId);
+        if (!characteristic) {
+            throw new Error("Characteristic is undefined");
+        }
+        // Convert the message to Uint8Array if it's a string
+        const valueToWrite = typeof message === "string" ? new TextEncoder().encode(message) : message;
+        // Write the value to the characteristic
+        await characteristic.writeValue(valueToWrite);
+        // Update the last written message
+        this.writeLast = message;
+        // Assign the provided callback to `writeCallback`
+        this.writeCallback = callback;
+        // If a duration is specified, resolve the promise after the duration
+        if (duration > 0) {
+            await new Promise((resolve) => setTimeout(resolve, duration));
         }
     };
-    /**
-     * A default write callback that logs the response
-     */
-    writeCallback = (data) => {
-        console.log(data);
-    };
-    /**
-     * The last message written to the device.
-     * @type {string | Uint8Array | null}
-     */
-    writeLast = null;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hangtime/grip-connect",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "description": "Griptonite Motherboard, Tindeq Progressor, PitchSix Force Board, WHC-06, Entralpi, Climbro, mySmartBoard: Web Bluetooth API Force-Sensing strength analysis for climbers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/{download.ts → helpers/download.ts}

@@ -1,4 +1,4 @@
-import type { DownloadPacket } from "./types/download"
+import type { DownloadPacket } from "../interfaces/download.interface"
 /**
  * Array of DownloadPacket entries.
  */

package/src/helpers/is-device.ts

@@ -1,49 +1,49 @@
+import { KilterBoard } from "../models"
 import type { Device } from "./../models/device.model"
-import { AuroraUUID } from "./../models/device/kilterboard.model"
 
 /**
- * Checks if the given device is an Entralpi device.
- * @param {Device} [board] - The device to check.
+ * Checks if the given device is an Entralpi.
+ * @param {Device} [device] - The device to check.
  * @returns {boolean} `true` if the device has a filter with the name "ENTRALPI", otherwise `false`.
  */
-export const isEntralpi = (board?: Device): boolean =>
-  board?.filters.some((filter) => filter.name === "ENTRALPI") ?? false
+export const isEntralpi = (device?: Device): boolean =>
+  device?.filters.some((filter) => filter.name === "ENTRALPI") ?? false
 /**
  * Checks if the given device is a Force Board.
- * @param {Device} [board] - The device to check.
+ * @param {Device} [device] - The device to check.
  * @returns {boolean} `true` if the device has a filter with the name "Force Board", otherwise `false`.
  */
-export const isForceBoard = (board?: Device): boolean =>
-  board?.filters.some((filter) => filter.name === "Force Board") ?? false
+export const isForceBoard = (device?: Device): boolean =>
+  device?.filters.some((filter) => filter.name === "Force Board") ?? false
 /**
- * Checks if the given device is a Kilterboard.
- * @param {Device} [board] - The device to check.
- * @returns {boolean} `true` if the device has a service UUID matching the Kilterboard Aurora UUID, otherwise `false`.
+ * Checks if the given device is a Kilter Board.
+ * @param {Device} [device] - The device to check.
+ * @returns {boolean} `true` if the device has a service UUID matching the Kilter Board Aurora UUID, otherwise `false`.
  */
-export const isKilterboard = (board?: Device): boolean => {
-  return board?.filters.some((filter) => filter.services?.includes(AuroraUUID)) ?? false
+export const isKilterBoard = (device?: Device): boolean => {
+  return device?.filters.some((filter) => filter.services?.includes(KilterBoard.AuroraUUID)) ?? false
 }
 /**
  * Checks if the given device is a Motherboard.
- * @param {Device} [board] - The device to check.
- * @returns {boolean} `true` if the device has a filter with the name "Motherboard", otherwise `false`.
+ * @param {Device} [device] - The device to check.
+ * @returns {boolean} `true` if the device has a filter with the name "Motherdevice", otherwise `false`.
  */
-export const isMotherboard = (board?: Device): boolean =>
-  board?.filters.some((filter) => filter.name === "Motherboard") ?? false
+export const isMotherboard = (device?: Device): boolean =>
+  device?.filters.some((filter) => filter.name === "Motherdevice") ?? false
 /**
  * Checks if the given device is a Progressor.
- * @param {Device} [board] - The device to check.
+ * @param {Device} [device] - The device to check.
  * @returns {boolean} `true` if the device has a filter with a namePrefix of "Progressor", otherwise `false`.
  */
-export const isProgressor = (board?: Device): boolean =>
-  board?.filters.some((filter) => filter.namePrefix === "Progressor") ?? false
+export const isProgressor = (device?: Device): boolean =>
+  device?.filters.some((filter) => filter.namePrefix === "Progressor") ?? false
 /**
  * Checks if the given device is a WH-C06.
- * @param {Device} [board] - The device to check.
+ * @param {Device} [device] - The device to check.
  * @returns {boolean} `true` if the device has a filter with the company identifier 0x0100, otherwise `false`.
  */
-export const isWHC06 = (board?: Device): boolean =>
-  board?.filters.some((filter) =>
+export const isWHC06 = (device?: Device): boolean =>
+  device?.filters.some((filter) =>
     filter.manufacturerData?.some(
       (data) => data.companyIdentifier === 0x0100, // Company identifier for WH-C06, also used by 'TomTom International BV': https://www.bluetooth.com/specifications/assigned-numbers/
     ),

package/src/index.ts

@@ -10,11 +10,10 @@ export {
 } from "./models/index"
 
 // helpers
-export { isEntralpi, isKilterboard, isMotherboard, isWHC06, isProgressor } from "./helpers/is-device"
+export { isEntralpi, isKilterBoard, isMotherboard, isWHC06, isProgressor } from "./helpers/is-device"
 
-// TODO: Make functions device specific
-export { download } from "./download"
+export { download } from "./helpers/download"
 
-export { active, isActive } from "./is-active"
+export { active, isActive } from "./helpers/is-active"
 
-export { tare } from "./tare"
+export { tare } from "./helpers/tare"

package/src/interfaces/callback.interface.ts

@@ -0,0 +1,56 @@
+/**
+ * Represents the mass data collected from a device.
+ */
+export interface massObject {
+  /**
+   * The total mass measured from the device.
+   * This is the overall weight or force reading.
+   */
+  massTotal: string
+
+  /**
+   * The maximum mass recorded during the session.
+   * This is the highest weight or force value detected.
+   */
+  massMax: string
+
+  /**
+   * The average mass calculated from all the recorded data points.
+   * This represents the mean value of the mass measurements.
+   */
+  massAverage: string
+
+  /**
+   * The mass recorded on the left side of the device (optional for Motherboard devices).
+   * Used for devices that measure force across multiple zones.
+   */
+  massLeft?: string
+
+  /**
+   * The mass recorded at the center of the device (optional for Motherboard devices).
+   * Used for devices that measure force distribution across a center zone.
+   */
+  massCenter?: string
+
+  /**
+   * The mass recorded on the right side of the device (optional for Motherboard devices).
+   * Used for devices that measure force across multiple zones.
+   */
+  massRight?: string
+}
+
+/**
+ * Defines the type for a callback function that handles mass data notifications.
+ * The callback receives a `massObject` as the parameter.
+ * @callback NotifyCallback
+ * @param {massObject} data - The mass data passed to the callback.
+ */
+export type NotifyCallback = (data: massObject) => void
+
+/**
+ * Defines the type for a callback function that handles write operations to the device.
+ * The callback receives the data string written to the device.
+ * @callback WriteCallback
+ * @param {string} data - The string data passed to the callback.
+ */
+export type WriteCallback = (data: string) => void

package/src/interfaces/command.interface.ts

@@ -0,0 +1,106 @@
+/**
+ * Represents the available commands for various devices such as the Motherboard and Tindeq Progressor.
+ */
+export interface Commands {
+  // Motherboard, Progressor
+
+  /**
+   * Starts a weight measurement on the device.
+   * Used to begin collecting weight or force data.
+   */
+  START_WEIGHT_MEAS?: string
+
+  /**
+   * Stops the current weight measurement on the device.
+   * Used to end the data collection.
+   */
+  STOP_WEIGHT_MEAS?: string
+
+  /**
+   * Puts the device to sleep or in a low-power mode.
+   * The format can be a string or a number depending on the device.
+   */
+  SLEEP?: number | string
+
+  /**
+   * Retrieves the serial number of the device.
+   * This command fetches the unique identifier assigned by the manufacturer.
+   */
+  GET_SERIAL?: string
+
+  // Griptonite Motherboard
+
+  /**
+   * Retrieves textual information from the device.
+   * May include readable data.
+   */
+  GET_TEXT?: string
+
+  /**
+   * Starts or stops a debug data stream from the device.
+   * Used for diagnostic purposes or to monitor real-time data.
+   */
+  DEBUG_STREAM?: string
+
+  /**
+   * Retrieves calibration data from the device.
+   * Used to ensure accurate measurements by applying calibration points.
+   */
+  GET_CALIBRATION?: string
+
+  // Tindeq Progressor
+
+  /**
+   * Tares the scale, zeroing the current weight measurement.
+   * Used to reset the baseline for weight data.
+   */
+  TARE_SCALE?: string
+
+  /**
+   * Starts measuring the peak rate of force development (RFD).
+   * Captures how quickly force is applied over time.
+   */
+  START_PEAK_RFD_MEAS?: string
+
+  /**
+   * Starts measuring a series of peak RFD measurements.
+   * This captures multiple RFD data points over a period of time.
+   */
+  START_PEAK_RFD_MEAS_SERIES?: string
+
+  /**
+   * Adds a calibration point to the device.
+   * Used to improve the accuracy of future measurements.
+   */
+  ADD_CALIB_POINT?: string
+
+  /**
+   * Saves the current calibration settings to the device.
+   * Ensures the device remembers the calibration for future sessions.
+   */
+  SAVE_CALIB?: string
+
+  /**
+   * Retrieves the firmware version of the device.
+   * Useful for ensuring compatibility and tracking updates.
+   */
+  GET_FW_VERSION?: string
+
+  /**
+   * Retrieves error information from the device.
+   * Provides details on any faults or issues that occurred during operation.
+   */
+  GET_ERR_INFO?: string
+
+  /**
+   * Clears the error information on the device.
+   * Used to reset error logs after troubleshooting or repair.
+   */
+  CLR_ERR_INFO?: string
+
+  /**
+   * Retrieves the battery voltage level of the device.
+   * Provides insight into the device's remaining battery power.
+   */
+  GET_BATT_VLTG?: string
+}

package/src/interfaces/device/forceboard.interface.ts

@@ -21,4 +21,23 @@ export interface IForceBoard extends IDevice {
    * @returns {Promise<string | undefined>} A Promise that resolves with the manufacturer information.
    */
   manufacturer(): 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 temperature information from the device.
+   * @returns {Promise<string | undefined>} A Promise that resolves with the humidity level.
+   */
+  temperature(): Promise<string | undefined>
 }