@hangtime/grip-connect 0.4.2 → 0.5.0

package/src/connect.ts

@@ -1,187 +0,0 @@
-import type { Device } from "./types/devices"
-import { handleEntralpiData, handleMotherboardData, handleProgressorData, handleWHC06Data } from "./data"
-import { isEntralpi, isMotherboard, isProgressor } from "./is-device"
-
-let server: BluetoothRemoteGATTServer
-const receiveBuffer: number[] = []
-
-/**
- * Handles the 'disconnected' event.
- * @param {Event} event - The 'disconnected' event.
- * @param {Device} board - The device that is disconnected.
- */
-const onDisconnected = (event: Event, board: Device): void => {
-  board.device = undefined
-  const device = event.target as BluetoothDevice
-  throw new Error(`Device ${device.name} is disconnected.`)
-}
-/**
- * Handles notifications received from a characteristic.
- * @param {Event} event - The notification event.
- * @param {Device} board - The device associated with the characteristic.
- */
-const handleNotifications = (event: Event, board: Device): void => {
-  const characteristic: BluetoothRemoteGATTCharacteristic = event.target as BluetoothRemoteGATTCharacteristic
-  const value: DataView | undefined = characteristic.value
-
-  if (value) {
-    // If the device is connected and it is a Motherboard device
-    if (isMotherboard(board)) {
-      for (let i = 0; i < value.byteLength; i++) {
-        receiveBuffer.push(value.getUint8(i))
-      }
-
-      let idx: number
-      while ((idx = receiveBuffer.indexOf(10)) >= 0) {
-        const line: number[] = receiveBuffer.splice(0, idx + 1).slice(0, -1) // Combine and remove LF
-        if (line.length > 0 && line[line.length - 1] === 13) line.pop() // Remove CR
-        const decoder: TextDecoder = new TextDecoder("utf-8")
-        const receivedData: string = decoder.decode(new Uint8Array(line))
-        handleMotherboardData(receivedData)
-      }
-    } else if (isEntralpi(board)) {
-      if (value.buffer) {
-        const buffer: ArrayBuffer = value.buffer
-        const rawData: DataView = new DataView(buffer)
-        const receivedData: string = (rawData.getUint16(0) / 100).toFixed(1)
-        handleEntralpiData(receivedData)
-      }
-    } else if (isProgressor(board)) {
-      if (value.buffer) {
-        const buffer: ArrayBuffer = value.buffer
-        const rawData: DataView = new DataView(buffer)
-        handleProgressorData(rawData)
-      }
-    } else {
-      console.log(value)
-    }
-  }
-}
-/**
- * Handles the 'connected' event.
- * @param {Device} board - The connected device.
- * @param {Function} onSuccess - Callback function to execute on successful connection.
- */
-const onConnected = async (board: Device, onSuccess: () => void): Promise<void> => {
-  // Connect to GATT server and set up characteristics
-  const services: BluetoothRemoteGATTService[] = await server.getPrimaryServices()
-
-  if (!services || services.length === 0) {
-    throw new Error("No services found")
-  }
-
-  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: Event) => {
-                handleNotifications(event, board)
-              })
-            }
-          }
-        } else {
-          throw new Error(`Characteristic ${characteristic.uuid} not found in service ${service.uuid}`)
-        }
-      }
-    }
-  }
-
-  // Call the onSuccess callback after successful connection and setup
-  onSuccess()
-}
-/**
- * Returns UUIDs of all services associated with the device.
- * @param {Device} device - The device.
- * @returns {string[]} Array of service UUIDs.
- */
-const getAllServiceUUIDs = (device: Device) => {
-  return device.services.map((service) => service.uuid)
-}
-/**
- * Connects to a Bluetooth device.
- * @param {Device} board - The device to connect to.
- * @param {Function} [onSuccess] - Optional callback function to execute on successful connection. Default logs success.
- * @param {Function} [onError] - Optional callback function to execute on error. Default logs the error.
- */
-export const connect = async (
-  board: Device,
-  onSuccess: () => void = () => console.log("Connected successfully"),
-  onError: (error: Error) => void = (error) => console.error(error),
-): Promise<void> => {
-  try {
-    // Request device and set up connection
-    const deviceServices = getAllServiceUUIDs(board)
-
-    // Only data matching the optionalManufacturerData parameter to requestDevice is included in the advertisement event: https://github.com/WebBluetoothCG/web-bluetooth/issues/598
-    const optionalManufacturerData = board.filters.flatMap(
-      (filter) => filter.manufacturerData?.map((data) => data.companyIdentifier) || [],
-    )
-
-    const device = await navigator.bluetooth.requestDevice({
-      filters: board.filters,
-      optionalServices: deviceServices,
-      optionalManufacturerData,
-    })
-
-    board.device = device
-
-    if (!board.device.gatt) {
-      throw new Error("GATT is not available on this device")
-    }
-
-    board.device.addEventListener("gattserverdisconnected", (event) => {
-      onDisconnected(event, board)
-    })
-
-    // WH-C06
-    const MANUFACTURER_ID = 256 // 0x0100
-
-    board.device.addEventListener("advertisementreceived", (event) => {
-      const manufacturerData = event.manufacturerData.get(MANUFACTURER_ID)
-      if (manufacturerData) {
-        // Device has no services / characteristics
-        onSuccess()
-        // Handle recieved data
-        handleWHC06Data(manufacturerData)
-      }
-    })
-
-    // When the companyIdentifier is provided we want to get manufacturerData using watchAdvertisements.
-    if (optionalManufacturerData.length) {
-      // Receive events when the system receives an advertisement packet from a watched device.
-      // To use this function in Chrome: chrome://flags/#enable-experimental-web-platform-features has to be enabled.
-      // More info: https://chromestatus.com/feature/5180688812736512
-      if (typeof board.device.watchAdvertisements === "function") {
-        await board.device.watchAdvertisements()
-      } else {
-        throw new Error(
-          "watchAdvertisements isn't supported. For Chrome, enable it at chrome://flags/#enable-experimental-web-platform-features.",
-        )
-      }
-    }
-
-    server = await board.device.gatt.connect()
-
-    if (server.connected) {
-      await onConnected(board, onSuccess)
-    }
-  } catch (error) {
-    onError(error as Error)
-  }
-}

