@hangtime/grip-connect 0.3.5 → 0.3.6

package/dist/battery.d.ts

@@ -0,0 +1,7 @@
+import type { Device } from "./types/devices";
+/**
+ * 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.
+ */
+export declare const battery: (board: Device) => Promise<void>;

package/dist/battery.js

@@ -0,0 +1,25 @@
+import { write } from "./write";
+import { read } from "./read";
+import { isConnected } from "./is-connected";
+import { Motherboard, Progressor } from "./devices";
+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.
+ */
+export const battery = async (board) => {
+    // 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")) {
+            // Read battery level information from the Motherboard
+            await read(Motherboard, "battery", "level", 250);
+        }
+        // If the device is connected and its name starts with "Progressor"
+        if (board.filters.some((filter) => filter.namePrefix === "Progressor")) {
+            // Write command to get battery voltage information to the Progressor
+            await write(Progressor, "progressor", "tx", ProgressorCommands.GET_BATT_VLTG, 250);
+        }
+    }
+};

package/dist/calibration.d.ts

@@ -0,0 +1,7 @@
+import type { Device } from "./types/devices";
+/**
+ * Writes a command to get calibration data from the device.
+ * @param {Device} board - The device.
+ * @returns {Promise<void>} A Promise that resolves when the command is successfully sent.
+ */
+export declare const calibration: (board: Device) => Promise<void>;

package/dist/calibration.js

@@ -0,0 +1,19 @@
+import { isConnected } from "./is-connected";
+import { write } from "./write";
+import { Motherboard } from "./devices";
+import { MotherboardCommands } from "./commands";
+/**
+ * Writes a command to get calibration data from the device.
+ * @param {Device} board - The device.
+ * @returns {Promise<void>} A Promise that resolves when the command is successfully sent.
+ */
+export const calibration = async (board) => {
+    // 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")) {
+            // Write the command to get calibration data to the device
+            await write(Motherboard, "uart", "tx", MotherboardCommands.GET_CALIBRATION, 2500);
+        }
+    }
+};

package/dist/characteristic.d.ts

@@ -0,0 +1,9 @@
+import type { Device } from "./types/devices";
+/**
+ * Retrieves the characteristic from the device's service.
+ * @param {Device} board - The device.
+ * @param {string} serviceId - The UUID of the service.
+ * @param {string} characteristicId - The UUID of the characteristic.
+ * @returns {BluetoothRemoteGATTCharacteristic | undefined} The characteristic, if found.
+ */
+export declare const getCharacteristic: (board: Device, serviceId: string, characteristicId: string) => BluetoothRemoteGATTCharacteristic | undefined;

package/dist/characteristic.js

@@ -0,0 +1,20 @@
+/**
+ * Retrieves the characteristic from the device's service.
+ * @param {Device} board - The device.
+ * @param {string} serviceId - The UUID of the service.
+ * @param {string} characteristicId - The UUID of the characteristic.
+ * @returns {BluetoothRemoteGATTCharacteristic | undefined} The characteristic, if found.
+ */
+export const getCharacteristic = (board, serviceId, characteristicId) => {
+    // Find the service with the specified serviceId
+    const boardService = board.services.find((service) => service.id === serviceId);
+    if (boardService) {
+        // If the service is found, find the characteristic with the specified characteristicId
+        const boardCharacteristic = boardService.characteristics.find((characteristic) => characteristic.id === characteristicId);
+        if (boardCharacteristic) {
+            // If the characteristic is found, return it
+            return boardCharacteristic.characteristic;
+        }
+    }
+    // Return undefined if the service or characteristic is not found
+};

package/dist/commands/climbro.d.ts

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

package/dist/commands/climbro.js

@@ -0,0 +1,5 @@
+/**
+ * Warning:
+ * Using other commands can seriously harm your device
+ */
+export const ClimbroCommands = {};

package/dist/commands/entralpi.d.ts

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

package/dist/commands/entralpi.js

@@ -0,0 +1,5 @@
+/**
+ * Warning:
+ * Using other commands can seriously harm your device
+ */
+export const EntralpiCommands = {};

package/dist/commands/index.d.ts

