@hangtime/grip-connect 0.0.5 → 0.0.7

package/build/index.js

@@ -1,175 +1,6 @@
-// Device service
-const DEVICE_SERVICE_UUID = "0000180a-0000-1000-8000-00805f9b34fb"
-const DEVICE_SN_CHARACTERISTIC_UUID = "00002a25-0000-1000-8000-00805f9b34fb"
-const DEVICE_FR_CHARACTERISTIC_UUID = "00002a26-0000-1000-8000-00805f9b34fb"
-const DEVICE_HR_CHARACTERISTIC_UUID = "00002a27-0000-1000-8000-00805f9b34fb"
-const DEVICE_MN_CHARACTERISTIC_UUID = "00002a29-0000-1000-8000-00805f9b34fb"
-// Battery service (Read / Notify)
-const BATTERY_SERVICE_UUID = "0000180f-0000-1000-8000-00805f9b34fb"
-const BATTERY_CHARACTERISTIC_UUID = "00002a19-0000-1000-8000-00805f9b34fb"
-// Led service
-const LED_SERVICE_UUID = "10ababcd-15e1-28ff-de13-725bea03b127"
-const LED_01_CHARACTERISTIC_UUID = "10ab1524-15e1-28ff-de13-725bea03b127"
-const LED_02_CHARACTERISTIC_UUID = "10ab1525-15e1-28ff-de13-725bea03b127"
-// An implementation of Nordic Semicondutor's UART/Serial Port Emulation over Bluetooth low energy
-const UART_SERVICE_UUID = "6e400001-b5a3-f393-e0a9-e50e24dcca9e"
-const UART_TX_CHARACTERISTIC_UUID = "6e400002-b5a3-f393-e0a9-e50e24dcca9e"
-const UART_RX_CHARACTERISTIC_UUID = "6e400003-b5a3-f393-e0a9-e50e24dcca9e"
-// https://github.com/sepp89117/GoPro_Web_RC/blob/main/GoPro_Web_RC.html
-const motherboard = {}
-const connect = () => {
-  navigator.bluetooth
-    .requestDevice({
-      filters: [
-        {
-          name: "Motherboard",
-        },
-        {
-          manufacturerData: [
-            {
-              companyIdentifier: 0x2a29,
-            },
-          ],
-        },
-      ],
-      optionalServices: [DEVICE_SERVICE_UUID, BATTERY_SERVICE_UUID, UART_SERVICE_UUID, LED_SERVICE_UUID],
-    })
-    .then(async (device) => {
-      motherboard.device = device
-      device.addEventListener("gattserverdisconnected", onDisconnected)
-      return device.gatt?.connect()
-    })
-    .then((server) => {
-      return server?.getPrimaryServices()
-    })
-    .then((services) => {
-      // console.log(services)
-      if (services === null) {
-        console.error("getPrimaryServices is 'null'")
-      } else {
-        if (services) {
-          for (const service of services) {
-            switch (service.uuid) {
-              case DEVICE_SERVICE_UUID:
-                // getCharacteristic(service, DEVICE_SN_CHARACTERISTIC_UUID) getCharacteristic(s) called with blocklisted UUID
-                getCharacteristic(service, DEVICE_FR_CHARACTERISTIC_UUID)
-                getCharacteristic(service, DEVICE_HR_CHARACTERISTIC_UUID)
-                getCharacteristic(service, DEVICE_MN_CHARACTERISTIC_UUID)
-                break
-              case BATTERY_SERVICE_UUID:
-                getCharacteristic(service, BATTERY_CHARACTERISTIC_UUID)
-                break
-              case LED_SERVICE_UUID:
-                getCharacteristic(service, LED_01_CHARACTERISTIC_UUID)
-                getCharacteristic(service, LED_02_CHARACTERISTIC_UUID)
-                break
-              case UART_SERVICE_UUID:
-                getCharacteristic(service, UART_TX_CHARACTERISTIC_UUID)
-                getCharacteristic(service, UART_RX_CHARACTERISTIC_UUID)
-                break
-              default:
-                break
-            }
-          }
-        }
-      }
-    })
-    .catch((error) => {
-      console.log(error)
-    })
-}
-const disconnect = () => {
-  if (!motherboard.device) return
-  if (motherboard.device.gatt?.connected) {
-    motherboard.device.gatt?.disconnect()
-  }
-}
-const onDisconnected = (event) => {
-  motherboard.device = undefined
-  const device = event.target
-  console.log(`Device ${device.name} is disconnected.`)
-}
-const handleNotifications = (event) => {
-  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)
-  // 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) {
-    // Define keys for the elements
-    const elementKeys = [
-      "frames",
-      "cycle",
-      "unknown",
-      "eleven",
-      "trippin1",
-      "pressure1",
-      "left",
-      "trippin2",
-      "pressure2",
-      "right",
-    ]
-    // Create a single object with keys and values
-    const dataObject = {}
-    if (parsedDecimalArray) {
-      elementKeys.forEach((key, index) => {
-        dataObject[key] = parsedDecimalArray[index]
-      })
-    }
-    // Print the formatted string on the screen
-    console.log(dataObject)
-  } else if (characteristic.value.byteLength === 14) {
-    console.log(characteristic.value.byteLength, parsedDecimalArray)
-  } else {
-    console.log(characteristic.value.byteLength, parsedDecimalArray)
-  }
-}
-const getCharacteristic = (service, uuid) => {
-  service.getCharacteristic(uuid).then((characteristic) => {
-    switch (characteristic.uuid) {
-      case DEVICE_SN_CHARACTERISTIC_UUID:
-        motherboard.devSn = characteristic
-        break
-      case DEVICE_FR_CHARACTERISTIC_UUID:
-        motherboard.devFr = characteristic
-        break
-      case DEVICE_HR_CHARACTERISTIC_UUID:
-        motherboard.devHr = characteristic
-        break
-      case DEVICE_MN_CHARACTERISTIC_UUID:
-        motherboard.devMn = characteristic
-        break
-      case BATTERY_CHARACTERISTIC_UUID:
-        motherboard.bat = characteristic
-        break
-      case LED_01_CHARACTERISTIC_UUID:
-        motherboard.led01 = characteristic
-        break
-      case LED_02_CHARACTERISTIC_UUID:
-        motherboard.led02 = characteristic
-        break
-      case UART_TX_CHARACTERISTIC_UUID:
-        motherboard.uartTx = characteristic
-        break
-      case UART_RX_CHARACTERISTIC_UUID:
-        motherboard.uartRx = characteristic
-        motherboard.uartRx.startNotifications()
-        motherboard.uartRx.addEventListener("characteristicvaluechanged", handleNotifications)
-        break
-      default:
-        break
-    }
-  })
-}
-export default motherboard
-export { disconnect, connect }
+export { Motherboard, Entralpi, Tindeq } from "./devices/index";
+export { connect } from "./connect";
+export { disconnect } from "./disconnect";
+export { notify } from "./notify";
+export { read } from "./read";
+export { write } from "./write";

