@hangtime/grip-connect 0.10.1 → 0.10.3

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

@@ -9,38 +9,82 @@ enum ProgressorResponses {
    * Response received after sending a command to the device.
    * This could include acknowledgment or specific data related to the command sent.
    */
-  COMMAND_RESPONSE,
+  RESPONSE_COMMAND,
 
   /**
    * Data representing a weight measurement from the device.
    * Typically used for tracking load or force applied.
    */
-  WEIGHT_MEASURE,
+  RESPONSE_WEIGHT_MEASUREMENT,
 
   /**
    * Peak rate of force development (RFD) measurement.
    * This measures how quickly the force is applied over time.
    */
-  PEAK_RFD_MEAS,
+  RESPONSE_RFD_PEAK,
 
   /**
    * Series of peak rate of force development (RFD) measurements.
    * This could be used for analyzing force trends over multiple data points.
    */
-  PEAK_RFD_MEAS_SERIES,
+  RESPONSE_RFD_PEAK_SERIES,
 
   /**
    * Low battery warning from the device.
    * Indicates that the battery level is below a critical threshold.
    */
-  LOW_BATTERY_WARNING,
+  RESPONSE_LOW_PWR_WARNING,
 }
 
 /**
  * Represents a Tindeq Progressor device.
  * {@link https://tindeq.com}
  */
+/** One second in microseconds (device timestamp unit). Used for Hz = samples in last 1s. */
+const ONE_SECOND_US = 1_000_000
+
+/**
+ * Format bytes as hex string.
+ * @param payload - Bytes to format
+ * @param separator - String between bytes (default " ")
+ */
+function toHex(payload: Uint8Array, separator = " "): string {
+  return Array.from(payload)
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join(separator)
+}
+
+/**
+ * Parse ProgressorId response: u64 little-endian, device may omit trailing zero bytes.
+ * Format as hex string MSB-first to match the official app.
+ */
+function parseProgressorIdPayload(payload: Uint8Array): string {
+  if (payload.length === 0) return ""
+  const reversed = Uint8Array.from(payload)
+  reversed.reverse()
+  return toHex(reversed, "").toUpperCase()
+}
+
+/**
+ * Parse calibration curve: 12 opaque bytes (CalibrationCurve = [u8; 12]).
+ * Progressor two-point calibration stores two raw ADC readings (zero + reference)
+ * and a third value (version/reserved). Exact layout is device-specific.
+ */
+function parseCalibrationCurvePayload(payload: Uint8Array): string {
+  const hex = toHex(payload)
+
+  if (payload.length !== 12) return hex
+
+  const view = new DataView(payload.buffer, payload.byteOffset, payload.byteLength)
+  const [v0, v1, v2] = [0, 4, 8].map((o) => view.getUint32(o, true))
+
+  return `${hex} — zero-point: ${v1.toLocaleString()} | ref-point: ${v0.toLocaleString()} | version: ${v2} (0x${v2.toString(16)})`
+}
+
 export class Progressor extends Device implements IProgressor {
+  /** Device timestamps (µs) of recent samples (samples in last 1s device time). */
+  private recentSampleTimestamps: number[] = []
+
   constructor() {
     super({
       filters: [{ namePrefix: "Progressor" }],
@@ -75,19 +119,23 @@ export class Progressor extends Device implements IProgressor {
           ],
         },
       ],
+      // Tindeq API: opcode = single byte (ASCII char code = decimal 100–114;)
       commands: {
-        TARE_SCALE: "d", // 0x64
-        START_WEIGHT_MEAS: "e", // 0x65
-        STOP_WEIGHT_MEAS: "f", // 0x66
-        START_PEAK_RFD_MEAS: "g", //  0x67
-        START_PEAK_RFD_MEAS_SERIES: "h", //  0x68
-        ADD_CALIB_POINT: "i", //  0x69
-        SAVE_CALIB: "j", //  0x6a
-        GET_FW_VERSION: "k", //  0x6b
-        GET_ERR_INFO: "l", //  0x6c
-        CLR_ERR_INFO: "m", //  0x6d
-        SLEEP: "n", // 0x6e
-        GET_BATT_VLTG: "o", //  0x6f
+        TARE_SCALE: "d", // 100 (0x64)
+        START_WEIGHT_MEAS: "e", // 101 (0x65)
+        STOP_WEIGHT_MEAS: "f", // 102 (0x66)
+        START_PEAK_RFD_MEAS: "g", // 103 (0x67)
+        START_PEAK_RFD_MEAS_SERIES: "h", // 104 (0x68)
+        ADD_CALIBRATION_POINT: "i", // 105 (0x69)
+        SAVE_CALIBRATION: "j", // 106 (0x6a)
+        GET_FIRMWARE_VERSION: "k", // 107 (0x6b)
+        GET_ERROR_INFORMATION: "l", // 108 (0x6c)
+        CLR_ERROR_INFORMATION: "m", // 109 (0x6d)
+        SLEEP: "n", // 110 (0x6e)
+        GET_BATTERY_VOLTAGE: "o", // 111 (0x6f)
+        GET_PROGRESSOR_ID: "p", // 112 (0x70)
+        RESET_CALIBRATION: "q", // 113 (0x71)
+        GET_CALIBRATION: "r", // 114 (0x72)
       },
     })
   }
