@hangtime/grip-connect 0.4.2 → 0.5.0

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

@@ -0,0 +1,9 @@
+import { Device } from "../device.model";
+import type { ImySmartBoard } from "../../interfaces/device/mysmartboard.interface";
+/**
+ * Represents a mySmartBoard device
+ * TODO: Add services, do you own a mySmartBoard? Help us!
+ */
+export declare class mySmartBoard extends Device implements ImySmartBoard {
+    constructor();
+}

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

@@ -0,0 +1,13 @@
+import { Device } from "../device.model";
+/**
+ * Represents a mySmartBoard device
+ * TODO: Add services, do you own a mySmartBoard? Help us!
+ */
+export class mySmartBoard extends Device {
+    constructor() {
+        super({
+            filters: [{ name: "mySmartBoard" }],
+            services: [],
+        });
+    }
+}

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

@@ -0,0 +1,32 @@
+import { Device } from "../device.model";
+import type { IProgressor } from "../../interfaces/device/progressor.interface";
+/**
+ * Represents a Tindeq Progressor device
+ */
+export declare class Progressor extends Device implements IProgressor {
+    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 firmware version from the device.
+     * @returns {Promise<string>} A Promise that resolves with the firmware version,
+     */
+    firmware: () => Promise<string | undefined>;
+    /**
+     * Handles data received from the 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: Event) => 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>;
+}

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

@@ -0,0 +1,177 @@
+import { Device } from "../device.model";
+import { notifyCallback } from "../../notify";
+import { applyTare } from "../../tare";
+import { checkActivity } from "../../is-active";
+import { ProgressorCommands, ProgressorResponses } from "../../commands/progressor";
+import struct from "../../struct";
+import { DownloadPackets, emptyDownloadPackets } from "../../download";
+import { lastWrite, write, writeCallback } from "../../write";
+import { stop } from "../../stop";
+// Constants
+let MASS_MAX = "0";
+let MASS_AVERAGE = "0";
+let MASS_TOTAL_SUM = 0;
+let DATAPOINT_COUNT = 0;
+/**
+ * Represents a Tindeq Progressor device
+ */
+export class Progressor extends Device {
+    constructor() {
+        super({
+            filters: [{ namePrefix: "Progressor" }],
+            services: [
+                {
+                    name: "Progressor Service",
+                    id: "progressor",
+                    uuid: "7e4e1701-1ea6-40c9-9dcc-13d34ffead57",
+                    characteristics: [
+                        {
+                            name: "Notify",
+                            id: "rx",
+                            uuid: "7e4e1702-1ea6-40c9-9dcc-13d34ffead57",
+                        },
+                        {
+                            name: "Write",
+                            id: "tx",
+                            uuid: "7e4e1703-1ea6-40c9-9dcc-13d34ffead57",
+                        },
+                    ],
+                },
+                {
+                    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",
+                        },
+                    ],
+                },
+            ],
+        });
+    }
+    /**
+     * 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()) {
+            let response = undefined;
+            await write(this, "progressor", "tx", ProgressorCommands.GET_BATT_VLTG, 250, (data) => {
+                response = data;
+            });
+            return response;
+        }
+        // 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 device
+            let response = undefined;
+            await write(this, "progressor", "tx", ProgressorCommands.GET_FW_VERSION, 250, (data) => {
+                response = data;
+            });
+            return response;
+        }
+        // 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 data = new DataView(buffer);
+                const receivedTime = Date.now();
+                const [kind] = struct("<bb").unpack(data.buffer.slice(0, 2));
+                if (kind === ProgressorResponses.WEIGHT_MEASURE) {
+                    const iterable = struct("<fi").iter_unpack(data.buffer.slice(2));
+                    // eslint-disable-next-line prefer-const
+                    for (let [weight, seconds] of iterable) {
+                        if (typeof weight === "number" && !isNaN(weight) && typeof seconds === "number" && !isNaN(seconds)) {
+                            // Add data to downloadable Array: sample and mass are the same
+                            DownloadPackets.push({
+                                received: receivedTime,
+                                sampleNum: seconds,
+                                battRaw: 0,
+                                samples: [weight],
+                                masses: [weight],
+                            });
+                            // Tare correction
+                            weight -= applyTare(weight);
+                            // Check for max weight
+                            MASS_MAX = Math.max(Number(MASS_MAX), Number(weight)).toFixed(1);
+                            // Update running sum and count
+                            const currentMassTotal = Math.max(-1000, Number(weight));
+                            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(weight);
+                            notifyCallback({
+                                massMax: MASS_MAX,
+                                massAverage: MASS_AVERAGE,
+                                massTotal: Math.max(-1000, weight).toFixed(1),
+                            });
+                        }
+                    }
+                }
+                else if (kind === ProgressorResponses.COMMAND_RESPONSE) {
+                    if (!lastWrite)
+                        return;
+                    let value = "";
+                    if (lastWrite === ProgressorCommands.GET_BATT_VLTG) {
+                        value = new DataView(data.buffer, 2).getUint32(0, true).toString();
+                    }
+                    else if (lastWrite === ProgressorCommands.GET_FW_VERSION) {
+                        value = new TextDecoder().decode(data.buffer.slice(2));
+                    }
+                    else if (lastWrite === ProgressorCommands.GET_ERR_INFO) {
+                        value = new TextDecoder().decode(data.buffer.slice(2));
+                    }
+                    writeCallback(value);
+                }
+                else if (kind === ProgressorResponses.LOW_BATTERY_WARNING) {
+                    console.warn("⚠️ Low power detected. Please consider connecting to a power source.");
+                }
+                else {
+                    throw new Error(`Unknown message kind detected: ${kind}`);
+                }
+            }
+        }
+    };
+    /**
+     * 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 = async (duration = 0) => {
+        if (this.isConnected()) {
+            // Reset download packets
+            emptyDownloadPackets();
+            // Start streaming data
+            await write(this, "progressor", "tx", ProgressorCommands.START_WEIGHT_MEAS, duration);
+            // Stop streaming if duration is set
+            if (duration !== 0) {
+                await stop(this);
+            }
+        }
+    };
+}

package/dist/models/device/wh-c06.model.d.ts

@@ -0,0 +1,15 @@
+import { Device } from "../device.model";
+import type { IWHC06 } from "../../interfaces/device/wh-c06.interface";
+/**
+ * Represents a  Weiheng - WH-C06 (or MAT Muscle Meter) device
+ * Enable 'Experimental Web Platform features' Chrome Flags.
+ */
+export declare class WHC06 extends Device implements IWHC06 {
+    constructor();
+    /**
+     * 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.
+     */
+    connect: (onSuccess?: () => void, onError?: (error: Error) => void) => Promise<void>;
+}

