@hangtime/grip-connect 0.8.7 → 0.10.0

package/src/models/device/kilterboard.model.ts

@@ -185,22 +185,23 @@ export class KilterBoard extends Device implements IKilterBoard {
   /**
    * 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).
+   * Format: 0bRRRGGGBB where RRR is 3 bits for red, GGG is 3 bits for green, BB is 2 bits for blue.
    * @param color - The color string in hexadecimal format (e.g., 'FFFFFF').
    * @returns The encoded /compressed color value.
    */
   private encodeColor(color: string): number {
-    const substring = color.substring(0, 2)
-    const substring2 = color.substring(2, 4)
+    const r = parseInt(color.substring(0, 2), 16)
+    const g = parseInt(color.substring(2, 4), 16)
+    const b = parseInt(color.substring(4, 6), 16)
 
-    const parsedSubstring = parseInt(substring, 16) / 32
-    const parsedSubstring2 = parseInt(substring2, 16) / 32
-    const parsedResult = (parsedSubstring << 5) | (parsedSubstring2 << 2)
+    // Integer division: R and G divided by 32, B divided by 64
+    // Then pack into 0bRRRGGGBB format
+    const rBits = Math.floor(r / 32) // 0-7 (3 bits)
+    const gBits = Math.floor(g / 32) // 0-7 (3 bits)
+    const bBits = Math.floor(b / 64) // 0-3 (2 bits)
 
-    const substring3 = color.substring(4, 6)
-    const parsedSubstring3 = parseInt(substring3, 16) / 64
-    const finalParsedResult = parsedResult | parsedSubstring3
-
-    return finalParsedResult
+    // Pack: RRR in bits 7-5, GGG in bits 4-2, BB in bits 1-0
+    return (rBits << 5) | (gBits << 2) | bBits
   }
 
   /**
@@ -215,23 +216,59 @@ export class KilterBoard extends Device implements IKilterBoard {
 
   /**
    * Prepares byte arrays for transmission based on a list of climb placements.
-   * @param {{ position: number; role_id: number }[]} climbPlacementList - The list of climb placements containing position and role ID.
+   * @param {{ position: number; role_id?: number; color?: string }[]} climbPlacementList - The list of climb placements containing position and either role ID or color.
    * @returns {number[]} The final byte array ready for transmission.
    */
-  private prepBytesV3(climbPlacementList: { position: number; role_id: number }[]): number[] {
+  private prepBytesV3(climbPlacementList: { position: number; role_id?: number; color?: string }[]): number[] {
     const resultArray: number[][] = []
     let tempArray: number[] = [KilterBoardPacket.V3_MIDDLE]
 
-    for (const climbPlacement of climbPlacementList) {
+    // Filter out any invalid placements and clean up objects before processing
+    const validPlacements = climbPlacementList
+      .filter((p) => {
+        // Explicitly check for color
+        const hasColor = p.color != null && typeof p.color === "string" && p.color.trim() !== ""
+        // Explicitly check for role_id - must be a number, not undefined or null
+        const hasRoleId = typeof p.role_id === "number" && !isNaN(p.role_id)
+
+        return hasColor || hasRoleId
+      })
+      .map((p) => {
+        // Create clean objects without undefined properties
+        if (p.color != null && typeof p.color === "string" && p.color.trim() !== "") {
+          return { position: p.position, color: p.color.trim() } as { position: number; color: string }
+        } else if (typeof p.role_id === "number" && !isNaN(p.role_id)) {
+          return { position: p.position, role_id: p.role_id } as { position: number; role_id: number }
+        }
+        // This should never happen due to the filter above, but TypeScript needs this
+        throw new Error("Invalid placement after filter")
+      })
+
+    for (const climbPlacement of validPlacements) {
       if (tempArray.length + 3 > KilterBoard.messageBodyMaxLength) {
         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`)
+
+      let colorHex: string
+
+      // Type guard: check if this placement has a color property
+      if ("color" in climbPlacement && climbPlacement.color) {
+        // Use direct color if provided
+        colorHex = climbPlacement.color.replace("#", "").toUpperCase()
+      } else if ("role_id" in climbPlacement && typeof climbPlacement.role_id === "number") {
+        // Fall back to role_id if no color provided
+        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`)
+        }
+        colorHex = role.led_color
+      } else {
+        // This should never happen due to the filter above, but just in case
+        throw new Error(`Either role_id or color must be provided for position ${climbPlacement.position}`)
       }
-      const encodedPlacement = this.encodePlacement(climbPlacement.position, role.led_color)
+
+      const encodedPlacement = this.encodePlacement(climbPlacement.position, colorHex)
       tempArray.push(...encodedPlacement)
     }
 
@@ -292,10 +329,10 @@ export class KilterBoard extends Device implements IKilterBoard {
 
   /**
    * Configures the LEDs based on an array of climb placements.
-   * @param {{ position: number; role_id: number }[]} config - Array of climb placements for the LEDs.
+   * @param {{ position: number; role_id?: number; color?: string }[]} config - Array of climb placements for the LEDs. Either role_id or color (hex string) must be 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.
    */
-  led = async (config: { position: number; role_id: number }[]): Promise<number[] | undefined> => {
+  led = async (config: { position: number; role_id?: number; color?: string }[]): Promise<number[] | undefined> => {
     // Handle Kilterboard logic: process placements and send payload if connected
     if (Array.isArray(config)) {
       // Prepares byte arrays for transmission based on a list of climb placements.

package/src/models/device/motherboard.model.ts

@@ -39,6 +39,14 @@ export class Motherboard extends Device implements IMotherboard {
    */
   private calibrationData: number[][][] = [[], [], [], []]
 
+  /** Per-zone peak and running sum for left/center/right (used for distribution stats). */
+  private leftPeak = Number.NEGATIVE_INFINITY
+  private leftSum = 0
+  private centerPeak = Number.NEGATIVE_INFINITY
+  private centerSum = 0
+  private rightPeak = Number.NEGATIVE_INFINITY
+  private rightSum = 0
+
   constructor() {
     super({
       filters: [{ name: "Motherboard" }],
@@ -281,28 +289,37 @@ export class Motherboard extends Device implements IMotherboard {
             center -= this.applyTare(center)
             right -= this.applyTare(right)
 
-            this.massMax = Math.max(Number(this.massMax), Math.max(-1000, left + center + right)).toFixed(1)
+            const totalCurrent = Math.max(-1000, left + center + right)
+            const leftClamped = Math.max(-1000, left)
+            const centerClamped = Math.max(-1000, center)
+            const rightClamped = Math.max(-1000, right)
+
+            this.peak = Math.max(this.peak, totalCurrent)
 
-            // Update running sum and count
-            const currentMassTotal = Math.max(-1000, left + center + right)
-            this.massTotalSum += currentMassTotal
+            // Update running sum and count (total)
+            this.sum += totalCurrent
             this.dataPointCount++
+            this.mean = this.sum / this.dataPointCount
 
-            // Calculate the average dynamically
-            this.massAverage = (this.massTotalSum / this.dataPointCount).toFixed(1)
+            // Per-zone peak and sum for distribution
+            this.leftPeak = Math.max(this.leftPeak, leftClamped)
+            this.leftSum += leftClamped
+            this.centerPeak = Math.max(this.centerPeak, centerClamped)
+            this.centerSum += centerClamped
+            this.rightPeak = Math.max(this.rightPeak, rightClamped)
+            this.rightSum += rightClamped
 
             // Check if device is being used
             this.activityCheck(center)
 
-            // Notify with weight data
-            this.notifyCallback({
-              massTotal: Math.max(-1000, left + center + right).toFixed(1),
-              massMax: this.massMax,
-              massAverage: this.massAverage,
-              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),
-            })
+            // Notify with weight data (distribution zones have proper peak/mean per zone)
+            this.notifyCallback(
+              this.buildForceMeasurement(totalCurrent, {
+                left: this.buildZoneMeasurement(leftClamped, this.leftPeak, this.leftSum / this.dataPointCount),
+                center: this.buildZoneMeasurement(centerClamped, this.centerPeak, this.centerSum / this.dataPointCount),
+                right: this.buildZoneMeasurement(rightClamped, this.rightPeak, this.rightSum / this.dataPointCount),
+              }),
+            )
           } else if (this.writeLast === this.commands.GET_CALIBRATION) {
             // check data integrity
             if ((receivedData.match(/,/g) || []).length === 3) {

package/src/models/device/pb-700bt.model.ts

@@ -0,0 +1,263 @@
+import { Device } from "../device.model.js"
+
+/**
+ * Represents a NSD PB-700BT device.
+ * {@link https://www.nsd.com.tw/}
+ */
+export class PB700BT extends Device {
+  constructor() {
+    super({
+      filters: [{ name: "NSD Workout" }],
+      services: [
+        {
+          name: "Battery Service",
+          id: "battery",
+          uuid: "0000180f-0000-1000-8000-00805f9b34fb",
+          characteristics: [
+            {
+              name: "Battery Level",
+              id: "level",
+              uuid: "00002a19-0000-1000-8000-00805f9b34fb", // 100
+            },
+          ],
+        },
+        {
+          name: "Custom Service", // Unknown custom service
+          id: "custom",
+          uuid: "0000feba-0000-1000-8000-00805f9b34fb",
+          characteristics: [
+            {
+              name: "Custom Characteristic 1", // Unknown characteristic
+              id: "custom1",
+              uuid: "0000fa10-0000-1000-8000-00805f9b34fb",
+            },
+            {
+              name: "Custom Characteristic 2", // Unknown characteristic
+              id: "custom2",
+              uuid: "0000fa11-0000-1000-8000-00805f9b34fb",
+            },
+            {
+              name: "Custom Characteristic 3", // Unknown characteristic
+              id: "custom3",
+              uuid: "0000fa13-0000-1000-8000-00805f9b34fb",
+            },
+          ],
+        },
+        {
+          name: "UART ISSC Transparent Service",
+          id: "uart",
+          uuid: "0000fff0-0000-1000-8000-00805f9b34fb",
+          characteristics: [
+            {
+              name: "TX",
+              id: "tx",
+              uuid: "0000fff1-0000-1000-8000-00805f9b34fb",
+            },
+            {
+              name: "Unknown UART Characteristic", // Unknown UART characteristic
+              id: "unknown1",
+              uuid: "0000fff3-0000-1000-8000-00805f9b34fb",
+            },
+            {
+              name: "RX",
+              id: "rx",
+              uuid: "0000fff4-0000-1000-8000-00805f9b34fb",
+            },
+            {
+              name: "Unknown UART Characteristic 2", // Unknown UART characteristic
+              id: "unknown2",
+              uuid: "0000fff6-0000-1000-8000-00805f9b34fb",
+            },
+            {
+              name: "Unknown UART Characteristic 3", // Unknown UART characteristic
+              id: "unknown3",
+              uuid: "0000fff7-0000-1000-8000-00805f9b34fb",
+            },
+            {
+              name: "Unknown UART Characteristic 4", // Unknown UART characteristic
+              id: "unknown4",
+              uuid: "0000fff8-0000-1000-8000-00805f9b34fb",
+            },
+          ],
+        },
+        {
+          name: "Device Information",
+          id: "device",
+          uuid: "0000180a-0000-1000-8000-00805f9b34fb",
+          characteristics: [
+            {
+              name: "System ID",
+              id: "system",
+              uuid: "00002a23-0000-1000-8000-00805f9b34fb",
+            },
+            {
+              name: "Model Number String",
+              id: "model",
+              uuid: "00002a24-0000-1000-8000-00805f9b34fb", // MD8107
+            },
+            // {
+            //   name: "Serial Number String (Blocked)",
+            //   id: "serial",
+            //   uuid: "00002a25-0000-1000-8000-00805f9b34fb",
+            // },
+            {
+              name: "Firmware Revision String",
+              id: "firmware",
+              uuid: "00002a26-0000-1000-8000-00805f9b34fb", // 0.7
+            },
+            {
+              name: "Hardware Revision String",
+              id: "hardware",
+              uuid: "00002a27-0000-1000-8000-00805f9b34fb",
+            },
+            {
+              name: "Software Revision String",
+              id: "software",
+              uuid: "00002a28-0000-1000-8000-00805f9b34fb",
+            },
+            {
+              name: "Manufacturer Name String",
+              id: "manufacturer",
+              uuid: "00002a29-0000-1000-8000-00805f9b34fb", // AMICCOM Elec.
+            },
+            {
+              name: "PnP ID",
+              id: "pnp",
+              uuid: "00002a50-0000-1000-8000-00805f9b34fb",
+            },
+          ],
+        },
+      ],
+    })
+  }
+
+  /**
+   * Retrieves battery or voltage information from the device.
+   * @returns {Promise<string | undefined>} A Promise that resolves with the battery or voltage information.
+   */
+  battery = async (): Promise<string | undefined> => {
+    return await this.read("battery", "level", 250)
+  }
+
+  /**
+   * Retrieves IEEE 11073-20601 Regulatory Certification from the device.
+   * @returns {Promise<string>} A Promise that resolves with the certification.
+   */
+  certification = async (): Promise<string | undefined> => {
+    return await this.read("device", "certification", 250)
+  }
+
+  /**
+   * Retrieves firmware version from the device.
+   * @returns {Promise<string>} A Promise that resolves with the firmware version.
+   */
+  firmware = async (): Promise<string | undefined> => {
+    return await this.read("device", "firmware", 250)
+  }
+
+  /**
+   * Handles data received from the device, processes weight measurements,
+   * and updates mass data including maximum and average values.
+   * It also handles command responses for retrieving device information.
+   *
+   * @param {DataView} value - The notification event.
+   */
+  override handleNotifications = (value: DataView): void => {
+    if (value) {
+      // Update timestamp
+      this.updateTimestamp()
+      if (value.buffer) {
+        const period = value.getUint32(0, false)
+
+        if (!Number.isFinite(period) || period === 0) return
+
+        const ts = value.getUint32(4, false)
+
+        const rpmFloat = 60 * (666666 / period)
+
+        // Accept only RPMs in plausible range (~800–15000)
+        if (!Number.isFinite(rpmFloat) || rpmFloat < 800 || rpmFloat > 15000) return
+
+        const receivedData = Math.round(rpmFloat)
+        const receivedTime = Date.now()
+
+        const numericData = receivedData - this.applyTare(receivedData)
+
+        // Add data to downloadable Array
+        this.downloadPackets.push({
+          received: receivedTime,
+          sampleNum: ts,
+          battRaw: 0,
+          samples: [numericData],
+          masses: [numericData],
+        })
+
+        // Update peak
+        this.peak = Math.max(this.peak, numericData)
+
+        // Update running sum and count
+        const currentMassTotal = Math.max(-1000, numericData)
+        this.sum += currentMassTotal
+        this.dataPointCount++
+
+        // Calculate the average dynamically
+        this.mean = this.sum / this.dataPointCount
+
+        // Check if device is being used
+        this.activityCheck(numericData)
+
+        // Notify with weight data
+        this.notifyCallback(this.buildForceMeasurement(Math.max(-1000, numericData)))
+      }
+    }
+  }
+
+  /**
+   * Retrieves hardware version from the device.
+   * @returns {Promise<string>} A Promise that resolves with the hardware version.
+   */
+  hardware = async (): Promise<string | undefined> => {
+    return await this.read("device", "hardware", 250)
+  }
+
+  /**
+   * Retrieves manufacturer information from the device.
+   * @returns {Promise<string>} A Promise that resolves with the manufacturer information.
+   */
+  manufacturer = async (): Promise<string | undefined> => {
+    return await this.read("device", "manufacturer", 250)
+  }
+
+  /**
+   * Retrieves model number from the device.
+   * @returns {Promise<string>} A Promise that resolves with the model number.
+   */
+  model = async (): Promise<string | undefined> => {
+    return await this.read("device", "model", 250)
+  }
+
+  /**
+   * Retrieves PnP ID from the device, a set of values that used to create a device ID value that is unique for this device.
+   * Included in the characteristic is a Vendor ID Source field, a Vendor ID field, a Product ID field and a Product Version field
+   * @returns {Promise<string>} A Promise that resolves with the PnP ID.
+   */
+  pnp = async (): Promise<string | undefined> => {
+    return await this.read("device", "pnp", 250)
+  }
+
+  /**
+   * Retrieves software version from the device.
+   * @returns {Promise<string>} A Promise that resolves with the software version.
+   */
+  software = async (): Promise<string | undefined> => {
+    return await this.read("device", "software", 250)
+  }
+
+  /**
+   * Retrieves system id from the device.
+   * @returns {Promise<string>} A Promise that resolves with the system id.
+   */
+  system = async (): Promise<string | undefined> => {
+    return await this.read("device", "system", 250)
+  }
+}

package/src/models/device/progressor.model.ts

@@ -158,23 +158,19 @@ export class Progressor extends Device implements IProgressor {
                 masses: [numericData],
               })
               // Check for max weight
-              this.massMax = Math.max(Number(this.massMax), Number(numericData)).toFixed(1)
+              this.peak = Math.max(this.peak, Number(numericData))
               // Update running sum and count
               const currentMassTotal = Math.max(-1000, Number(numericData))
-              this.massTotalSum += currentMassTotal
+              this.sum += currentMassTotal
               this.dataPointCount++
 
               // Calculate the average dynamically
-              this.massAverage = (this.massTotalSum / this.dataPointCount).toFixed(1)
+              this.mean = this.sum / this.dataPointCount
 
               // Check if device is being used
               this.activityCheck(numericData)
 
-              this.notifyCallback({
-                massMax: this.massMax,
-                massAverage: this.massAverage,
-                massTotal: Math.max(-1000, numericData).toFixed(1),
-              })
+              this.notifyCallback(this.buildForceMeasurement(Math.max(-1000, numericData)))
             }
           }
         } else if (kind === ProgressorResponses.COMMAND_RESPONSE) {

package/src/models/device/smartboard-pro.model.ts

@@ -12,8 +12,8 @@ export class SmartBoardPro extends Device implements ISmartBoardPro {
       filters: [{ name: "SMARTBOARD" }],
       services: [
         {
-          name: "Basic Audio Announcement",
-          id: "audio",
+          name: "Weight Scale Service",
+          id: "weight",
           uuid: "00001851-0000-1000-8000-00805f9b34fb",
           characteristics: [
             {
@@ -24,13 +24,13 @@ export class SmartBoardPro extends Device implements ISmartBoardPro {
           ],
         },
         {
-          name: "Read + Notify",
-          id: "",
+          name: "Smartboard Service",
+          id: "smartboard",
           uuid: "0000403d-0000-1000-8000-00805f9b34fb",
           characteristics: [
             {
-              name: "",
-              id: "",
+              name: "SmartBoard Measurement",
+              id: "rx",
               uuid: "00001583-0000-1000-8000-00805f9b34fb",
             },
           ],
@@ -50,4 +50,71 @@ export class SmartBoardPro extends Device implements ISmartBoardPro {
       ],
     })
   }
+
+  /**
+   * Handles data received from the device, processes weight measurements,
+   * and updates mass data including maximum and average values.
+   * It also handles command responses for retrieving device information.
+   *
+   * @param {DataView} value - The notification event.
+   */
+  override handleNotifications = (value: DataView): void => {
+    if (value) {
+      // Update timestamp
+      this.updateTimestamp()
+      if (value.buffer) {
+        const length = value.byteLength / 2
+        const dataArray: number[] = []
+
+        for (let i = 0; i < length; i++) {
+          const offset = i * 2
+          if (offset + 1 < value.byteLength) {
+            const intValue = value.getInt16(offset, true)
+            // For debugging purposes
+            console.log(intValue)
+
+            dataArray.push(intValue)
+          }
+        }
+
+        if (dataArray.length === 0) return
+
+        const receivedTime = Date.now()
+
+        // Process each data point
+        for (const receivedData of dataArray) {
+          // Skip invalid values
+          if (!Number.isFinite(receivedData)) continue
+
+          const numericData = receivedData - this.applyTare(receivedData)
+
+          // Add data to downloadable Array
+          this.downloadPackets.push({
+            received: receivedTime,
+            sampleNum: this.dataPointCount,
+            battRaw: 0,
+            samples: [numericData],
+            masses: [numericData],
+          })
+
+          // Update peak
+          this.peak = Math.max(this.peak, numericData)
+
+          // Update running sum and count
+          const currentMassTotal = Math.max(-1000, numericData)
+          this.sum += currentMassTotal
+          this.dataPointCount++
+
+          // Calculate the average dynamically
+          this.mean = this.sum / this.dataPointCount
+
+          // Check if device is being used
+          this.activityCheck(numericData)
+
+          // Notify with weight data
+          this.notifyCallback(this.buildForceMeasurement(Math.max(-1000, numericData)))
+        }
+      }
+    }
+  }
 }

package/src/models/device/wh-c06.model.ts

@@ -117,26 +117,22 @@ export class WHC06 extends Device implements IWHC06 {
             masses: [numericData],
           })
 
-          // Update massMax
-          this.massMax = Math.max(Number(this.massMax), numericData).toFixed(1)
+          // Update peak
+          this.peak = Math.max(this.peak, numericData)
 
           // Update running sum and count
           const currentMassTotal = Math.max(-1000, numericData)
-          this.massTotalSum += currentMassTotal
+          this.sum += currentMassTotal
           this.dataPointCount++
 
           // Calculate the average dynamically
-          this.massAverage = (this.massTotalSum / this.dataPointCount).toFixed(1)
+          this.mean = this.sum / this.dataPointCount
 
           // Check if device is being used
           this.activityCheck(numericData)
 
           // Notify with weight data
-          this.notifyCallback({
-            massMax: this.massMax,
-            massAverage: this.massAverage,
-            massTotal: Math.max(-1000, numericData).toFixed(1),
-          })
+          this.notifyCallback(this.buildForceMeasurement(Math.max(-1000, numericData)))
         }
         // Reset "still advertising" counter
         this.resetAdvertisementTimeout()