@hangtime/grip-connect 0.0.5 → 0.0.7

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/)
@@ -54,13 +56,13 @@ motherboardButton.addEventListener("click", () => {
     })
 
     // read battery + device info
-    await read(Motherboard, "battery", "level")
-    await read(Motherboard, "device", "manufacturer")
-    await read(Motherboard, "device", "hardware")
-    await read(Motherboard, "device", "firmware")
+    await read(Motherboard, "battery", "level", 1000)
+    await read(Motherboard, "device", "manufacturer", 1000)
+    await read(Motherboard, "device", "hardware", 1000)
+    await read(Motherboard, "device", "firmware", 1000)
 
     // Calibrate?
-    await write(Motherboard, "uart", "tx", "C", 5000)
+    await write(Motherboard, "uart", "tx", "C", 10000)
 
     // Read stream?
     await write(Motherboard, "unknown", "01", "1", 2500)

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 to the BluetoothDevice
+ * @param device
+ * @param onSuccess
+ */
+export declare const connect: (board: Device, onSuccess: () => void) => Promise<void>;

package/build/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/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";