package/dist/models/device/wh-c06.model.js

@@ -0,0 +1,97 @@
+import { Device } from "../device.model";
+import { applyTare } from "../../tare";
+import { checkActivity } from "../../is-active";
+import { notifyCallback } from "../../notify";
+// Constants
+let MASS_MAX = "0";
+let MASS_AVERAGE = "0";
+let MASS_TOTAL_SUM = 0;
+let DATAPOINT_COUNT = 0;
+const WEIGHT_OFFSET = 10;
+// const STABLE_OFFSET = 14
+/**
+ * Represents a  Weiheng - WH-C06 (or MAT Muscle Meter) device
+ * Enable 'Experimental Web Platform features' Chrome Flags.
+ */
+export class WHC06 extends Device {
+    constructor() {
+        super({
+            filters: [
+                {
+                    // namePrefix: "IF_B7",
+                    manufacturerData: [
+                        {
+                            companyIdentifier: 0x0100, // 256
+                        },
+                    ],
+                },
+            ],
+            services: [],
+        });
+    }
+    /**
+     * 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.
+     */
+    connect = async (onSuccess = () => console.log("Connected successfully"), onError = (error) => console.error(error)) => {
+        try {
+            // Only data matching the optionalManufacturerData parameter to requestDevice is included in the advertisement event: https://github.com/WebBluetoothCG/web-bluetooth/issues/598
+            const optionalManufacturerData = this.filters.flatMap((filter) => filter.manufacturerData?.map((data) => data.companyIdentifier) || []);
+            this.bluetooth = await navigator.bluetooth.requestDevice({
+                filters: this.filters,
+                optionalManufacturerData,
+            });
+            if (!this.bluetooth.gatt) {
+                throw new Error("GATT is not available on this device");
+            }
+            // WH-C06
+            const MANUFACTURER_ID = 256; // 0x0100
+            this.bluetooth.addEventListener("advertisementreceived", (event) => {
+                const data = event.manufacturerData.get(MANUFACTURER_ID);
+                if (data) {
+                    // Device has no services / characteristics
+                    onSuccess();
+                    // Handle recieved data
+                    const weight = (data.getUint8(WEIGHT_OFFSET) << 8) | data.getUint8(WEIGHT_OFFSET + 1);
+                    // const stable = (data.getUint8(STABLE_OFFSET) & 0xf0) >> 4
+                    // const unit = data.getUint8(STABLE_OFFSET) & 0x0f
+                    let numericData = weight / 100;
+                    // 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),
+                    });
+                }
+            });
+            // When the companyIdentifier is provided we want to get manufacturerData using watchAdvertisements.
+            if (optionalManufacturerData.length) {
+                // Receive events when the system receives an advertisement packet from a watched device.
+                // To use this function in Chrome: chrome://flags/#enable-experimental-web-platform-features has to be enabled.
+                // More info: https://chromestatus.com/feature/5180688812736512
+                if (typeof this.bluetooth.watchAdvertisements === "function") {
+                    await this.bluetooth.watchAdvertisements();
+                }
+                else {
+                    throw new Error("watchAdvertisements isn't supported. For Chrome, enable it at chrome://flags/#enable-experimental-web-platform-features.");
+                }
+            }
+        }
+        catch (error) {
+            onError(error);
+        }
+    };
+}

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