@@ -98,24 +146,116 @@ export class Progressor extends Device implements IProgressor {
    */
   battery = async (): Promise<string | undefined> => {
     let response: string | undefined = undefined
-    await this.write("progressor", "tx", this.commands.GET_BATT_VLTG, 250, (data) => {
+    await this.write("progressor", "tx", this.commands.GET_BATTERY_VOLTAGE, 250, (data) => {
       response = data
     })
     return response
   }
 
   /**
-   * Retrieves firmware version from the device.
+   * Retrieves firmware version from the device (GetAppVersion, opcode 0x6B).
    * @returns {Promise<string>} A Promise that resolves with the firmware version,
    */
   firmware = async (): Promise<string | undefined> => {
     let response: string | undefined = undefined
-    await this.write("progressor", "tx", this.commands.GET_FW_VERSION, 250, (data) => {
+    await this.write("progressor", "tx", this.commands.GET_FIRMWARE_VERSION, 250, (data) => {
+      response = data
+    })
+    return response
+  }
+
+  /**
+   * Retrieves the Progressor ID from the device (opcode 0x70).
+   * @returns {Promise<string>} A Promise that resolves with the raw response (hex of payload).
+   */
+  progressorId = async (): Promise<string | undefined> => {
+    let response: string | undefined = undefined
+    await this.write("progressor", "tx", this.commands.GET_PROGRESSOR_ID, 250, (data) => {
       response = data
     })
     return response
   }
 
+  /**
+   * Retrieves calibration values from the device.
+   * @returns {Promise<string>} A Promise that resolves with the raw response (hex of payload).
+   */
+  calibration = async (): Promise<string | undefined> => {
+    let response: string | undefined = undefined
+    await this.write("progressor", "tx", this.commands.GET_CALIBRATION, 250, (data) => {
+      response = data
+    })
+    return response
+  }
+
+  /**
+   * Saves the current calibration to the device. Call after adding both calibration points.
+   * @returns {Promise<void>} A Promise that resolves when the command is sent.
+   */
+  saveCalibration = async (): Promise<void> => {
+    await this.write("progressor", "tx", this.commands.SAVE_CALIBRATION, 0)
+  }
+
+  /**
+   * Resets the calibration to default values of the device.
+   * @returns {Promise<void>} A Promise that resolves when the command is sent.
+   */
+  resetCalibration = async (): Promise<void> => {
+    await this.write("progressor", "tx", this.commands.RESET_CALIBRATION, 0)
+  }
+
+  /**
+   * Adds a calibration point: 0x69 + 32-bit float (weight in kg), 5 bytes to the control characteristic.
+   * Use for two-point calibration: (1) zero weight — addCalibrationPoint(0); (2) known weight — addCalibrationPoint(knownKg).
+   * Order can be either way; writing zero first is recommended (hysteresis). Then call saveCalibration().
+   * @param {number} weightKg - Weight in kg (use 0 for zero point, or known reference weight &lt; 150 kg).
+   * @returns {Promise<void>} A Promise that resolves when the command is sent.
+   */
+  addCalibrationPoint = async (weightKg: number): Promise<void> => {
+    const payload = new Uint8Array(5)
+    payload[0] = (this.commands.ADD_CALIBRATION_POINT as string).charCodeAt(0) // 0x69
+    new DataView(payload.buffer).setFloat32(1, weightKg, true)
+    await this.write("progressor", "tx", payload, 0)
+  }
+
+  /**
+   * Sends the device tare command to zero the scale (hardware tare).
+   * For software tare over a duration, use the base tare(duration) method.
+   * @returns {Promise<void>} A Promise that resolves when the command is sent.
+   */
+  tareScale = async (): Promise<void> => {
+    await this.write("progressor", "tx", this.commands.TARE_SCALE, 0)
+  }
+
+  /**
+   * Puts the device to sleep / shutdown.
+   * @returns {Promise<void>} A Promise that resolves when the command is sent.
+   */
+  sleep = async (): Promise<void> => {
+    const cmd = this.commands.SLEEP
+    await this.write("progressor", "tx", typeof cmd === "string" ? cmd : String(cmd), 0)
+  }
+
+  /**
+   * Retrieves error information from the device.
+   * @returns {Promise<string | undefined>} A Promise that resolves with the error info text.
+   */
+  errorInfo = async (): Promise<string | undefined> => {
+    let response: string | undefined = undefined
+    await this.write("progressor", "tx", this.commands.GET_ERROR_INFORMATION, 250, (data) => {
+      response = data
+    })
+    return response
+  }
+
+  /**
+   * Clears error information on the device.
+   * @returns {Promise<void>} A Promise that resolves when the command is sent.
+   */
+  clearErrorInfo = async (): Promise<void> => {
+    await this.write("progressor", "tx", this.commands.CLR_ERROR_INFORMATION, 0)
+  }
+
   /**
    * Handles data received from the device, processes weight measurements,
    * and updates mass data including maximum and average values.
@@ -132,61 +272,83 @@ export class Progressor extends Device implements IProgressor {
         // Read the first byte of the buffer to determine the kind of message
         const kind = value.getInt8(0)
         // Check if the message is a weight measurement
-        if (kind === ProgressorResponses.WEIGHT_MEASURE) {
-          // Start parsing data from the 3rd byte (index 2)
-          let offset = 2
-          // Continue parsing while there's data left in the buffer
-          while (offset < value.byteLength) {
-            // Read a 32-bit float (4 bytes) for the weight, using little-endian
+        if (kind === ProgressorResponses.RESPONSE_WEIGHT_MEASUREMENT) {
+          // Payload = bytes from index 2 (skip byte 0 = message type, byte 1 = reserved/length)
+          const payloadLength = value.byteLength - 2
+          if (payloadLength % 8 !== 0) return
+          const samplesPerPacket = payloadLength / 8
+          this.currentSamplesPerPacket = samplesPerPacket
+          this.recordPacketReceived()
+
+          //  for (i = 0; i < samplesPerPacket; i++) { offset = i*8; weight = getFloat32(offset); timestampUs = getUint32(offset+4); }
+          for (let i = 0; i < samplesPerPacket; i++) {
+            const offset = 2 + i * 8
             const weight = value.getFloat32(offset, true)
-            // Move the offset by 4 bytes
-            offset += 4
-            // Read a 32-bit integer (4 bytes) for the seconds, using little-endian
-            const seconds = value.getInt32(offset, true)
-            // Move the offset by 4 bytes
-            offset += 4
-            // Check if both weight and seconds are valid numbers
-            if (!isNaN(weight) && !isNaN(seconds)) {
-              // Tare correction
+            const timestampUs = value.getUint32(offset + 4, true)
+            if (!isNaN(weight)) {
               const numericData = weight - this.applyTare(weight)
-              // Add data to downloadable Array
-              this.downloadPackets.push({
-                received: receivedTime,
-                sampleNum: seconds,
-                battRaw: 0,
-                samples: [weight],
-                masses: [numericData],
-              })
-              // Check for max weight
-              this.peak = Math.max(this.peak, Number(numericData))
-              // Update running sum and count
               const currentMassTotal = Math.max(-1000, Number(numericData))
+
+              // Update session stats before building packet
+              this.peak = Math.max(this.peak, Number(numericData))
+              this.min = Math.min(this.min, Math.max(-1000, Number(numericData)))
               this.sum += currentMassTotal
               this.dataPointCount++
-
-              // Calculate the average dynamically
               this.mean = this.sum / this.dataPointCount
 
-              // Check if device is being used
+              this.downloadPackets.push(
+                this.buildDownloadPacket(currentMassTotal, [weight], {
+                  timestamp: receivedTime,
+                  sampleIndex: timestampUs,
+                }),
+              )
               this.activityCheck(numericData)
 
-              this.notifyCallback(this.buildForceMeasurement(Math.max(-1000, numericData)))
+              // Hz from device timestamps: keep only samples in last 1s
+              this.recentSampleTimestamps.push(timestampUs)
+              const latestUs = this.recentSampleTimestamps[this.recentSampleTimestamps.length - 1] ?? 0
+              this.recentSampleTimestamps = this.recentSampleTimestamps.filter((ts) => latestUs - ts <= ONE_SECOND_US)
+              const samplingRateHz = this.recentSampleTimestamps.length
+
+              const payload = this.buildForceMeasurement(currentMassTotal)
+              if (payload.performance) payload.performance.samplingRateHz = samplingRateHz
+              this.notifyCallback(payload)
             }
           }
-        } else if (kind === ProgressorResponses.COMMAND_RESPONSE) {
+        }
+        // Command response
+        else if (kind === ProgressorResponses.RESPONSE_COMMAND) {
           if (!this.writeLast) return
 
           let output = ""
+          const payload = new Uint8Array(value.buffer).slice(2)
 
-          if (this.writeLast === this.commands.GET_BATT_VLTG) {
+          if (this.writeLast === this.commands.GET_BATTERY_VOLTAGE) {
             output = new DataView(value.buffer, 2).getUint32(0, true).toString()
-          } else if (this.writeLast === this.commands.GET_FW_VERSION) {
-            output = new TextDecoder().decode(new Uint8Array(value.buffer).slice(2))
-          } else if (this.writeLast === this.commands.GET_ERR_INFO) {
-            output = new TextDecoder().decode(new Uint8Array(value.buffer.slice(2)))
+          } else if (this.writeLast === this.commands.GET_FIRMWARE_VERSION) {
+            output = new TextDecoder().decode(payload)
+          } else if (this.writeLast === this.commands.GET_ERROR_INFORMATION) {
+            output = new TextDecoder().decode(payload)
+          } else if (this.writeLast === this.commands.GET_PROGRESSOR_ID) {
+            output = parseProgressorIdPayload(payload)
+          } else if (this.writeLast === this.commands.GET_CALIBRATION) {
+            output = parseCalibrationCurvePayload(payload)
+          } else {
+            // Unknown command response: return raw hex
+            output = toHex(payload)
           }
           this.writeCallback(output)
-        } else if (kind === ProgressorResponses.LOW_BATTERY_WARNING) {
+        }
+        // RFD peak response
+        else if (kind === ProgressorResponses.RESPONSE_RFD_PEAK) {
+          console.warn("⚠️ RFD peak is currently unsupported.")
+        }
+        // RFD peak series response
+        else if (kind === ProgressorResponses.RESPONSE_RFD_PEAK_SERIES) {
+          console.warn("⚠️ RFD peak series is currently unsupported.")
+        }
+        // Low power warning response
+        else if (kind === ProgressorResponses.RESPONSE_LOW_PWR_WARNING) {
           console.warn("⚠️ Low power detected. Please consider connecting to a power source.")
         } else {
           throw new Error(`Unknown message kind detected: ${kind}`)
@@ -209,8 +371,15 @@ export class Progressor extends Device implements IProgressor {
    * @returns {Promise<void>} A promise that resolves when the streaming operation is completed.
    */
   stream = async (duration = 0): Promise<void> => {
-    // Reset download packets
+    // Reset download packets and session stats for fresh measurement
     this.downloadPackets.length = 0
+    this.peak = Number.NEGATIVE_INFINITY
+    this.mean = 0
+    this.sum = 0
+    this.dataPointCount = 0
+    this.min = Number.POSITIVE_INFINITY
+    this.resetPacketTracking()
+    this.recentSampleTimestamps = []
     // Start streaming data
     await this.write("progressor", "tx", this.commands.START_WEIGHT_MEAS, duration)
     // Stop streaming if duration is set

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

@@ -60,7 +60,6 @@ export class SmartBoardPro extends Device implements ISmartBoardPro {
    */
   override handleNotifications = (value: DataView): void => {
     if (value) {
-      // Update timestamp
       this.updateTimestamp()
       if (value.buffer) {
         const length = value.byteLength / 2
@@ -70,49 +69,45 @@ export class SmartBoardPro extends Device implements ISmartBoardPro {
           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
 
+        this.currentSamplesPerPacket = dataArray.length
+        this.recordPacketReceived()
         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],
-          })
+          const currentMassTotal = Math.max(-1000, numericData)
 
-          // Update peak
+          // Update session stats before building packet
           this.peak = Math.max(this.peak, numericData)
-
-          // Update running sum and count
-          const currentMassTotal = Math.max(-1000, numericData)
+          this.min = Math.min(this.min, Math.max(-1000, numericData))
           this.sum += currentMassTotal
           this.dataPointCount++
-
-          // Calculate the average dynamically
           this.mean = this.sum / this.dataPointCount
 
+          // Add data to downloadable Array
+          this.downloadPackets.push(
+            this.buildDownloadPacket(currentMassTotal, [numericData], {
+              timestamp: receivedTime,
+              sampleIndex: this.dataPointCount,
+            }),
+          )
+
           // Check if device is being used
           this.activityCheck(numericData)
 
           // Notify with weight data
-          this.notifyCallback(this.buildForceMeasurement(Math.max(-1000, numericData)))
+          this.notifyCallback(this.buildForceMeasurement(currentMassTotal))
         }
       }
     }

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

@@ -99,7 +99,8 @@ export class WHC06 extends Device implements IWHC06 {
       this.bluetooth.addEventListener("advertisementreceived", (event) => {
         const data = event.manufacturerData.get(WHC06.manufacturerId)
         if (data) {
-          // Handle recieved data
+          this.currentSamplesPerPacket = 1
+          this.recordPacketReceived()
           const weight = (data.getUint8(WHC06.weightOffset) << 8) | data.getUint8(WHC06.weightOffset + 1)
           // const stable = (data.getUint8(STABLE_OFFSET) & 0xf0) >> 4
           // const unit = data.getUint8(STABLE_OFFSET) & 0x0f
@@ -107,32 +108,28 @@ export class WHC06 extends Device implements IWHC06 {
           const receivedData = weight / 100
 
           const numericData = receivedData - this.applyTare(receivedData) * -1
+          const currentMassTotal = Math.max(-1000, numericData)
 
-          // Add data to downloadable Array
-          this.downloadPackets.push({
-            received: receivedTime,
-            sampleNum: this.dataPointCount,
-            battRaw: 0,
-            samples: [numericData],
-            masses: [numericData],
-          })
-
-          // Update peak
+          // Update session stats before building packet
           this.peak = Math.max(this.peak, numericData)
-
-          // Update running sum and count
-          const currentMassTotal = Math.max(-1000, numericData)
+          this.min = Math.min(this.min, Math.max(-1000, numericData))
           this.sum += currentMassTotal
           this.dataPointCount++
-
-          // Calculate the average dynamically
           this.mean = this.sum / this.dataPointCount
 
+          // Add data to downloadable Array
+          this.downloadPackets.push(
+            this.buildDownloadPacket(currentMassTotal, [numericData], {
+              timestamp: receivedTime,
+              sampleIndex: this.dataPointCount,
+            }),
+          )
+
           // Check if device is being used
           this.activityCheck(numericData)
 
           // Notify with weight data
-          this.notifyCallback(this.buildForceMeasurement(Math.max(-1000, numericData)))
+          this.notifyCallback(this.buildForceMeasurement(currentMassTotal))
         }
         // Reset "still advertising" counter
         this.resetAdvertisementTimeout()