@@ -0,0 +1,6 @@
+export { ClimbroCommands } from "./climbro";
+export { EntralpiCommands } from "./entralpi";
+export { MotherboardCommands } from "./motherboard";
+export { WHC06Commands } from "./wh-c06";
+export { ProgressorCommands } from "./progressor";
+export { mySmartBoardCommands } from "./mysmartboard";

package/dist/commands/index.js

@@ -0,0 +1,6 @@
+export { ClimbroCommands } from "./climbro";
+export { EntralpiCommands } from "./entralpi";
+export { MotherboardCommands } from "./motherboard";
+export { WHC06Commands } from "./wh-c06";
+export { ProgressorCommands } from "./progressor";
+export { mySmartBoardCommands } from "./mysmartboard";

package/dist/commands/kilterboard.d.ts

@@ -0,0 +1,23 @@
+/**
+ * For API level 2 and API level 3.
+ * The first byte in the data is dependent on where the packet is in the message as a whole.
+ * More details: https://github.com/1-max-1/fake_kilter_board
+ */
+export declare enum KilterBoardPacket {
+    /** If this packet is in the middle, the byte gets set to 77 (M). */
+    V2_MIDDLE = 77,
+    /** If this packet is the first packet in the message, then this byte gets set to 78 (N). */
+    V2_FIRST = 78,
+    /** If this is the last packet in the message, this byte gets set to 79 (0). */
+    V2_LAST = 79,
+    /** If this packet is the only packet in the message, the byte gets set to 80 (P). Note that this takes priority over the other conditions. */
+    V2_ONLY = 80,
+    /** If this packet is in the middle, the byte gets set to 81 (Q). */
+    V3_MIDDLE = 81,
+    /** If this packet is the first packet in the message, then this byte gets set to 82 (R). */
+    V3_FIRST = 82,
+    /** If this is the last packet in the message, this byte gets set to 83 (S). */
+    V3_LAST = 83,
+    /** If this packet is the only packet in the message, the byte gets set to 84 (T). Note that this takes priority over the other conditions. */
+    V3_ONLY = 84
+}

package/dist/commands/kilterboard.js

@@ -0,0 +1,24 @@
+/**
+ * For API level 2 and API level 3.
+ * The first byte in the data is dependent on where the packet is in the message as a whole.
+ * More details: https://github.com/1-max-1/fake_kilter_board
+ */
+export var KilterBoardPacket;
+(function (KilterBoardPacket) {
+    /** If this packet is in the middle, the byte gets set to 77 (M). */
+    KilterBoardPacket[KilterBoardPacket["V2_MIDDLE"] = 77] = "V2_MIDDLE";
+    /** If this packet is the first packet in the message, then this byte gets set to 78 (N). */
+    KilterBoardPacket[KilterBoardPacket["V2_FIRST"] = 78] = "V2_FIRST";
+    /** If this is the last packet in the message, this byte gets set to 79 (0). */
+    KilterBoardPacket[KilterBoardPacket["V2_LAST"] = 79] = "V2_LAST";
+    /** If this packet is the only packet in the message, the byte gets set to 80 (P). Note that this takes priority over the other conditions. */
+    KilterBoardPacket[KilterBoardPacket["V2_ONLY"] = 80] = "V2_ONLY";
+    /** If this packet is in the middle, the byte gets set to 81 (Q). */
+    KilterBoardPacket[KilterBoardPacket["V3_MIDDLE"] = 81] = "V3_MIDDLE";
+    /** If this packet is the first packet in the message, then this byte gets set to 82 (R). */
+    KilterBoardPacket[KilterBoardPacket["V3_FIRST"] = 82] = "V3_FIRST";
+    /** If this is the last packet in the message, this byte gets set to 83 (S). */
+    KilterBoardPacket[KilterBoardPacket["V3_LAST"] = 83] = "V3_LAST";
+    /** If this packet is the only packet in the message, the byte gets set to 84 (T). Note that this takes priority over the other conditions. */
+    KilterBoardPacket[KilterBoardPacket["V3_ONLY"] = 84] = "V3_ONLY";
+})(KilterBoardPacket || (KilterBoardPacket = {}));

package/dist/commands/motherboard.d.ts

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

package/dist/commands/motherboard.js