@@ -0,0 +1,45 @@
+import { BaseModel } from "./../models/base.model";
+import type { IDevice, Service } from "../interfaces/device.interface";
+export declare class Device extends BaseModel implements IDevice {
+    filters: BluetoothLEScanFilter[];
+    services: Service[];
+    bluetooth?: BluetoothDevice | undefined;
+    constructor(device: Partial<IDevice>);
+    /**
+     * Handles the 'disconnected' event.
+     * @param {Event} event - The 'disconnected' event.
+     */
+    onDisconnected: (event: Event) => void;
+    /**
+     * Handles notifications received from a characteristic.
+     * @param {Event} event - The notification event.
+     */
+    handleNotifications: (event: Event) => void;
+    /**
+     * Handles the 'connected' event.
+     * @param {Function} onSuccess - Callback function to execute on successful connection.
+     */
+    onConnected: (onSuccess: () => void) => Promise<void>;
+    /**
+     * Returns UUIDs of all services associated with the device.
+     * @returns {string[]} Array of service UUIDs.
+     */
+    getAllServiceUUIDs: () => string[];
+    /**
+     * 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.
+     */
+    connect: (onSuccess?: () => void, onError?: (error: Error) => void) => Promise<void>;
+    /**
+     * Checks if a Bluetooth device is connected.
+     * @returns {boolean} A boolean indicating whether the device is connected.
+     */
+    isConnected: () => boolean;
+    /**
+     * 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.
+     */
+    disconnect: () => void;
+}

package/dist/models/device.model.js

