@hangtime/grip-connect 0.4.0 → 0.4.2

package/README.md

@@ -60,10 +60,14 @@ motherboardButton.addEventListener("click", () => {
         console.log(data)
       })
 
-      // Check if device is being used
-      active((value) => {
-        console.log(value)
-      })
+      // Reactive check if device is active
+      active(
+        (isActive) => {
+          console.log(isActive)
+        },
+        // Optionally using a weight threshold and duration
+        { threshold: 2.5, duration: 1000 },
+      )
 
       // Read info: battery + firmware
       const batteryLevel = await battery(Motherboard)
@@ -72,7 +76,8 @@ motherboardButton.addEventListener("click", () => {
       const firmwareVersion = await firmware(Motherboard)
       console.log(firmwareVersion)
 
-      // trigger LEDs
+      // LEDs: "green", "red", "orange", or no argument to turn off
+      // await led(Motherboard, "red")
       // await led(Motherboard)
 
       // Start weight streaming (for a minute) remove parameter for a continues stream
@@ -127,6 +132,7 @@ available services with us.
 | [Hardware](https://stevie-ray.github.io/hangtime-grip-connect/api/hardware.html)         | ✅          |            |        |          |              |         |              |
 | [isActive](https://stevie-ray.github.io/hangtime-grip-connect/api/is-active.html)        | ✅          | ✅         | ✅     | ✅       |              |         |              |
 | [isConnected](https://stevie-ray.github.io/hangtime-grip-connect/api/is-connected.html)  | ✅          | ✅         | ✅     | ✅       | ✅           |         |              |
+| [isDevice](https://stevie-ray.github.io/hangtime-grip-connect/api/is-device.html)        | ✅          | ✅         | ✅     | ✅       | ✅           |         |              |
 | [Led](https://stevie-ray.github.io/hangtime-grip-connect/api/led.html)                   | ✅          |            |        |          | ✅           |         |              |
 | [Manufacturer](https://stevie-ray.github.io/hangtime-grip-connect/api/manufacturer.html) | ✅          |            |        |          |              |         |              |
 | [Notify](https://stevie-ray.github.io/hangtime-grip-connect/api/notify.html)             | ✅          | ✅         | ✅     | ✅       |              |         |              |

package/dist/battery.d.ts

@@ -6,7 +6,5 @@ import type { Device } from "./types/devices";
  *
  * @param {Device} board - The device from which to retrieve battery information.
  * @returns {Promise<string | undefined>} A Promise that resolves with the battery or voltage information,
- *                            or rejects with an error if the device is not connected.
- * @throws {Error} Throws an error if the device is not connected.
  */
 export declare const battery: (board: Device) => Promise<string | undefined>;

package/dist/battery.js

@@ -1,7 +1,7 @@
 import { write } from "./write";
 import { read } from "./read";
 import { isConnected } from "./is-connected";
-import { Motherboard, Progressor } from "./devices";
+import { isMotherboard, isProgressor } from "./is-device";
 import { ProgressorCommands } from "./commands";
 /**
  * Retrieves battery or voltage information from the device.
@@ -10,28 +10,25 @@ import { ProgressorCommands } from "./commands";
  *
  * @param {Device} board - The device from which to retrieve battery information.
  * @returns {Promise<string | undefined>} A Promise that resolves with the battery or voltage 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 battery = async (board) => {
     // Check if the device is connected
     if (isConnected(board)) {
         // If the device is connected and it is a Motherboard device
-        if (board.filters.some((filter) => filter.name === "Motherboard")) {
+        if (isMotherboard(board)) {
             // Read battery level information from the Motherboard
-            return await read(Motherboard, "battery", "level", 250);
+            return await read(board, "battery", "level", 250);
         }
         // If the device is connected and its name starts with "Progressor"
-        if (board.filters.some((filter) => filter.namePrefix === "Progressor")) {
+        if (isProgressor(board)) {
             // Write command to get battery voltage information to the Progressor
             let response = undefined;
-            await write(Progressor, "progressor", "tx", ProgressorCommands.GET_BATT_VLTG, 250, (data) => {
+            await write(board, "progressor", "tx", ProgressorCommands.GET_BATT_VLTG, 250, (data) => {
                 response = data;
             });
             return response;
         }
-        // If device is not found, return undefined
-        return;
     }
-    throw new Error("Not connected.");
+    // If device is not found, return undefined
+    return undefined;
 };

package/dist/calibration.js

@@ -1,6 +1,6 @@
 import { isConnected } from "./is-connected";
 import { write } from "./write";
-import { Motherboard } from "./devices";
+import { isMotherboard } from "./is-device";
 import { MotherboardCommands } from "./commands";
 /**
  * Writes a command to get calibration data from the device.
@@ -11,9 +11,9 @@ export const calibration = async (board) => {
     // Check if the device is connected
     if (isConnected(board)) {
         // If the device is connected, and it is a Motherboard device
-        if (board.filters.some((filter) => filter.name === "Motherboard")) {
+        if (isMotherboard(board)) {
             // Write the command to get calibration data to the device
-            await write(Motherboard, "uart", "tx", MotherboardCommands.GET_CALIBRATION, 2500, (data) => {
+            await write(board, "uart", "tx", MotherboardCommands.GET_CALIBRATION, 2500, (data) => {
                 console.log(data);
             });
         }

package/dist/characteristic.js

@@ -17,4 +17,5 @@ export const getCharacteristic = (board, serviceId, characteristicId) => {
         }
     }
     // Return undefined if the service or characteristic is not found
+    return undefined;
 };

package/dist/connect.js

@@ -1,4 +1,5 @@
 import { handleEntralpiData, handleMotherboardData, handleProgressorData, handleWHC06Data } from "./data";
+import { isEntralpi, isMotherboard, isProgressor } from "./is-device";
 let server;
 const receiveBuffer = [];
 /**
@@ -21,7 +22,7 @@ const handleNotifications = (event, board) => {
     const value = characteristic.value;
     if (value) {
         // If the device is connected and it is a Motherboard device
-        if (board.filters.some((filter) => filter.name === "Motherboard")) {
+        if (isMotherboard(board)) {
             for (let i = 0; i < value.byteLength; i++) {
                 receiveBuffer.push(value.getUint8(i));
             }
@@ -35,7 +36,7 @@ const handleNotifications = (event, board) => {
                 handleMotherboardData(receivedData);
             }
         }
-        else if (board.filters.some((filter) => filter.name === "ENTRALPI")) {
+        else if (isEntralpi(board)) {
             if (value.buffer) {
                 const buffer = value.buffer;
                 const rawData = new DataView(buffer);
@@ -43,7 +44,7 @@ const handleNotifications = (event, board) => {
                 handleEntralpiData(receivedData);
             }
         }
-        else if (board.filters.some((filter) => filter.namePrefix === "Progressor")) {
+        else if (isProgressor(board)) {
             if (value.buffer) {
                 const buffer = value.buffer;
                 const rawData = new DataView(buffer);

package/dist/devices/kilterboard.d.ts

@@ -1,4 +1,8 @@
 import type { Device } from "../types/devices";
+/**
+ * Aurora Climbing Advertising service
+ */
+export declare 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

package/dist/devices/kilterboard.js

@@ -1,3 +1,7 @@
+/**
+ * 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
@@ -5,7 +9,7 @@
 export const KilterBoard = {
     filters: [
         {
-            services: ["4488b571-7806-4df6-bcff-a2897e4953ff"], // Aurora Climbing Advertising service
+            services: [AuroraUUID],
         },
     ],
     services: [

package/dist/disconnect.d.ts

@@ -1,6 +1,8 @@
 import type { Device } from "./types/devices";
 /**
- * Disconnects the device if it is connected.
- * @param {Device} board - The device to disconnect.
+ * Disconnects the device if it is currently connected.
+ * - Checks if the device is connected via its GATT server.
+ * - If the device is connected, it attempts to gracefully disconnect.
+ * @param {Device} board - The device to be disconnected. The device must have a `gatt` property accessible through `board.device`.
  */
 export declare const disconnect: (board: Device) => void;

package/dist/disconnect.js

@@ -1,12 +1,14 @@
 import { isConnected } from "./is-connected";
 /**
- * Disconnects the device if it is connected.
- * @param {Device} board - The device to disconnect.
+ * Disconnects the device if it is currently connected.
+ * - Checks if the device is connected via its GATT server.
+ * - If the device is connected, it attempts to gracefully disconnect.
+ * @param {Device} board - The device to be disconnected. The device must have a `gatt` property accessible through `board.device`.
  */
 export const disconnect = (board) => {
-    // Check if the device is connected
+    // Verify that the device is connected using the provided helper function
     if (isConnected(board)) {
-        // Disconnect the device using optional chaining
+        // Safely attempt to disconnect the device's GATT server, if available
         board.device?.gatt?.disconnect();
     }
 };

package/dist/firmware.d.ts

@@ -6,7 +6,5 @@ import type { Device } from "./types/devices";
  *
  * @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 declare const firmware: (board: Device) => Promise<string | undefined>;

package/dist/firmware.js

@@ -1,8 +1,8 @@
 import { write } from "./write";
 import { read } from "./read";
 import { isConnected } from "./is-connected";
-import { Motherboard, Progressor } from "./devices";
 import { ProgressorCommands } from "./commands";
+import { isMotherboard, isProgressor } from "./is-device";
 /**
  * Retrieves firmware version from the device.
  * - For Motherboard devices, it reads the firmare version.
@@ -10,28 +10,25 @@ import { ProgressorCommands } from "./commands";
  *
  * @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) => {
     // Check if the device is connected
     if (isConnected(board)) {
         // If the device is connected and it is a Motherboard device
-        if (board.filters.some((filter) => filter.name === "Motherboard")) {
+        if (isMotherboard(board)) {
             // Read firmware version from the Motherboard
-            return await read(Motherboard, "device", "firmware", 250);
+            return await read(board, "device", "firmware", 250);
         }
         // If the device is connected and its name starts with "Progressor"
-        if (board.filters.some((filter) => filter.namePrefix === "Progressor")) {
+        if (isProgressor(board)) {
             // Write command to get firmware version information to the Progressor
             let response = undefined;
-            await write(Progressor, "progressor", "tx", ProgressorCommands.GET_FW_VERSION, 250, (data) => {
+            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.");
+    // If device is not found, return undefined
+    return undefined;
 };

package/dist/hardware.d.ts

@@ -5,7 +5,5 @@ import type { Device } from "./types/devices";
  *
  * @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 declare const hardware: (board: Device) => Promise<string | undefined>;

package/dist/hardware.js

@@ -1,25 +1,22 @@
 import { read } from "./read";
 import { isConnected } from "./is-connected";
-import { Motherboard } from "./devices";
+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) => {
     // Check if the device is connected
     if (isConnected(board)) {
         // If the device is connected and it is a Motherboard device
-        if (board.filters.some((filter) => filter.name === "Motherboard")) {
+        if (isMotherboard(board)) {
             // Read hardware version from the Motherboard
-            return await read(Motherboard, "device", "hardware", 250);
+            return await read(board, "device", "hardware", 250);
         }
-        // If device is not found, return undefined
-        return;
     }
-    throw new Error("Not connected.");
+    // If device is not found, return undefined
+    return;
 };

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { Climbro, Entralpi, KilterBoard, Motherboard, mySmartBoard, WHC06, Progressor } from "./devices/index";
+export { isEntralpi, isKilterboard, isMotherboard, isWHC06, isProgressor } from "./is-device";
 export { calibration } from "./calibration";
 export { download } from "./download";
 export { connect } from "./connect";

package/dist/index.js

@@ -1,5 +1,7 @@
 // Export device types
 export { Climbro, Entralpi, KilterBoard, Motherboard, mySmartBoard, WHC06, Progressor } from "./devices/index";
+// Export isDevice functions
+export { isEntralpi, isKilterboard, isMotherboard, isWHC06, isProgressor } from "./is-device";
 // Export calibration function
 export { calibration } from "./calibration";
 // Export download function

package/dist/is-active.d.ts

@@ -9,16 +9,24 @@ type IsActiveCallback = (value: boolean) => void;
  */
 export declare let isActive: boolean;
 /**
- * Sets the callback function to be called when the activity status changes.
+ * Sets the callback function to be called when the activity status changes,
+ * and optionally sets the configuration for threshold and duration.
  *
  * This function allows you to specify a callback that will be invoked whenever
  * the activity status changes, indicating whether the device is currently active.
+ * It also allows optionally configuring the threshold and duration used to determine activity.
  *
  * @param {IsActiveCallback} callback - The callback function to be set. This function
  *                                      receives a boolean value indicating the new activity status.
+ * @param {object} [options] - Optional configuration object containing the threshold and duration.
+ * @param {number} [options.threshold=2.5] - The threshold value for determining activity.
+ * @param {number} [options.duration=1000] - The duration (in milliseconds) to monitor the input for activity.
  * @returns {void}
  */
-export declare const active: (callback: IsActiveCallback) => void;
+export declare const active: (callback: IsActiveCallback, options?: {
+    threshold?: number;
+    duration?: number;
+}) => void;
 /**
  * Checks if a dynamic value is active based on a threshold and duration.
  *
@@ -27,11 +35,7 @@ export declare const active: (callback: IsActiveCallback) => void;
  * 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 declare const checkActivity: (input: number) => Promise<void>;
 export {};

package/dist/is-active.js

@@ -5,17 +5,31 @@ let activeCallback;
  */
 export let isActive = false;
 /**
- * Sets the callback function to be called when the activity status changes.
+ * Configuration for threshold and duration.
+ */
+let config = { threshold: 2.5, duration: 1000 };
+/**
+ * Sets the callback function to be called when the activity status changes,
+ * and optionally sets the configuration for threshold and duration.
  *
  * This function allows you to specify a callback that will be invoked whenever
  * the activity status changes, indicating whether the device is currently active.
+ * It also allows optionally configuring the threshold and duration used to determine activity.
  *
  * @param {IsActiveCallback} callback - The callback function to be set. This function
  *                                      receives a boolean value indicating the new activity status.
+ * @param {object} [options] - Optional configuration object containing the threshold and duration.
+ * @param {number} [options.threshold=2.5] - The threshold value for determining activity.
+ * @param {number} [options.duration=1000] - The duration (in milliseconds) to monitor the input for activity.
  * @returns {void}
  */
-export const active = (callback) => {
+export const active = (callback, options) => {
     activeCallback = callback;
+    // Update the config values only if provided, otherwise use defaults
+    config = {
+        threshold: options?.threshold ?? config.threshold, // Use new threshold if provided, else use default
+        duration: options?.duration ?? config.duration, // Use new duration if provided, else use default
+    };
 };
 /**
  * Checks if a dynamic value is active based on a threshold and duration.
@@ -25,18 +39,14 @@ export const active = (callback) => {
  * 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) => {
+export const checkActivity = (input) => {
     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;
+            // Determine the activity status based on the stored threshold in the config
+            const activeNow = input > config.threshold;
             if (isActive !== activeNow) {
                 isActive = activeNow;
                 if (activeCallback) {
@@ -44,6 +54,6 @@ export const checkActivity = (input, threshold = 2.5, duration = 1000) => {
                 }
             }
             resolve();
-        }, duration);
+        }, config.duration);
     });
 };

package/dist/is-device.d.ts

@@ -0,0 +1,31 @@
+import type { Device } from "./types/devices";
+/**
+ * Checks if the given device is a Motherboard.
+ * @param {Device} [board] - The device to check.
+ * @returns {boolean} `true` if the device has a filter with the name "Motherboard", otherwise `false`.
+ */
+export declare const isMotherboard: (board?: Device) => boolean;
+/**
+ * Checks if the given device is a Progressor.
+ * @param {Device} [board] - The device to check.
+ * @returns {boolean} `true` if the device has a filter with a namePrefix of "Progressor", otherwise `false`.
+ */
+export declare const isProgressor: (board?: Device) => boolean;
+/**
+ * Checks if the given device is an Entralpi device.
+ * @param {Device} [board] - The device to check.
+ * @returns {boolean} `true` if the device has a filter with the name "ENTRALPI", otherwise `false`.
+ */
+export declare const isEntralpi: (board?: Device) => boolean;
+/**
+ * Checks if the given device is a Kilterboard.
+ * @param {Device} [board] - The device to check.
+ * @returns {boolean} `true` if the device has a service UUID matching the Kilterboard Aurora UUID, otherwise `false`.
+ */
+export declare const isKilterboard: (board?: Device) => boolean;
+/**
+ * Checks if the given device is a WH-C06.
+ * @param {Device} [board] - The device to check.
+ * @returns {boolean} `true` if the device has a filter with the company identifier 0x0100, otherwise `false`.
+ */
+export declare const isWHC06: (board?: Device) => boolean;

package/dist/is-device.js

@@ -0,0 +1,33 @@
+import { AuroraUUID } from "./devices/kilterboard";
+/**
+ * Checks if the given device is a Motherboard.
+ * @param {Device} [board] - The device to check.
+ * @returns {boolean} `true` if the device has a filter with the name "Motherboard", otherwise `false`.
+ */
+export const isMotherboard = (board) => board?.filters.some((filter) => filter.name === "Motherboard") ?? false;
+/**
+ * Checks if the given device is a Progressor.
+ * @param {Device} [board] - The device to check.
+ * @returns {boolean} `true` if the device has a filter with a namePrefix of "Progressor", otherwise `false`.
+ */
+export const isProgressor = (board) => board?.filters.some((filter) => filter.namePrefix === "Progressor") ?? false;
+/**
+ * Checks if the given device is an Entralpi device.
+ * @param {Device} [board] - The device to check.
+ * @returns {boolean} `true` if the device has a filter with the name "ENTRALPI", otherwise `false`.
+ */
+export const isEntralpi = (board) => board?.filters.some((filter) => filter.name === "ENTRALPI") ?? false;
+/**
+ * Checks if the given device is a Kilterboard.
+ * @param {Device} [board] - The device to check.
+ * @returns {boolean} `true` if the device has a service UUID matching the Kilterboard Aurora UUID, otherwise `false`.
+ */
+export const isKilterboard = (board) => {
+    return board?.filters.some((filter) => filter.services?.includes(AuroraUUID)) ?? false;
+};
+/**
+ * Checks if the given device is a WH-C06.
+ * @param {Device} [board] - The device to check.
+ * @returns {boolean} `true` if the device has a filter with the company identifier 0x0100, otherwise `false`.
+ */
+export const isWHC06 = (board) => board?.filters.some((filter) => filter.manufacturerData?.some((data) => data.companyIdentifier === 0x0100)) ?? false;

package/dist/led.d.ts

@@ -12,9 +12,13 @@ declare class ClimbPlacement {
 export declare function prepBytesV3(climbPlacementList: ClimbPlacement[]): number[];
 /**
  * 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 {ClimbPlacement[]} [placement] - An optional array of climb placements for LED positioning.
- * @returns {Promise<number[] | undefined>} A promise that resolves with the payload array if LED settings were applied, or `undefined` if no action was taken.
+ * @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 declare const led: (board: Device, placement?: ClimbPlacement[]) => Promise<number[] | undefined>;
+export declare const led: (board: Device, config?: "green" | "red" | "orange" | ClimbPlacement[]) => Promise<number[] | undefined>;
 export {};

package/dist/led.js

@@ -1,7 +1,7 @@
 import { write } from "./write";
 import { isConnected } from "./is-connected";
-import { KilterBoard, Motherboard } from "./devices";
 import { KilterBoardPacket, KilterBoardPlacementRoles } from "./commands/kilterboard";
+import { isKilterboard, isMotherboard } from "./is-device";
 /**
  * Maximum length of the message body for byte wrapping.
  */
@@ -152,44 +152,44 @@ const splitMessages = (buffer) => splitEvery(MAX_BLUETOOTH_MESSAGE_SIZE, buffer)
 /**
  * Sends a series of messages to a device.
  */
-async function writeMessageSeries(messages) {
+async function writeMessageSeries(board, messages) {
     for (const message of messages) {
-        await write(KilterBoard, "uart", "tx", message);
+        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 {ClimbPlacement[]} [placement] - An optional array of climb placements for LED positioning.
- * @returns {Promise<number[] | undefined>} A promise that resolves with the payload array if LED settings were applied, or `undefined` if no action was taken.
+ * @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, placement) => {
-    // Check if the filter contains the Aurora Climbing Advertising service
-    const AuroraUUID = "4488b571-7806-4df6-bcff-a2897e4953ff";
-    if (board.filters.some((filter) => filter.services?.includes(AuroraUUID))) {
-        // The Aurora Boards needs a LED / Postion Placememnet Array
-        if (placement) {
-            // Prepares byte arrays for transmission based on a list of climb placements.
-            const payload = prepBytesV3(placement);
-            // Sends the payload to the device by splitting it into messages and writing each message.
-            if (isConnected(board)) {
-                writeMessageSeries(splitMessages(payload));
-            }
-            return payload;
+export const led = async (board, config) => {
+    // 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;
     }
-    if (board.filters.some((filter) => filter.name === "Motherboard")) {
-        console.log("Green");
-        await write(Motherboard, "led", "red", new Uint8Array([0x00]));
-        await write(Motherboard, "led", "green", new Uint8Array([0x01]), 1250);
-        console.log("Red");
-        await write(Motherboard, "led", "red", new Uint8Array([0x01]));
-        await write(Motherboard, "led", "green", new Uint8Array([0x00]), 1250);
-        console.log("Orage");
-        await write(Motherboard, "led", "red", new Uint8Array([0x01]));
-        await write(Motherboard, "led", "green", new Uint8Array([0x01]), 1250);
-        console.log("Off");
-        await write(Motherboard, "led", "red", new Uint8Array([0x00]));
-        await write(Motherboard, "led", "green", new Uint8Array([0x00]), 1250);
+    // Handle Motherboard logic: set color if provided
+    if (isMotherboard(board)) {
+        const colorMapping = {
+            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 undefined;
 };

package/dist/manufacturer.d.ts

@@ -5,7 +5,5 @@ import type { Device } from "./types/devices";
  *
  * @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 declare const manufacturer: (board: Device) => Promise<string | undefined>;