@hangtime/grip-connect 0.0.5 → 0.0.6

package/README.md

@@ -1,7 +1,9 @@
-# Force-Sensing Climbing Training
+# Grip Connect
 
-The objective of this project is to create a client that can establish connections with various Force-Sensing
-Hangboards/Plates used by climbers for strength measurement. Examples of such hangboards include the
+**Force-Sensing Climbing Training**
+
+The objective of this project is to create 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](https://griptonite.io/shop/motherboard/), [Climbro](https://climbro.com/),
 [SmartBoard](https://www.smartboard-climbing.com/), [Entralpi](https://entralpi.com/) or
 [Tindeq Progressor](https://tindeq.com/)

package/build/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/build/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/build/connect.d.ts

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

package/build/connect.js

@@ -0,0 +1,149 @@
+import { notifyCallback } from "./notify";
+/**
+ * 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 });
+        }
+    }
+};
+/**
+ * Return all service UUIDs
+ * @param device
+ */
+function getAllServiceUUIDs(device) {
+    return device.services.map((service) => service.uuid);
+}
+/**
+ * connect
+ * @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;
+        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");
+            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}`);
+                    }
+                }
+            }
+        }
+        onSuccess();
+    }
+    catch (error) {
+        console.error(error);
+    }
+};

package/build/devices/entralpi.d.ts

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

package/build/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/build/devices/index.d.ts

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

package/build/devices/index.js

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

package/build/devices/moterboard.d.ts

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

package/build/devices/moterboard.js

@@ -0,0 +1,79 @@
+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",
+                },
+            ],
+        },
+    ],
+};

package/build/devices/tindeq.d.ts

@@ -0,0 +1,17 @@
+import { Device } from "./types";
+export declare const Tindeq: Device;
+export declare const Commands: {
+    TARE_SCALE: number;
+    START_MEASURING: number;
+    STOP_MEASURING: number;
+    GET_APP_VERSION: number;
+    GET_ERROR_INFO: number;
+    CLEAR_ERR_INFO: number;
+    GET_BATTERY_LEVEL: number;
+    SLEEP: number;
+};
+export declare const NotificationTypes: {
+    COMMAND_RESPONSE: number;
+    WEIGHT_MEASURE: number;
+    LOW_BATTERY_WARNING: number;
+};

package/build/devices/tindeq.js

@@ -0,0 +1,37 @@
+export const Tindeq = {
+    name: "Tindeq",
+    services: [
+        {
+            name: "Progressor Service",
+            id: "progressor",
+            uuid: "7e4e1701-1ea6-40c9-9dcc-13d34ffead57",
+            characteristics: [
+                {
+                    name: "Write",
+                    id: "tx",
+                    uuid: "7e4e1703-1ea6-40c9-9dcc-13d34ffead57",
+                },
+                {
+                    name: "Notify",
+                    id: "rx",
+                    uuid: "7e4e1702-1ea6-40c9-9dcc-13d34ffead57",
+                },
+            ],
+        },
+    ],
+};
+export const Commands = {
+    TARE_SCALE: 0x64,
+    START_MEASURING: 0x65,
+    STOP_MEASURING: 0x66,
+    GET_APP_VERSION: 0x6b,
+    GET_ERROR_INFO: 0x6c,
+    CLEAR_ERR_INFO: 0x6d,
+    GET_BATTERY_LEVEL: 0x6f,
+    SLEEP: 0x6e,
+};
+export const NotificationTypes = {
+    COMMAND_RESPONSE: 0,
+    WEIGHT_MEASURE: 1,
+    LOW_BATTERY_WARNING: 2,
+};

package/build/devices/types.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="web-bluetooth" />
+interface Characteristic {
+    name: string;
+    id: string;
+    uuid: string;
+    characteristic?: BluetoothRemoteGATTCharacteristic;
+}
+interface Service {
+    name: string;
+    id: string;
+    uuid: string;
+    characteristics: Characteristic[];
+}
+export interface Device {
+    name: string;
+    companyId?: number;
+    services: Service[];
+    device?: BluetoothDevice;
+}
+export {};

package/build/devices/types.js

@@ -0,0 +1 @@
+export {};

package/build/disconnect.d.ts

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

package/build/disconnect.js

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

package/build/index.d.ts

@@ -1,18 +1,6 @@
-/// <reference types="web-bluetooth" />
-interface Motherboard {
-  device?: BluetoothDevice
-  devSn?: BluetoothRemoteGATTCharacteristic
-  devFr?: BluetoothRemoteGATTCharacteristic
-  devHr?: BluetoothRemoteGATTCharacteristic
-  devMn?: BluetoothRemoteGATTCharacteristic
-  bat?: BluetoothRemoteGATTCharacteristic
-  led01?: BluetoothRemoteGATTCharacteristic
-  led02?: BluetoothRemoteGATTCharacteristic
-  uartTx?: BluetoothRemoteGATTCharacteristic
-  uartRx?: BluetoothRemoteGATTCharacteristic
-}
-declare const motherboard: Motherboard
-declare const connect: () => void
-declare const disconnect: () => void
-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/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) => Promise<void>;

package/build/read.js

@@ -0,0 +1,40 @@
+import { notifyCallback } from "./notify";
+import { getCharacteristic } from "./characteristic";
+/**
+ * read
+ * @param characteristic
+ */
+export const read = (board, serviceId, characteristicId) => {
+    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;
+                    }
+                    notifyCallback({ uuid: characteristic.uuid, value: decodedValue });
+                    resolve();
+                })
+                    .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.6",
   "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/connect.d.ts

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

package/src/connect.js

@@ -0,0 +1,149 @@
+import { notifyCallback } from "./notify";
+/**
+ * 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 });
+        }
+    }
+};
+/**
+ * Return all service UUIDs
+ * @param device
+ */
+function getAllServiceUUIDs(device) {
+    return device.services.map((service) => service.uuid);
+}
+/**
+ * connect
+ * @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;
+        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");
+            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}`);
+                    }
+                }
+            }
+        }
+        onSuccess();
+    }
+    catch (error) {
+        console.error(error);
+    }
+};

package/src/connect.ts

@@ -48,12 +48,12 @@ const handleNotifications = (event: Event, board: Device): void => {
         "pressure2",
         "right",
       ]
-      const dataObject = {}
+      const dataObject: { [key: string]: number } = {};
 
       if (parsedDecimalArray) {
-        elementKeys.forEach((key, index) => {
-          dataObject[key] = parsedDecimalArray[index]
-        })
+        elementKeys.forEach((key: string, index: number) => {
+          dataObject[key] = parsedDecimalArray[index];
+        });
       }
       if (notifyCallback) {
         notifyCallback({ uuid: characteristic.uuid, value: dataObject })