package/src/data/entralpi.ts

@@ -1,41 +0,0 @@
-import { notifyCallback } from "./../notify"
-import { checkActivity } from "./../is-active"
-import { applyTare } from "./../tare"
-
-// Constants
-let MASS_MAX = "0"
-let MASS_AVERAGE = "0"
-let MASS_TOTAL_SUM = 0
-let DATAPOINT_COUNT = 0
-
-/**
- * Handles data received from the Entralpi device.
- * @param {string} receivedData - The received data string.
- */
-export const handleEntralpiData = (receivedData: string): void => {
-  let numericData = Number(receivedData)
-
-  // Tare correction
-  numericData -= applyTare(numericData)
-
-  // Update MASS_MAX
-  MASS_MAX = Math.max(Number(MASS_MAX), numericData).toFixed(1)
-
-  // Update running sum and count
-  const currentMassTotal = Math.max(-1000, numericData)
-  MASS_TOTAL_SUM += currentMassTotal
-  DATAPOINT_COUNT++
-
-  // Calculate the average dynamically
-  MASS_AVERAGE = (MASS_TOTAL_SUM / DATAPOINT_COUNT).toFixed(1)
-
-  // Check if device is being used
-  checkActivity(numericData)
-
-  // Notify with weight data
-  notifyCallback({
-    massMax: MASS_MAX,
-    massAverage: MASS_AVERAGE,
-    massTotal: Math.max(-1000, numericData).toFixed(1),
-  })
-}

package/src/data/index.ts

@@ -1,7 +0,0 @@
-export { handleEntralpiData } from "./entralpi"
-
-export { handleMotherboardData } from "./motherboard"
-
-export { handleProgressorData } from "./progressor"
-
-export { handleWHC06Data } from "./wh-c06"

package/src/data/motherboard.ts

