@hangtime/grip-connect 0.0.5

package/README.md

@@ -0,0 +1,83 @@
+# 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/)
+
+## Roadmap
+
+- ➡️ Connect with devices
+  - ✅ Griptonte Motherboard
+  - ✅ Tindeq Progressor
+  - ✅ Entralpi
+  - ➡️ Climbro
+  - ➡️ SmartBoard
+- ✅ Read / Write / Notify using Bluetooth
+- ➡️ Calibrate Devices
+- ➡️ Output weight/force stream
+
+## Development
+
+```bash
+git clone https://github.com/Stevie-Ray/hangtime-grip-connect
+cd hangtime-grip-connect
+npm install
+```
+
+## Install
+
+```sh [npm]
+$ npm install @hangtime/grip-connect
+```
+
+## Example usage (Motherboard)
+
+Simply importing the utilities you need from `@hangtime/grip-connect`. Devices that are currently supported:
+`Motherboard`, `Tindeq` and `Entralpi`.
+
+```html
+<button id="motherboard" type="button">Connect Motherboard</button>
+```
+
+```js
+import { Motherboard, connect, disconnect, read, write, notify } from "@hangtime/grip-connect"
+
+const motherboardButton = document.querySelector("#motherboard")
+
+motherboardButton.addEventListener("click", () => {
+  connect(Motherboard, async () => {
+    // Listen for notifications
+    notify((data) => {
+      console.log(data)
+    })
+
+    // read battery + device info
+    await read(Motherboard, "battery", "level")
+    await read(Motherboard, "device", "manufacturer")
+    await read(Motherboard, "device", "hardware")
+    await read(Motherboard, "device", "firmware")
+
+    // Calibrate?
+    await write(Motherboard, "uart", "tx", "C", 5000)
+
+    // Read stream?
+    await write(Motherboard, "unknown", "01", "1", 2500)
+    await write(Motherboard, "unknown", "02", "0", 2500)
+    await write(Motherboard, "uart", "tx", "S30", 5000)
+
+    // Read stream (2x)?
+    await write(Motherboard, "unknown", "01", "0", 2500)
+    await write(Motherboard, "unknown", "02", "1", 2500)
+    await write(Motherboard, "uart", "tx", "S30", 5000)
+
+    // disconnect from device after we are done
+    disconnect(Motherboard)
+  })
+})
+```
+
+## License
+
+MIT © [Stevie-Ray Hartog](https://github.com/Stevie-Ray)

package/build/index.d.ts

@@ -0,0 +1,18 @@
+/// <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 }

package/build/index.js

@@ -0,0 +1,175 @@
+// 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 }

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@hangtime/grip-connect",
+  "version": "0.0.5",
+  "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": {
+    "build": "tsc --build"
+  },
+  "author": "Stevie-Ray Hartog <mail@stevie-ray.nl>",
+  "license": "MIT",
+  "devDependencies": {},
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Stevie-Ray/hangtime-grip-connect.git"
+  },
+  "keywords": [
+    "climbing",
+    "bluetooth",
+    "griptonite",
+    "hangboard",
+    "hangboarding",
+    "beastmaker",
+    "motherboard"
+  ],
+  "bugs": {
+    "url": "https://github.com/Stevie-Ray/hangtime-grip-connect/issues"
+  },
+  "homepage": "https://stevie-ray.github.io/hangtime-grip-connect/"
+}

package/src/characteristic.ts