@@ -0,0 +1,13 @@
+/**
+ * Warning:
+ * Using other commands can seriously harm your device
+ */
+export const MotherboardCommands = {
+    GET_SERIAL: "#",
+    START_WEIGHT_MEAS: "S30",
+    STOP_WEIGHT_MEAS: "", // All commands will stop the data stream.
+    GET_CALIBRATION: "C",
+    SLEEP: 0,
+    GET_TEXT: "T",
+    DEBUG_STREAM: "D",
+};

package/dist/commands/mysmartboard.d.ts

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

package/dist/commands/mysmartboard.js

@@ -0,0 +1,5 @@
+/**
+ * Warning:
+ * Using other commands can seriously harm your device
+ */
+export const mySmartBoardCommands = {};

package/dist/commands/progressor.d.ts

@@ -0,0 +1,17 @@
+import type { Commands } from "../types/commands";
+/**
+ * Warning:
+ * Using other commands can seriously harm your device
+ */
+export declare const ProgressorCommands: Commands;
+/**
+ * The Progressor returns a Uint8Array.
+ * The first item [0] is the type of response it returns
+ */
+export declare enum ProgressorResponses {
+    COMMAND_RESPONSE = 0,
+    WEIGHT_MEASURE = 1,
+    PEAK_RFD_MEAS = 2,
+    PEAK_RFD_MEAS_SERIES = 3,
+    LOW_BATTERY_WARNING = 4
+}

package/dist/commands/progressor.js

@@ -0,0 +1,30 @@
+/**
+ * Warning:
+ * Using other commands can seriously harm your device
+ */
+export const ProgressorCommands = {
+    TARE_SCALE: "d", // 0x64,
+    START_WEIGHT_MEAS: "e", // 0x65,
+    STOP_WEIGHT_MEAS: "f", // 0x66,
+    START_PEAK_RFD_MEAS: "g", //  0x67,
+    START_PEAK_RFD_MEAS_SERIES: "h", //  0x68,
+    ADD_CALIB_POINT: "i", //  0x69,
+    SAVE_CALIB: "j", //  0x6a,
+    GET_FW_VERSION: "k", //  0x6b,
+    GET_ERR_INFO: "l", //  0x6c,
+    CLR_ERR_INFO: "m", //  0x6d,
+    SLEEP: "n", // 0x6e,
+    GET_BATT_VLTG: "o", //  0x6f,
+};
+/**
+ * The Progressor returns a Uint8Array.
+ * The first item [0] is the type of response it returns
+ */
+export var ProgressorResponses;
+(function (ProgressorResponses) {
+    ProgressorResponses[ProgressorResponses["COMMAND_RESPONSE"] = 0] = "COMMAND_RESPONSE";
+    ProgressorResponses[ProgressorResponses["WEIGHT_MEASURE"] = 1] = "WEIGHT_MEASURE";
+    ProgressorResponses[ProgressorResponses["PEAK_RFD_MEAS"] = 2] = "PEAK_RFD_MEAS";
+    ProgressorResponses[ProgressorResponses["PEAK_RFD_MEAS_SERIES"] = 3] = "PEAK_RFD_MEAS_SERIES";
+    ProgressorResponses[ProgressorResponses["LOW_BATTERY_WARNING"] = 4] = "LOW_BATTERY_WARNING";
+})(ProgressorResponses || (ProgressorResponses = {}));

package/dist/commands/wh-c06.d.ts

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

package/dist/commands/wh-c06.js

@@ -0,0 +1,5 @@
+/**
+ * Warning:
+ * Using other commands can seriously harm your device
+ */
+export const WHC06Commands = {};

package/dist/connect.d.ts

@@ -0,0 +1,7 @@
+import type { Device } from "./types/devices";
+/**
+ * Connects to a Bluetooth device.
+ * @param {Device} board - The device to connect to.
+ * @param {Function} onSuccess - Callback function to execute on successful connection.
+ */
+export declare const connect: (board: Device, onSuccess: () => void) => Promise<void>;

package/dist/connect.js

