node-poweredup 9.0.0 → 10.0.0

package/dist/node/protocol.js

@@ -0,0 +1,730 @@
+"use strict";
+/**
+ * PoweredUp Protocol
+ * LEGO Wireless Protocol 3.0 (LWP3) message encoding/decoding
+ * https://lego.github.io/lego-ble-wireless-protocol-docs/
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorCode = exports.ModeInformationType = exports.PortInformationType = exports.MotorSubCommand = exports.AlertOperation = exports.HubAction = exports.HubPropertyOperation = exports.HubProperty = exports.MessageType = exports.BLE_BOOTLOADER_CHARACTERISTIC_UUID = exports.BLE_BOOTLOADER_SERVICE_UUID = exports.BLE_CHARACTERISTIC_UUID = exports.BLE_SERVICE_UUID = void 0;
+exports.decodeMessageLength = decodeMessageLength;
+exports.encodeMessageLength = encodeMessageLength;
+exports.decodeVersion = decodeVersion;
+exports.decodeMACAddress = decodeMACAddress;
+exports.decodeMessage = decodeMessage;
+exports.encodeMessage = encodeMessage;
+exports.createHubPropertyRequest = createHubPropertyRequest;
+exports.createHubPropertySet = createHubPropertySet;
+exports.createHubAction = createHubAction;
+exports.createAlertSubscription = createAlertSubscription;
+exports.createPortInformationRequest = createPortInformationRequest;
+exports.createPortModeInformationRequest = createPortModeInformationRequest;
+exports.createPortInputFormatSetup = createPortInputFormatSetup;
+exports.createVirtualPortSetup = createVirtualPortSetup;
+exports.createStartPower = createStartPower;
+exports.createStartPowerDual = createStartPowerDual;
+exports.createStartSpeed = createStartSpeed;
+exports.createStartSpeedDual = createStartSpeedDual;
+exports.createStartSpeedForTime = createStartSpeedForTime;
+exports.createStartSpeedForDegrees = createStartSpeedForDegrees;
+exports.createGotoAbsolutePosition = createGotoAbsolutePosition;
+exports.createPresetEncoder = createPresetEncoder;
+exports.createSetAccTime = createSetAccTime;
+exports.createSetDecTime = createSetDecTime;
+exports.createSetLEDColor = createSetLEDColor;
+exports.createSetLEDRGB = createSetLEDRGB;
+exports.parseMotorFeedback = parseMotorFeedback;
+exports.parseHubPropertyValue = parseHubPropertyValue;
+const types_1 = require("./types");
+// ============================================================================
+// BLE Service and Characteristic UUIDs
+// ============================================================================
+exports.BLE_SERVICE_UUID = "00001623-1212-efde-1623-785feabcd123";
+exports.BLE_CHARACTERISTIC_UUID = "00001624-1212-efde-1623-785feabcd123";
+exports.BLE_BOOTLOADER_SERVICE_UUID = "00001625-1212-efde-1623-785feabcd123";
+exports.BLE_BOOTLOADER_CHARACTERISTIC_UUID = "00001626-1212-efde-1623-785feabcd123";
+// ============================================================================
+// Message Types
+// https://lego.github.io/lego-ble-wireless-protocol-docs/index.html#message-types
+// ============================================================================
+var MessageType;
+(function (MessageType) {
+    MessageType[MessageType["HUB_PROPERTIES"] = 1] = "HUB_PROPERTIES";
+    MessageType[MessageType["HUB_ACTIONS"] = 2] = "HUB_ACTIONS";
+    MessageType[MessageType["HUB_ALERTS"] = 3] = "HUB_ALERTS";
+    MessageType[MessageType["HUB_ATTACHED_IO"] = 4] = "HUB_ATTACHED_IO";
+    MessageType[MessageType["GENERIC_ERROR_MESSAGES"] = 5] = "GENERIC_ERROR_MESSAGES";
+    MessageType[MessageType["HW_NETWORK_COMMANDS"] = 8] = "HW_NETWORK_COMMANDS";
+    MessageType[MessageType["FW_UPDATE_GO_INTO_BOOT_MODE"] = 16] = "FW_UPDATE_GO_INTO_BOOT_MODE";
+    MessageType[MessageType["FW_UPDATE_LOCK_MEMORY"] = 17] = "FW_UPDATE_LOCK_MEMORY";
+    MessageType[MessageType["FW_UPDATE_LOCK_STATUS_REQUEST"] = 18] = "FW_UPDATE_LOCK_STATUS_REQUEST";
+    MessageType[MessageType["FW_LOCK_STATUS"] = 19] = "FW_LOCK_STATUS";
+    MessageType[MessageType["PORT_INFORMATION_REQUEST"] = 33] = "PORT_INFORMATION_REQUEST";
+    MessageType[MessageType["PORT_MODE_INFORMATION_REQUEST"] = 34] = "PORT_MODE_INFORMATION_REQUEST";
+    MessageType[MessageType["PORT_INPUT_FORMAT_SETUP_SINGLE"] = 65] = "PORT_INPUT_FORMAT_SETUP_SINGLE";
+    MessageType[MessageType["PORT_INPUT_FORMAT_SETUP_COMBINEDMODE"] = 66] = "PORT_INPUT_FORMAT_SETUP_COMBINEDMODE";
+    MessageType[MessageType["PORT_INFORMATION"] = 67] = "PORT_INFORMATION";
+    MessageType[MessageType["PORT_MODE_INFORMATION"] = 68] = "PORT_MODE_INFORMATION";
+    MessageType[MessageType["PORT_VALUE_SINGLE"] = 69] = "PORT_VALUE_SINGLE";
+    MessageType[MessageType["PORT_VALUE_COMBINEDMODE"] = 70] = "PORT_VALUE_COMBINEDMODE";
+    MessageType[MessageType["PORT_INPUT_FORMAT_SINGLE"] = 71] = "PORT_INPUT_FORMAT_SINGLE";
+    MessageType[MessageType["PORT_INPUT_FORMAT_COMBINEDMODE"] = 72] = "PORT_INPUT_FORMAT_COMBINEDMODE";
+    MessageType[MessageType["VIRTUAL_PORT_SETUP"] = 97] = "VIRTUAL_PORT_SETUP";
+    MessageType[MessageType["PORT_OUTPUT_COMMAND"] = 129] = "PORT_OUTPUT_COMMAND";
+    MessageType[MessageType["PORT_OUTPUT_COMMAND_FEEDBACK"] = 130] = "PORT_OUTPUT_COMMAND_FEEDBACK";
+})(MessageType || (exports.MessageType = MessageType = {}));
+// ============================================================================
+// Hub Property References
+// ============================================================================
+var HubProperty;
+(function (HubProperty) {
+    HubProperty[HubProperty["ADVERTISING_NAME"] = 1] = "ADVERTISING_NAME";
+    HubProperty[HubProperty["BUTTON"] = 2] = "BUTTON";
+    HubProperty[HubProperty["FW_VERSION"] = 3] = "FW_VERSION";
+    HubProperty[HubProperty["HW_VERSION"] = 4] = "HW_VERSION";
+    HubProperty[HubProperty["RSSI"] = 5] = "RSSI";
+    HubProperty[HubProperty["BATTERY_VOLTAGE"] = 6] = "BATTERY_VOLTAGE";
+    HubProperty[HubProperty["BATTERY_TYPE"] = 7] = "BATTERY_TYPE";
+    HubProperty[HubProperty["MANUFACTURER_NAME"] = 8] = "MANUFACTURER_NAME";
+    HubProperty[HubProperty["RADIO_FIRMWARE_VERSION"] = 9] = "RADIO_FIRMWARE_VERSION";
+    HubProperty[HubProperty["LWP_PROTOCOL_VERSION"] = 10] = "LWP_PROTOCOL_VERSION";
+    HubProperty[HubProperty["SYSTEM_TYPE_ID"] = 11] = "SYSTEM_TYPE_ID";
+    HubProperty[HubProperty["HW_NETWORK_ID"] = 12] = "HW_NETWORK_ID";
+    HubProperty[HubProperty["PRIMARY_MAC_ADDRESS"] = 13] = "PRIMARY_MAC_ADDRESS";
+    HubProperty[HubProperty["SECONDARY_MAC_ADDRESS"] = 14] = "SECONDARY_MAC_ADDRESS";
+    HubProperty[HubProperty["HW_NETWORK_FAMILY"] = 15] = "HW_NETWORK_FAMILY";
+})(HubProperty || (exports.HubProperty = HubProperty = {}));
+var HubPropertyOperation;
+(function (HubPropertyOperation) {
+    HubPropertyOperation[HubPropertyOperation["SET"] = 1] = "SET";
+    HubPropertyOperation[HubPropertyOperation["ENABLE_UPDATES"] = 2] = "ENABLE_UPDATES";
+    HubPropertyOperation[HubPropertyOperation["DISABLE_UPDATES"] = 3] = "DISABLE_UPDATES";
+    HubPropertyOperation[HubPropertyOperation["RESET"] = 4] = "RESET";
+    HubPropertyOperation[HubPropertyOperation["REQUEST_UPDATE"] = 5] = "REQUEST_UPDATE";
+    HubPropertyOperation[HubPropertyOperation["UPDATE"] = 6] = "UPDATE";
+})(HubPropertyOperation || (exports.HubPropertyOperation = HubPropertyOperation = {}));
+// ============================================================================
+// Hub Actions
+// ============================================================================
+var HubAction;
+(function (HubAction) {
+    HubAction[HubAction["SWITCH_OFF_HUB"] = 1] = "SWITCH_OFF_HUB";
+    HubAction[HubAction["DISCONNECT"] = 2] = "DISCONNECT";
+    HubAction[HubAction["VCC_PORT_CONTROL_ON"] = 3] = "VCC_PORT_CONTROL_ON";
+    HubAction[HubAction["VCC_PORT_CONTROL_OFF"] = 4] = "VCC_PORT_CONTROL_OFF";
+    HubAction[HubAction["ACTIVATE_BUSY_INDICATION"] = 5] = "ACTIVATE_BUSY_INDICATION";
+    HubAction[HubAction["RESET_BUSY_INDICATION"] = 6] = "RESET_BUSY_INDICATION";
+    HubAction[HubAction["SHUTDOWN"] = 47] = "SHUTDOWN";
+    HubAction[HubAction["HUB_WILL_SWITCH_OFF"] = 48] = "HUB_WILL_SWITCH_OFF";
+    HubAction[HubAction["HUB_WILL_DISCONNECT"] = 49] = "HUB_WILL_DISCONNECT";
+    HubAction[HubAction["HUB_WILL_GO_INTO_BOOT_MODE"] = 50] = "HUB_WILL_GO_INTO_BOOT_MODE";
+})(HubAction || (exports.HubAction = HubAction = {}));
+// ============================================================================
+// Alert Operations
+// ============================================================================
+var AlertOperation;
+(function (AlertOperation) {
+    AlertOperation[AlertOperation["ENABLE_UPDATE"] = 1] = "ENABLE_UPDATE";
+    AlertOperation[AlertOperation["DISABLE_UPDATE"] = 2] = "DISABLE_UPDATE";
+    AlertOperation[AlertOperation["REQUEST_UPDATE"] = 3] = "REQUEST_UPDATE";
+    AlertOperation[AlertOperation["UPDATE"] = 4] = "UPDATE";
+})(AlertOperation || (exports.AlertOperation = AlertOperation = {}));
+// ============================================================================
+// Port Output Sub-Commands
+// ============================================================================
+var MotorSubCommand;
+(function (MotorSubCommand) {
+    MotorSubCommand[MotorSubCommand["START_POWER"] = 1] = "START_POWER";
+    MotorSubCommand[MotorSubCommand["START_POWER_DUAL"] = 2] = "START_POWER_DUAL";
+    MotorSubCommand[MotorSubCommand["SET_ACC_TIME"] = 5] = "SET_ACC_TIME";
+    MotorSubCommand[MotorSubCommand["SET_DEC_TIME"] = 6] = "SET_DEC_TIME";
+    MotorSubCommand[MotorSubCommand["START_SPEED"] = 7] = "START_SPEED";
+    MotorSubCommand[MotorSubCommand["START_SPEED_DUAL"] = 8] = "START_SPEED_DUAL";
+    MotorSubCommand[MotorSubCommand["START_SPEED_FOR_TIME"] = 9] = "START_SPEED_FOR_TIME";
+    MotorSubCommand[MotorSubCommand["START_SPEED_FOR_TIME_DUAL"] = 10] = "START_SPEED_FOR_TIME_DUAL";
+    MotorSubCommand[MotorSubCommand["START_SPEED_FOR_DEGREES"] = 11] = "START_SPEED_FOR_DEGREES";
+    MotorSubCommand[MotorSubCommand["START_SPEED_FOR_DEGREES_DUAL"] = 12] = "START_SPEED_FOR_DEGREES_DUAL";
+    MotorSubCommand[MotorSubCommand["GOTO_ABSOLUTE_POSITION"] = 13] = "GOTO_ABSOLUTE_POSITION";
+    MotorSubCommand[MotorSubCommand["GOTO_ABSOLUTE_POSITION_DUAL"] = 14] = "GOTO_ABSOLUTE_POSITION_DUAL";
+    MotorSubCommand[MotorSubCommand["PRESET_ENCODER"] = 19] = "PRESET_ENCODER";
+    MotorSubCommand[MotorSubCommand["PRESET_ENCODER_DUAL"] = 20] = "PRESET_ENCODER_DUAL";
+    MotorSubCommand[MotorSubCommand["WRITE_DIRECT"] = 80] = "WRITE_DIRECT";
+    MotorSubCommand[MotorSubCommand["WRITE_DIRECT_MODE_DATA"] = 81] = "WRITE_DIRECT_MODE_DATA";
+})(MotorSubCommand || (exports.MotorSubCommand = MotorSubCommand = {}));
+// ============================================================================
+// Port Information Types
+// ============================================================================
+var PortInformationType;
+(function (PortInformationType) {
+    PortInformationType[PortInformationType["PORT_VALUE"] = 0] = "PORT_VALUE";
+    PortInformationType[PortInformationType["MODE_INFO"] = 1] = "MODE_INFO";
+    PortInformationType[PortInformationType["POSSIBLE_MODE_COMBINATIONS"] = 2] = "POSSIBLE_MODE_COMBINATIONS";
+})(PortInformationType || (exports.PortInformationType = PortInformationType = {}));
+var ModeInformationType;
+(function (ModeInformationType) {
+    ModeInformationType[ModeInformationType["NAME"] = 0] = "NAME";
+    ModeInformationType[ModeInformationType["RAW"] = 1] = "RAW";
+    ModeInformationType[ModeInformationType["PCT"] = 2] = "PCT";
+    ModeInformationType[ModeInformationType["SI"] = 3] = "SI";
+    ModeInformationType[ModeInformationType["SYMBOL"] = 4] = "SYMBOL";
+    ModeInformationType[ModeInformationType["MAPPING"] = 5] = "MAPPING";
+    ModeInformationType[ModeInformationType["MOTOR_BIAS"] = 7] = "MOTOR_BIAS";
+    ModeInformationType[ModeInformationType["CAPABILITY_BITS"] = 8] = "CAPABILITY_BITS";
+    ModeInformationType[ModeInformationType["VALUE_FORMAT"] = 128] = "VALUE_FORMAT";
+})(ModeInformationType || (exports.ModeInformationType = ModeInformationType = {}));
+// ============================================================================
+// Error Codes
+// ============================================================================
+var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode[ErrorCode["ACK"] = 1] = "ACK";
+    ErrorCode[ErrorCode["MACK"] = 2] = "MACK";
+    ErrorCode[ErrorCode["BUFFER_OVERFLOW"] = 3] = "BUFFER_OVERFLOW";
+    ErrorCode[ErrorCode["TIMEOUT"] = 4] = "TIMEOUT";
+    ErrorCode[ErrorCode["COMMAND_NOT_RECOGNIZED"] = 5] = "COMMAND_NOT_RECOGNIZED";
+    ErrorCode[ErrorCode["INVALID_USE"] = 6] = "INVALID_USE";
+    ErrorCode[ErrorCode["OVERCURRENT"] = 7] = "OVERCURRENT";
+    ErrorCode[ErrorCode["INTERNAL_ERROR"] = 8] = "INTERNAL_ERROR";
+})(ErrorCode || (exports.ErrorCode = ErrorCode = {}));
+// ============================================================================
+// Message Decoding
+// ============================================================================
+/**
+ * Decode the message length from raw bytes
+ * Messages longer than 127 bytes use two-byte length encoding
+ */
+function decodeMessageLength(data) {
+    if (data.length === 0) {
+        return { length: 0, headerSize: 0 };
+    }
+    const firstByte = data[0];
+    if ((firstByte & 0x80) === 0) {
+        // Single byte length
+        return { length: firstByte, headerSize: 1 };
+    }
+    else {
+        // Two byte length
+        if (data.length < 2) {
+            return { length: 0, headerSize: 0 };
+        }
+        const length = (firstByte & 0x7f) | (data[1] << 7);
+        return { length, headerSize: 2 };
+    }
+}
+/**
+ * Encode message length as header bytes
+ */
+function encodeMessageLength(length) {
+    if (length < 128) {
+        return Buffer.from([length]);
+    }
+    else {
+        return Buffer.from([(length & 0x7f) | 0x80, (length >> 7) & 0xff]);
+    }
+}
+/**
+ * Decode a version number from 4 bytes (BCD encoded)
+ */
+function decodeVersion(data, offset = 0) {
+    if (data.length < offset + 4) {
+        return "0.0.00.0000";
+    }
+    const byte3 = data[offset + 3];
+    const byte2 = data[offset + 2];
+    const byte1 = data[offset + 1];
+    const byte0 = data[offset];
+    const major = (byte3 >> 4) & 0x07;
+    const minor = byte3 & 0x0f;
+    const bugfix = ((byte2 >> 4) * 10) + (byte2 & 0x0f);
+    const build = ((byte1 >> 4) * 1000) + ((byte1 & 0x0f) * 100) + ((byte0 >> 4) * 10) + (byte0 & 0x0f);
+    return `${major}.${minor}.${bugfix.toString().padStart(2, "0")}.${build.toString().padStart(4, "0")}`;
+}
+/**
+ * Decode a MAC address from 6 bytes
+ */
+function decodeMACAddress(data, offset = 0) {
+    if (data.length < offset + 6) {
+        return "00:00:00:00:00:00";
+    }
+    const bytes = [];
+    for (let i = 0; i < 6; i++) {
+        bytes.push(data[offset + i].toString(16).padStart(2, "0").toUpperCase());
+    }
+    return bytes.join(":");
+}
+/**
+ * Decode a complete LWP3 message
+ */
+function decodeMessage(data) {
+    const { length, headerSize } = decodeMessageLength(data);
+    if (length === 0 || data.length < length) {
+        return null;
+    }
+    // Hub ID is at headerSize (always 0x00 for now), message type is at headerSize + 1
+    const messageType = data[headerSize + 1];
+    switch (messageType) {
+        case MessageType.HUB_PROPERTIES:
+            return decodeHubPropertyMessage(data, headerSize);
+        case MessageType.HUB_ACTIONS:
+            return decodeHubActionMessage(data, headerSize);
+        case MessageType.HUB_ALERTS:
+            return decodeHubAlertMessage(data, headerSize);
+        case MessageType.HUB_ATTACHED_IO:
+            return decodeAttachedIOMessage(data, headerSize);
+        case MessageType.GENERIC_ERROR_MESSAGES:
+            return decodeGenericErrorMessage(data, headerSize);
+        case MessageType.PORT_INFORMATION:
+            return decodePortInformationMessage(data, headerSize);
+        case MessageType.PORT_MODE_INFORMATION:
+            return decodePortModeInformationMessage(data, headerSize);
+        case MessageType.PORT_VALUE_SINGLE:
+            return decodePortValueSingleMessage(data, headerSize);
+        case MessageType.PORT_VALUE_COMBINEDMODE:
+            return decodePortValueCombinedMessage(data, headerSize);
+        case MessageType.PORT_INPUT_FORMAT_SINGLE:
+            return decodePortInputFormatSingleMessage(data, headerSize);
+        case MessageType.PORT_INPUT_FORMAT_COMBINEDMODE:
+            return decodePortInputFormatCombinedMessage(data, headerSize);
+        case MessageType.PORT_OUTPUT_COMMAND_FEEDBACK:
+            return decodePortOutputFeedbackMessage(data, headerSize);
+        default:
+            return null;
+    }
+}
+function decodeHubPropertyMessage(data, headerSize) {
+    return {
+        type: MessageType.HUB_PROPERTIES,
+        property: data[headerSize + 2],
+        operation: data[headerSize + 3],
+        payload: data.subarray(headerSize + 4),
+    };
+}
+function decodeHubActionMessage(data, headerSize) {
+    return {
+        type: MessageType.HUB_ACTIONS,
+        action: data[headerSize + 2],
+    };
+}
+function decodeHubAlertMessage(data, headerSize) {
+    return {
+        type: MessageType.HUB_ALERTS,
+        alertType: data[headerSize + 2],
+        operation: data[headerSize + 3],
+        payload: data.length > headerSize + 4 ? data[headerSize + 4] : 0,
+    };
+}
+function decodeAttachedIOMessage(data, headerSize) {
+    const portId = data[headerSize + 2];
+    const event = data[headerSize + 3];
+    const message = {
+        type: MessageType.HUB_ATTACHED_IO,
+        portId,
+        event,
+        deviceType: types_1.DeviceType.UNKNOWN,
+    };
+    if (event === types_1.PortEvent.ATTACHED) {
+        message.deviceType = data.readUInt16LE(headerSize + 4);
+        if (data.length >= headerSize + 12) {
+            message.hardwareRevision = decodeVersion(data, headerSize + 6);
+            message.softwareRevision = decodeVersion(data, headerSize + 10);
+        }
+    }
+    else if (event === types_1.PortEvent.ATTACHED_VIRTUAL) {
+        message.deviceType = data.readUInt16LE(headerSize + 4);
+        message.portIdA = data[headerSize + 6];
+        message.portIdB = data[headerSize + 7];
+    }
+    return message;
+}
+function decodeGenericErrorMessage(data, headerSize) {
+    return {
+        type: MessageType.GENERIC_ERROR_MESSAGES,
+        commandType: data[headerSize + 2],
+        errorCode: data[headerSize + 3],
+    };
+}
+function decodePortInformationMessage(data, headerSize) {
+    const portId = data[headerSize + 2];
+    const informationType = data[headerSize + 3];
+    const message = {
+        type: MessageType.PORT_INFORMATION,
+        portId,
+        informationType,
+    };
+    if (informationType === PortInformationType.MODE_INFO) {
+        message.capabilities = data[headerSize + 4];
+        message.modeCount = data[headerSize + 5];
+        message.inputModes = data.readUInt16LE(headerSize + 6);
+        message.outputModes = data.readUInt16LE(headerSize + 8);
+    }
+    else if (informationType === PortInformationType.POSSIBLE_MODE_COMBINATIONS) {
+        const combinations = [];
+        for (let i = headerSize + 4; i < data.length; i += 2) {
+            if (i + 1 < data.length) {
+                combinations.push(data.readUInt16LE(i));
+            }
+        }
+        message.modeCombinations = combinations;
+    }
+    return message;
+}
+function decodePortModeInformationMessage(data, headerSize) {
+    const portId = data[headerSize + 2];
+    const mode = data[headerSize + 3];
+    const informationType = data[headerSize + 4];
+    const message = {
+        type: MessageType.PORT_MODE_INFORMATION,
+        portId,
+        mode,
+        informationType,
+    };
+    const payload = data.subarray(headerSize + 5);
+    switch (informationType) {
+        case ModeInformationType.NAME:
+            message.name = payload.toString("ascii").replace(/\0+$/, "");
+            break;
+        case ModeInformationType.RAW:
+            message.rawRange = {
+                min: payload.readFloatLE(0),
+                max: payload.readFloatLE(4),
+            };
+            break;
+        case ModeInformationType.PCT:
+            message.pctRange = {
+                min: payload.readFloatLE(0),
+                max: payload.readFloatLE(4),
+            };
+            break;
+        case ModeInformationType.SI:
+            message.siRange = {
+                min: payload.readFloatLE(0),
+                max: payload.readFloatLE(4),
+            };
+            break;
+        case ModeInformationType.SYMBOL:
+            message.symbol = payload.toString("ascii").replace(/\0+$/, "");
+            break;
+        case ModeInformationType.MAPPING:
+            message.mapping = payload.readUInt16LE(0);
+            break;
+        case ModeInformationType.MOTOR_BIAS:
+            message.motorBias = payload[0];
+            break;
+        case ModeInformationType.CAPABILITY_BITS:
+            message.capabilityBits = payload.subarray(0, 6);
+            break;
+        case ModeInformationType.VALUE_FORMAT:
+            message.valueFormat = {
+                datasetCount: payload[0],
+                datasetType: payload[1],
+                figures: payload[2],
+                decimals: payload[3],
+            };
+            break;
+    }
+    return message;
+}
+function decodePortValueSingleMessage(data, headerSize) {
+    return {
+        type: MessageType.PORT_VALUE_SINGLE,
+        portId: data[headerSize + 2],
+        value: data.subarray(headerSize + 3),
+    };
+}
+function decodePortValueCombinedMessage(data, headerSize) {
+    return {
+        type: MessageType.PORT_VALUE_COMBINEDMODE,
+        portId: data[headerSize + 2],
+        modeDatasets: data.readUInt16LE(headerSize + 3),
+        values: data.subarray(headerSize + 5),
+    };
+}
+function decodePortInputFormatSingleMessage(data, headerSize) {
+    return {
+        type: MessageType.PORT_INPUT_FORMAT_SINGLE,
+        portId: data[headerSize + 2],
+        mode: data[headerSize + 3],
+        deltaInterval: data.readUInt32LE(headerSize + 4),
+        notificationEnabled: data[headerSize + 8] === 1,
+    };
+}
+function decodePortInputFormatCombinedMessage(data, headerSize) {
+    return {
+        type: MessageType.PORT_INPUT_FORMAT_COMBINEDMODE,
+        portId: data[headerSize + 2],
+        combinedControl: data[headerSize + 3],
+        modeDatasetPointer: data.readUInt16LE(headerSize + 4),
+    };
+}
+function decodePortOutputFeedbackMessage(data, headerSize) {
+    return {
+        type: MessageType.PORT_OUTPUT_COMMAND_FEEDBACK,
+        portId: data[headerSize + 2],
+        feedback: data[headerSize + 3],
+    };
+}
+// ============================================================================
+// Message Encoding
+// ============================================================================
+/**
+ * Wrap payload with LWP3 message header
+ */
+function encodeMessage(messageType, payload) {
+    const length = 3 + payload.length; // length byte(s) + hub ID (0x00) + message type + payload
+    const header = encodeMessageLength(length);
+    return Buffer.concat([
+        header,
+        Buffer.from([0x00, messageType]),
+        payload,
+    ]);
+}
+/**
+ * Create hub property request message
+ */
+function createHubPropertyRequest(property, operation) {
+    return encodeMessage(MessageType.HUB_PROPERTIES, Buffer.from([property, operation]));
+}
+/**
+ * Create hub property set message (for writable properties)
+ */
+function createHubPropertySet(property, value) {
+    return encodeMessage(MessageType.HUB_PROPERTIES, Buffer.concat([Buffer.from([property, HubPropertyOperation.SET]), value]));
+}
+/**
+ * Create hub action message
+ */
+function createHubAction(action) {
+    return encodeMessage(MessageType.HUB_ACTIONS, Buffer.from([action]));
+}
+/**
+ * Create alert subscription message
+ */
+function createAlertSubscription(alertType, enable) {
+    return encodeMessage(MessageType.HUB_ALERTS, Buffer.from([alertType, enable ? AlertOperation.ENABLE_UPDATE : AlertOperation.DISABLE_UPDATE]));
+}
+/**
+ * Create port information request message
+ */
+function createPortInformationRequest(portId, informationType) {
+    return encodeMessage(MessageType.PORT_INFORMATION_REQUEST, Buffer.from([portId, informationType]));
+}
+/**
+ * Create port mode information request message
+ */
+function createPortModeInformationRequest(portId, mode, infoType) {
+    return encodeMessage(MessageType.PORT_MODE_INFORMATION_REQUEST, Buffer.from([portId, mode, infoType]));
+}
+/**
+ * Create port input format setup (subscribe/unsubscribe to notifications)
+ */
+function createPortInputFormatSetup(portId, mode, deltaInterval, notificationEnabled) {
+    const payload = Buffer.alloc(8);
+    payload[0] = portId;
+    payload[1] = mode;
+    payload.writeUInt32LE(deltaInterval, 2);
+    payload[6] = notificationEnabled ? 1 : 0;
+    return encodeMessage(MessageType.PORT_INPUT_FORMAT_SETUP_SINGLE, payload);
+}
+/**
+ * Create virtual port setup message (connect/disconnect)
+ */
+function createVirtualPortSetup(connect, portIdA, portIdB, virtualPortId) {
+    if (connect && portIdB !== undefined) {
+        return encodeMessage(MessageType.VIRTUAL_PORT_SETUP, Buffer.from([0x01, portIdA, portIdB]));
+    }
+    else if (!connect && virtualPortId !== undefined) {
+        return encodeMessage(MessageType.VIRTUAL_PORT_SETUP, Buffer.from([0x00, virtualPortId]));
+    }
+    throw new Error("Invalid virtual port setup parameters");
+}
+// ============================================================================
+// Port Output Commands
+// ============================================================================
+/**
+ * Create port output command wrapper
+ */
+function createPortOutputCommand(portId, startupCompletion, subCommand, payload) {
+    return encodeMessage(MessageType.PORT_OUTPUT_COMMAND, Buffer.concat([Buffer.from([portId, startupCompletion, subCommand]), payload]));
+}
+/**
+ * Set motor power (unregulated)
+ */
+function createStartPower(portId, power) {
+    // Clamp power to -100..100
+    power = Math.max(-100, Math.min(100, power));
+    const signedPower = power < 0 ? 256 + power : power;
+    return createPortOutputCommand(portId, 0x11, // Execute immediately, command feedback
+    MotorSubCommand.WRITE_DIRECT_MODE_DATA, Buffer.from([0x00, signedPower]) // Mode 0 = power
+    );
+}
+/**
+ * Set motor power for dual motors (virtual port)
+ */
+function createStartPowerDual(portId, power1, power2) {
+    power1 = Math.max(-100, Math.min(100, power1));
+    power2 = Math.max(-100, Math.min(100, power2));
+    const signedPower1 = power1 < 0 ? 256 + power1 : power1;
+    const signedPower2 = power2 < 0 ? 256 + power2 : power2;
+    return createPortOutputCommand(portId, 0x11, MotorSubCommand.START_POWER_DUAL, Buffer.from([signedPower1, signedPower2]));
+}
+/**
+ * Set motor speed (regulated)
+ */
+function createStartSpeed(portId, speed, maxPower = 100, useProfile = types_1.Profile.DO_NOT_USE) {
+    speed = Math.max(-100, Math.min(100, speed));
+    maxPower = Math.max(0, Math.min(100, maxPower));
+    const signedSpeed = speed < 0 ? 256 + speed : speed;
+    return createPortOutputCommand(portId, 0x11, MotorSubCommand.START_SPEED, Buffer.from([signedSpeed, maxPower, useProfile]));
+}
+/**
+ * Set motor speed for dual motors (virtual port)
+ */
+function createStartSpeedDual(portId, speed1, speed2, maxPower = 100, useProfile = types_1.Profile.DO_NOT_USE) {
+    speed1 = Math.max(-100, Math.min(100, speed1));
+    speed2 = Math.max(-100, Math.min(100, speed2));
+    maxPower = Math.max(0, Math.min(100, maxPower));
+    const signedSpeed1 = speed1 < 0 ? 256 + speed1 : speed1;
+    const signedSpeed2 = speed2 < 0 ? 256 + speed2 : speed2;
+    return createPortOutputCommand(portId, 0x11, MotorSubCommand.START_SPEED_DUAL, Buffer.from([signedSpeed1, signedSpeed2, maxPower, useProfile]));
+}
+/**
+ * Run motor for a specified time
+ */
+function createStartSpeedForTime(portId, time, speed, maxPower = 100, endState = types_1.BrakingStyle.BRAKE, useProfile = types_1.Profile.DO_NOT_USE) {
+    speed = Math.max(-100, Math.min(100, speed));
+    maxPower = Math.max(0, Math.min(100, maxPower));
+    const signedSpeed = speed < 0 ? 256 + speed : speed;
+    const payload = Buffer.alloc(6);
+    payload.writeUInt16LE(time, 0);
+    payload[2] = signedSpeed;
+    payload[3] = maxPower;
+    payload[4] = endState;
+    payload[5] = useProfile;
+    return createPortOutputCommand(portId, 0x11, MotorSubCommand.START_SPEED_FOR_TIME, payload);
+}
+/**
+ * Run motor for a specified number of degrees
+ */
+function createStartSpeedForDegrees(portId, degrees, speed, maxPower = 100, endState = types_1.BrakingStyle.BRAKE, useProfile = types_1.Profile.DO_NOT_USE) {
+    speed = Math.max(-100, Math.min(100, speed));
+    maxPower = Math.max(0, Math.min(100, maxPower));
+    const signedSpeed = speed < 0 ? 256 + speed : speed;
+    const payload = Buffer.alloc(8);
+    payload.writeInt32LE(Math.abs(degrees), 0);
+    payload[4] = signedSpeed;
+    payload[5] = maxPower;
+    payload[6] = endState;
+    payload[7] = useProfile;
+    return createPortOutputCommand(portId, 0x11, MotorSubCommand.START_SPEED_FOR_DEGREES, payload);
+}
+/**
+ * Go to absolute position
+ */
+function createGotoAbsolutePosition(portId, position, speed, maxPower = 100, endState = types_1.BrakingStyle.BRAKE, useProfile = types_1.Profile.DO_NOT_USE) {
+    speed = Math.max(0, Math.min(100, Math.abs(speed)));
+    maxPower = Math.max(0, Math.min(100, maxPower));
+    const payload = Buffer.alloc(8);
+    payload.writeInt32LE(position, 0);
+    payload[4] = speed;
+    payload[5] = maxPower;
+    payload[6] = endState;
+    payload[7] = useProfile;
+    return createPortOutputCommand(portId, 0x11, MotorSubCommand.GOTO_ABSOLUTE_POSITION, payload);
+}
+/**
+ * Preset (reset) encoder position
+ */
+function createPresetEncoder(portId, position = 0) {
+    const payload = Buffer.alloc(4);
+    payload.writeInt32LE(position, 0);
+    return createPortOutputCommand(portId, 0x11, MotorSubCommand.WRITE_DIRECT_MODE_DATA, Buffer.concat([Buffer.from([0x02]), payload]) // Mode 2 = position preset
+    );
+}
+/**
+ * Set acceleration time
+ */
+function createSetAccTime(portId, time, profileNumber = 0) {
+    const payload = Buffer.alloc(3);
+    payload.writeUInt16LE(time, 0);
+    payload[2] = profileNumber;
+    return createPortOutputCommand(portId, 0x11, MotorSubCommand.SET_ACC_TIME, payload);
+}
+/**
+ * Set deceleration time
+ */
+function createSetDecTime(portId, time, profileNumber = 0) {
+    const payload = Buffer.alloc(3);
+    payload.writeUInt16LE(time, 0);
+    payload[2] = profileNumber;
+    return createPortOutputCommand(portId, 0x11, MotorSubCommand.SET_DEC_TIME, payload);
+}
+// ============================================================================
+// LED Commands
+// ============================================================================
+/**
+ * Set LED color by color number
+ */
+function createSetLEDColor(portId, color) {
+    return createPortOutputCommand(portId, 0x11, MotorSubCommand.WRITE_DIRECT_MODE_DATA, Buffer.from([0x00, color]) // Mode 0 = color number
+    );
+}
+/**
+ * Set LED color by RGB values
+ */
+function createSetLEDRGB(portId, red, green, blue) {
+    red = Math.max(0, Math.min(255, red));
+    green = Math.max(0, Math.min(255, green));
+    blue = Math.max(0, Math.min(255, blue));
+    return createPortOutputCommand(portId, 0x11, MotorSubCommand.WRITE_DIRECT_MODE_DATA, Buffer.from([0x01, red, green, blue]) // Mode 1 = RGB
+    );
+}
+// ============================================================================
+// Utility Functions
+// ============================================================================
+/**
+ * Parse motor feedback flags
+ */
+function parseMotorFeedback(feedback) {
+    return {
+        portId: 0, // To be set by caller
+        busy: (feedback & 0x01) !== 0,
+        completed: (feedback & 0x02) !== 0,
+        discarded: (feedback & 0x04) !== 0,
+    };
+}
+/**
+ * Convert hub property payload to typed value
+ */
+function parseHubPropertyValue(property, payload) {
+    switch (property) {
+        case HubProperty.ADVERTISING_NAME:
+            return payload.toString("ascii").replace(/\0+$/, "");
+        case HubProperty.BUTTON:
+            return payload[0] === 1 ? types_1.ButtonState.PRESSED : types_1.ButtonState.RELEASED;
+        case HubProperty.FW_VERSION:
+        case HubProperty.HW_VERSION:
+            return decodeVersion(payload);
+        case HubProperty.RSSI:
+            return payload.readInt8(0);
+        case HubProperty.BATTERY_VOLTAGE:
+            return payload[0];
+        case HubProperty.BATTERY_TYPE:
+            return payload[0];
+        case HubProperty.MANUFACTURER_NAME:
+        case HubProperty.RADIO_FIRMWARE_VERSION:
+            return payload.toString("ascii").replace(/\0+$/, "");
+        case HubProperty.LWP_PROTOCOL_VERSION:
+            return `${(payload[1] >> 4) & 0x0f}${payload[1] & 0x0f}.${(payload[0] >> 4) & 0x0f}${payload[0] & 0x0f}`;
+        case HubProperty.SYSTEM_TYPE_ID:
+            return payload[0];
+        case HubProperty.HW_NETWORK_ID:
+            return payload[0];
+        case HubProperty.PRIMARY_MAC_ADDRESS:
+        case HubProperty.SECONDARY_MAC_ADDRESS:
+            return decodeMACAddress(payload);
+        case HubProperty.HW_NETWORK_FAMILY:
+            return payload[0];
+        default:
+            return payload;
+    }
+}
+//# sourceMappingURL=protocol.js.map