@hangtime/grip-connect 0.3.10 → 0.4.1

package/dist/led.js

@@ -1,7 +1,7 @@
 import { write } from "./write";
 import { isConnected } from "./is-connected";
-import { KilterBoard, Motherboard } from "./devices";
 import { KilterBoardPacket, KilterBoardPlacementRoles } from "./commands/kilterboard";
+import { isKilterboard, isMotherboard } from "./is-device";
 /**
  * Maximum length of the message body for byte wrapping.
  */
@@ -152,44 +152,45 @@ const splitMessages = (buffer) => splitEvery(MAX_BLUETOOTH_MESSAGE_SIZE, buffer)
 /**
  * Sends a series of messages to a device.
  */
-async function writeMessageSeries(messages) {
+async function writeMessageSeries(board, messages) {
     for (const message of messages) {
-        await write(KilterBoard, "uart", "tx", message);
+        await write(board, "uart", "tx", message);
     }
 }
 /**
  * Sets the LEDs on the specified device.
+ *
+ * - For Kilter Board: Configures the LEDs based on an array of climb placements. If a configuration is provided, it prepares and sends a payload to the device.
+ * - For Motherboard: Sets the LED color based on a single color option. Defaults to turning the LEDs off if no configuration is provided.
+ *
  * @param {Device} board - The device on which to set the LEDs.
- * @param {ClimbPlacement[]} [placement] - An optional array of climb placements for LED positioning.
- * @returns {Promise<number[] | undefined>} A promise that resolves with the payload array if LED settings were applied, or `undefined` if no action was taken.
+ * @param {"green" | "red" | "orange" | ClimbPlacement[]} [config] - Optional color or array of climb placements for the LEDs. Ignored if placements are provided.
+ * @returns {Promise<number[] | undefined>} A promise that resolves with the payload array for the Kilter Board if LED settings were applied, or `undefined` if no action was taken or for the Motherboard.
  */
-export const led = async (board, placement) => {
-    // Check if the filter contains the Aurora Climbing Advertising service
-    const AuroraUUID = "4488b571-7806-4df6-bcff-a2897e4953ff";
-    if (board.filters.some((filter) => filter.services?.includes(AuroraUUID))) {
-        // The Aurora Boards needs a LED / Postion Placememnet Array
-        if (placement) {
-            // Prepares byte arrays for transmission based on a list of climb placements.
-            const payload = prepBytesV3(placement);
-            // Sends the payload to the device by splitting it into messages and writing each message.
-            if (isConnected(board)) {
-                writeMessageSeries(splitMessages(payload));
-            }
-            return payload;
+export const led = async (board, config) => {
+    // Handle Kilterboard logic: process placements and send payload if connected
+    if (isKilterboard(board) && Array.isArray(config)) {
+        // Prepares byte arrays for transmission based on a list of climb placements.
+        const payload = prepBytesV3(config);
+        if (isConnected(board)) {
+            await writeMessageSeries(board, splitMessages(payload));
         }
+        return payload;
     }
-    if (board.filters.some((filter) => filter.name === "Motherboard")) {
-        console.log("Green");
-        await write(Motherboard, "led", "red", new Uint8Array([0x00]));
-        await write(Motherboard, "led", "green", new Uint8Array([0x01]), 2500);
-        console.log("Red");
-        await write(Motherboard, "led", "red", new Uint8Array([0x01]));
-        await write(Motherboard, "led", "green", new Uint8Array([0x00]), 2500);
-        console.log("Orage");
-        await write(Motherboard, "led", "red", new Uint8Array([0x01]));
-        await write(Motherboard, "led", "green", new Uint8Array([0x01]), 2500);
-        console.log("Off");
-        await write(Motherboard, "led", "red", new Uint8Array([0x00]));
-        await write(Motherboard, "led", "green", new Uint8Array([0x00]), 2500);
+    // Handle Motherboard logic: set color if provided
+    if (isMotherboard(board)) {
+        const colorMapping = {
+            green: [[0x00], [0x01]],
+            red: [[0x01], [0x00]],
+            orange: [[0x01], [0x01]],
+            off: [[0x00], [0x00]],
+        };
+        // Default to "off" color if config is not set or not found in colorMapping
+        const color = typeof config === "string" && colorMapping[config] ? config : "off";
+        const [redValue, greenValue] = colorMapping[color];
+        await write(board, "led", "red", new Uint8Array(redValue));
+        await write(board, "led", "green", new Uint8Array(greenValue), 1250);
+        return;
     }
+    return;
 };

package/dist/manufacturer.d.ts

@@ -0,0 +1,11 @@
+import type { Device } from "./types/devices";
+/**
+ * Retrieves manufacturer information from the device.
+ * - For Motherboard devices, it reads the manufacturer information.
+ *
+ * @param {Device} board - The device from which to retrieve manufacturer information.
+ * @returns {Promise<string>} A Promise that resolves with the manufacturer information,
+ *                            or rejects with an error if the device is not connected.
+ * @throws {Error} Throws an error if the device is not connected.
+ */
+export declare const manufacturer: (board: Device) => Promise<string | undefined>;

package/dist/manufacturer.js

@@ -0,0 +1,25 @@
+import { read } from "./read";
+import { isConnected } from "./is-connected";
+import { isMotherboard } from "./is-device";
+/**
+ * Retrieves manufacturer information from the device.
+ * - For Motherboard devices, it reads the manufacturer information.
+ *
+ * @param {Device} board - The device from which to retrieve manufacturer information.
+ * @returns {Promise<string>} A Promise that resolves with the manufacturer information,
+ *                            or rejects with an error if the device is not connected.
+ * @throws {Error} Throws an error if the device is not connected.
+ */
+export const manufacturer = async (board) => {
+    // Check if the device is connected
+    if (isConnected(board)) {
+        // If the device is connected and it is a Motherboard device
+        if (isMotherboard(board)) {
+            // Read manufacturer information from the Motherboard
+            return await read(board, "device", "manufacturer", 250);
+        }
+        // If device is not found, return undefined
+        return;
+    }
+    throw new Error("Not connected.");
+};

package/dist/read.d.ts

@@ -5,6 +5,6 @@ import type { Device } from "./types/devices";
  * @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<void>} A promise that resolves when the read operation is completed.
+ * @returns {Promise<string>} A promise that resolves when the read operation is completed.
  */
-export declare const read: (board: Device, serviceId: string, characteristicId: string, duration?: number) => Promise<void>;
+export declare const read: (board: Device, serviceId: string, characteristicId: string, duration?: number) => Promise<string>;

package/dist/read.js

@@ -6,7 +6,7 @@ import { isConnected } from "./is-connected";
  * @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<void>} A promise that resolves when the read operation is completed.
+ * @returns {Promise<string>} A promise that resolves when the read operation is completed.
  */
 export const read = (board, serviceId, characteristicId, duration = 0) => {
     return new Promise((resolve, reject) => {
@@ -21,17 +21,15 @@ export const read = (board, serviceId, characteristicId, duration = 0) => {
                     switch (characteristicId) {
                         case "level":
                             // TODO: This is Motherboard specific.
-                            decodedValue = value.getUint8(0);
+                            decodedValue = value.getUint8(0).toString();
                             break;
                         default:
                             decodedValue = decoder.decode(value);
                             break;
                     }
-                    // TODO: Create Read callback
-                    console.log(decodedValue);
                     // Resolve after specified duration
                     setTimeout(() => {
-                        resolve();
+                        return resolve(decodedValue);
                     }, duration);
                 })
                     .catch((error) => {

package/dist/serial.d.ts

@@ -0,0 +1,11 @@
+import type { Device } from "./types/devices";
+/**
+ * Retrieves serial number from the device.
+ * - For Motherboard devices, it reads the serial number.
+ *
+ * @param {Device} board - The device from which to retrieve serial number.
+ * @returns {Promise<string>} A Promise that resolves with the serial number,
+ *                            or rejects with an error if the device is not connected.
+ * @throws {Error} Throws an error if the device is not connected.
+ */
+export declare const serial: (board: Device) => Promise<string | undefined>;

package/dist/serial.js

@@ -0,0 +1,30 @@
+import { write } from "./write";
+import { isConnected } from "./is-connected";
+import { MotherboardCommands } from "./commands";
+import { isMotherboard } from "./is-device";
+/**
+ * Retrieves serial number from the device.
+ * - For Motherboard devices, it reads the serial number.
+ *
+ * @param {Device} board - The device from which to retrieve serial number.
+ * @returns {Promise<string>} A Promise that resolves with the serial number,
+ *                            or rejects with an error if the device is not connected.
+ * @throws {Error} Throws an error if the device is not connected.
+ */
+export const serial = async (board) => {
+    // Check if the device is connected
+    if (isConnected(board)) {
+        // If the device is connected and it is a Motherboard device
+        if (isMotherboard(board)) {
+            // Write serial number command to the Motherboard and read output
+            let response = undefined;
+            await write(board, "uart", "tx", MotherboardCommands.GET_SERIAL, 250, (data) => {
+                response = data;
+            });
+            return response;
+        }
+        // If device is not found, return undefined
+        return;
+    }
+    throw new Error("Not connected.");
+};

package/dist/stop.js

@@ -1,7 +1,7 @@
 import { write } from "./write";
 import { isConnected } from "./is-connected";
-import { Motherboard, Progressor } from "./devices";
 import { MotherboardCommands, ProgressorCommands } from "./commands";
+import { isMotherboard, isProgressor } from "./is-device";
 /**
  * Stops the data stream on the specified device.
  * @param {Device} board - The device to stop the stream on.
@@ -9,13 +9,13 @@ import { MotherboardCommands, ProgressorCommands } from "./commands";
  */
 export const stop = async (board) => {
     if (isConnected(board)) {
-        if (board.filters.some((filter) => filter.name === "Motherboard")) {
+        if (isMotherboard(board)) {
             // Stop stream on Motherboard
-            await write(Motherboard, "uart", "tx", MotherboardCommands.STOP_WEIGHT_MEAS, 0);
+            await write(board, "uart", "tx", MotherboardCommands.STOP_WEIGHT_MEAS, 0);
         }
-        if (board.filters.some((filter) => filter.namePrefix === "Progressor")) {
+        if (isProgressor(board)) {
             // Stop stream on Progressor
-            await write(Progressor, "progressor", "tx", ProgressorCommands.STOP_WEIGHT_MEAS, 0);
+            await write(board, "progressor", "tx", ProgressorCommands.STOP_WEIGHT_MEAS, 0);
         }
     }
 };

package/dist/stream.js

@@ -1,7 +1,7 @@
 import { isConnected } from "./is-connected";
 import { write } from "./write";
 import { stop } from "./stop";
-import { Motherboard, Progressor } from "./devices";
+import { isMotherboard, isProgressor } from "./is-device";
 import { MotherboardCommands, ProgressorCommands } from "./commands";
 import { emptyDownloadPackets } from "./download";
 import { CALIBRATION } from "./data/motherboard";
@@ -17,24 +17,24 @@ export const stream = async (board, duration = 0) => {
         // Reset download packets
         emptyDownloadPackets();
         // Device specific logic
-        if (board.filters.some((filter) => filter.name === "Motherboard")) {
+        if (isMotherboard(board)) {
             // Read calibration data if not already available
             if (!CALIBRATION[0].length) {
-                await calibration(Motherboard);
+                await calibration(board);
             }
             // Start streaming data
-            await write(Motherboard, "uart", "tx", MotherboardCommands.START_WEIGHT_MEAS, duration);
+            await write(board, "uart", "tx", MotherboardCommands.START_WEIGHT_MEAS, duration);
             // Stop streaming if duration is set
             if (duration !== 0) {
-                await stop(Motherboard);
+                await stop(board);
             }
         }
-        if (board.filters.some((filter) => filter.namePrefix === "Progressor")) {
+        if (isProgressor(board)) {
             // Start streaming data
-            await write(Progressor, "progressor", "tx", ProgressorCommands.START_WEIGHT_MEAS, duration);
+            await write(board, "progressor", "tx", ProgressorCommands.START_WEIGHT_MEAS, duration);
             // Stop streaming if duration is set
             if (duration !== 0) {
-                await stop(Progressor);
+                await stop(board);
             }
         }
     }

package/dist/text.d.ts

@@ -0,0 +1,14 @@
+import type { Device } from "./types/devices";
+/**
+ * Retrieves the entire 320 bytes of non-volatile memory from the device.
+ *
+ * The memory consists of 10 segments, each 32 bytes long. If any segment was previously written,
+ * the corresponding data will appear in the response. Unused portions of the memory are
+ * padded with whitespace.
+ *
+ * @param {Device} board - The device from which to retrieve text information.
+ * @returns {Promise<string>} A Promise that resolves with the 320-byte memory content as a string,
+ *                            which includes both the written data and any unused, whitespace-padded segments.
+ * @throws {Error} Throws an error if the device is not connected.
+ */
+export declare const text: (board: Device) => Promise<string | undefined>;

package/dist/text.js

@@ -0,0 +1,33 @@
+import { write } from "./write";
+import { isConnected } from "./is-connected";
+import { isMotherboard } from "./is-device";
+import { MotherboardCommands } from "./commands";
+/**
+ * Retrieves the entire 320 bytes of non-volatile memory from the device.
+ *
+ * The memory consists of 10 segments, each 32 bytes long. If any segment was previously written,
+ * the corresponding data will appear in the response. Unused portions of the memory are
+ * padded with whitespace.
+ *
+ * @param {Device} board - The device from which to retrieve text information.
+ * @returns {Promise<string>} A Promise that resolves with the 320-byte memory content as a string,
+ *                            which includes both the written data and any unused, whitespace-padded segments.
+ * @throws {Error} Throws an error if the device is not connected.
+ */
+export const text = async (board) => {
+    // Check if the device is connected
+    if (isConnected(board)) {
+        // If the device is connected and it is a Motherboard device
+        if (isMotherboard(board)) {
+            // Write text information command to the Motherboard and read output
+            let response = undefined;
+            await write(board, "uart", "tx", MotherboardCommands.GET_TEXT, 250, (data) => {
+                response = data;
+            });
+            return response;
+        }
+        // If device is not found, return undefined
+        return;
+    }
+    throw new Error("Not connected.");
+};

package/dist/write.d.ts

@@ -4,13 +4,31 @@ import type { Device } from "./types/devices";
  * @type {string | Uint8Array | null}
  */
 export declare let lastWrite: string | Uint8Array | null;
+/** Define the type for the callback function */
+type WriteCallback = (data: string) => void;
 /**
- * Writes a message to the specified characteristic of the device.
- * @param {Device} board - The device board to write to.
- * @param {string} serviceId - The service ID where the characteristic belongs.
- * @param {string} characteristicId - The characteristic ID to write to.
- * @param {string | Uint8Array | undefined} message - The message to write.
- * @param {number} [duration=0] - The duration to wait before resolving the promise, in milliseconds.
- * @returns {Promise<void>} A promise that resolves when the write operation is completed.
+ * A default write callback that logs the response
  */
-export declare const write: (board: Device, serviceId: string, characteristicId: string, message: string | Uint8Array | undefined, duration?: number) => Promise<void>;
+export declare let writeCallback: WriteCallback;
+/**
+ * Writes a message to the specified characteristic of a Bluetooth device and optionally provides a callback to handle responses.
+ *
+ * @param {Device} board - The Bluetooth device to which the message will be written.
+ * @param {string} serviceId - The service UUID of the Bluetooth device containing the target characteristic.
+ * @param {string} characteristicId - The characteristic UUID where the message will be written.
+ * @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.
+ *
+ * @throws {Error} Throws an error if the characteristic is undefined or if the device is not connected.
+ *
+ * @example
+ * // Example usage of the write function with a custom callback
+ * await write(device, "serviceId", "characteristicId", "Hello World", 250, (data) => {
+ *   console.log(`Custom response: ${data}`);
+ * });
+ */
+export declare const write: (board: Device, serviceId: string, characteristicId: string, message: string | Uint8Array | undefined, duration?: number, callback?: WriteCallback) => Promise<void>;
+export {};

package/dist/write.js

@@ -6,52 +6,55 @@ import { getCharacteristic } from "./characteristic";
  */
 export let lastWrite = null;
 /**
- * Writes a message to the specified characteristic of the device.
- * @param {Device} board - The device board to write to.
- * @param {string} serviceId - The service ID where the characteristic belongs.
- * @param {string} characteristicId - The characteristic ID to write to.
- * @param {string | Uint8Array | undefined} message - The message to write.
- * @param {number} [duration=0] - The duration to wait before resolving the promise, in milliseconds.
- * @returns {Promise<void>} A promise that resolves when the write operation is completed.
+ * A default write callback that logs the response
  */
-export const write = (board, serviceId, characteristicId, message, duration = 0) => {
-    return new Promise((resolve, reject) => {
-        if (isConnected(board)) {
-            // 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 = getCharacteristic(board, serviceId, characteristicId);
-            if (characteristic) {
-                // 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
-                characteristic
-                    .writeValue(valueToWrite)
-                    .then(() => {
-                    // Update the last written message
-                    lastWrite = message;
-                    // If a duration is specified, resolve the promise after the duration
-                    if (duration > 0) {
-                        setTimeout(() => {
-                            resolve();
-                        }, duration);
-                    }
-                    else {
-                        // Otherwise, resolve the promise immediately
-                        resolve();
-                    }
-                })
-                    .catch((error) => {
-                    reject(error);
-                });
-            }
-            else {
-                // Reject if characteristic is undefined
-                reject(new Error("Characteristics is undefined"));
-            }
-        }
-    });
+export let writeCallback = (data) => {
+    console.log(data);
+};
+/**
+ * Writes a message to the specified characteristic of a Bluetooth device and optionally provides a callback to handle responses.
+ *
+ * @param {Device} board - The Bluetooth device to which the message will be written.
+ * @param {string} serviceId - The service UUID of the Bluetooth device containing the target characteristic.
+ * @param {string} characteristicId - The characteristic UUID where the message will be written.
+ * @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.
+ *
+ * @throws {Error} Throws an error if the characteristic is undefined or if the device is not connected.
+ *
+ * @example
+ * // Example usage of the write function with a custom callback
+ * await write(device, "serviceId", "characteristicId", "Hello World", 250, (data) => {
+ *   console.log(`Custom response: ${data}`);
+ * });
+ */
+export const write = async (board, serviceId, characteristicId, message, duration = 0, callback = writeCallback) => {
+    if (!isConnected(board)) {
+        throw new Error("Device is not connected");
+    }
+    // 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 = getCharacteristic(board, 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
+    lastWrite = message;
+    // Assign the provided callback to `writeCallback`
+    writeCallback = callback;
+    // If a duration is specified, resolve the promise after the duration
+    if (duration > 0) {
+        await new Promise((resolve) => setTimeout(resolve, duration));
+    }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hangtime/grip-connect",
-  "version": "0.3.10",
+  "version": "0.4.1",
   "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",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/battery.ts

@@ -2,26 +2,38 @@ import type { Device } from "./types/devices"
 import { write } from "./write"
 import { read } from "./read"
 import { isConnected } from "./is-connected"
-import { Motherboard, Progressor } from "./devices"
+import { isMotherboard, isProgressor } from "./is-device"
 import { ProgressorCommands } from "./commands"
 
 /**
  * Retrieves battery or voltage information from the device.
- * @param {Device} board - The device.
- * @returns {Promise<void>} A Promise that resolves when the information is successfully retrieved.
+ * - For Motherboard devices, it reads the battery level.
+ * - For Progressor devices, it sends a command to retrieve battery voltage information.
+ *
+ * @param {Device} board - The device from which to retrieve battery information.
+ * @returns {Promise<string | undefined>} A Promise that resolves with the battery or voltage information,
+ *                            or rejects with an error if the device is not connected.
+ * @throws {Error} Throws an error if the device is not connected.
  */
-export const battery = async (board: Device): Promise<void> => {
+export const battery = async (board: Device): Promise<string | undefined> => {
   // Check if the device is connected
   if (isConnected(board)) {
     // If the device is connected and it is a Motherboard device
-    if (board.filters.some((filter) => filter.name === "Motherboard")) {
+    if (isMotherboard(board)) {
       // Read battery level information from the Motherboard
-      await read(Motherboard, "battery", "level", 250)
+      return await read(board, "battery", "level", 250)
     }
     // If the device is connected and its name starts with "Progressor"
-    if (board.filters.some((filter) => filter.namePrefix === "Progressor")) {
+    if (isProgressor(board)) {
       // Write command to get battery voltage information to the Progressor
-      await write(Progressor, "progressor", "tx", ProgressorCommands.GET_BATT_VLTG, 250)
+      let response: string | undefined = undefined
+      await write(board, "progressor", "tx", ProgressorCommands.GET_BATT_VLTG, 250, (data) => {
+        response = data
+      })
+      return response
     }
+    // If device is not found, return undefined
+    return
   }
+  throw new Error("Not connected.")
 }

package/src/calibration.ts

@@ -1,7 +1,7 @@
 import type { Device } from "./types/devices"
 import { isConnected } from "./is-connected"
 import { write } from "./write"
-import { Motherboard } from "./devices"
+import { isMotherboard } from "./is-device"
 import { MotherboardCommands } from "./commands"
 
 /**
@@ -13,9 +13,11 @@ export const calibration = async (board: Device): Promise<void> => {
   // Check if the device is connected
   if (isConnected(board)) {
     // If the device is connected, and it is a Motherboard device
-    if (board.filters.some((filter) => filter.name === "Motherboard")) {
+    if (isMotherboard(board)) {
       // Write the command to get calibration data to the device
-      await write(Motherboard, "uart", "tx", MotherboardCommands.GET_CALIBRATION, 2500)
+      await write(board, "uart", "tx", MotherboardCommands.GET_CALIBRATION, 2500, (data) => {
+        console.log(data)
+      })
     }
   }
 }

package/src/commands/kilterboard.ts

@@ -58,7 +58,7 @@ export const KilterBoardPlacementRoles = [
     position: 4,
     name: "foot",
     full_name: "Foot Only",
-    led_color: "FFA500",
+    led_color: "FFB600",
     screen_color: "FFA500",
   },
 ]

package/src/connect.ts

@@ -1,5 +1,6 @@
 import type { Device } from "./types/devices"
 import { handleEntralpiData, handleMotherboardData, handleProgressorData, handleWHC06Data } from "./data"
+import { isEntralpi, isMotherboard, isProgressor } from "./is-device"
 
 let server: BluetoothRemoteGATTServer
 const receiveBuffer: number[] = []
@@ -25,7 +26,7 @@ const handleNotifications = (event: Event, board: Device): void => {
 
   if (value) {
     // If the device is connected and it is a Motherboard device
-    if (board.filters.some((filter) => filter.name === "Motherboard")) {
+    if (isMotherboard(board)) {
       for (let i = 0; i < value.byteLength; i++) {
         receiveBuffer.push(value.getUint8(i))
       }
@@ -38,14 +39,14 @@ const handleNotifications = (event: Event, board: Device): void => {
         const receivedData: string = decoder.decode(new Uint8Array(line))
         handleMotherboardData(receivedData)
       }
-    } else if (board.filters.some((filter) => filter.name === "ENTRALPI")) {
+    } else if (isEntralpi(board)) {
       if (value.buffer) {
         const buffer: ArrayBuffer = value.buffer
         const rawData: DataView = new DataView(buffer)
         const receivedData: string = (rawData.getUint16(0) / 100).toFixed(1)
         handleEntralpiData(receivedData)
       }
-    } else if (board.filters.some((filter) => filter.namePrefix === "Progressor")) {
+    } else if (isProgressor(board)) {
       if (value.buffer) {
         const buffer: ArrayBuffer = value.buffer
         const rawData: DataView = new DataView(buffer)

package/src/data/motherboard.ts

@@ -1,4 +1,5 @@
 import { notifyCallback } from "./../notify"
+import { writeCallback } from "./../write"
 import { applyTare } from "./../tare"
 import { MotherboardCommands } from "./../commands"
 import { checkActivity } from "./../is-active"
@@ -57,8 +58,12 @@ const applyCalibration = (sample: number, calibration: number[][]): number => {
   return sign * final
 }
 /**
- * Handles data received from the Motherboard device.
- * @param {string} receivedData - The received data string.
+ * Handles data received from the Motherboard device. Processes hex-encoded streaming packets
+ * to extract samples, calibrate masses, and update running averages of mass data.
+ * If the received data is not a valid hex packet, it returns the unprocessed data.
+ *
+ * @param {string} receivedData - The raw data received from the Motherboard device.
+ * @returns {void}
  */
 export const handleMotherboardData = (receivedData: string): void => {
   const receivedTime: number = Date.now()
@@ -153,6 +158,6 @@ export const handleMotherboardData = (receivedData: string): void => {
     }
   } else {
     // unhandled data
-    console.log(receivedData)
+    writeCallback(receivedData)
   }
 }