@@ -0,0 +1,140 @@
+import { BaseModel } from "./../models/base.model";
+let server;
+export class Device extends BaseModel {
+    filters;
+    services;
+    bluetooth;
+    constructor(device) {
+        super(device);
+        this.filters = device.filters || [];
+        this.services = device.services || [];
+        this.bluetooth = device.bluetooth;
+    }
+    /**
+     * Handles the 'disconnected' event.
+     * @param {Event} event - The 'disconnected' event.
+     */
+    onDisconnected = (event) => {
+        this.bluetooth = undefined;
+        const device = event.target;
+        throw new Error(`Device ${device.name} is disconnected.`);
+    };
+    /**
+     * Handles notifications received from a characteristic.
+     * @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;
+                console.log(new Uint8Array(buffer));
+                const rawData = new DataView(buffer);
+                console.log(rawData);
+            }
+            else {
+                console.log(value);
+            }
+        }
+    };
+    /**
+     * 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();
+        if (!services || services.length === 0) {
+            throw new Error("No services found");
+        }
+        for (const service of services) {
+            const matchingService = this.services.find((boardService) => boardService.uuid === service.uuid);
+            if (matchingService) {
+                // Android bug: Introduce a delay before getting characteristics
+                await new Promise((resolve) => setTimeout(resolve, 100));
+                const characteristics = await service.getCharacteristics();
+                for (const characteristic of matchingService.characteristics) {
+                    const matchingCharacteristic = characteristics.find((char) => char.uuid === characteristic.uuid);
+                    if (matchingCharacteristic) {
+                        const element = matchingService.characteristics.find((char) => char.uuid === matchingCharacteristic.uuid);
+                        if (element) {
+                            element.characteristic = matchingCharacteristic;
+                            // notify
+                            if (element.id === "rx") {
+                                matchingCharacteristic.startNotifications();
+                                matchingCharacteristic.addEventListener("characteristicvaluechanged", (event) => {
+                                    this.handleNotifications(event);
+                                });
+                            }
+                        }
+                    }
+                    else {
+                        throw new Error(`Characteristic ${characteristic.uuid} not found in service ${service.uuid}`);
+                    }
+                }
+            }
+        }
+        // Call the onSuccess callback after successful connection and setup
+        onSuccess();
+    };
+    /**
+     * Returns UUIDs of all services associated with the device.
+     * @returns {string[]} Array of service UUIDs.
+     */
+    getAllServiceUUIDs = () => {
+        return this.services.map((service) => service.uuid);
+    };
+    /**
+     * 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.
+     */
+    connect = async (onSuccess = () => console.log("Connected successfully"), onError = (error) => console.error(error)) => {
+        try {
+            // Request device and set up connection
+            const deviceServices = this.getAllServiceUUIDs();
+            this.bluetooth = await navigator.bluetooth.requestDevice({
+                filters: this.filters,
+                optionalServices: deviceServices,
+            });
+            if (!this.bluetooth.gatt) {
+                throw new Error("GATT is not available on this device");
+            }
+            this.bluetooth.addEventListener("gattserverdisconnected", (event) => {
+                this.onDisconnected(event);
+            });
+            server = await this.bluetooth.gatt.connect();
+            if (server.connected) {
+                await this.onConnected(onSuccess);
+            }
+        }
+        catch (error) {
+            onError(error);
+        }
+    };
+    /**
+     * Checks if a Bluetooth device is connected.
+     * @returns {boolean} A boolean indicating whether the device is connected.
+     */
+    isConnected = () => {
+        // Check if the device is defined and available
+        if (!this?.bluetooth) {
+            return false;
+        }
+        // Check if the device is connected
+        return !!this.bluetooth.gatt?.connected;
+    };
+    /**
+     * 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.
+     */
+    disconnect = () => {
+        // Verify that the device is connected using the provided helper function
+        if (this.isConnected()) {
+            // Safely attempt to disconnect the device's GATT server, if available
+            this.bluetooth?.gatt?.disconnect();
+        }
+    };
+}

package/dist/models/index.d.ts

@@ -0,0 +1,8 @@
+export { Climbro } from "./device/climbro.model";
+export { Entralpi } from "./device/entralpi.model";
+export { ForceBoard } from "./device/forceboard.model";
+export { KilterBoard } from "./device/kilterboard.model";
+export { Motherboard } from "./device/motherboard.model";
+export { mySmartBoard } from "./device/mysmartboard.model";
+export { Progressor } from "./device/progressor.model";
+export { WHC06 } from "./device/wh-c06.model";

package/dist/models/index.js

@@ -0,0 +1,8 @@
+export { Climbro } from "./device/climbro.model";
+export { Entralpi } from "./device/entralpi.model";
+export { ForceBoard } from "./device/forceboard.model";
+export { KilterBoard } from "./device/kilterboard.model";
+export { Motherboard } from "./device/motherboard.model";
+export { mySmartBoard } from "./device/mysmartboard.model";
+export { Progressor } from "./device/progressor.model";
+export { WHC06 } from "./device/wh-c06.model";

