@hangtime/grip-connect 0.1.1 → 0.2.0

package/src/devices/motherboard.js

@@ -1,7 +1,3 @@
-import { notifyCallback } from "../notify";
-const PACKET_LENGTH = 32;
-const NUM_SAMPLES = 3;
-const CALIBRATION = [[], [], [], []];
 export const Motherboard = {
     name: "Motherboard",
     companyId: 0x2a29,
@@ -81,109 +77,3 @@ export const Motherboard = {
         },
     ],
 };
-/**
- * applyCalibration
- * @param sample
- * @param calibration
- */
-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;
-};
-/**
- * handleMotherboardData
- * @param uuid - Unique identifier
- * @param receivedData - Received data string
- */
-export function handleMotherboardData(uuid, 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;
-            }
-            // TODO: make sure device is calibrated
-            if (!CALIBRATION[0].length)
-                return;
-            packet.masses[i] = applyCalibration(packet.samples[i], CALIBRATION[i]);
-        }
-        // invert center and right values
-        packet.masses[1] *= -1;
-        packet.masses[2] *= -1;
-        // map to variables
-        const left = packet.masses[0];
-        const center = packet.masses[1];
-        const right = packet.masses[2];
-        if (notifyCallback) {
-            notifyCallback({
-                uuid,
-                value: {
-                    massTotal: Math.max(-1000, left + right + center).toFixed(1),
-                    massLeft: Math.max(-1000, left).toFixed(1),
-                    massRight: Math.max(-1000, right).toFixed(1),
-                    massCenter: Math.max(-1000, center).toFixed(1),
-                },
-            });
-        }
-    }
-    else if ((receivedData.match(/,/g) || []).length === 3) {
-        console.log(receivedData);
-        // if the returned notification is a calibration string add them to the array
-        const parts = receivedData.split(",");
-        const numericParts = parts.map((x) => parseFloat(x));
-        CALIBRATION[numericParts[0]].push(numericParts.slice(1));
-    }
-    else {
-        // unhanded data
-        console.log(receivedData);
-    }
-}

package/src/devices/motherboard.ts

@@ -1,9 +1,4 @@
 import { Device } from "./types"
-import { notifyCallback } from "../notify"
-
-const PACKET_LENGTH: number = 32
-const NUM_SAMPLES: number = 3
-const CALIBRATION = [[], [], [], []]
 
 export const Motherboard: Device = {
   name: "Motherboard",
@@ -84,132 +79,3 @@ export const Motherboard: Device = {
     },
   ],
 }
-/**
- * applyCalibration
- * @param sample
- * @param calibration
- */
-const applyCalibration = (sample: number, calibration: number[][]): number => {
-  // Extract the calibrated value for the zero point
-  const zeroCalibration: number = calibration[0][2]
-
-  // Initialize sign as positive
-  let sign: number = 1
-
-  // Initialize the final calibrated value
-  let final: number = 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: number = calibration[i - 1][2]
-    const calibrationEnd: number = 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
-}
-
-interface Packet {
-  received: number
-  sampleNum: number
-  battRaw: number
-  samples: number[]
-  masses: number[]
-}
-
-/**
- * handleMotherboardData
- * @param uuid - Unique identifier
- * @param receivedData - Received data string
- */
-export function handleMotherboardData(uuid: string, receivedData: string): void {
-  const receivedTime: number = Date.now()
-
-  // Check if the line is entirely hex characters
-  const isAllHex: boolean = /^[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: number[] = 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: 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: number = 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
-      }
-
-      // TODO: make sure device is calibrated
-      if (!CALIBRATION[0].length) return
-      packet.masses[i] = applyCalibration(packet.samples[i], CALIBRATION[i])
-    }
-    // invert center and right values
-    packet.masses[1] *= -1
-    packet.masses[2] *= -1
-    // map to variables
-    const left: number = packet.masses[0]
-    const center: number = packet.masses[1]
-    const right: number = packet.masses[2]
-    if (notifyCallback) {
-      notifyCallback({
-        uuid,
-        value: {
-          massTotal: Math.max(-1000, left + right + center).toFixed(1),
-          massLeft: Math.max(-1000, left).toFixed(1),
-          massRight: Math.max(-1000, right).toFixed(1),
-          massCenter: Math.max(-1000, center).toFixed(1),
-        },
-      })
-    }
-  } else if ((receivedData.match(/,/g) || []).length === 3) {
-    console.log(receivedData)
-    // if the returned notification is a calibration string add them to the array
-    const parts: string[] = receivedData.split(",")
-    const numericParts: number[] = parts.map((x) => parseFloat(x))
-    ;(CALIBRATION[numericParts[0]] as number[][]).push(numericParts.slice(1))
-  } else {
-    // unhanded data
-    console.log(receivedData)
-  }
-}

