@hangtime/grip-connect 0.0.6 → 0.0.8

package/src/connect.js

@@ -1,4 +1,7 @@
 import { notifyCallback } from "./notify";
+import { handleMotherboardData } from "./devices/moterboard";
+let server;
+const receiveBuffer = [];
 /**
  * onDisconnected
  * @param board
@@ -16,63 +19,83 @@ const onDisconnected = (event, board) => {
  */
 const handleNotifications = (event, board) => {
     const characteristic = event.target;
-    const receivedData = new Uint8Array(characteristic.value.buffer);
-    // Create an array to store the parsed decimal values
-    const decimalArray = [];
-    // Iterate through each byte and convert to decimal
-    for (let i = 0; i < receivedData.length; i++) {
-        decimalArray.push(receivedData[i]);
-    }
-    // Convert the decimal array to a string representation
-    const receivedString = String.fromCharCode(...decimalArray);
-    if (board.name === "Motherboard") {
-        // Split the string into pairs of characters
-        const hexPairs = receivedString.match(/.{1,2}/g);
-        // Convert each hexadecimal pair to decimal
-        const parsedDecimalArray = hexPairs?.map((hexPair) => parseInt(hexPair, 16));
-        // Handle different types of data
-        if (characteristic.value.byteLength === 20) {
-            const elementKeys = [
-                "frames",
-                "cycle",
-                "unknown",
-                "eleven",
-                "dynamic1",
-                "pressure1",
-                "left",
-                "dynamic2",
-                "pressure2",
-                "right",
-            ];
-            const dataObject = {};
-            if (parsedDecimalArray) {
-                elementKeys.forEach((key, index) => {
-                    dataObject[key] = parsedDecimalArray[index];
-                });
+    const value = characteristic.value;
+    if (value) {
+        if (board.name === "Motherboard") {
+            if (value) {
+                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 receivedString = decoder.decode(new Uint8Array(line));
+                    handleMotherboardData(characteristic.uuid, receivedString);
+                }
             }
+        }
+        else if (board.name === "ENTRALPI") {
+            // TODO: handle Entralpi notify
+            // characteristic.value!.getInt16(0) / 100;
             if (notifyCallback) {
-                notifyCallback({ uuid: characteristic.uuid, value: dataObject });
+                notifyCallback({ uuid: characteristic.uuid, value: value });
             }
         }
-        else if (characteristic.value.byteLength === 14) {
-            // TODO: handle 14 byte data
-            // notifyCallback({ uuid: characteristic.uuid, value: characteristic.value!.getInt8(0) / 100 })
+        else if (board.name === "Tindeq") {
+            // TODO: handle Tindeq notify
         }
-    }
-    else if (board.name === "ENTRALPI") {
-        // TODO: handle Entralpi notify
-        // characteristic.value!.getInt16(0) / 100;
-        if (notifyCallback) {
-            notifyCallback({ uuid: characteristic.uuid, value: receivedString });
+        else {
+            if (notifyCallback) {
+                notifyCallback({ uuid: characteristic.uuid, value: value });
+            }
         }
     }
-    else if (board.name === "Tindeq") {
-        // TODO: handle Tindeq notify
-    }
-    else {
-        if (notifyCallback) {
-            notifyCallback({ uuid: characteristic.uuid, value: receivedString });
+};
+/**
+ * onConnected
+ * @param event
+ * @param board
+ */
+const onConnected = async (board, onSuccess) => {
+    try {
+        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);
     }
 };
 /**
@@ -83,7 +106,7 @@ function getAllServiceUUIDs(device) {
     return device.services.map((service) => service.uuid);
 }
 /**
- * connect
+ * Connect to the BluetoothDevice
  * @param device
  * @param onSuccess
  */
@@ -111,37 +134,15 @@ export const connect = async (board, onSuccess) => {
             optionalServices: deviceServices,
         });
         board.device = device;
-        device.addEventListener("gattserverdisconnected", (event) => onDisconnected(event, board));
-        const server = await device.gatt?.connect();
-        const services = await server?.getPrimaryServices();
-        if (!services || services.length === 0) {
-            console.error("No services found");
+        if (!board.device.gatt) {
+            console.error("GATT is not available on this device");
             return;
         }
-        for (const service of services) {
-            const matchingService = board.services.find((boardService) => boardService.uuid === service.uuid);
-            if (matchingService) {
-                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}`);
-                    }
-                }
-            }
+        server = await board.device?.gatt?.connect();
+        board.device.addEventListener("gattserverdisconnected", (event) => onDisconnected(event, board));
+        if (server.connected) {
+            await onConnected(board, onSuccess);
         }
-        onSuccess();
     }
     catch (error) {
         console.error(error);

package/src/connect.ts

@@ -1,5 +1,9 @@
 import { Device } from "./devices/types"
 import { notifyCallback } from "./notify"
+import { handleMotherboardData } from "./devices/moterboard"
+
+let server: BluetoothRemoteGATTServer
+const receiveBuffer: number[] = []
 
 /**
  * onDisconnected
@@ -18,62 +22,88 @@ const onDisconnected = (event: Event, board: Device): void => {
  */
 const handleNotifications = (event: Event, board: Device): void => {
   const characteristic = event.target as BluetoothRemoteGATTCharacteristic
-  const receivedData = new Uint8Array(characteristic.value!.buffer)
-  // Create an array to store the parsed decimal values
-  const decimalArray: number[] = []
+  const value = characteristic.value
+  if (value) {
+    if (board.name === "Motherboard") {
+      if (value) {
+        for (let i = 0; i < value.byteLength; i++) {
+          receiveBuffer.push(value.getUint8(i))
+        }
 
-  // Iterate through each byte and convert to decimal
-  for (let i = 0; i < receivedData.length; i++) {
-    decimalArray.push(receivedData[i])
-  }
-  // Convert the decimal array to a string representation
-  const receivedString: string = String.fromCharCode(...decimalArray)
-
-  if (board.name === "Motherboard") {
-    // Split the string into pairs of characters
-    const hexPairs: RegExpMatchArray | null = receivedString.match(/.{1,2}/g)
-    // Convert each hexadecimal pair to decimal
-    const parsedDecimalArray: number[] | undefined = hexPairs?.map((hexPair) => parseInt(hexPair, 16))
-    // Handle different types of data
-    if (characteristic.value!.byteLength === 20) {
-      const elementKeys = [
-        "frames",
-        "cycle",
-        "unknown",
-        "eleven",
-        "dynamic1",
-        "pressure1",
-        "left",
-        "dynamic2",
-        "pressure2",
-        "right",
-      ]
-      const dataObject: { [key: string]: number } = {};
-
-      if (parsedDecimalArray) {
-        elementKeys.forEach((key: string, index: number) => {
-          dataObject[key] = parsedDecimalArray[index];
-        });
+        let idx: number
+        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 receivedString = decoder.decode(new Uint8Array(line))
+          handleMotherboardData(characteristic.uuid, receivedString)
+        }
+      }
+    } else if (board.name === "ENTRALPI") {
+      // TODO: handle Entralpi notify
+      // characteristic.value!.getInt16(0) / 100;
+      if (notifyCallback) {
+        notifyCallback({ uuid: characteristic.uuid, value: value })
       }
+    } else if (board.name === "Tindeq") {
+      // TODO: handle Tindeq notify
+    } else {
       if (notifyCallback) {
-        notifyCallback({ uuid: characteristic.uuid, value: dataObject })
+        notifyCallback({ uuid: characteristic.uuid, value: value })
       }
-    } else if (characteristic.value!.byteLength === 14) {
-      // TODO: handle 14 byte data
-      // notifyCallback({ uuid: characteristic.uuid, value: characteristic.value!.getInt8(0) / 100 })
     }
-  } else if (board.name === "ENTRALPI") {
-    // TODO: handle Entralpi notify
-    // characteristic.value!.getInt16(0) / 100;
-    if (notifyCallback) {
-      notifyCallback({ uuid: characteristic.uuid, value: receivedString })
+  }
+}
+/**
+ * onConnected
+ * @param event
+ * @param board
+ */
+const onConnected = async (board: Device, onSuccess: () => void): Promise<void> => {
+  try {
+    const services = await server?.getPrimaryServices()
+
+    if (!services || services.length === 0) {
+      console.error("No services found")
+      return
     }
-  } else if (board.name === "Tindeq") {
-    // TODO: handle Tindeq notify
-  } else {
-    if (notifyCallback) {
-      notifyCallback({ uuid: characteristic.uuid, value: receivedString })
+
+    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)
   }
 }
 /**
@@ -84,7 +114,7 @@ function getAllServiceUUIDs(device: Device) {
   return device.services.map((service) => service.uuid)
 }
 /**
- * connect
+ * Connect to the BluetoothDevice
  * @param device
  * @param onSuccess
  */
@@ -117,45 +147,18 @@ export const connect = async (board: Device, onSuccess: () => void): Promise<voi
 
     board.device = device
 
-    device.addEventListener("gattserverdisconnected", (event) => onDisconnected(event, board))
-
-    const server = await device.gatt?.connect()
-    const services = await server?.getPrimaryServices()
-
-    if (!services || services.length === 0) {
-      console.error("No services found")
+    if (!board.device.gatt) {
+      console.error("GATT is not available on this device")
       return
     }
 
-    for (const service of services) {
-      const matchingService = board.services.find((boardService) => boardService.uuid === service.uuid)
+    server = await board.device?.gatt?.connect()
 
-      if (matchingService) {
-        const characteristics = await service.getCharacteristics()
+    board.device.addEventListener("gattserverdisconnected", (event) => onDisconnected(event, board))
 
-        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}`)
-          }
-        }
-      }
+    if (server.connected) {
+      await onConnected(board, onSuccess)
     }
-    onSuccess()
   } catch (error) {
     console.error(error)
   }

package/src/devices/entralpi.d.ts

@@ -0,0 +1,2 @@
+import { Device } from "./types";
+export declare const Entralpi: Device;

package/src/devices/entralpi.js

@@ -0,0 +1,52 @@
+export const Entralpi = {
+    name: "ENTRALPI",
+    services: [
+        {
+            name: "Device Information",
+            id: "device",
+            uuid: "0000180a-0000-1000-8000-00805f9b34fb",
+            characteristics: [],
+        },
+        {
+            name: "Battery Service",
+            id: "battery",
+            uuid: "0000180f-0000-1000-8000-00805f9b34fb",
+            characteristics: [],
+        },
+        {
+            name: "Generic Attribute",
+            id: "attribute",
+            uuid: "00001801-0000-1000-8000-00805f9b34fb",
+            characteristics: [],
+        },
+        {
+            name: "UART ISSC Transparent Service",
+            id: "uart",
+            uuid: "0000fff0-0000-1000-8000-00805f9b34fb",
+            characteristics: [
+                {
+                    name: "TX",
+                    id: "tx",
+                    uuid: "0000fff5-0000-1000-8000-00805f9b34fb",
+                },
+                {
+                    name: "RX",
+                    id: "rx",
+                    uuid: "0000fff4-0000-1000-8000-00805f9b34fb",
+                },
+            ],
+        },
+        {
+            name: "Weight Scale",
+            id: "weight",
+            uuid: "0000181d-0000-1000-8000-00805f9b34fb",
+            characteristics: [],
+        },
+        {
+            name: "Generic Access",
+            id: "access",
+            uuid: "00001800-0000-1000-8000-00805f9b34fb",
+            characteristics: [],
+        },
+    ],
+};

package/src/devices/index.d.ts

@@ -0,0 +1,3 @@
+export { Motherboard } from "./moterboard";
+export { Entralpi } from "./entralpi";
+export { Tindeq } from "./tindeq";

package/src/devices/index.js

@@ -0,0 +1,3 @@
+export { Motherboard } from "./moterboard";
+export { Entralpi } from "./entralpi";
+export { Tindeq } from "./tindeq";

package/src/devices/moterboard.d.ts

@@ -0,0 +1,7 @@
+import { Device } from "./types";
+export declare const Motherboard: Device;
+/**
+ * handleMotherboardData
+ * @param line
+ */
+export declare function handleMotherboardData(uuid: string, receivedString: string): void;

package/src/devices/moterboard.js

@@ -0,0 +1,163 @@
+import { notifyCallback } from "../notify";
+const PACKET_LENGTH = 32;
+const NUM_SAMPLES = 3;
+const CALIBRATION = [[], [], [], []];
+export const Motherboard = {
+    name: "Motherboard",
+    companyId: 0x2a29,
+    services: [
+        {
+            name: "Device Information",
+            id: "device",
+            uuid: "0000180a-0000-1000-8000-00805f9b34fb",
+            characteristics: [
+                // {
+                //     name: 'Serial Number (Blocked)',
+                //     id: 'serial'
+                //     uuid: '00002a25-0000-1000-8000-00805f9b34fb'
+                // },
+                {
+                    name: "Firmware Revision",
+                    id: "firmware",
+                    uuid: "00002a26-0000-1000-8000-00805f9b34fb",
+                },
+                {
+                    name: "Hardware Revision",
+                    id: "hardware",
+                    uuid: "00002a27-0000-1000-8000-00805f9b34fb",
+                },
+                {
+                    name: "Manufacturer Name",
+                    id: "manufacturer",
+                    uuid: "00002a29-0000-1000-8000-00805f9b34fb",
+                },
+            ],
+        },
+        {
+            name: "Battery Service",
+            id: "battery",
+            uuid: "0000180f-0000-1000-8000-00805f9b34fb",
+            characteristics: [
+                {
+                    name: "Battery Level",
+                    id: "level",
+                    uuid: "00002a19-0000-1000-8000-00805f9b34fb",
+                },
+            ],
+        },
+        {
+            name: "Unknown Service",
+            id: "unknown",
+            uuid: "10ababcd-15e1-28ff-de13-725bea03b127",
+            characteristics: [
+                {
+                    name: "Unknown 01",
+                    id: "01",
+                    uuid: "10ab1524-15e1-28ff-de13-725bea03b127",
+                },
+                {
+                    name: "Unknown 02",
+                    id: "02",
+                    uuid: "10ab1525-15e1-28ff-de13-725bea03b127",
+                },
+            ],
+        },
+        {
+            name: "UART Nordic Service",
+            id: "uart",
+            uuid: "6e400001-b5a3-f393-e0a9-e50e24dcca9e",
+            characteristics: [
+                {
+                    name: "TX",
+                    id: "tx",
+                    uuid: "6e400002-b5a3-f393-e0a9-e50e24dcca9e",
+                },
+                {
+                    name: "RX",
+                    id: "rx",
+                    uuid: "6e400003-b5a3-f393-e0a9-e50e24dcca9e",
+                },
+            ],
+        },
+    ],
+};
+/**
+ * applyCalibration
+ * @param sample
+ * @param calibration
+ */
+const applyCalibration = (sample, calibration) => {
+    const zeroCalib = calibration[0][2];
+    let sgn = 1;
+    let final = 0;
+    if (sample < zeroCalib) {
+        sgn = -1;
+        sample = 2 * zeroCalib - sample;
+    }
+    for (let i = 1; i < calibration.length; i++) {
+        const calibStart = calibration[i - 1][2];
+        const calibEnd = calibration[i][2];
+        if (sample < calibEnd) {
+            final =
+                calibration[i - 1][1] +
+                    ((sample - calibStart) / (calibEnd - calibStart)) * (calibration[i][1] - calibration[i - 1][1]);
+            break;
+        }
+    }
+    return sgn * final;
+};
+/**
+ * handleMotherboardData
+ * @param line
+ */
+export function handleMotherboardData(uuid, receivedString) {
+    const receivedTime = Date.now();
+    // Check if the line is entirely hex characters
+    const allHex = /^[0-9A-Fa-f]+$/g.test(receivedString);
+    // Decide if this is a streaming packet
+    if (allHex && receivedString.length === PACKET_LENGTH) {
+        // Base-16 decode the string: convert hex pairs to byte values
+        const bytes = Array.from({ length: receivedString.length / 2 }, (_, i) => Number(`0x${receivedString.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: [],
+        };
+        for (let i = 0; i < NUM_SAMPLES; i++) {
+            const sampleStart = 4 + 3 * i;
+            packet.samples[i] = bytes[sampleStart] | (bytes[sampleStart + 1] << 8) | (bytes[sampleStart + 2] << 16);
+            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]);
+        }
+        const left = packet.masses[0];
+        const center = packet.masses[1];
+        const right = packet.masses[2];
+        notifyCallback({
+            uuid,
+            value: {
+                massTotal: Math.max(-1000, left + right + center).toFixed(3),
+                massLeft: Math.max(-1000, left).toFixed(3),
+                massRight: Math.max(-1000, right).toFixed(3),
+                massCentre: Math.max(-1000, center).toFixed(3),
+            },
+        });
+    }
+    else if ((receivedString.match(/,/g) || []).length === 3) {
+        // if the returned notification is a calibration string add them to the array
+        const parts = receivedString.split(",");
+        const numericParts = parts.map((x) => parseFloat(x));
+        CALIBRATION[numericParts[0]].push(numericParts.slice(1));
+    }
+    else {
+        // unhanded data
+        console.log(receivedString);
+    }
+}