@hangtime/grip-connect 0.3.7 → 0.3.8

package/README.md

@@ -47,7 +47,7 @@ Simply importing the utilities you need from `@hangtime/grip-connect`.
 ```
 
 ```js
-import { Motherboard, battery, connect, disconnect, info, notify, stream } from "@hangtime/grip-connect"
+import { Motherboard, active, battery, connect, disconnect, info, notify, stream } from "@hangtime/grip-connect"
 
 const motherboardButton = document.querySelector("#motherboard")
 
@@ -59,10 +59,18 @@ motherboardButton.addEventListener("click", () => {
       console.log(data)
     })
 
+    // Check if device is being used
+    active((value) => {
+      console.log(value)
+    })
+
     // Read battery + device info
     await battery(Motherboard)
     await info(Motherboard)
 
+    // trigger LEDs
+    // await led(device)
+
     // Start weight streaming (for a minute) remove parameter for a continues stream
     await stream(Motherboard, 60000)
 
@@ -106,6 +114,7 @@ available services with us.
 - ✅ Read calibration
 - ✅ Device info: firmware / serial etc.
 - ✅ Check if device is connected
+- ✅ Check if device is being used
 - ✅ Peak / Average load
 - ✅️ Tare / unladen weight
 - ✅️ Download data to CVS

package/dist/data/entralpi.js

@@ -1,4 +1,5 @@
 import { notifyCallback } from "./../notify";
+import { checkActivity } from "./../is-active";
 import { applyTare } from "./../tare";
 // Constants
 let MASS_MAX = "0";
