@hangtime/grip-connect 0.5.6 → 0.5.8

package/README.md

@@ -43,68 +43,65 @@ $ npm install @hangtime/grip-connect
 
 ## Example usage (with a Motherboard)
 
-Simply importing the utilities you need from `@hangtime/grip-connect`.
+Simply importing the device you need from `@hangtime/grip-connect`.
 
 ```html
 <button id="motherboard" type="button">Connect Motherboard</button>
 ```
 
 ```js
-import { Motherboard, active } from "@hangtime/grip-connect"
+import { Motherboard } from "@hangtime/grip-connect"
 
-const motherboardButton = document.querySelector("#motherboard")
+// Initiate device
+const motherboard = new Motherboard()
 
-motherboardButton.addEventListener("click", () => {
-  // setup device
-  const motherboard = new Motherboard()
-  // connect to device
-  motherboard.connect(
+// Optional: Custom data handler
+motherboard.notify((data) => {
+  // { massTotal: "0", massMax: "0", massAverage: "0", massLeft: "0", massCenter: "0", massRight: "0" }
+  console.log(data)
+})
+
+// Optional: Check if the device is active
+motherboard.active(
+  (isActive) => {
+    console.log(isActive)
+  },
+  // Optionally using a weight threshold and duration
+  { threshold: 2.5, duration: 1000 },
+)
+
+document.querySelector("#motherboard").addEventListener("click", async () => {
+  // Connect to device
+  await motherboard.connect(
     async () => {
-      // Listen for stream notifications
-      motherboard.notify((data) => {
-        // { massTotal: "0", massMax: "0", massAverage: "0", massLeft: "0", massCenter: "0", massRight: "0" }
-        console.log(data)
-      })
-
-      // Reactive check if device is active
-      active(
-        (isActive) => {
-          console.log(isActive)
-        },
-        // Optionally using a weight threshold and duration
-        { threshold: 2.5, duration: 1000 },
-      )
-
-      // Read device specific data: battery + firmware
+      // Example: Read device specific data
       const batteryLevel = await motherboard.battery()
       console.log(batteryLevel)
 
-      const firmwareVersion = await motherboard.firmware()
-      console.log(firmwareVersion)
-
       // LEDs: "green", "red", "orange", or no argument to turn off
-      // await motherboard.led(Motherboard, "red")
-      // await motherboard.led(Motherboard)
+      // await motherboard.led("red")
+      // await motherboard.led()
 
-      // Start weight streaming (for a minute) remove parameter for a continues stream
-      await motherboard.stream(60000)
+      // Start weight streaming (for 30s) remove parameter for a continues stream
+      await motherboard.stream(30000)
 
       // Manualy tare the device when the stream is running
-      // await tare(5000)
+      // await motherboard.tare(5000)
 
       // Manually call stop method if stream is continues
       // await motherboard.stop()
 
       // Download data as CSV, JSON, or XML (default: CSV) format => timestamp, frame, battery, samples, masses
-      // download('json')
+      // motherboard.download('json')
+
+      // Optionally disconnect from device after we are done
+      motherboard.disconnect(Motherboard)
     },
     (error) => {
       // Optinal custom error handeling
       console.error(error.message)
     },
   )
-  // Disconnect from device after we are done
-  motherboard.disconnect(Motherboard)
 })
 ```
 

package/dist/index.d.ts

@@ -1,5 +1 @@
 export { Climbro, Entralpi, ForceBoard, KilterBoard, Motherboard, mySmartBoard, WHC06, Progressor, } from "./models/index";
-export { isEntralpi, isKilterBoard, isMotherboard, isWHC06, isProgressor } from "./helpers/is-device";
-export { download } from "./helpers/download";
-export { active, isActive } from "./helpers/is-active";
-export { tare } from "./helpers/tare";

package/dist/index.js

@@ -1,6 +1 @@
 export { Climbro, Entralpi, ForceBoard, KilterBoard, Motherboard, mySmartBoard, WHC06, Progressor, } from "./models/index";