package/src/disconnect.js

@@ -1,11 +1,10 @@
+import { isConnected } from "./is-connected";
 /**
  * disconnect
  * @param board
  */
 export const disconnect = (board) => {
-    if (!board.device)
-        return;
-    if (board.device.gatt?.connected) {
-        board.device.gatt?.disconnect();
+    if (isConnected(board)) {
+        board.device?.gatt?.disconnect();
     }
 };

package/src/disconnect.ts

@@ -1,12 +1,12 @@
 import { Device } from "./devices/types"
+import { isConnected } from "./is-connected"
 
 /**
  * disconnect
  * @param board
  */
 export const disconnect = (board: Device): void => {
-  if (!board.device) return
-  if (board.device.gatt?.connected) {
-    board.device.gatt?.disconnect()
+  if (isConnected(board)) {
+    board.device?.gatt?.disconnect()
   }
 }

package/src/index.d.ts

@@ -1,8 +1,10 @@
 export { Climbro, Entralpi, Motherboard, SmartBoard, Tindeq } from "./devices/index";
+export { battery } from "./battery";
 export { calibration } from "./calibration";
 export { connect } from "./connect";
 export { disconnect } from "./disconnect";
+export { isConnected } from "./is-connected";
+export { info } from "./info";
 export { notify } from "./notify";
-export { read } from "./read";
 export { stop } from "./stop";
 export { stream } from "./stream";

package/src/index.js

@@ -1,8 +1,12 @@
 export { Climbro, Entralpi, Motherboard, SmartBoard, Tindeq } from "./devices/index";
+export { battery } from "./battery";
 export { calibration } from "./calibration";
 export { connect } from "./connect";
 export { disconnect } from "./disconnect";
+export { isConnected } from "./is-connected";
+export { info } from "./info";
 export { notify } from "./notify";
-export { read } from "./read";
+// export { read } from "./read"
 export { stop } from "./stop";
 export { stream } from "./stream";
+// export { write } from "./write"

package/src/index.ts

@@ -1,15 +1,23 @@
 export { Climbro, Entralpi, Motherboard, SmartBoard, Tindeq } from "./devices/index"
 
+export { battery } from "./battery"
+
 export { calibration } from "./calibration"
 
 export { connect } from "./connect"
 
 export { disconnect } from "./disconnect"
 
+export { isConnected } from "./is-connected"
+
+export { info } from "./info"
+
 export { notify } from "./notify"
 
-export { read } from "./read"
+// export { read } from "./read"
 
 export { stop } from "./stop"
 
 export { stream } from "./stream"
+
+// export { write } from "./write"

package/src/info.d.ts

@@ -0,0 +1,6 @@
+import { Device } from "./devices/types";
+/**
+ * Get device information
+ * @param board
+ */
+export declare const info: (board: Device) => Promise<void>;

package/src/info.js

@@ -0,0 +1,23 @@
+import { write } from "./write";
+import { read } from "./read";
+import { isConnected } from "./is-connected";
+import { Motherboard, Tindeq } from "./devices";
+import { MotherboardCommands, TindeqCommands } from "./commands";
+/**
+ * Get device information
+ * @param board
+ */
+export const info = async (board) => {
+    if (isConnected(board)) {
+        if (board.name === "Motherboard") {
+            await read(Motherboard, "device", "manufacturer", 250);
+            await read(Motherboard, "device", "hardware", 250);
+            await read(Motherboard, "device", "firmware", 250);
+            await write(Motherboard, "uart", "tx", String(MotherboardCommands.GET_TEXT), 250);
+            await write(Motherboard, "uart", "tx", String(MotherboardCommands.GET_SERIAL), 250);
+        }
+        if (board.name === "Tindeq") {
+            await write(Tindeq, "progressor", "tx", String(TindeqCommands.GET_APP_VERSION), 250);
+        }
+    }
+};

package/src/info.ts

@@ -0,0 +1,25 @@
+import { Device } from "./devices/types"
+import { write } from "./write"
+import { read } from "./read"
+import { isConnected } from "./is-connected"
+import { Motherboard, Tindeq } from "./devices"
+import { MotherboardCommands, TindeqCommands } from "./commands"
+
+/**
+ * Get device information
+ * @param board
+ */
+export const info = async (board: Device): Promise<void> => {
+  if (isConnected(board)) {
+    if (board.name === "Motherboard") {
+      await read(Motherboard, "device", "manufacturer", 250)
+      await read(Motherboard, "device", "hardware", 250)
+      await read(Motherboard, "device", "firmware", 250)
+      await write(Motherboard, "uart", "tx", String(MotherboardCommands.GET_TEXT), 250)
+      await write(Motherboard, "uart", "tx", String(MotherboardCommands.GET_SERIAL), 250)
+    }
+    if (board.name === "Tindeq") {
+      await write(Tindeq, "progressor", "tx", String(TindeqCommands.GET_APP_VERSION), 250)
+    }
+  }
+}

package/src/is-connected.d.ts

@@ -0,0 +1,7 @@
+import { Device } from "./devices/types";
+/**
+ * Checks if a Bluetooth device is connected
+ * @param board
+ * @return boolean
+ */
+export declare const isConnected: (board: Device) => boolean;

package/src/is-connected.js

@@ -0,0 +1,10 @@
+/**
+ * Checks if a Bluetooth device is connected
+ * @param board
+ * @return boolean
+ */
+export const isConnected = (board) => {
+    if (!board.device)
+        return false;
+    return !!board.device.gatt?.connected;
+};

package/src/is-connected.ts

@@ -0,0 +1,11 @@
+import { Device } from "./devices/types"
+
+/**
+ * Checks if a Bluetooth device is connected
+ * @param board
+ * @return boolean
+ */
+export const isConnected = (board: Device): boolean => {
+  if (!board.device) return false
+  return !!board.device.gatt?.connected
+}

package/src/notify.js

@@ -1,6 +1,6 @@
 // Initialize the callback variable
 export let notifyCallback;
-// Export a function to set the callback
+// Export a cost to set the callback
 export const notify = (callback) => {
     notifyCallback = callback;
 };

package/src/notify.ts

@@ -1,10 +1,10 @@
-// Define the callback function type
+// Define the callbacks type
 type NotifyCallback = (data: object) => void
 
 // Initialize the callback variable
 export let notifyCallback: NotifyCallback
 
-// Export a function to set the callback
+// Export a cost to set the callback
 export const notify = (callback: NotifyCallback) => {
   notifyCallback = callback
 }

package/src/read.js

@@ -1,12 +1,13 @@
 import { notifyCallback } from "./notify";
 import { getCharacteristic } from "./characteristic";
+import { isConnected } from "./is-connected";
 /**
  * read
  * @param characteristic
  */
 export const read = (board, serviceId, characteristicId, duration = 0) => {
     return new Promise((resolve, reject) => {
-        if (board.device?.gatt?.connected) {
+        if (isConnected(board)) {
             const characteristic = getCharacteristic(board, serviceId, characteristicId);
             if (characteristic) {
                 characteristic

package/src/read.ts

@@ -1,6 +1,7 @@
 import { Device } from "./devices/types"
 import { notifyCallback } from "./notify"
 import { getCharacteristic } from "./characteristic"
+import { isConnected } from "./is-connected"
 
 /**
  * read
@@ -13,7 +14,7 @@ export const read = (
   duration: number = 0,
 ): Promise<void> => {
   return new Promise((resolve, reject) => {
-    if (board.device?.gatt?.connected) {
+    if (isConnected(board)) {
       const characteristic = getCharacteristic(board, serviceId, characteristicId)
 
       if (characteristic) {

package/src/stop.js

@@ -1,14 +1,13 @@
+import { write } from "./write";
+import { isConnected } from "./is-connected";
 import { Motherboard, Tindeq } from "./devices";
 import { MotherboardCommands, TindeqCommands } from "./commands";
-import { write } from "./write";
 /**
  * read calibration
  * @param board
  */
 export const stop = async (board) => {
-    if (!board.device)
-        return;
-    if (board.device.gatt?.connected) {
+    if (isConnected(board)) {
         if (board.name === "Motherboard") {
             await write(Motherboard, "uart", "tx", String(MotherboardCommands.STOP_WEIGHT_MEAS), 0);
         }

package/src/stop.ts

@@ -1,15 +1,15 @@
 import { Device } from "./devices/types"
+import { write } from "./write"
+import { isConnected } from "./is-connected"
 import { Motherboard, Tindeq } from "./devices"
 import { MotherboardCommands, TindeqCommands } from "./commands"
-import { write } from "./write"
 
 /**
  * read calibration
  * @param board
  */
 export const stop = async (board: Device): Promise<void> => {
-  if (!board.device) return
-  if (board.device.gatt?.connected) {
+  if (isConnected(board)) {
     if (board.name === "Motherboard") {
       await write(Motherboard, "uart", "tx", String(MotherboardCommands.STOP_WEIGHT_MEAS), 0)
     }

package/src/stream.js

@@ -1,20 +1,24 @@
-import { Motherboard, Tindeq } from "./devices";
-import { MotherboardCommands, TindeqCommands } from "./commands";
+import { isConnected } from "./is-connected";
 import { write } from "./write";
 import { stop } from "./stop";
+import { Motherboard, Tindeq } from "./devices";
+import { MotherboardCommands, TindeqCommands } from "./commands";
+import { CALIBRATION } from "./data";
+import { calibration } from "./calibration";
 /**
  * stream output
  * @param board
  */
 export const stream = async (board, duration = 0) => {
-    if (!board.device)
-        return;
-    if (board.device.gatt?.connected) {
+    if (isConnected(board)) {
         if (board.name === "Motherboard") {
-            // TODO: add check if device is recalibrated
+            // read calibration (required before reading data)
+            if (!CALIBRATION[0].length) {
+                await calibration(Motherboard);
+            }
             // start stream
             await write(Motherboard, "uart", "tx", String(MotherboardCommands.START_WEIGHT_MEAS), duration);
-            // end stream
+            // end stream if duration is set
             if (duration !== 0) {
                 await stop(Motherboard);
             }
@@ -22,7 +26,7 @@ export const stream = async (board, duration = 0) => {
         if (board.name === "Tindeq") {
             // start stream
             await write(Tindeq, "progressor", "tx", String(TindeqCommands.START_WEIGHT_MEAS), duration);
-            // end stream
+            // end stream if duration is set
             if (duration !== 0) {
                 await stop(Tindeq);
             }

package/src/stream.ts

@@ -1,21 +1,26 @@
 import { Device } from "./devices/types"
-import { Motherboard, Tindeq } from "./devices"
-import { MotherboardCommands, TindeqCommands } from "./commands"
+import { isConnected } from "./is-connected"
 import { write } from "./write"
 import { stop } from "./stop"
+import { Motherboard, Tindeq } from "./devices"
+import { MotherboardCommands, TindeqCommands } from "./commands"
+import { CALIBRATION } from "./data"
+import { calibration } from "./calibration"
 
 /**
  * stream output
  * @param board
  */
 export const stream = async (board: Device, duration: number = 0): Promise<void> => {
-  if (!board.device) return
-  if (board.device.gatt?.connected) {
+  if (isConnected(board)) {
     if (board.name === "Motherboard") {
-      // TODO: add check if device is recalibrated
+      // read calibration (required before reading data)
+      if (!CALIBRATION[0].length) {
+        await calibration(Motherboard)
+      }
       // start stream
       await write(Motherboard, "uart", "tx", String(MotherboardCommands.START_WEIGHT_MEAS), duration)
-      // end stream
+      // end stream if duration is set
       if (duration !== 0) {
         await stop(Motherboard)
       }
@@ -23,7 +28,7 @@ export const stream = async (board: Device, duration: number = 0): Promise<void>
     if (board.name === "Tindeq") {
       // start stream
       await write(Tindeq, "progressor", "tx", String(TindeqCommands.START_WEIGHT_MEAS), duration)
-      // end stream
+      // end stream if duration is set
       if (duration !== 0) {
         await stop(Tindeq)
       }

package/src/write.js

@@ -1,3 +1,4 @@
+import { isConnected } from "./is-connected";
 import { getCharacteristic } from "./characteristic";
 /**
  * write
@@ -6,16 +7,18 @@ import { getCharacteristic } from "./characteristic";
  */
 export const write = (board, serviceId, characteristicId, message, duration = 0) => {
     return new Promise((resolve, reject) => {
-        if (board.device?.gatt?.connected) {
+        if (isConnected(board)) {
             const encoder = new TextEncoder();
             const characteristic = getCharacteristic(board, serviceId, characteristicId);
             if (characteristic) {
                 characteristic
                     .writeValue(encoder.encode(message))
                     .then(() => {
-                    setTimeout(() => {
-                        resolve();
-                    }, duration);
+                    if (duration !== 0) {
+                        setTimeout(() => {
+                            resolve();
+                        }, duration);
+                    }
                 })
                     .catch((error) => {
                     reject(error);