@@ -21,6 +22,8 @@ export const handleEntralpiData = (receivedData) => {
     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,

package/dist/data/motherboard.js

@@ -1,6 +1,7 @@
 import { notifyCallback } from "./../notify";
 import { applyTare } from "./../tare";
 import { MotherboardCommands } from "./../commands";
+import { checkActivity } from "./../is-active";
 import { lastWrite } from "./../write";
 import { DownloadPackets } from "./../download";
 // Constants
@@ -108,6 +109,8 @@ export const handleMotherboardData = (receivedData) => {
         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),

package/dist/data/progressor.js

@@ -1,5 +1,6 @@
 import { notifyCallback } from "./../notify";
 import { applyTare } from "./../tare";
+import { checkActivity } from "./../is-active";
 import { ProgressorCommands, ProgressorResponses } from "./../commands/progressor";
 import { lastWrite } from "./../write";
 import struct from "./../struct";
@@ -39,6 +40,8 @@ export const handleProgressorData = (data) => {
                 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,

package/dist/data/wh-c06.js

@@ -1,3 +1,4 @@
+import { checkActivity } from "./../is-active";
 import { notifyCallback } from "./../notify";
 import { applyTare } from "./../tare";
 // Constants
@@ -26,6 +27,8 @@ export const handleWHC06Data = (data) => {
     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,

package/dist/index.d.ts

@@ -4,6 +4,7 @@ export { calibration } from "./calibration";
 export { download } from "./download";
 export { connect } from "./connect";
 export { disconnect } from "./disconnect";
+export { active, isActive } from "./is-active";
 export { isConnected } from "./is-connected";
 export { info } from "./info";
 export { led } from "./led";

package/dist/index.js

@@ -9,6 +9,7 @@ export { download } from "./download";
 // Export connection related functions
 export { connect } from "./connect";
 export { disconnect } from "./disconnect";
+export { active, isActive } from "./is-active";
 export { isConnected } from "./is-connected";
 // Export information retrieval function
 export { info } from "./info";

package/dist/is-active.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Type definition for the callback function that is called when the activity status changes.
+ * @param {boolean} value - The new activity status (true if active, false if not).
+ */
+type IsActiveCallback = (value: boolean) => void;
+/**
+ * Indicates whether the device is currently active.
+ * @type {boolean}
+ */
+export declare let isActive: boolean;
+/**
+ * Sets the callback function to be called when the activity status changes.
+ *
+ * This function allows you to specify a callback that will be invoked whenever
+ * the activity status changes, indicating whether the device is currently active.
+ *
+ * @param {IsActiveCallback} callback - The callback function to be set. This function
+ *                                      receives a boolean value indicating the new activity status.
+ * @returns {void}
+ */
+export declare const active: (callback: IsActiveCallback) => void;
+/**
+ * Checks if a dynamic value is active based on a threshold and duration.
+ *
+ * This function assesses whether a given dynamic value surpasses a specified threshold
+ * and remains active for a specified duration. If the activity status changes from
+ * the previous state, the callback function is called with the updated activity status.
+ *
+ * @param {number} input - The dynamic value to check for activity status.
+ * @param {number} [threshold=2.5] - The threshold value to determine if the input is considered active.
+ *                                    Defaults to 2.5 if not provided.
+ * @param {number} [duration=1000] - The duration (in milliseconds) to monitor the input for activity.
+ *                                    Defaults to 1000 milliseconds if not provided.
+ * @returns {Promise<void>} A promise that resolves once the activity check is complete.
+ */
+export declare const checkActivity: (input: number, threshold?: number, duration?: number) => Promise<void>;
+export {};

package/dist/is-active.js

@@ -0,0 +1,49 @@
+let activeCallback;
+/**
+ * Indicates whether the device is currently active.
+ * @type {boolean}
+ */
+export let isActive = false;
+/**
+ * Sets the callback function to be called when the activity status changes.
+ *
+ * This function allows you to specify a callback that will be invoked whenever
+ * the activity status changes, indicating whether the device is currently active.
+ *
+ * @param {IsActiveCallback} callback - The callback function to be set. This function
+ *                                      receives a boolean value indicating the new activity status.
+ * @returns {void}
+ */
+export const active = (callback) => {
+    activeCallback = callback;
+};
+/**
+ * Checks if a dynamic value is active based on a threshold and duration.
+ *
+ * This function assesses whether a given dynamic value surpasses a specified threshold
+ * and remains active for a specified duration. If the activity status changes from
+ * the previous state, the callback function is called with the updated activity status.
+ *
+ * @param {number} input - The dynamic value to check for activity status.
+ * @param {number} [threshold=2.5] - The threshold value to determine if the input is considered active.
+ *                                    Defaults to 2.5 if not provided.
+ * @param {number} [duration=1000] - The duration (in milliseconds) to monitor the input for activity.
+ *                                    Defaults to 1000 milliseconds if not provided.
+ * @returns {Promise<void>} A promise that resolves once the activity check is complete.
+ */
+export const checkActivity = (input, threshold = 2.5, duration = 1000) => {
+    return new Promise((resolve) => {
+        // Check the activity status after the specified duration
+        setTimeout(() => {
+            // Determine the activity status based on the threshold
+            const activeNow = input > threshold;
+            if (isActive !== activeNow) {
+                isActive = activeNow;
+                if (activeCallback) {
+                    activeCallback(activeNow);
+                }
+            }
+            resolve();
+        }, duration);
+    });
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hangtime/grip-connect",
-  "version": "0.3.7",
+  "version": "0.3.8",
   "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 Griptonite Motherboard, Climbro, SmartBoard, Entralpi or Tindeq Progressor",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/data/entralpi.ts

@@ -1,4 +1,5 @@
 import { notifyCallback } from "./../notify"
+import { checkActivity } from "./../is-active"
 import { applyTare } from "./../tare"
 
 // Constants
@@ -28,6 +29,9 @@ export const handleEntralpiData = (receivedData: string): void => {
   // 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,

package/src/data/motherboard.ts

@@ -1,6 +1,7 @@
 import { notifyCallback } from "./../notify"
 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"
@@ -131,6 +132,9 @@ export const handleMotherboardData = (receivedData: string): void => {
     // 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),

package/src/data/progressor.ts

@@ -1,5 +1,6 @@
 import { notifyCallback } from "./../notify"
 import { applyTare } from "./../tare"
+import { checkActivity } from "./../is-active"
 import { ProgressorCommands, ProgressorResponses } from "./../commands/progressor"
 import { lastWrite } from "./../write"
 import struct from "./../struct"
@@ -43,6 +44,9 @@ export const handleProgressorData = (data: DataView): void => {
         // 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,

package/src/data/wh-c06.ts

@@ -1,3 +1,4 @@
+import { checkActivity } from "./../is-active"
 import { notifyCallback } from "./../notify"
 import { applyTare } from "./../tare"
 
@@ -34,6 +35,9 @@ export const handleWHC06Data = (data: DataView): void => {
   // 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,

package/src/index.ts

@@ -13,6 +13,7 @@ export { download } from "./download"
 // Export connection related functions
 export { connect } from "./connect"
 export { disconnect } from "./disconnect"
+export { active, isActive } from "./is-active"
 export { isConnected } from "./is-connected"
 
 // Export information retrieval function

package/src/is-active.ts

@@ -0,0 +1,58 @@
+/**
+ * Type definition for the callback function that is called when the activity status changes.
+ * @param {boolean} value - The new activity status (true if active, false if not).
+ */
+type IsActiveCallback = (value: boolean) => void
+
+let activeCallback: IsActiveCallback | undefined
+
+/**
+ * Indicates whether the device is currently active.
+ * @type {boolean}
+ */
+export let isActive = false
+
+/**
+ * Sets the callback function to be called when the activity status changes.
+ *
+ * This function allows you to specify a callback that will be invoked whenever
+ * the activity status changes, indicating whether the device is currently active.
+ *
+ * @param {IsActiveCallback} callback - The callback function to be set. This function
+ *                                      receives a boolean value indicating the new activity status.
+ * @returns {void}
+ */
+export const active = (callback: IsActiveCallback): void => {
+  activeCallback = callback
+}
+
+/**
+ * Checks if a dynamic value is active based on a threshold and duration.
+ *
+ * This function assesses whether a given dynamic value surpasses a specified threshold
+ * and remains active for a specified duration. If the activity status changes from
+ * the previous state, the callback function is called with the updated activity status.
+ *
+ * @param {number} input - The dynamic value to check for activity status.
+ * @param {number} [threshold=2.5] - The threshold value to determine if the input is considered active.
+ *                                    Defaults to 2.5 if not provided.
+ * @param {number} [duration=1000] - The duration (in milliseconds) to monitor the input for activity.
+ *                                    Defaults to 1000 milliseconds if not provided.
+ * @returns {Promise<void>} A promise that resolves once the activity check is complete.
+ */
+export const checkActivity = (input: number, threshold = 2.5, duration = 1000): Promise<void> => {
+  return new Promise((resolve) => {
+    // Check the activity status after the specified duration
+    setTimeout(() => {
+      // Determine the activity status based on the threshold
+      const activeNow = input > threshold
+      if (isActive !== activeNow) {
+        isActive = activeNow
+        if (activeCallback) {
+          activeCallback(activeNow)
+        }
+      }
+      resolve()
+    }, duration)
+  })
+}