@hangtime/grip-connect 0.0.6 → 0.0.7

package/README.md

@@ -56,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/connect.d.ts

@@ -1,6 +1,6 @@
 import { Device } from "./devices/types";
 /**
- * connect
+ * Connect to the BluetoothDevice
  * @param device
  * @param onSuccess
  */

package/build/connect.js

@@ -1,4 +1,5 @@
 import { notifyCallback } from "./notify";
+let server;
 /**
  * onDisconnected
  * @param board
@@ -75,6 +76,50 @@ const handleNotifications = (event, board) => {
         }
     }
 };
+/**
+ * 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
@@ -83,7 +128,7 @@ function getAllServiceUUIDs(device) {
     return device.services.map((service) => service.uuid);
 }
 /**
- * connect
+ * Connect to the BluetoothDevice
  * @param device
  * @param onSuccess
  */
@@ -108,40 +153,18 @@ export const connect = async (board, onSuccess) => {
         }
         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();
-                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/build/read.d.ts

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

package/build/read.js

@@ -4,7 +4,7 @@ import { getCharacteristic } from "./characteristic";
  * read
  * @param characteristic
  */
-export const read = (board, serviceId, characteristicId) => {
+export const read = (board, serviceId, characteristicId, duration = 0) => {
     return new Promise((resolve, reject) => {
         if (board.device?.gatt?.connected) {
             const characteristic = getCharacteristic(board, serviceId, characteristicId);
@@ -22,8 +22,12 @@ export const read = (board, serviceId, characteristicId) => {
                             decodedValue = decoder.decode(value);
                             break;
                     }
-                    notifyCallback({ uuid: characteristic.uuid, value: decodedValue });
-                    resolve();
+                    if (notifyCallback) {
+                        notifyCallback({ uuid: characteristic.uuid, value: decodedValue });
+                    }
+                    setTimeout(() => {
+                        resolve();
+                    }, duration);
                 })
                     .catch((error) => {
                     reject(error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hangtime/grip-connect",
-  "version": "0.0.6",
+  "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

@@ -1,6 +1,6 @@
 import { Device } from "./devices/types";
 /**
- * connect
+ * Connect to the BluetoothDevice
  * @param device
  * @param onSuccess
  */

package/src/connect.js

@@ -1,4 +1,5 @@
 import { notifyCallback } from "./notify";
+let server;
 /**
  * onDisconnected
  * @param board
@@ -75,6 +76,50 @@ const handleNotifications = (event, board) => {
         }
     }
 };
+/**
+ * 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
@@ -83,7 +128,7 @@ function getAllServiceUUIDs(device) {
     return device.services.map((service) => service.uuid);
 }
 /**
- * connect
+ * Connect to the BluetoothDevice
  * @param device
  * @param onSuccess
  */
@@ -108,40 +153,18 @@ export const connect = async (board, onSuccess) => {
         }
         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();
-                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,6 +1,8 @@
 import { Device } from "./devices/types"
 import { notifyCallback } from "./notify"
 
+let server: BluetoothRemoteGATTServer
+
 /**
  * onDisconnected
  * @param board
@@ -48,12 +50,12 @@ const handleNotifications = (event: Event, board: Device): void => {
         "pressure2",
         "right",
       ]
-      const dataObject: { [key: string]: number } = {};
+      const dataObject: { [key: string]: number } = {}
 
       if (parsedDecimalArray) {
         elementKeys.forEach((key: string, index: number) => {
-          dataObject[key] = parsedDecimalArray[index];
-        });
+          dataObject[key] = parsedDecimalArray[index]
+        })
       }
       if (notifyCallback) {
         notifyCallback({ uuid: characteristic.uuid, value: dataObject })
@@ -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;

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,2 @@
+import { Device } from "./types";
+export declare const Motherboard: Device;

package/src/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/src/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/src/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/src/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/src/devices/types.js

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

package/src/disconnect.d.ts

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

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

@@ -0,0 +1,6 @@
+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/src/index.js

@@ -0,0 +1,6 @@
+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/src/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/src/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/src/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/src/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/src/read.ts

@@ -6,7 +6,7 @@ import { getCharacteristic } from "./characteristic"
  * read
  * @param characteristic
  */
-export const read = (board: Device, serviceId: string, characteristicId: string): Promise<void> => {
+export const read = (board: Device, serviceId: string, characteristicId: string, duration: number = 0): Promise<void> => {
   return new Promise((resolve, reject) => {
     if (board.device?.gatt?.connected) {
       const characteristic = getCharacteristic(board, serviceId, characteristicId)
@@ -25,8 +25,12 @@ export const read = (board: Device, serviceId: string, characteristicId: string)
                 decodedValue = decoder.decode(value)
                 break
             }
-            notifyCallback({ uuid: characteristic.uuid, value: decodedValue })
-            resolve()
+            if (notifyCallback) {
+              notifyCallback({ uuid: characteristic.uuid, value: decodedValue })
+            }
+            setTimeout(() => {
+              resolve()
+            }, duration)
           })
           .catch((error) => {
             reject(error)

package/src/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/src/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"));
+        }
+    });
+};