@@ -1,163 +0,0 @@
-import { notifyCallback } from "./../notify"
-import { writeCallback } from "./../write"
-import { applyTare } from "./../tare"
-import { MotherboardCommands } from "./../commands"
-import { checkActivity } from "./../is-active"
-import { lastWrite } from "./../write"
-import { DownloadPackets } from "./../download"
-import type { DownloadPacket } from "./../types/download"
-
-// Constants
-const PACKET_LENGTH = 32
-const NUM_SAMPLES = 3
-let MASS_MAX = "0"
-let MASS_AVERAGE = "0"
-let MASS_TOTAL_SUM = 0
-let DATAPOINT_COUNT = 0
-export const CALIBRATION = [[], [], [], []]
-
-/**
- * Applies calibration to a sample value.
- * @param {number} sample - The sample value to calibrate.
- * @param {number[][]} calibration - The calibration data.
- * @returns {number} The calibrated sample value.
- */
-const applyCalibration = (sample: number, calibration: number[][]): number => {
-  // Extract the calibrated value for the zero point
-  const zeroCalibration: number = calibration[0][2]
-  // Initialize sign as positive
-  let sign = 1
-  // Initialize the final calibrated value
-  let final = 0
-
-  // If the sample value is less than the zero calibration point
-  if (sample < zeroCalibration) {
-    // Change the sign to negative
-    sign = -1
-    // Reflect the sample around the zero calibration point
-    sample = /* 2 * zeroCalibration */ -sample
-  }
-
-  // Iterate through the calibration data
-  for (let i = 1; i < calibration.length; i++) {
-    // Extract the lower and upper bounds of the current calibration range
-    const calibrationStart: number = calibration[i - 1][2]
-    const calibrationEnd: number = calibration[i][2]
-
-    // If the sample value is within the current calibration range
-    if (sample < calibrationEnd) {
-      // Interpolate to get the calibrated value within the range
-      final =
-        calibration[i - 1][1] +
-        ((sample - calibrationStart) / (calibrationEnd - calibrationStart)) *
-          (calibration[i][1] - calibration[i - 1][1])
-      break
-    }
-  }
-  // Return the calibrated value with the appropriate sign (positive/negative)
-  return sign * final
-}
-/**
- * Handles data received from the Motherboard device. Processes hex-encoded streaming packets
- * to extract samples, calibrate masses, and update running averages of mass data.
- * If the received data is not a valid hex packet, it returns the unprocessed data.
- *
- * @param {string} receivedData - The raw data received from the Motherboard device.
- * @returns {void}
- */
-export const handleMotherboardData = (receivedData: string): void => {
-  const receivedTime: number = Date.now()
-
-  // Check if the line is entirely hex characters
-  const isAllHex: boolean = /^[0-9A-Fa-f]+$/g.test(receivedData)
-
-  // Handle streaming packet
-  if (isAllHex && receivedData.length === PACKET_LENGTH) {
-    // Base-16 decode the string: convert hex pairs to byte values
-    const bytes: number[] = Array.from({ length: receivedData.length / 2 }, (_, i) =>
-      Number(`0x${receivedData.substring(i * 2, i * 2 + 2)}`),
-    )
-
-    // Translate header into packet, number of samples from the packet length
-    const packet: DownloadPacket = {
-      received: receivedTime,
-      sampleNum: new DataView(new Uint8Array(bytes).buffer).getUint16(0, true),
-      battRaw: new DataView(new Uint8Array(bytes).buffer).getUint16(2, true),
-      samples: [],
-      masses: [],
-    }
-
-    const dataView = new DataView(new Uint8Array(bytes).buffer)
-
-    for (let i = 0; i < NUM_SAMPLES; i++) {
-      const sampleStart: number = 4 + 3 * i
-      // Use DataView to read the 24-bit unsigned integer
-      const rawValue =
-        dataView.getUint8(sampleStart) |
-        (dataView.getUint8(sampleStart + 1) << 8) |
-        (dataView.getUint8(sampleStart + 2) << 16)
-
-      // Ensure unsigned 32-bit integer
-      packet.samples[i] = rawValue >>> 0
-
-      if (packet.samples[i] >= 0x7fffff) {
-        packet.samples[i] -= 0x1000000
-      }
-      packet.masses[i] = applyCalibration(packet.samples[i], CALIBRATION[i])
-    }
-    // invert center and right values
-    packet.masses[1] *= -1
-    packet.masses[2] *= -1
-
-    // Add data to downloadable Array
-    DownloadPackets.push({
-      received: packet.received,
-      sampleNum: packet.battRaw,
-      battRaw: packet.received,
-      samples: [...packet.samples],
-      masses: [...packet.masses],
-    })
-
-    let left: number = packet.masses[0]
-    let center: number = packet.masses[1]
-    let right: number = packet.masses[2]
-
-    // Tare correction
-    left -= applyTare(left)
-    center -= applyTare(center)
-    right -= applyTare(right)
-
-    MASS_MAX = Math.max(Number(MASS_MAX), Math.max(-1000, left + center + right)).toFixed(1)
-
-    // Update running sum and count
-    const currentMassTotal = Math.max(-1000, left + center + right)
-    MASS_TOTAL_SUM += currentMassTotal
-    DATAPOINT_COUNT++
-
-    // Calculate the average dynamically
-    MASS_AVERAGE = (MASS_TOTAL_SUM / DATAPOINT_COUNT).toFixed(1)
-
-    // Check if device is being used
-    checkActivity(center)
-
-    // Notify with weight data
-    notifyCallback({
-      massTotal: Math.max(-1000, left + center + right).toFixed(1),
-      massMax: MASS_MAX,
-      massAverage: MASS_AVERAGE,
-      massLeft: Math.max(-1000, packet.masses[0]).toFixed(1),
-      massCenter: Math.max(-1000, packet.masses[1]).toFixed(1),
-      massRight: Math.max(-1000, packet.masses[2]).toFixed(1),
-    })
-  } else if (lastWrite === MotherboardCommands.GET_CALIBRATION) {
-    // check data integrity
-    if ((receivedData.match(/,/g) || []).length === 3) {
-      const parts: string[] = receivedData.split(",")
-      const numericParts: number[] = parts.map((x) => parseFloat(x))
-      ;(CALIBRATION[numericParts[0]] as number[][]).push(numericParts.slice(1))
-    }
-  } else {
-    // unhandled data
-    writeCallback(receivedData)
-  }
-}