-// helpers
-export { isEntralpi, isKilterBoard, isMotherboard, isWHC06, isProgressor } from "./helpers/is-device";
-export { download } from "./helpers/download";
-export { active, isActive } from "./helpers/is-active";
-export { tare } from "./helpers/tare";

package/dist/interfaces/callback.interface.d.ts

@@ -47,3 +47,9 @@ export type NotifyCallback = (data: massObject) => void;
  * @param {string} data - The string data passed to the callback.
  */
 export type WriteCallback = (data: string) => void;
+/**
+ * Type definition for the callback function that is called when the activity status changes.
+ * @callback ActiveCallback
+ * @param {boolean} value - The new activity status (true if active, false if not).
+ */
+export type ActiveCallback = (data: boolean) => void;

package/dist/interfaces/device/motherboard.interface.d.ts

@@ -3,13 +3,6 @@ import type { IDevice } from "../device.interface";
  * Interface representing the Griptonite Motherboard device.
  */
 export interface IMotherboard extends IDevice {
-    /**
-     * 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.

package/dist/interfaces/device.interface.d.ts

@@ -34,81 +34,87 @@ export interface IDevice extends IBase {
     /**
      * Filters to identify the device during Bluetooth scanning.
      * Used to match devices that meet specific criteria such as name, service UUIDs, etc.
+     * @type {BluetoothLEScanFilter[]}
+     * @public
+     * @readonly
      */
     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.
+     * @type {Service[]}
+     * @public
+     * @readonly
      */
     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.
+     * @type {BluetoothDevice | undefined}
+     * @public
      */
     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.
+     * @type {Commands}
+     * @public
+     * @readonly
      */
     commands: Commands;
     /**
      * Connects to a Bluetooth device.
      * @param {Function} [onSuccess] - Optional callback function to execute on successful connection. Default logs success.
      * @param {Function} [onError] - Optional callback function to execute on error. Default logs the error.
+     * @public
      */
     connect(onSuccess?: () => void, onError?: (error: Error) => void): Promise<void>;
     /**
      * Disconnects the device if it is currently connected.
      * - Checks if the device is connected via it's GATT server.
      * - If the device is connected, it attempts to gracefully disconnect.
+     * @public
      */
     disconnect(): void;
     /**
-     * Returns UUIDs of all services associated with the device.
-     * @returns {string[]} Array of service UUIDs.
-     */
-    getAllServiceUUIDs(): string[];
-    /**
-     * Retrieves the characteristic from the device's service.
-     * @param {string} serviceId - The UUID of the service.
-     * @param {string} characteristicId - The UUID of the characteristic.
-     * @returns {BluetoothRemoteGATTCharacteristic | undefined} The characteristic, if found.
-     */
-    getCharacteristic(serviceId: string, characteristicId: string): BluetoothRemoteGATTCharacteristic | undefined;
-    /**
-     * Handles notifications received from a characteristic.
-     * @param {Event} event - The notification event.
+     * Exports the data in the specified format (CSV, JSON, XML) with a filename format:
+     * 'data-export-YYYY-MM-DD-HH-MM-SS.{format}'.
+     *
+     * @param {('csv' | 'json' | 'xml')} [format='csv'] - The format in which to download the data.
+     * Defaults to 'csv'. Accepted values are 'csv', 'json', and 'xml'.
+     *
+     * @returns {void} Initiates a download of the data in the specified format.
+     * @private
      */
-    handleNotifications(event: Event): void;
+    download(format?: "csv" | "json" | "xml"): void;
     /**
      * Checks if a Bluetooth device is connected.
      * @returns {boolean} A boolean indicating whether the device is connected.
+     * @public
      */
     isConnected(): boolean;
     /**
      * Sets the callback function to be called when notifications are received.
      * @param {NotifyCallback} callback - The callback function to be set.
      * @returns {void}
+     * @public
      */
     notify(callback: (data: massObject) => void): void;
-    /**
-     * Handles the 'connected' event.
-     * @param {Function} onSuccess - Callback function to execute on successful connection.
-     */
-    onConnected(onSuccess: () => void): Promise<void>;
-    /**
-     * Handles the 'disconnected' event.
-     * @param {Event} event - The 'disconnected' event.
-     */
-    onDisconnected(event: Event): void;
     /**
      * Reads the value of the specified characteristic from the device.
      * @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 | undefined>} A promise that resolves when the read operation is completed.
+     * @public
      */
     read(serviceId: string, characteristicId: string, duration?: number): Promise<string | undefined>;
+    /**
+     * Initiates the tare calibration process.
+     * @param {number} duration - The duration time for tare calibration.
+     * @returns {void}
+     */
+    tare(duration?: number): void;
     /**
      * 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.
@@ -116,9 +122,8 @@ export interface IDevice extends IBase {
      * @param {string | Uint8Array | undefined} message - The message to be written to the characteristic. It can be a string or a Uint8Array.
      * @param {number} [duration=0] - Optional. The time in milliseconds to wait before resolving the promise. Defaults to 0 for immediate resolution.
      * @param {WriteCallback} [callback=writeCallback] - Optional. A custom callback to handle the response after the write operation is successful.
-     *
      * @returns {Promise<void>} A promise that resolves once the write operation is complete.
-     *
+     * @public
      * @throws {Error} Throws an error if the characteristic is undefined.
      *
      * @example

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

@@ -1,7 +1,4 @@
 import { Device } from "../device.model";
-import { applyTare } from "../../helpers/tare";
-import { checkActivity } from "../../helpers/is-active";
-import { DownloadPackets } from "../../helpers/download";
 export class Entralpi extends Device {
     constructor() {
         super({
@@ -157,15 +154,16 @@ export class Entralpi extends Device {
         const value = characteristic.value;
         if (value) {
             if (value.buffer) {
-                const buffer = value.buffer;
-                const rawData = new DataView(buffer);
                 const receivedTime = Date.now();
-                const receivedData = (rawData.getUint16(0) / 100).toFixed(1);
+                const receivedData = (value.getUint16(0) / 100).toFixed(1);
                 const convertedData = Number(receivedData);
-                // Tare correction
-                const numericData = convertedData - applyTare(convertedData);
+                // Adjust weight by using the tare value
+                // If tare is 0, use the original weight, otherwise subtract tare and invert.
+                // This will display the removed or 'no-hanging' weight.
+                const tare = this.applyTare(convertedData);
+                const numericData = tare === 0 ? convertedData : (convertedData - tare) * -1;
                 // Add data to downloadable Array
-                DownloadPackets.push({
+                this.downloadPackets.push({
                     received: receivedTime,
                     sampleNum: this.dataPointCount,
                     battRaw: 0,
@@ -181,7 +179,7 @@ export class Entralpi extends Device {
                 // Calculate the average dynamically
                 this.massAverage = (this.massTotalSum / this.dataPointCount).toFixed(1);
                 // Check if device is being used
-                checkActivity(numericData);
+                this.activityCheck(numericData);
                 // Notify with weight data
                 this.notifyCallback({
                     massMax: this.massMax,

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

@@ -1,7 +1,4 @@
 import { Device } from "../device.model";
-import { DownloadPackets, emptyDownloadPackets } from "../../helpers/download";
-import { checkActivity } from "../../helpers/is-active";
-import { applyTare } from "../../helpers/tare";
 /**
  * Represents a PitchSix Force Board device
  */
@@ -186,38 +183,41 @@ export class ForceBoard extends Device {
         const value = characteristic.value;
         if (value) {
             if (value.buffer) {
-                const buffer = value.buffer;
-                const rawData = new DataView(buffer);
                 const receivedTime = Date.now();
-                const receivedData = rawData.getUint8(4); // Read the value at index 4
-                // Convert from LBS to KG
-                const convertedReceivedData = receivedData * 0.453592;
-                // Tare correction
-                const numericData = convertedReceivedData - applyTare(convertedReceivedData);
-                // Add data to downloadable Array
-                DownloadPackets.push({
-                    received: receivedTime,
-                    sampleNum: this.dataPointCount,
-                    battRaw: 0,
-                    samples: [convertedReceivedData],
-                    masses: [numericData],
-                });
-                // Update massMax
-                this.massMax = Math.max(Number(this.massMax), numericData).toFixed(1);
-                // Update running sum and count
-                const currentMassTotal = Math.max(-1000, numericData);
-                this.massTotalSum += currentMassTotal;
-                this.dataPointCount++;
-                // Calculate the average dynamically
-                this.massAverage = (this.massTotalSum / this.dataPointCount).toFixed(1);
-                // Check if device is being used
-                checkActivity(numericData);
-                // Notify with weight data
-                this.notifyCallback({
-                    massMax: this.massMax,
-                    massAverage: this.massAverage,
-                    massTotal: Math.max(-1000, numericData).toFixed(1),
-                });
+                const dataArray = new Uint8Array(value.buffer);
+                // Skip the first 2 bytes, which are the command and length
+                // The data is sent in groups of 3 bytes
+                for (let i = 2; i < dataArray.length; i += 3) {
+                    const receivedData = (dataArray[i] << 16) | (dataArray[i + 1] << 8) | dataArray[i + 2];
+                    // Convert from LBS to KG
+                    const convertedReceivedData = receivedData * 0.453592;
+                    // Tare correction
+                    const numericData = convertedReceivedData - this.applyTare(convertedReceivedData);
+                    // Add data to downloadable Array
+                    this.downloadPackets.push({
+                        received: receivedTime,
+                        sampleNum: this.dataPointCount,
+                        battRaw: 0,
+                        samples: [convertedReceivedData],
+                        masses: [numericData],
+                    });
+                    // Update massMax
+                    this.massMax = Math.max(Number(this.massMax), numericData).toFixed(1);
+                    // Update running sum and count
+                    const currentMassTotal = Math.max(-1000, numericData);
+                    this.massTotalSum += currentMassTotal;
+                    this.dataPointCount++;
+                    // Calculate the average dynamically
+                    this.massAverage = (this.massTotalSum / this.dataPointCount).toFixed(1);
+                    // Check if device is being used
+                    this.activityCheck(numericData);
+                    // Notify with weight data
+                    this.notifyCallback({
+                        massMax: this.massMax,
+                        massAverage: this.massAverage,
+                        massTotal: Math.max(-1000, numericData).toFixed(1),
+                    });
+                }
             }
         }
     };
@@ -249,7 +249,7 @@ export class ForceBoard extends Device {
      */
     stream = async (duration = 0) => {
         // Reset download packets
-        emptyDownloadPackets();
+        this.downloadPackets.length = 0;
         // Start streaming data
         await this.write("weight", "tx", new Uint8Array([0x04]), duration); // ASCII control character EOT (End of Transmission)
         // Stop streaming if duration is set

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

@@ -43,28 +43,32 @@ export declare class KilterBoard extends Device implements IKilterBoard {
     /**
      * UUID for the Aurora Climbing Advertising service.
      * This constant is used to identify the specific Bluetooth service for Kilter Boards.
-     *
      * @type {string}
+     * @static
+     * @readonly
+     * @constant
      */
-    static AuroraUUID: string;
+    static readonly AuroraUUID: string;
     /**
      * Maximum length of the message body for byte wrapping.
      * This value defines the limit for the size of messages that can be sent or received
      * to ensure proper byte wrapping in communication.
-     *
      * @type {number}
      * @private
+     * @readonly
+     * @constant
      */
-    private MESSAGE_BODY_MAX_LENGTH;
+    private static readonly messageBodyMaxLength;
     /**
      * Maximum length of the Bluetooth message chunk.
      * This value sets the upper limit for the size of individual Bluetooth messages
      * sent to and from the device to comply with Bluetooth protocol constraints.
-     *
      * @type {number}
      * @private
+     * @readonly
+     * @constant
      */
-    private MAX_BLUETOOTH_MESSAGE_SIZE;
+    private static readonly maxBluetoothMessageSize;
     constructor();
     /**
      * Calculates the checksum for a byte array by summing up all bytes ot hre packet in a single-byte variable.

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

@@ -72,28 +72,32 @@ export class KilterBoard extends Device {
     /**
      * UUID for the Aurora Climbing Advertising service.
      * This constant is used to identify the specific Bluetooth service for Kilter Boards.
-     *
      * @type {string}
+     * @static
+     * @readonly
+     * @constant
      */
     static AuroraUUID = "4488b571-7806-4df6-bcff-a2897e4953ff";
     /**
      * Maximum length of the message body for byte wrapping.
      * This value defines the limit for the size of messages that can be sent or received
      * to ensure proper byte wrapping in communication.
-     *
      * @type {number}
      * @private
+     * @readonly
+     * @constant
      */
-    MESSAGE_BODY_MAX_LENGTH = 255;
+    static messageBodyMaxLength = 255;
     /**
      * Maximum length of the Bluetooth message chunk.
      * This value sets the upper limit for the size of individual Bluetooth messages
      * sent to and from the device to comply with Bluetooth protocol constraints.
-     *
      * @type {number}
      * @private
+     * @readonly
+     * @constant
      */
-    MAX_BLUETOOTH_MESSAGE_SIZE = 20;
+    static maxBluetoothMessageSize = 20;
     constructor() {
         super({
             filters: [
@@ -140,7 +144,7 @@ export class KilterBoard extends Device {
      * @returns The wrapped byte array.
      */
     wrapBytes(data) {
-        if (data.length > this.MESSAGE_BODY_MAX_LENGTH) {
+        if (data.length > KilterBoard.messageBodyMaxLength) {
             return [];
         }
         /**
@@ -202,7 +206,7 @@ export class KilterBoard extends Device {
         const resultArray = [];
         let tempArray = [KilterBoardPacket.V3_MIDDLE];
         for (const climbPlacement of climbPlacementList) {
-            if (tempArray.length + 3 > this.MESSAGE_BODY_MAX_LENGTH) {
+            if (tempArray.length + 3 > KilterBoard.messageBodyMaxLength) {
                 resultArray.push(tempArray);
                 tempArray = [KilterBoardPacket.V3_MIDDLE];
             }
@@ -252,7 +256,7 @@ export class KilterBoard extends Device {
      *
      * @param buffer
      */
-    splitMessages = (buffer) => this.splitEvery(this.MAX_BLUETOOTH_MESSAGE_SIZE, buffer).map((arr) => new Uint8Array(arr));
+    splitMessages = (buffer) => this.splitEvery(KilterBoard.maxBluetoothMessageSize, buffer).map((arr) => new Uint8Array(arr));
     /**
      * Sends a series of messages to a device.
      */

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

@@ -6,28 +6,32 @@ import type { IMotherboard } from "../../interfaces/device/motherboard.interface
 export declare class Motherboard extends Device implements IMotherboard {
     /**
      * Length of the packet received from the device.
-     * @private
      * @type {number}
+     * @static
+     * @readonly
+     * @constant
      */
-    private PACKET_LENGTH;
+    private static readonly packetLength;
     /**
      * Number of samples contained in the data packet.
-     * @private
      * @type {number}
+     * @static
+     * @readonly
+     * @constant
      */
-    private NUM_SAMPLES;
+    private static readonly samplesNumber;
     /**
      * Buffer to store received data from the device.
-     * @private
      * @type {number[]}
+     * @private
      */
     private receiveBuffer;
     /**
      * Calibration data for each sensor of the device.
-     * @private
      * @type {number[][][]}
+     * @private
      */
-    private CALIBRATION;
+    private calibrationData;
     constructor();
     /**
      * Applies calibration to a sample value.
@@ -35,7 +39,7 @@ export declare class Motherboard extends Device implements IMotherboard {
      * @param {number[][]} calibration - The calibration data.
      * @returns {number} The calibrated sample value.
      */
-    applyCalibration: (sample: number, calibration: number[][]) => number;
+    private applyCalibration;
     /**
      * Retrieves battery or voltage information from the device.
      * @returns {Promise<string | undefined>} A Promise that resolves with the battery or voltage information,