@hangtime/grip-connect 0.5.2 → 0.5.3

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");
         }
@@ -256,15 +322,4 @@ export class Device extends BaseModel {
             }
         }
     };
-    /**
-     * 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.3",
   "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.interface.ts

@@ -1,5 +1,6 @@
 import type { IBase } from "./base.interface"
-import type { massObject } from "../types/notify"
+import type { massObject } from "./callback.interface"
+import type { Commands } from "./command.interface"
 
 /**
  * Represents a characteristic of a Bluetooth service.
@@ -33,13 +34,30 @@ export interface Service {
  * Represents a Bluetooth device.
  */
 export interface IDevice extends IBase {
-  /** Filters to indentify the device */
+  /**
+   * 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 */
+
+  /**
+   * 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 */
+
+  /**
+   * 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
 
+  /**
+   * 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
+
   /**
    * Connects to a Bluetooth device.
    * @param {Function} [onSuccess] - Optional callback function to execute on successful connection. Default logs success.
@@ -87,13 +105,6 @@ export interface IDevice extends IBase {
    */
   notify(callback: (data: massObject) => void): void
 
-  /**
-   * Defines the type for the callback function.
-   * @callback NotifyCallback
-   * @param {massObject} data - The data passed to the callback.
-   */
-  notifyCallback: (data: massObject) => void
-
   /**
    * Handles the 'connected' event.
    * @param {Function} onSuccess - Callback function to execute on successful connection.
@@ -140,14 +151,4 @@ export interface IDevice extends IBase {
     duration?: number,
     callback?: (data: string) => void,
   ): Promise<void>
-
-  /**
-   * A default write callback that logs the response
-   */
-  writeCallback: (data: string) => void
-  /**
-   * The last message written to the device.
-   * @type {string | Uint8Array | null}
-   */
-  writeLast: string | Uint8Array | null
 }

package/src/models/device/entralpi.model.ts

@@ -1,13 +1,7 @@
 import { Device } from "../device.model"
 import type { IEntralpi } from "../../interfaces/device/entralpi.interface"
-import { applyTare } from "../../tare"
-import { checkActivity } from "../../is-active"
-
-// Constants
-let MASS_MAX = "0"
-let MASS_AVERAGE = "0"
-let MASS_TOTAL_SUM = 0
-let DATAPOINT_COUNT = 0
+import { applyTare } from "../../helpers/tare"
+import { checkActivity } from "../../helpers/is-active"
 
 export class Entralpi extends Device implements IEntralpi {
   constructor() {
@@ -194,24 +188,24 @@ export class Entralpi extends Device implements IEntralpi {
         // Tare correction
         numericData -= applyTare(numericData)
 
-        // Update MASS_MAX
-        MASS_MAX = Math.max(Number(MASS_MAX), numericData).toFixed(1)
+        // Update massMax
+        this.massMax = Math.max(Number(this.massMax), numericData).toFixed(1)
 
         // Update running sum and count
         const currentMassTotal = Math.max(-1000, numericData)
-        MASS_TOTAL_SUM += currentMassTotal
-        DATAPOINT_COUNT++
+        this.massTotalSum += currentMassTotal
+        this.dataPointCount++
 
         // Calculate the average dynamically
-        MASS_AVERAGE = (MASS_TOTAL_SUM / DATAPOINT_COUNT).toFixed(1)
+        this.massAverage = (this.massTotalSum / this.dataPointCount).toFixed(1)
 
         // Check if device is being used
         checkActivity(numericData)
 
         // Notify with weight data
         this.notifyCallback({
-          massMax: MASS_MAX,
-          massAverage: MASS_AVERAGE,
+          massMax: this.massMax,
+          massAverage: this.massAverage,
           massTotal: Math.max(-1000, numericData).toFixed(1),
         })
       }

package/src/models/device/forceboard.model.ts

@@ -80,19 +80,19 @@ export class ForceBoard extends Device implements IForceBoard {
           ],
         },
         {
-          name: "",
-          id: "",
+          name: "Temperature Serivce",
+          id: "temperature",
           uuid: "3a90328c-c266-4c76-b05a-6af6104a0b13",
           characteristics: [
             {
               name: "Read",
-              id: "",
+              id: "level",
               uuid: "3a90328d-c266-4c76-b05a-6af6104a0b13",
             },
           ],
         },
         {
-          name: "",
+          name: "Forceboard Service",
           id: "forceboard",
           uuid: "9a88d67f-8df2-4afe-9e0d-c2bbbe773dd0",
           characteristics: [