@@ -0,0 +1,19 @@
+import { Device } from "./devices/types"
+
+/**
+ * getCharacteristic
+ * @param board
+ * @param serviceId
+ * @param characteristicId
+ */
+export const getCharacteristic = (board: Device, serviceId: string, characteristicId: string) => {
+  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.ts

@@ -0,0 +1,162 @@
+import { Device } from "./devices/types"
+import { notifyCallback } from "./notify"
+
+/**
+ * onDisconnected
+ * @param board
+ * @param event
+ */
+const onDisconnected = (event: Event, board: Device): void => {
+  board.device = undefined
+  const device = event.target as BluetoothDevice
+  console.log(`Device ${device.name} is disconnected.`)
+}
+/**
+ * handleNotifications
+ * @param event
+ * @param onNotify
+ */
+const handleNotifications = (event: Event, board: Device): void => {
+  const characteristic = event.target as BluetoothRemoteGATTCharacteristic
+  const receivedData = new Uint8Array(characteristic.value!.buffer)
+  // Create an array to store the parsed decimal values
+  const decimalArray: number[] = []
+
+  // Iterate through each byte and convert to decimal
+  for (let i = 0; i < receivedData.length; i++) {
+    decimalArray.push(receivedData[i])
+  }
+  // Convert the decimal array to a string representation
+  const receivedString: string = String.fromCharCode(...decimalArray)
+
+  if (board.name === "Motherboard") {
+    // Split the string into pairs of characters
+    const hexPairs: RegExpMatchArray | null = receivedString.match(/.{1,2}/g)
+    // Convert each hexadecimal pair to decimal
+    const parsedDecimalArray: number[] | undefined = hexPairs?.map((hexPair) => parseInt(hexPair, 16))
+    // Handle different types of data
+    if (characteristic.value!.byteLength === 20) {
+      const elementKeys = [
+        "frames",
+        "cycle",
+        "unknown",
+        "eleven",
+        "dynamic1",
+        "pressure1",
+        "left",
+        "dynamic2",
+        "pressure2",
+        "right",
+      ]
+      const dataObject = {}
+
+      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: Device) {
+  return device.services.map((service) => service.uuid)
+}
+/**
+ * connect
+ * @param device
+ * @param onSuccess
+ */
+export const connect = async (board: Device, onSuccess: () => void): Promise<void> => {
+  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/devices/entralpi.ts

@@ -0,0 +1,54 @@
+import { Device } from "./types"
+
+export const Entralpi: Device = {
+  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.ts

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

package/src/devices/moterboard.ts

@@ -0,0 +1,81 @@
+import { Device } from "./types"
+
+export const Motherboard: Device = {
+  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.ts

@@ -0,0 +1,41 @@
+import { Device } from "./types"
+
+export const Tindeq: Device = {
+  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.ts

@@ -0,0 +1,20 @@
+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
+}

package/src/disconnect.ts

@@ -0,0 +1,12 @@
+import { Device } from "./devices/types"
+
+/**
+ * disconnect
+ * @param board
+ */
+export const disconnect = (board: Device): void => {
+  if (!board.device) return
+  if (board.device.gatt?.connected) {
+    board.device.gatt?.disconnect()
+  }
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+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.ts

@@ -0,0 +1,10 @@
+// Define the callback function type
+type NotifyCallback = (data: object) => void
+
+// Initialize the callback variable
+export let notifyCallback: NotifyCallback
+
+// Export a function to set the callback
+export const notify = (callback: NotifyCallback) => {
+  notifyCallback = callback
+}

package/src/read.ts

@@ -0,0 +1,41 @@
+import { Device } from "./devices/types"
+import { notifyCallback } from "./notify"
+import { getCharacteristic } from "./characteristic"
+
+/**
+ * read
+ * @param characteristic
+ */
+export const read = (board: Device, serviceId: string, characteristicId: string): Promise<void> => {
+  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/src/write.ts

@@ -0,0 +1,39 @@
+import { Device } from "./devices/types"
+import { getCharacteristic } from "./characteristic"
+/**
+ * write
+ * @param characteristic
+ * @param message
+ */
+export const write = (
+  board: Device,
+  serviceId: string,
+  characteristicId: string,
+  message: string,
+  duration: number = 0,
+): Promise<void> => {
+  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/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "include": ["src"],
+  "compilerOptions": {
+    "tsBuildInfoFile": "node_modules/.cache/.tsbuildinfo",
+    "types": ["web-bluetooth"],
+    "outDir": "./build"
+  }
+}