package/build/notify.d.ts

@@ -0,0 +1,4 @@
+type NotifyCallback = (data: object) => void;
+export declare let notifyCallback: NotifyCallback;
+export declare const notify: (callback: NotifyCallback) => void;
+export {};

package/build/notify.js

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

package/build/read.d.ts

@@ -0,0 +1,6 @@
+import { Device } from "./devices/types";
+/**
+ * read
+ * @param characteristic
+ */
+export declare const read: (board: Device, serviceId: string, characteristicId: string, duration?: number) => Promise<void>;

package/build/read.js

@@ -0,0 +1,44 @@
+import { notifyCallback } from "./notify";
+import { getCharacteristic } from "./characteristic";
+/**
+ * read
+ * @param characteristic
+ */
+export const read = (board, serviceId, characteristicId, duration = 0) => {
+    return new Promise((resolve, reject) => {
+        if (board.device?.gatt?.connected) {
+            const characteristic = getCharacteristic(board, serviceId, characteristicId);
+            if (characteristic) {
+                characteristic
+                    .readValue()
+                    .then((value) => {
+                    let decodedValue;
+                    const decoder = new TextDecoder("utf-8");
+                    switch (characteristicId) {
+                        case "level":
+                            decodedValue = value.getUint8(0);
+                            break;
+                        default:
+                            decodedValue = decoder.decode(value);
+                            break;
+                    }
+                    if (notifyCallback) {
+                        notifyCallback({ uuid: characteristic.uuid, value: decodedValue });
+                    }
+                    setTimeout(() => {
+                        resolve();
+                    }, duration);
+                })
+                    .catch((error) => {
+                    reject(error);
+                });
+            }
+            else {
+                reject(new Error("Characteristic is undefined"));
+            }
+        }
+        else {
+            reject(new Error("Device is not connected"));
+        }
+    });
+};

package/build/write.d.ts

@@ -0,0 +1,7 @@
+import { Device } from "./devices/types";
+/**
+ * write
+ * @param characteristic
+ * @param message
+ */
+export declare const write: (board: Device, serviceId: string, characteristicId: string, message: string, duration?: number) => Promise<void>;

package/build/write.js