package/src/data/progressor.ts

@@ -1,79 +0,0 @@
-import { notifyCallback } from "./../notify"
-import { applyTare } from "./../tare"
-import { checkActivity } from "./../is-active"
-import { ProgressorCommands, ProgressorResponses } from "./../commands/progressor"
-import { lastWrite, writeCallback } from "./../write"
-import struct from "./../struct"
-import { DownloadPackets } from "./../download"
-
-// Constants
-let MASS_MAX = "0"
-let MASS_AVERAGE = "0"
-let MASS_TOTAL_SUM = 0
-let DATAPOINT_COUNT = 0
-
-/**
- * Handles data received from the Progressor device, processes weight measurements,
- * and updates mass data including maximum and average values.
- * It also handles command responses for retrieving device information.
- *
- * @param {DataView} data - The raw binary data received from the Progressor device.
- * @returns {void}
- */
-export const handleProgressorData = (data: DataView): void => {
-  const receivedTime: number = Date.now()
-  const [kind] = struct("<bb").unpack(data.buffer.slice(0, 2))
-  if (kind === ProgressorResponses.WEIGHT_MEASURE) {
-    const iterable: IterableIterator<unknown[]> = struct("<fi").iter_unpack(data.buffer.slice(2))
-    // eslint-disable-next-line prefer-const
-    for (let [weight, seconds] of iterable) {
-      if (typeof weight === "number" && !isNaN(weight) && typeof seconds === "number" && !isNaN(seconds)) {
-        // Add data to downloadable Array: sample and mass are the same
-        DownloadPackets.push({
-          received: receivedTime,
-          sampleNum: seconds,
-          battRaw: 0,
-          samples: [weight],
-          masses: [weight],
-        })
-        // Tare correction
-        weight -= applyTare(weight)
-        // Check for max weight
-        MASS_MAX = Math.max(Number(MASS_MAX), Number(weight)).toFixed(1)
-        // Update running sum and count
-        const currentMassTotal = Math.max(-1000, Number(weight))
-        MASS_TOTAL_SUM += currentMassTotal
-        DATAPOINT_COUNT++
-
-        // Calculate the average dynamically
-        MASS_AVERAGE = (MASS_TOTAL_SUM / DATAPOINT_COUNT).toFixed(1)
-
-        // Check if device is being used
-        checkActivity(weight)
-
-        notifyCallback({
-          massMax: MASS_MAX,
-          massAverage: MASS_AVERAGE,
-          massTotal: Math.max(-1000, weight).toFixed(1),
-        })
-      }
-    }
-  } else if (kind === ProgressorResponses.COMMAND_RESPONSE) {
-    if (!lastWrite) return
-
-    let value = ""
-
-    if (lastWrite === ProgressorCommands.GET_BATT_VLTG) {
-      value = new DataView(data.buffer, 2).getUint32(0, true).toString()
-    } else if (lastWrite === ProgressorCommands.GET_FW_VERSION) {
-      value = new TextDecoder().decode(data.buffer.slice(2))
-    } else if (lastWrite === ProgressorCommands.GET_ERR_INFO) {
-      value = new TextDecoder().decode(data.buffer.slice(2))
-    }
-    writeCallback(value)
-  } else if (kind === ProgressorResponses.LOW_BATTERY_WARNING) {
-    console.warn("⚠️ Low power detected. Please consider connecting to a power source.")
-  } else {
-    throw new Error(`Unknown message kind detected: ${kind}`)
-  }
-}