@@ -0,0 +1,159 @@
+import { handleEntralpiData, handleMotherboardData, handleProgressorData, handleWHC06Data } from "./data";
+let server;
+const receiveBuffer = [];
+/**
+ * Handles the 'disconnected' event.
+ * @param {Event} event - The 'disconnected' event.
+ * @param {Device} board - The device that is disconnected.
+ */
+const onDisconnected = (event, board) => {
+    board.device = undefined;
+    const device = event.target;
+    console.log(`Device ${device.name} is disconnected.`);
+};
+/**
+ * Handles notifications received from a characteristic.
+ * @param {Event} event - The notification event.
+ * @param {Device} board - The device associated with the characteristic.
+ */
+const handleNotifications = (event, board) => {
+    const characteristic = event.target;
+    const value = characteristic.value;
+    if (value) {
+        // If the device is connected and it is a Motherboard device
+        if (board.filters.some((filter) => filter.name === "Motherboard")) {
+            for (let i = 0; i < value.byteLength; i++) {
+                receiveBuffer.push(value.getUint8(i));
+            }
+            let idx;
+            while ((idx = receiveBuffer.indexOf(10)) >= 0) {
+                const line = receiveBuffer.splice(0, idx + 1).slice(0, -1); // Combine and remove LF
+                if (line.length > 0 && line[line.length - 1] === 13)
+                    line.pop(); // Remove CR
+                const decoder = new TextDecoder("utf-8");
+                const receivedData = decoder.decode(new Uint8Array(line));
+                handleMotherboardData(receivedData);
+            }
+        }
+        else if (board.filters.some((filter) => filter.name === "ENTRALPI")) {
+            if (value.buffer) {
+                const buffer = value.buffer;
+                const rawData = new DataView(buffer);
+                const receivedData = (rawData.getUint16(0) / 100).toFixed(1);
+                handleEntralpiData(receivedData);
+            }
+        }
+        else if (board.filters.some((filter) => filter.namePrefix === "Progressor")) {
+            if (value.buffer) {
+                const buffer = value.buffer;
+                const rawData = new DataView(buffer);
+                handleProgressorData(rawData);
+            }
+        }
+        else {
+            console.log(value);
+        }
+    }
+};
+/**
+ * Handles the 'connected' event.
+ * @param {Device} board - The connected device.
+ * @param {Function} onSuccess - Callback function to execute on successful connection.
+ */
+const onConnected = async (board, onSuccess) => {
+    try {
+        // Connect to GATT server and set up characteristics
+        const services = await server.getPrimaryServices();
+        if (!services || services.length === 0) {
+            console.error("No services found");
+            return;
+        }
+        for (const service of services) {
+            const matchingService = board.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) => {
+                                    handleNotifications(event, board);
+                                });
+                            }
+                        }
+                    }
+                    else {
+                        console.warn(`Characteristic ${characteristic.uuid} not found in service ${service.uuid}`);
+                    }
+                }
+            }
+        }
+        // Call the onSuccess callback after successful connection and setup
+        onSuccess();
+    }
+    catch (error) {
+        console.error(error);
+    }
+};
+/**
+ * Returns UUIDs of all services associated with the device.
+ * @param {Device} device - The device.
+ * @returns {string[]} Array of service UUIDs.
+ */
+const getAllServiceUUIDs = (device) => {
+    return device.services.map((service) => service.uuid);
+};
+/**
+ * Connects to a Bluetooth device.
+ * @param {Device} board - The device to connect to.
+ * @param {Function} onSuccess - Callback function to execute on successful connection.
+ */
+export const connect = async (board, onSuccess) => {
+    try {
+        // Request device and set up connection
+        const deviceServices = getAllServiceUUIDs(board);
+        // Only data matching the optionalManufacturerData parameter to requestDevice is included in the advertisement event: https://github.com/WebBluetoothCG/web-bluetooth/issues/598
+        const optionalManufacturerData = board.filters.flatMap((filter) => filter.manufacturerData?.map((data) => data.companyIdentifier) || []);
+        const device = await navigator.bluetooth.requestDevice({
+            filters: board.filters,
+            optionalServices: deviceServices,
+            optionalManufacturerData,
+        });
+        board.device = device;
+        if (!board.device.gatt) {
+            console.error("GATT is not available on this device");
+            return;
+        }
+        board.device.addEventListener("gattserverdisconnected", (event) => {
+            onDisconnected(event, board);
+        });
+        // WH-C06
+        const MANUFACTURER_ID = 256; // 0x0100
+        board.device.addEventListener("advertisementreceived", (event) => {
+            const manufacturerData = event.manufacturerData.get(MANUFACTURER_ID);
+            if (manufacturerData) {
+                // Device has no services / characteristics
+                onSuccess();
+                // Handle recieved data
+                handleWHC06Data(manufacturerData);
+            }
+        });
+        if (optionalManufacturerData.length) {
+            await board.device.watchAdvertisements();
+        }
+        server = await board.device.gatt.connect();
+        if (server.connected) {
+            await onConnected(board, onSuccess);
+        }
+    }
+    catch (error) {
+        console.error(error);
+    }
+};