@@ -0,0 +1,32 @@
+import { getCharacteristic } from "./characteristic";
+/**
+ * write
+ * @param characteristic
+ * @param message
+ */
+export const write = (board, serviceId, characteristicId, message, duration = 0) => {
+    return new Promise((resolve, reject) => {
+        if (board.device?.gatt?.connected) {
+            const encoder = new TextEncoder();
+            const characteristic = getCharacteristic(board, serviceId, characteristicId);
+            if (characteristic) {
+                characteristic
+                    .writeValue(encoder.encode(message))
+                    .then(() => {
+                    setTimeout(() => {
+                        resolve();
+                    }, duration);
+                })
+                    .catch((error) => {
+                    reject(error);
+                });
+            }
+            else {
+                reject(new Error("Characteristics is undefined"));
+            }
+        }
+        else {
+            reject(new Error("Device is not connected"));
+        }
+    });
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hangtime/grip-connect",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "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 Motherboard, Climbro, SmartBoard, Entralpi or Tindeq Progressor",
   "main": "src/index.ts",
   "scripts": {

package/src/characteristic.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="web-bluetooth" />
+import { Device } from "./devices/types";
+/**
+ * getCharacteristic
+ * @param board
+ * @param serviceId
+ * @param characteristicId
+ */
+export declare const getCharacteristic: (board: Device, serviceId: string, characteristicId: string) => BluetoothRemoteGATTCharacteristic | undefined;

package/src/characteristic.js

@@ -0,0 +1,15 @@
+/**
+ * getCharacteristic
+ * @param board
+ * @param serviceId
+ * @param characteristicId
+ */
+export const getCharacteristic = (board, serviceId, characteristicId) => {
+    const boardService = board.services.find((service) => service.id === serviceId);
+    if (boardService) {
+        const boardCharacteristic = boardService.characteristics.find((characteristic) => characteristic.id === characteristicId);
+        if (boardCharacteristic) {
+            return boardCharacteristic.characteristic;
+        }
+    }
+};

package/src/connect.d.ts

@@ -0,0 +1,7 @@
+import { Device } from "./devices/types";
+/**
+ * Connect to the BluetoothDevice
+ * @param device
+ * @param onSuccess
+ */
+export declare const connect: (board: Device, onSuccess: () => void) => Promise<void>;

package/src/connect.js

@@ -0,0 +1,172 @@
+import { notifyCallback } from "./notify";
+let server;
+/**
+ * onDisconnected
+ * @param board
+ * @param event
+ */
+const onDisconnected = (event, board) => {
+    board.device = undefined;
+    const device = event.target;
+    console.log(`Device ${device.name} is disconnected.`);
+};
+/**
+ * handleNotifications
+ * @param event
+ * @param onNotify
+ */
+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];
+                });
+            }
+            if (notifyCallback) {
+                notifyCallback({ uuid: characteristic.uuid, value: dataObject });
+            }
+        }
+        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 });
+        }
+    }
+    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);
+    }
+};
+/**
+ * Return all service UUIDs
+ * @param device
+ */
+function getAllServiceUUIDs(device) {
+    return device.services.map((service) => service.uuid);
+}
+/**
+ * Connect to the BluetoothDevice
+ * @param device
+ * @param onSuccess
+ */
+export const connect = async (board, onSuccess) => {
+    try {
+        const deviceServices = getAllServiceUUIDs(board);
+        // setup filter list
+        const filters = [];
+        if (board.name) {
+            filters.push({
+                name: board.name,
+            });
+        }
+        if (board.companyId) {
+            filters.push({
+                manufacturerData: [
+                    {
+                        companyIdentifier: board.companyId,
+                    },
+                ],
+            });
+        }
+        const device = await navigator.bluetooth.requestDevice({
+            filters: filters,
+            optionalServices: deviceServices
+        });
+        board.device = device;
+        if (!board.device.gatt) {
+            console.error("GATT is not available on this device");
+            return;
+        }
+        server = await board.device?.gatt?.connect();
+        board.device.addEventListener("gattserverdisconnected", (event) => onDisconnected(event, board));
+        if (server.connected) {
+            await onConnected(board, onSuccess);
+        }
+    }
+    catch (error) {
+        console.error(error);
+    }
+};

package/src/connect.ts

@@ -1,6 +1,8 @@
 import { Device } from "./devices/types"
 import { notifyCallback } from "./notify"
 
+let server: BluetoothRemoteGATTServer
+
 /**
  * onDisconnected
  * @param board
@@ -48,10 +50,10 @@ const handleNotifications = (event: Event, board: Device): void => {
         "pressure2",
         "right",
       ]
-      const dataObject = {}
+      const dataObject: { [key: string]: number } = {}
 
       if (parsedDecimalArray) {
-        elementKeys.forEach((key, index) => {
+        elementKeys.forEach((key: string, index: number) => {
           dataObject[key] = parsedDecimalArray[index]
         })
       }
@@ -76,6 +78,58 @@ const handleNotifications = (event: Event, board: Device): void => {
     }
   }
 }
+/**
+ * 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
+    }
+
+    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)
+  }
+}
 /**
  * Return all service UUIDs
  * @param device
@@ -84,7 +138,7 @@ function getAllServiceUUIDs(device: Device) {
   return device.services.map((service) => service.uuid)
 }
 /**
- * connect
+ * Connect to the BluetoothDevice
  * @param device
  * @param onSuccess
  */
@@ -112,50 +166,23 @@ export const connect = async (board: Device, onSuccess: () => void): Promise<voi
 
     const device = await navigator.bluetooth.requestDevice({
       filters: filters,
-      optionalServices: deviceServices,
+      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()
+    server = await board.device?.gatt?.connect()
 
-        for (const characteristic of matchingService.characteristics) {
-          const matchingCharacteristic = characteristics.find((char) => char.uuid === characteristic.uuid)
+    board.device.addEventListener("gattserverdisconnected", (event) => onDisconnected(event, board))
 
-          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;