package/src/data/wh-c06.ts

@@ -1,47 +0,0 @@
-import { checkActivity } from "./../is-active"
-import { notifyCallback } from "./../notify"
-import { applyTare } from "./../tare"
-
-// Constants
-let MASS_MAX = "0"
-let MASS_AVERAGE = "0"
-let MASS_TOTAL_SUM = 0
-let DATAPOINT_COUNT = 0
-const WEIGHT_OFFSET = 10
-// const STABLE_OFFSET = 14
-
-/**
- * Handles data received from the WH-C06 device.
- * @param {DataView} data - The received data.
- */
-export const handleWHC06Data = (data: DataView): void => {
-  const weight = (data.getUint8(WEIGHT_OFFSET) << 8) | data.getUint8(WEIGHT_OFFSET + 1)
-  // const stable = (data.getUint8(STABLE_OFFSET) & 0xf0) >> 4
-  // const unit = data.getUint8(STABLE_OFFSET) & 0x0f
-
-  let numericData = weight / 100
-
-  // Tare correction
-  numericData -= applyTare(numericData)
-
-  // Update MASS_MAX
-  MASS_MAX = Math.max(Number(MASS_MAX), numericData).toFixed(1)
-
-  // Update running sum and count
-  const currentMassTotal = Math.max(-1000, numericData)
-  MASS_TOTAL_SUM += currentMassTotal
-  DATAPOINT_COUNT++
-
-  // Calculate the average dynamically
-  MASS_AVERAGE = (MASS_TOTAL_SUM / DATAPOINT_COUNT).toFixed(1)
-
-  // Check if device is being used
-  checkActivity(numericData)
-
-  // Notify with weight data
-  notifyCallback({
-    massMax: MASS_MAX,
-    massAverage: MASS_AVERAGE,
-    massTotal: Math.max(-1000, numericData).toFixed(1),
-  })
-}

package/src/devices/climbro.ts

@@ -1,10 +0,0 @@
-import type { Device } from "../types/devices"
-
-/**
- * Represents a Climbro device
- * TODO: Add services, do you own a Climbro? Help us!
- */
-export const Climbro: Device = {
-  filters: [{ name: "Climbro" }],
-  services: [],
-}

package/src/devices/entralpi.ts

@@ -1,61 +0,0 @@
-import type { Device } from "../types/devices"
-
-/**
- * Represents a Entralpi device
- */
-export const Entralpi: Device = {
-  filters: [
-    {
-      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

@@ -1,13 +0,0 @@
-export { Climbro } from "./climbro"
-
-export { Entralpi } from "./entralpi"
-
-export { KilterBoard } from "./kilterboard"
-
-export { Motherboard } from "./motherboard"
-
-export { mySmartBoard } from "./mysmartboard"
-
-export { WHC06 } from "./wh-c06"
-
-export { Progressor } from "./progressor"

package/src/devices/kilterboard.ts

@@ -1,37 +0,0 @@
-import type { Device } from "../types/devices"
-
-/**
- * Aurora Climbing Advertising service
- */
-export const AuroraUUID = "4488b571-7806-4df6-bcff-a2897e4953ff"
-
-/**
- * Represents a Aurora Climbing device
- * Kilter Board, Tension Board, Decoy Board, Touchstone Board, Grasshopper Board, Aurora Board, So iLL Board
- */
-export const KilterBoard: Device = {
-  filters: [
-    {
-      services: [AuroraUUID],
-    },
-  ],
-  services: [
-    {
-      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",
-        // },
-      ],
-    },
-  ],
-}