package/dist/data/entralpi.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Handles data received from the Entralpi device.
+ * @param {string} receivedData - The received data string.
+ */
+export declare const handleEntralpiData: (receivedData: string) => void;

package/dist/data/entralpi.js

@@ -0,0 +1,30 @@
+import { notifyCallback } from "./../notify";
+import { applyTare } from "./../tare";
+// Constants
+let MASS_MAX = "0";
+let MASS_AVERAGE = "0";
+let MASS_TOTAL_SUM = 0;
+let DATAPOINT_COUNT = 0;
+/**
+ * Handles data received from the Entralpi device.
+ * @param {string} receivedData - The received data string.
+ */
+export const handleEntralpiData = (receivedData) => {
+    let numericData = Number(receivedData);
+    // 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);
+    // Notify with weight data
+    notifyCallback({
+        massMax: MASS_MAX,
+        massAverage: MASS_AVERAGE,
+        massTotal: Math.max(-1000, numericData).toFixed(1),
+    });
+};

package/dist/data/index.d.ts

@@ -0,0 +1,4 @@
+export { handleEntralpiData } from "./entralpi";
+export { handleMotherboardData } from "./motherboard";
+export { handleProgressorData } from "./progressor";
+export { handleWHC06Data } from "./wh-c06";

package/dist/data/index.js

@@ -0,0 +1,4 @@
+export { handleEntralpiData } from "./entralpi";
+export { handleMotherboardData } from "./motherboard";
+export { handleProgressorData } from "./progressor";
+export { handleWHC06Data } from "./wh-c06";

package/dist/data/motherboard.d.ts

@@ -0,0 +1,6 @@
+export declare const CALIBRATION: never[][];
+/**
+ * Handles data received from the Motherboard device.
+ * @param {string} receivedData - The received data string.
+ */
+export declare const handleMotherboardData: (receivedData: string) => void;

package/dist/data/motherboard.js