package/dist/notify.js

@@ -3,7 +3,7 @@
  * @callback NotifyCallback
  * @param {massObject} data - The data passed to the callback.
  */
-export let notifyCallback;
+export let notifyCallback = (data) => console.log(data);
 /**
  * Sets the callback function to be called when notifications are received.
  * @param {NotifyCallback} callback - The callback function to be set.

package/dist/read.d.ts

@@ -1,4 +1,4 @@
-import type { Device } from "./types/devices";
+import type { Device } from "./models/device.model";
 /**
  * Reads the value of the specified characteristic from the device.
  * @param {Device} board - The device to read from.

package/dist/read.js

@@ -1,5 +1,4 @@
 import { getCharacteristic } from "./characteristic";
-import { isConnected } from "./is-connected";
 /**
  * Reads the value of the specified characteristic from the device.
  * @param {Device} board - The device to read from.
@@ -10,7 +9,7 @@ import { isConnected } from "./is-connected";
  */
 export const read = (board, serviceId, characteristicId, duration = 0) => {
     return new Promise((resolve, reject) => {
-        if (isConnected(board)) {
+        if (board.isConnected()) {
             const characteristic = getCharacteristic(board, serviceId, characteristicId);
             if (characteristic) {
                 characteristic

package/dist/stop.d.ts

@@ -1,4 +1,4 @@
-import type { Device } from "./types/devices";
+import type { Device } from "./models/device.model";
 /**
  * Stops the data stream on the specified device.
  * @param {Device} board - The device to stop the stream on.

package/dist/stop.js

@@ -1,5 +1,4 @@
 import { write } from "./write";
-import { isConnected } from "./is-connected";
 import { MotherboardCommands, ProgressorCommands } from "./commands";
 import { isMotherboard, isProgressor } from "./is-device";
 /**
@@ -8,7 +7,7 @@ import { isMotherboard, isProgressor } from "./is-device";
  * @returns {Promise<void>} A promise that resolves when the stream is stopped.
  */
 export const stop = async (board) => {
-    if (isConnected(board)) {
+    if (board.isConnected()) {
         if (isMotherboard(board)) {
             // Stop stream on Motherboard
             await write(board, "uart", "tx", MotherboardCommands.STOP_WEIGHT_MEAS, 0);

package/dist/write.d.ts

@@ -1,4 +1,4 @@
-import type { Device } from "./types/devices";
+import type { Device } from "./models/device.model";
 /**
  * The last message written to the device.
  * @type {string | Uint8Array | null}

package/dist/write.js

@@ -1,4 +1,3 @@
-import { isConnected } from "./is-connected";
 import { getCharacteristic } from "./characteristic";
 /**
  * The last message written to the device.
@@ -32,7 +31,7 @@ export let writeCallback = (data) => {
  * });
  */
 export const write = async (board, serviceId, characteristicId, message, duration = 0, callback = writeCallback) => {
-    if (isConnected(board)) {
+    if (board.isConnected()) {
         // Check if message is provided
         if (message === undefined) {
             // If not provided, return without performing write operation

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hangtime/grip-connect",
-  "version": "0.4.2",
-  "description": "A client that can establish connections with various Force-Sensing Hangboards/Plates used by climbers for strength measurement. Examples of such hangboards include the Griptonite Motherboard, Climbro, SmartBoard, Entralpi or Tindeq Progressor",
+  "version": "0.5.0",
+  "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",
   "scripts": {
@@ -23,6 +23,8 @@
     "motherboard",
     "tindeq",
     "progressor",
+    "pitchsix",
+    "forceboard",
     "entralpi",
     "wh-c06",
     "kilterboard"

package/src/characteristic.ts

@@ -1,4 +1,4 @@
-import type { Device } from "./types/devices"
+import type { Device } from "./models/device.model"
 
 /**
  * Retrieves the characteristic from the device's service.

package/src/commands/forceboard.ts

@@ -0,0 +1,6 @@
+import type { Commands } from "../types/commands"
+/**
+ * Warning:
+ * Using other commands can seriously harm your device
+ */
+export const ForceBoardCommands: Commands = {}