@hangtime/grip-connect 0.4.1 → 0.5.0

package/src/devices/motherboard.ts

@@ -1,83 +0,0 @@
-import type { Device } from "../types/devices"
-
-/**
- * Represents a Griptonite Motherboard device
- */
-export const Motherboard: Device = {
-  filters: [{ name: "Motherboard" }],
-  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: "LED Service",
-      id: "led",
-      uuid: "10ababcd-15e1-28ff-de13-725bea03b127",
-      characteristics: [
-        {
-          name: "Red LED",
-          id: "red",
-          uuid: "10ab1524-15e1-28ff-de13-725bea03b127",
-        },
-        {
-          name: "Green LED",
-          id: "green",
-          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/mysmartboard.ts

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

package/src/devices/progressor.ts

@@ -1,38 +0,0 @@
-import type { Device } from "../types/devices"
-/**
- * Represents a Tindeq Progressor device
- */
-export const Progressor: Device = {
-  filters: [{ namePrefix: "Progressor" }],
-  services: [
-    {
-      name: "Progressor Service",
-      id: "progressor",
-      uuid: "7e4e1701-1ea6-40c9-9dcc-13d34ffead57",
-      characteristics: [
-        {
-          name: "Notify",
-          id: "rx",
-          uuid: "7e4e1702-1ea6-40c9-9dcc-13d34ffead57",
-        },
-        {
-          name: "Write",
-          id: "tx",
-          uuid: "7e4e1703-1ea6-40c9-9dcc-13d34ffead57",
-        },
-      ],
-    },
-    {
-      name: "Nordic Device Firmware Update (DFU) Service",
-      id: "dfu",
-      uuid: "0000fe59-0000-1000-8000-00805f9b34fb",
-      characteristics: [
-        {
-          name: "Buttonless DFU",
-          id: "dfu",
-          uuid: "8ec90003-f315-4f60-9fb8-838830daea50",
-        },
-      ],
-    },
-  ],
-}

package/src/devices/wh-c06.ts

@@ -1,19 +0,0 @@
-import type { Device } from "../types/devices"
-
-/**
- * Represents a  Weiheng - WH-C06 (or MAT Muscle Meter) device
- * Enable 'Experimental Web Platform features' Chrome Flags.
- */
-export const WHC06: Device = {
-  filters: [
-    {
-      // namePrefix: "IF_B7",
-      manufacturerData: [
-        {
-          companyIdentifier: 0x0100, // 256
-        },
-      ],
-    },
-  ],
-  services: [],
-}

package/src/disconnect.ts

@@ -1,14 +0,0 @@
-import type { Device } from "./types/devices"
-import { isConnected } from "./is-connected"
-
-/**
- * Disconnects the device if it is connected.
- * @param {Device} board - The device to disconnect.
- */
-export const disconnect = (board: Device): void => {
-  // Check if the device is connected
-  if (isConnected(board)) {
-    // Disconnect the device using optional chaining
-    board.device?.gatt?.disconnect()
-  }
-}

package/src/firmware.ts

@@ -1,39 +0,0 @@
-import type { Device } from "./types/devices"
-import { write } from "./write"
-import { read } from "./read"
-import { isConnected } from "./is-connected"
-import { ProgressorCommands } from "./commands"
-import { isMotherboard, isProgressor } from "./is-device"
-
-/**
- * Retrieves firmware version from the device.
- * - For Motherboard devices, it reads the firmare version.
- * - For Progressor devices, it sends a command to retrieve firware version.
- *
- * @param {Device} board - The device from which to retrieve firmware version.
- * @returns {Promise<string>} A Promise that resolves with the firmware version,
- *                            or rejects with an error if the device is not connected.
- * @throws {Error} Throws an error if the device is not connected.
- */
-export const firmware = async (board: Device): Promise<string | undefined> => {
-  // Check if the device is connected
-  if (isConnected(board)) {
-    // If the device is connected and it is a Motherboard device
-    if (isMotherboard(board)) {
-      // Read firmware version from the Motherboard
-      return await read(board, "device", "firmware", 250)
-    }
-    // If the device is connected and its name starts with "Progressor"
-    if (isProgressor(board)) {
-      // Write command to get firmware version information to the Progressor
-      let response: string | undefined = undefined
-      await write(board, "progressor", "tx", ProgressorCommands.GET_FW_VERSION, 250, (data) => {
-        response = data
-      })
-      return response
-    }
-    // If device is not found, return undefined
-    return
-  }
-  throw new Error("Not connected.")
-}

package/src/hardware.ts

@@ -1,27 +0,0 @@
-import type { Device } from "./types/devices"
-import { read } from "./read"
-import { isConnected } from "./is-connected"
-import { isMotherboard } from "./is-device"
-
-/**
- * Retrieves hardware version from the device.
- * - For Motherboard devices, it reads the hardware version.
- *
- * @param {Device} board - The device from which to retrieve hardware version.
- * @returns {Promise<string>} A Promise that resolves with the hardware version,
- *                            or rejects with an error if the device is not connected.
- * @throws {Error} Throws an error if the device is not connected.
- */
-export const hardware = async (board: Device): Promise<string | undefined> => {
-  // Check if the device is connected
-  if (isConnected(board)) {
-    // If the device is connected and it is a Motherboard device
-    if (isMotherboard(board)) {
-      // Read hardware version from the Motherboard
-      return await read(board, "device", "hardware", 250)
-    }
-    // If device is not found, return undefined
-    return
-  }
-  throw new Error("Not connected.")
-}

package/src/is-connected.ts

@@ -1,15 +0,0 @@
-import type { Device } from "./types/devices"
-
-/**
- * Checks if a Bluetooth device is connected.
- * @param {Device} board - The device to check for connection.
- * @returns {boolean} A boolean indicating whether the device is connected.
- */
-export const isConnected = (board?: Device): boolean => {
-  // Check if the device is defined and available
-  if (!board?.device) {
-    return false
-  }
-  // Check if the device is connected
-  return !!board.device.gatt?.connected
-}

package/src/led.ts

@@ -1,211 +0,0 @@
-import type { Device } from "./types/devices"
-import { write } from "./write"
-import { isConnected } from "./is-connected"
-import { KilterBoardPacket, KilterBoardPlacementRoles } from "./commands/kilterboard"
-import { isKilterboard, isMotherboard } from "./is-device"
-
-/**
- * Maximum length of the message body for byte wrapping.
- */
-const MESSAGE_BODY_MAX_LENGTH = 255
-/**
- * Maximum length of the the bluetooth chunk.
- */
-const MAX_BLUETOOTH_MESSAGE_SIZE = 20
-/**
- * Calculates the checksum for a byte array by summing up all bytes ot hre packet in a single-byte variable.
- * @param data - The array of bytes to calculate the checksum for.
- * @returns The calculated checksum value.
- */
-function checksum(data: number[]) {
-  let i = 0
-  for (const value of data) {
-    i = (i + value) & 255
-  }
-  return ~i & 255
-}
-/**
- * Wraps a byte array with header and footer bytes for transmission.
- * @param data - The array of bytes to wrap.
- * @returns The wrapped byte array.
- */
-function wrapBytes(data: number[]) {
-  if (data.length > MESSAGE_BODY_MAX_LENGTH) {
-    return []
-  }
-  /**
-  - 0x1
-  - len(packets)
-  - checksum(packets)
-  - 0x2
-  - *packets
-  - 0x3
-  
-  First byte is always 1, the second is a number of packets, then checksum, then 2, packets themselves, and finally 3.
-   */
-  return [1, data.length, checksum(data), 2, ...data, 3]
-}
-class ClimbPlacement {
-  position: number
-  role_id: number
-
-  constructor(position: number, role_id: number) {
-    this.position = position
-    this.role_id = role_id
-  }
-}
-/**
- * Encodes a position into a byte array.
- * The lowest 8 bits of the position get put in the first byte of the group.
- * The highest 8 bits of the position get put in the second byte of the group.
- * @param position - The position to encode.
- * @returns The encoded byte array representing the position.
- */
-function encodePosition(position: number) {
-  const position1 = position & 255
-  const position2 = (position & 65280) >> 8
-
-  return [position1, position2]
-}
-/**
- * Encodes a color string into a numeric representation.
- * The rgb color, 3 bits for the R and G components, 2 bits for the B component, with the 3 R bits occupying the high end of the byte and the 2 B bits in the low end (hence 3 G bits in the middle).
- * @param color - The color string in hexadecimal format (e.g., 'FFFFFF').
- * @returns The encoded /compressed color value.
- */
-function encodeColor(color: string) {
-  const substring = color.substring(0, 2)
-  const substring2 = color.substring(2, 4)
-
-  const parsedSubstring = parseInt(substring, 16) / 32
-  const parsedSubstring2 = parseInt(substring2, 16) / 32
-  const parsedResult = (parsedSubstring << 5) | (parsedSubstring2 << 2)
-
-  const substring3 = color.substring(4, 6)
-  const parsedSubstring3 = parseInt(substring3, 16) / 64
-  const finalParsedResult = parsedResult | parsedSubstring3
-
-  return finalParsedResult
-}
-/**
- * Encodes a placement (requires a 16-bit position and a 24-bit rgb color. ) into a byte array.
- * @param position - The position to encode.
- * @param ledColor - The color of the LED in hexadecimal format (e.g., 'FFFFFF').
- * @returns The encoded byte array representing the placement.
- */
-function encodePlacement(position: number, ledColor: string) {
-  return [...encodePosition(position), encodeColor(ledColor)]
-}
-/**
- * Prepares byte arrays for transmission based on a list of climb placements.
- * @param climbPlacementList - The list of climb placements containing position and role ID.
- * @returns The final byte array ready for transmission.
- */
-export function prepBytesV3(climbPlacementList: ClimbPlacement[]) {
-  const resultArray: number[][] = []
-  let tempArray: number[] = [KilterBoardPacket.V3_MIDDLE]
-
-  for (const climbPlacement of climbPlacementList) {
-    if (tempArray.length + 3 > MESSAGE_BODY_MAX_LENGTH) {
-      resultArray.push(tempArray)
-      tempArray = [KilterBoardPacket.V3_MIDDLE]
-    }
-    const role = KilterBoardPlacementRoles.find((placement) => placement.id === climbPlacement.role_id)
-    if (!role) {
-      throw new Error(`Role with id ${climbPlacement.role_id} not found in placement_roles`)
-    }
-    const encodedPlacement = encodePlacement(climbPlacement.position, role.led_color)
-    tempArray.push(...encodedPlacement)
-  }
-
-  resultArray.push(tempArray)
-
-  if (resultArray.length === 1) {
-    resultArray[0][0] = KilterBoardPacket.V3_ONLY
-  } else if (resultArray.length > 1) {
-    resultArray[0][0] = KilterBoardPacket.V3_FIRST
-    resultArray[resultArray.length - 1][0] = KilterBoardPacket.V3_LAST
-  }
-
-  const finalResultArray: number[] = []
-  for (const currentArray of resultArray) {
-    finalResultArray.push(...wrapBytes(currentArray))
-  }
-
-  return finalResultArray
-}
-/**
- * Splits a collection into slices of the specified length.
- * https://github.com/ramda/ramda/blob/master/source/splitEvery.js
- * @param {Number} n
- * @param {Array} list
- * @return {Array}
- */
-function splitEvery(n: number, list: number[]) {
-  if (n <= 0) {
-    throw new Error("First argument to splitEvery must be a positive integer")
-  }
-  const result = []
-  let idx = 0
-  while (idx < list.length) {
-    result.push(list.slice(idx, (idx += n)))
-  }
-  return result
-}
-/**
- * The kilter board only supports messages of 20 bytes
- * at a time. This method splits a full message into parts
- * of 20 bytes
- *
- * @param buffer
- */
-const splitMessages = (buffer: number[]) =>
-  splitEvery(MAX_BLUETOOTH_MESSAGE_SIZE, buffer).map((arr) => new Uint8Array(arr))
-/**
- * Sends a series of messages to a device.
- */
-async function writeMessageSeries(board: Device, messages: Uint8Array[]) {
-  for (const message of messages) {
-    await write(board, "uart", "tx", message)
-  }
-}
-/**
- * Sets the LEDs on the specified device.
- *
- * - For Kilter Board: Configures the LEDs based on an array of climb placements. If a configuration is provided, it prepares and sends a payload to the device.
- * - For Motherboard: Sets the LED color based on a single color option. Defaults to turning the LEDs off if no configuration is provided.
- *
- * @param {Device} board - The device on which to set the LEDs.
- * @param {"green" | "red" | "orange" | ClimbPlacement[]} [config] - Optional color or array of climb placements for the LEDs. Ignored if placements are provided.
- * @returns {Promise<number[] | undefined>} A promise that resolves with the payload array for the Kilter Board if LED settings were applied, or `undefined` if no action was taken or for the Motherboard.
- */
-export const led = async (
-  board: Device,
-  config?: "green" | "red" | "orange" | ClimbPlacement[],
-): Promise<number[] | undefined> => {
-  // Handle Kilterboard logic: process placements and send payload if connected
-  if (isKilterboard(board) && Array.isArray(config)) {
-    // Prepares byte arrays for transmission based on a list of climb placements.
-    const payload = prepBytesV3(config)
-    if (isConnected(board)) {
-      await writeMessageSeries(board, splitMessages(payload))
-    }
-    return payload
-  }
-  // Handle Motherboard logic: set color if provided
-  if (isMotherboard(board)) {
-    const colorMapping: Record<string, number[][]> = {
-      green: [[0x00], [0x01]],
-      red: [[0x01], [0x00]],
-      orange: [[0x01], [0x01]],
-      off: [[0x00], [0x00]],
-    }
-    // Default to "off" color if config is not set or not found in colorMapping
-    const color = typeof config === "string" && colorMapping[config] ? config : "off"
-    const [redValue, greenValue] = colorMapping[color]
-    await write(board, "led", "red", new Uint8Array(redValue))
-    await write(board, "led", "green", new Uint8Array(greenValue), 1250)
-    return
-  }
-  return
-}

package/src/manufacturer.ts

@@ -1,27 +0,0 @@
-import type { Device } from "./types/devices"
-import { read } from "./read"
-import { isConnected } from "./is-connected"
-import { isMotherboard } from "./is-device"
-
-/**
- * Retrieves manufacturer information from the device.
- * - For Motherboard devices, it reads the manufacturer information.
- *
- * @param {Device} board - The device from which to retrieve manufacturer information.
- * @returns {Promise<string>} A Promise that resolves with the manufacturer information,
- *                            or rejects with an error if the device is not connected.
- * @throws {Error} Throws an error if the device is not connected.
- */
-export const manufacturer = async (board: Device): Promise<string | undefined> => {
-  // Check if the device is connected
-  if (isConnected(board)) {
-    // If the device is connected and it is a Motherboard device
-    if (isMotherboard(board)) {
-      // Read manufacturer information from the Motherboard
-      return await read(board, "device", "manufacturer", 250)
-    }
-    // If device is not found, return undefined
-    return
-  }
-  throw new Error("Not connected.")
-}

package/src/serial.ts

@@ -1,32 +0,0 @@
-import type { Device } from "./types/devices"
-import { write } from "./write"
-import { isConnected } from "./is-connected"
-import { MotherboardCommands } from "./commands"
-import { isMotherboard } from "./is-device"
-
-/**
- * Retrieves serial number from the device.
- * - For Motherboard devices, it reads the serial number.
- *
- * @param {Device} board - The device from which to retrieve serial number.
- * @returns {Promise<string>} A Promise that resolves with the serial number,
- *                            or rejects with an error if the device is not connected.
- * @throws {Error} Throws an error if the device is not connected.
- */
-export const serial = async (board: Device): Promise<string | undefined> => {
-  // Check if the device is connected
-  if (isConnected(board)) {
-    // If the device is connected and it is a Motherboard device
-    if (isMotherboard(board)) {
-      // Write serial number command to the Motherboard and read output
-      let response: string | undefined = undefined
-      await write(board, "uart", "tx", MotherboardCommands.GET_SERIAL, 250, (data) => {
-        response = data
-      })
-      return response
-    }
-    // If device is not found, return undefined
-    return
-  }
-  throw new Error("Not connected.")
-}

package/src/stream.ts

@@ -1,43 +0,0 @@
-import type { Device } from "./types/devices"
-import { isConnected } from "./is-connected"
-import { write } from "./write"
-import { stop } from "./stop"
-import { isMotherboard, isProgressor } from "./is-device"
-import { MotherboardCommands, ProgressorCommands } from "./commands"
-import { emptyDownloadPackets } from "./download"
-import { CALIBRATION } from "./data/motherboard"
-import { calibration } from "./calibration"
-
-/**
- * Starts streaming data from the specified device.
- * @param {Device} board - The device to stream data from.
- * @param {number} [duration=0] - The duration of the stream in milliseconds. If set to 0, stream will continue indefinitely.
- * @returns {Promise<void>} A promise that resolves when the streaming operation is completed.
- */
-export const stream = async (board: Device, duration = 0): Promise<void> => {
-  if (isConnected(board)) {
-    // Reset download packets
-    emptyDownloadPackets()
-    // Device specific logic
-    if (isMotherboard(board)) {
-      // Read calibration data if not already available
-      if (!CALIBRATION[0].length) {
-        await calibration(board)
-      }
-      // Start streaming data
-      await write(board, "uart", "tx", MotherboardCommands.START_WEIGHT_MEAS, duration)
-      // Stop streaming if duration is set
-      if (duration !== 0) {
-        await stop(board)
-      }
-    }
-    if (isProgressor(board)) {
-      // Start streaming data
-      await write(board, "progressor", "tx", ProgressorCommands.START_WEIGHT_MEAS, duration)
-      // Stop streaming if duration is set
-      if (duration !== 0) {
-        await stop(board)
-      }
-    }
-  }
-}

package/src/text.ts

@@ -1,35 +0,0 @@
-import type { Device } from "./types/devices"
-import { write } from "./write"
-import { isConnected } from "./is-connected"
-import { isMotherboard } from "./is-device"
-import { MotherboardCommands } from "./commands"
-
-/**
- * Retrieves the entire 320 bytes of non-volatile memory from the device.
- *
- * The memory consists of 10 segments, each 32 bytes long. If any segment was previously written,
- * the corresponding data will appear in the response. Unused portions of the memory are
- * padded with whitespace.
- *
- * @param {Device} board - The device from which to retrieve text information.
- * @returns {Promise<string>} A Promise that resolves with the 320-byte memory content as a string,
- *                            which includes both the written data and any unused, whitespace-padded segments.
- * @throws {Error} Throws an error if the device is not connected.
- */
-export const text = async (board: Device): Promise<string | undefined> => {
-  // Check if the device is connected
-  if (isConnected(board)) {
-    // If the device is connected and it is a Motherboard device
-    if (isMotherboard(board)) {
-      // Write text information command to the Motherboard and read output
-      let response: string | undefined = undefined
-      await write(board, "uart", "tx", MotherboardCommands.GET_TEXT, 250, (data) => {
-        response = data
-      })
-      return response
-    }
-    // If device is not found, return undefined
-    return
-  }
-  throw new Error("Not connected.")
-}

package/src/types/devices.ts

@@ -1,39 +0,0 @@
-/**
- * Represents a characteristic of a Bluetooth service.
- */
-interface Characteristic {
-  /** Name of the characteristic */
-  name: string
-  /** Identifier of the characteristic */
-  id: string
-  /** UUID of the characteristic */
-  uuid: string
-  /** Reference to the characteristic object */
-  characteristic?: BluetoothRemoteGATTCharacteristic
-}
-
-/**
- * Represents a Bluetooth service.
- */
-interface Service {
-  /**  Name of the service */
-  name: string
-  /** Identifier of the service */
-  id: string
-  /** UUID of the service */
-  uuid: string
-  /** Array of characteristics belonging to this service */
-  characteristics: Characteristic[]
-}
-
-/**
- * Represents a Bluetooth device.
- */
-export interface Device {
-  /** Filters to indentify the device */
-  filters: BluetoothLEScanFilter[]
-  /** Array of services provided by the device */
-  services: Service[]
-  /** Reference to the BluetoothDevice object representing this device */
-  device?: BluetoothDevice
-}