@@ -0,0 +1,133 @@
+import { notifyCallback } from "./../notify";
+import { applyTare } from "./../tare";
+import { MotherboardCommands } from "./../commands";
+import { lastWrite } from "./../write";
+import { DownloadPackets } from "./../download";
+// Constants
+const PACKET_LENGTH = 32;
+const NUM_SAMPLES = 3;
+let MASS_MAX = "0";
+let MASS_AVERAGE = "0";
+let MASS_TOTAL_SUM = 0;
+let DATAPOINT_COUNT = 0;
+export const CALIBRATION = [[], [], [], []];
+/**
+ * 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.
+ */
+const applyCalibration = (sample, calibration) => {
+    // Extract the calibrated value for the zero point
+    const zeroCalibration = calibration[0][2];
+    // Initialize sign as positive
+    let sign = 1;
+    // Initialize the final calibrated value
+    let final = 0;
+    // If the sample value is less than the zero calibration point
+    if (sample < zeroCalibration) {
+        // Change the sign to negative
+        sign = -1;
+        // Reflect the sample around the zero calibration point
+        sample = /* 2 * zeroCalibration */ -sample;
+    }
+    // Iterate through the calibration data
+    for (let i = 1; i < calibration.length; i++) {
+        // Extract the lower and upper bounds of the current calibration range
+        const calibrationStart = calibration[i - 1][2];
+        const calibrationEnd = calibration[i][2];
+        // If the sample value is within the current calibration range
+        if (sample < calibrationEnd) {
+            // Interpolate to get the calibrated value within the range
+            final =
+                calibration[i - 1][1] +
+                    ((sample - calibrationStart) / (calibrationEnd - calibrationStart)) *
+                        (calibration[i][1] - calibration[i - 1][1]);
+            break;
+        }
+    }
+    // Return the calibrated value with the appropriate sign (positive/negative)
+    return sign * final;
+};
+/**
+ * Handles data received from the Motherboard device.
+ * @param {string} receivedData - The received data string.
+ */
+export const handleMotherboardData = (receivedData) => {
+    const receivedTime = Date.now();
+    // Check if the line is entirely hex characters
+    const isAllHex = /^[0-9A-Fa-f]+$/g.test(receivedData);
+    // Handle streaming packet
+    if (isAllHex && receivedData.length === PACKET_LENGTH) {
+        // Base-16 decode the string: convert hex pairs to byte values
+        const bytes = Array.from({ length: receivedData.length / 2 }, (_, i) => Number(`0x${receivedData.substring(i * 2, i * 2 + 2)}`));
+        // Translate header into packet, number of samples from the packet length
+        const packet = {
+            received: receivedTime,
+            sampleNum: new DataView(new Uint8Array(bytes).buffer).getUint16(0, true),
+            battRaw: new DataView(new Uint8Array(bytes).buffer).getUint16(2, true),
+            samples: [],
+            masses: [],
+        };
+        const dataView = new DataView(new Uint8Array(bytes).buffer);
+        for (let i = 0; i < NUM_SAMPLES; i++) {
+            const sampleStart = 4 + 3 * i;
+            // Use DataView to read the 24-bit unsigned integer
+            const rawValue = dataView.getUint8(sampleStart) |
+                (dataView.getUint8(sampleStart + 1) << 8) |
+                (dataView.getUint8(sampleStart + 2) << 16);
+            // Ensure unsigned 32-bit integer
+            packet.samples[i] = rawValue >>> 0;
+            if (packet.samples[i] >= 0x7fffff) {
+                packet.samples[i] -= 0x1000000;
+            }
+            packet.masses[i] = applyCalibration(packet.samples[i], CALIBRATION[i]);
+        }
+        // invert center and right values
+        packet.masses[1] *= -1;
+        packet.masses[2] *= -1;
+        // Add data to downloadable Array
+        DownloadPackets.push({
+            received: packet.received,
+            sampleNum: packet.battRaw,
+            battRaw: packet.received,
+            samples: [...packet.samples],
+            masses: [...packet.masses],
+        });
+        let left = packet.masses[0];
+        let center = packet.masses[1];
+        let right = packet.masses[2];
+        // Tare correction
+        left -= applyTare(left);
+        center -= applyTare(center);
+        right -= applyTare(right);
+        MASS_MAX = Math.max(Number(MASS_MAX), Math.max(-1000, left + center + right)).toFixed(1);
+        // Update running sum and count
+        const currentMassTotal = Math.max(-1000, left + center + right);
+        MASS_TOTAL_SUM += currentMassTotal;
+        DATAPOINT_COUNT++;
+        // Calculate the average dynamically
+        MASS_AVERAGE = (MASS_TOTAL_SUM / DATAPOINT_COUNT).toFixed(1);
+        // Notify with weight data
+        notifyCallback({
+            massTotal: Math.max(-1000, left + center + right).toFixed(1),
+            massMax: MASS_MAX,
+            massAverage: MASS_AVERAGE,
+            massLeft: Math.max(-1000, packet.masses[0]).toFixed(1),
+            massCenter: Math.max(-1000, packet.masses[1]).toFixed(1),
+            massRight: Math.max(-1000, packet.masses[2]).toFixed(1),
+        });
+    }
+    else if (lastWrite === MotherboardCommands.GET_CALIBRATION) {
+        // check data integrity
+        if ((receivedData.match(/,/g) || []).length === 3) {
+            const parts = receivedData.split(",");
+            const numericParts = parts.map((x) => parseFloat(x));
+            CALIBRATION[numericParts[0]].push(numericParts.slice(1));
+        }
+    }
+    else {
+        // unhandled data
+        console.log(receivedData);
+    }
+};