node-poweredup 9.0.0 → 10.0.0

package/dist/node/hub.js

@@ -0,0 +1,778 @@
+"use strict";
+/**
+ * Hub - Main hub class for LEGO Powered UP hubs
+ *
+ * Follows the event-driven pattern from node-coral/node-wedo/node-controllab.
+ * Hubs emit device attach/detach events when peripherals are connected/disconnected.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuploTrainBase = exports.RemoteControl = exports.TechnicMediumHub = exports.MoveHub = exports.WeDo2Hub = exports.LWP3Hub = exports.BaseHub = void 0;
+exports.createHub = createHub;
+const events_1 = require("events");
+const types_1 = require("./types");
+const connection_1 = require("./connection");
+const Protocol = __importStar(require("./protocol"));
+const WeDo2Protocol = __importStar(require("./protocol-wedo"));
+const commands = __importStar(require("./commands"));
+const devices_1 = require("./devices");
+// ============================================================================
+// Hub Base Class
+// ============================================================================
+/**
+ * Base class for all LEGO Powered UP hubs
+ */
+class BaseHub extends events_1.EventEmitter {
+    constructor(peripheral, hubType) {
+        super();
+        this._ports = new Map();
+        this._devices = new Map(); // Registered device instances
+        this._isConnected = false;
+        this._peripheral = peripheral;
+        this.hubType = hubType;
+        this._properties = {
+            name: peripheral.name || "",
+            firmwareVersion: "",
+            hardwareVersion: "",
+            batteryLevel: 0,
+            rssi: peripheral.rssi || 0,
+            batteryType: types_1.BatteryType.NORMAL,
+            primaryMACAddress: "",
+        };
+    }
+    /**
+     * Get hub name
+     */
+    get name() {
+        return this._properties.name;
+    }
+    /**
+     * Get firmware version
+     */
+    get firmwareVersion() {
+        return this._properties.firmwareVersion;
+    }
+    /**
+     * Get hardware version
+     */
+    get hardwareVersion() {
+        return this._properties.hardwareVersion;
+    }
+    /**
+     * Get battery level (0-100)
+     */
+    get batteryLevel() {
+        return this._properties.batteryLevel;
+    }
+    /**
+     * Get RSSI signal strength
+     */
+    get rssi() {
+        return this._properties.rssi;
+    }
+    /**
+     * Check if hub is connected
+     */
+    get isConnected() {
+        return this._isConnected;
+    }
+    /**
+     * Get attached ports
+     */
+    get ports() {
+        return new Map(this._ports);
+    }
+    /**
+     * Get port info by port ID
+     */
+    getPort(portId) {
+        return this._ports.get(portId);
+    }
+    /**
+     * Get ports by device type
+     */
+    getPortsByType(deviceType) {
+        const result = [];
+        for (const [, port] of this._ports) {
+            if (port.deviceType === deviceType) {
+                result.push(port);
+            }
+        }
+        return result;
+    }
+    /**
+     * Wait for a device of a specific type to be attached
+     * @param deviceType The device type to wait for
+     * @param timeout Timeout in milliseconds (default: 10000)
+     * @returns Promise that resolves to the Device
+     */
+    async waitForDeviceByType(deviceType, timeout = 10000) {
+        // Check if device is already attached
+        for (const [portId, port] of this._ports) {
+            if (port.deviceType === deviceType) {
+                return this._getOrCreateDevice(portId, port);
+            }
+        }
+        // Wait for device to be attached
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                this.removeListener("attach", attachHandler);
+                reject(new Error(`Timeout waiting for device type ${deviceType}`));
+            }, timeout);
+            const attachHandler = (deviceInfo) => {
+                if (deviceInfo.deviceType === deviceType) {
+                    clearTimeout(timeoutId);
+                    this.removeListener("attach", attachHandler);
+                    resolve(this._getOrCreateDevice(deviceInfo.portId, deviceInfo));
+                }
+            };
+            this.on("attach", attachHandler);
+        });
+    }
+    /**
+     * Wait for a device at a specific port
+     * @param portName The port name (e.g., "A", "B", "LEFT", "RIGHT")
+     * @param timeout Timeout in milliseconds (default: 10000)
+     * @returns Promise that resolves to the Device
+     */
+    async waitForDeviceAtPort(portName, timeout = 10000) {
+        const portId = this._portNameToId(portName);
+        // Check if device is already attached
+        const existingPort = this._ports.get(portId);
+        if (existingPort) {
+            return this._getOrCreateDevice(portId, existingPort);
+        }
+        // Wait for device to be attached
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                this.removeListener("attach", attachHandler);
+                reject(new Error(`Timeout waiting for device at port ${portName}`));
+            }, timeout);
+            const attachHandler = (deviceInfo) => {
+                if (deviceInfo.portId === portId) {
+                    clearTimeout(timeoutId);
+                    this.removeListener("attach", attachHandler);
+                    resolve(this._getOrCreateDevice(portId, deviceInfo));
+                }
+            };
+            this.on("attach", attachHandler);
+        });
+    }
+    /**
+     * Get existing device or create and register a new one
+     */
+    _getOrCreateDevice(portId, portInfo) {
+        let device = this._devices.get(portId);
+        if (!device) {
+            device = (0, devices_1.createDevice)(this, portInfo);
+            this._devices.set(portId, device);
+        }
+        return device;
+    }
+    /**
+     * Convert port name to port ID
+     */
+    _portNameToId(portName) {
+        const name = portName.toUpperCase();
+        // WeDo2 uses different port IDs
+        if (this.hubType === types_1.HubType.WEDO2_SMART_HUB) {
+            switch (name) {
+                case "A": return 1;
+                case "B": return 2;
+                case "LED": return 6;
+                default:
+                    const num = parseInt(portName, 10);
+                    if (!isNaN(num))
+                        return num;
+                    throw new Error(`Unknown port name: ${portName}`);
+            }
+        }
+        // LWP3 hubs (Powered UP, Boost, Technic, etc.)
+        switch (name) {
+            case "A": return 0;
+            case "B": return 1;
+            case "C": return 2;
+            case "D": return 3;
+            case "LEFT": return 0;
+            case "RIGHT": return 1;
+            default:
+                // Try to parse as number
+                const num = parseInt(portName, 10);
+                if (!isNaN(num))
+                    return num;
+                throw new Error(`Unknown port name: ${portName}`);
+        }
+    }
+    /**
+     * Sleep for a specified time
+     * @param ms Time to sleep in milliseconds
+     */
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    // Event emitter type overrides
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    once(event, listener) {
+        return super.once(event, listener);
+    }
+    emit(event, ...args) {
+        return super.emit(event, ...args);
+    }
+}
+exports.BaseHub = BaseHub;
+// ============================================================================
+// LWP3 Hub (Powered UP, Boost, Technic, etc.)
+// ============================================================================
+/**
+ * Hub class for LWP3-based hubs (Powered UP, Boost Move Hub, Technic, etc.)
+ */
+class LWP3Hub extends BaseHub {
+    constructor(peripheral, hubType) {
+        super(peripheral, hubType);
+        this._connection = new connection_1.LWP3Connection(peripheral);
+    }
+    /**
+     * Connect to the hub and initialize
+     */
+    async connect() {
+        // Set up message handler before connecting
+        this._connection.on("message", (message) => this._handleMessage(message));
+        this._connection.on("disconnect", () => this._handleDisconnect());
+        // Connect to the peripheral
+        await this._connection.open();
+        this._isConnected = true;
+        // Request hub properties
+        await this._requestHubProperties();
+        // Enable button notifications
+        await this._enableButtonNotifications();
+        this.emit("connect");
+    }
+    /**
+     * Disconnect from the hub
+     */
+    async disconnect() {
+        if (!this._isConnected)
+            return;
+        const message = commands.disconnect();
+        await this._connection.send(message);
+        await this._connection.close();
+        this._isConnected = false;
+    }
+    /**
+     * Shutdown the hub (power off)
+     */
+    async shutdown() {
+        if (!this._isConnected)
+            return;
+        const message = commands.shutdown();
+        await this._connection.send(message);
+        this._isConnected = false;
+    }
+    /**
+     * Set the hub name
+     */
+    async setName(name) {
+        const message = commands.setName(name);
+        await this._connection.send(message);
+        this._properties.name = name;
+    }
+    /**
+     * Set the hub LED color
+     */
+    async setLEDColor(color) {
+        const ledPort = this._findPortByDeviceType(types_1.DeviceType.HUB_LED);
+        if (ledPort === undefined) {
+            throw new Error("Hub LED not found");
+        }
+        const message = commands.ledColor(ledPort, color);
+        await this._connection.send(message);
+    }
+    /**
+     * Set the hub LED to RGB color
+     */
+    async setLEDRGB(red, green, blue) {
+        const ledPort = this._findPortByDeviceType(types_1.DeviceType.HUB_LED);
+        if (ledPort === undefined) {
+            throw new Error("Hub LED not found");
+        }
+        const message = commands.ledRGB(ledPort, red, green, blue);
+        await this._connection.send(message);
+    }
+    /**
+     * Run a motor at a given power level (-100 to 100)
+     */
+    async motorPower(portId, power) {
+        const message = commands.motorPower(portId, power);
+        await this._connection.send(message);
+    }
+    /**
+     * Run a motor at a given speed (-100 to 100) with power regulation
+     */
+    async motorSpeed(portId, speed, maxPower = 100) {
+        const message = commands.motorSpeed(portId, speed, maxPower);
+        await this._connection.send(message);
+    }
+    /**
+     * Run a motor for a specified time
+     */
+    async motorRunForTime(portId, time, speed, maxPower = 100, endState = types_1.BrakingStyle.BRAKE) {
+        const message = commands.motorRunForTime(portId, time, speed, maxPower, endState);
+        await this._connection.send(message);
+    }
+    /**
+     * Run a motor for a specified number of degrees
+     */
+    async motorRunForDegrees(portId, degrees, speed, maxPower = 100, endState = types_1.BrakingStyle.BRAKE) {
+        const message = commands.motorRunForDegrees(portId, degrees, speed, maxPower, endState);
+        await this._connection.send(message);
+    }
+    /**
+     * Move motor to absolute position
+     */
+    async motorGotoPosition(portId, position, speed, maxPower = 100, endState = types_1.BrakingStyle.BRAKE) {
+        const message = commands.motorGotoPosition(portId, position, speed, maxPower, endState);
+        await this._connection.send(message);
+    }
+    /**
+     * Stop a motor
+     */
+    async motorStop(portId) {
+        const message = commands.motorStop(portId);
+        await this._connection.send(message);
+    }
+    /**
+     * Brake a motor
+     */
+    async motorBrake(portId) {
+        const message = commands.motorBrake(portId);
+        await this._connection.send(message);
+    }
+    /**
+     * Subscribe to sensor updates on a port
+     */
+    async subscribe(portId, mode = 0, deltaInterval = 1) {
+        const message = commands.subscribe(portId, mode, deltaInterval);
+        await this._connection.send(message);
+    }
+    /**
+     * Unsubscribe from sensor updates on a port
+     */
+    async unsubscribe(portId, mode = 0) {
+        const message = commands.unsubscribe(portId, mode);
+        await this._connection.send(message);
+    }
+    /**
+     * Send raw command to the hub
+     */
+    async sendRaw(data) {
+        await this._connection.send(data);
+    }
+    // ========================================================================
+    // Private methods
+    // ========================================================================
+    async _requestHubProperties() {
+        // Request hub name
+        await this._connection.send(commands.requestProperty(Protocol.HubProperty.ADVERTISING_NAME));
+        // Request firmware version
+        await this._connection.send(commands.requestProperty(Protocol.HubProperty.FW_VERSION));
+        // Request hardware version
+        await this._connection.send(commands.requestProperty(Protocol.HubProperty.HW_VERSION));
+        // Request battery level and enable updates
+        await this._connection.send(commands.requestProperty(Protocol.HubProperty.BATTERY_VOLTAGE));
+        await this._connection.send(commands.enablePropertyUpdates(Protocol.HubProperty.BATTERY_VOLTAGE));
+    }
+    async _enableButtonNotifications() {
+        await this._connection.send(commands.enablePropertyUpdates(Protocol.HubProperty.BUTTON));
+    }
+    _handleMessage(message) {
+        switch (message.type) {
+            case Protocol.MessageType.HUB_PROPERTIES:
+                this._handleHubProperty(message);
+                break;
+            case Protocol.MessageType.HUB_ATTACHED_IO:
+                this._handleAttachedIO(message);
+                break;
+            case Protocol.MessageType.PORT_VALUE_SINGLE:
+                this._handlePortValue(message);
+                break;
+            case Protocol.MessageType.PORT_OUTPUT_COMMAND_FEEDBACK:
+                this._handleCommandFeedback(message);
+                break;
+            case Protocol.MessageType.HUB_ALERTS:
+                this._handleAlert(message);
+                break;
+            case Protocol.MessageType.GENERIC_ERROR_MESSAGES:
+                this._handleError(message);
+                break;
+        }
+    }
+    _handleHubProperty(message) {
+        switch (message.property) {
+            case Protocol.HubProperty.ADVERTISING_NAME:
+                this._properties.name = message.payload.toString("ascii");
+                break;
+            case Protocol.HubProperty.FW_VERSION:
+                this._properties.firmwareVersion = this._parseVersion(message.payload);
+                break;
+            case Protocol.HubProperty.HW_VERSION:
+                this._properties.hardwareVersion = this._parseVersion(message.payload);
+                break;
+            case Protocol.HubProperty.BATTERY_VOLTAGE:
+                this._properties.batteryLevel = message.payload[0];
+                this.emit("batteryLevel", this._properties.batteryLevel);
+                break;
+            case Protocol.HubProperty.BUTTON:
+                const buttonState = message.payload[0] === 1 ? types_1.ButtonState.PRESSED : types_1.ButtonState.RELEASED;
+                this.emit("button", buttonState);
+                break;
+            case Protocol.HubProperty.RSSI:
+                this._properties.rssi = message.payload.readInt8(0);
+                this.emit("rssi", this._properties.rssi);
+                break;
+        }
+    }
+    _handleAttachedIO(message) {
+        const portId = message.portId;
+        const event = message.event;
+        switch (event) {
+            case types_1.PortEvent.ATTACHED:
+            case types_1.PortEvent.ATTACHED_VIRTUAL: {
+                const deviceType = message.deviceType;
+                const deviceInfo = {
+                    portId,
+                    deviceType,
+                    hardwareRevision: message.hardwareRevision,
+                    softwareRevision: message.softwareRevision,
+                };
+                this._ports.set(portId, deviceInfo);
+                this.emit("attach", deviceInfo);
+                break;
+            }
+            case types_1.PortEvent.DETACHED: {
+                const deviceInfo = this._ports.get(portId);
+                if (deviceInfo) {
+                    this._ports.delete(portId);
+                    this.emit("detach", portId);
+                }
+                break;
+            }
+        }
+    }
+    _handlePortValue(message) {
+        const device = this._devices.get(message.portId);
+        if (device && typeof device.handlePortValue === "function") {
+            device.handlePortValue(message.value);
+        }
+    }
+    _handleCommandFeedback(message) {
+        // Command feedback can be used for promise resolution
+    }
+    _handleAlert(message) {
+        this.emit("alert", message.alertType);
+    }
+    _handleError(message) {
+        this.emit("error", new Error(`Hub error: command 0x${message.commandType.toString(16)}, error 0x${message.errorCode.toString(16)}`));
+    }
+    _handleDisconnect() {
+        this._isConnected = false;
+        this._ports.clear();
+        this.emit("disconnect");
+    }
+    _findPortByDeviceType(deviceType) {
+        for (const [portId, port] of this._ports) {
+            if (port.deviceType === deviceType) {
+                return portId;
+            }
+        }
+        return undefined;
+    }
+    _parseVersion(buffer) {
+        if (buffer.length < 4)
+            return "";
+        const version = buffer.readUInt32LE(0);
+        const major = (version >> 28) & 0x0f;
+        const minor = (version >> 24) & 0x0f;
+        const bugfix = (version >> 16) & 0xff;
+        const build = version & 0xffff;
+        return `${major}.${minor}.${bugfix}.${build}`;
+    }
+}
+exports.LWP3Hub = LWP3Hub;
+// ============================================================================
+// WeDo 2.0 Hub
+// ============================================================================
+/**
+ * Hub class for WeDo 2.0 Smart Hub
+ */
+class WeDo2Hub extends BaseHub {
+    constructor(peripheral) {
+        super(peripheral, types_1.HubType.WEDO2_SMART_HUB);
+        this._connection = new connection_1.WeDo2Connection(peripheral);
+    }
+    /**
+     * Connect to the hub and initialize
+     */
+    async connect() {
+        // Set up message handlers - WeDo2Connection emits separate events for each message type
+        this._connection.on("port", (message) => this._handlePortInfo(message));
+        this._connection.on("sensor", (message) => this._handleSensorValue(message));
+        this._connection.on("button", (message) => this._handleButton(message));
+        this._connection.on("battery", (message) => this._handleBattery(message));
+        this._connection.on("disconnect", () => this._handleDisconnect());
+        // Connect to the peripheral
+        await this._connection.open();
+        this._isConnected = true;
+        // Note: Internal devices (LED, voltage, current, piezo) are detected via
+        // PORT_TYPE notifications during connection, so no manual registration needed
+        this.emit("connect");
+    }
+    /**
+     * Disconnect from the hub
+     */
+    async disconnect() {
+        if (!this._isConnected)
+            return;
+        await this._connection.close();
+        this._isConnected = false;
+    }
+    /**
+     * Shutdown the hub (WeDo 2.0 doesn't support remote shutdown)
+     */
+    async shutdown() {
+        await this.disconnect();
+    }
+    /**
+     * Set the hub name
+     */
+    async setName(name) {
+        const message = WeDo2Protocol.createWeDo2SetName(name);
+        await this._connection.send(WeDo2Protocol.WEDO2_CHARACTERISTICS.NAME_ID, message);
+        this._properties.name = name;
+    }
+    /**
+     * Set the hub LED color
+     */
+    async setLEDColor(color) {
+        const message = WeDo2Protocol.createWeDo2LEDColor(WeDo2Protocol.WEDO2_PORT_MAP.HUB_LED, color);
+        await this._connection.send(WeDo2Protocol.WEDO2_CHARACTERISTICS.MOTOR_VALUE_WRITE, message);
+    }
+    /**
+     * Set the hub LED to RGB color
+     */
+    async setLEDRGB(red, green, blue) {
+        const message = WeDo2Protocol.createWeDo2LEDRGB(WeDo2Protocol.WEDO2_PORT_MAP.HUB_LED, red, green, blue);
+        await this._connection.send(WeDo2Protocol.WEDO2_CHARACTERISTICS.MOTOR_VALUE_WRITE, message);
+    }
+    /**
+     * Run a motor at a given power level (-100 to 100)
+     */
+    async motorPower(portId, power) {
+        const message = WeDo2Protocol.createWeDo2MotorPower(portId, power);
+        await this._connection.send(WeDo2Protocol.WEDO2_CHARACTERISTICS.MOTOR_VALUE_WRITE, message);
+    }
+    /**
+     * Stop a motor
+     */
+    async motorStop(portId) {
+        await this.motorPower(portId, 0);
+    }
+    /**
+     * Play a tone
+     */
+    async playTone(frequency, duration) {
+        const message = WeDo2Protocol.createWeDo2PiezoTone(WeDo2Protocol.WEDO2_PORT_MAP.PIEZO, frequency, duration);
+        await this._connection.send(WeDo2Protocol.WEDO2_CHARACTERISTICS.MOTOR_VALUE_WRITE, message);
+    }
+    /**
+     * Stop tone playback
+     */
+    async stopTone() {
+        const message = WeDo2Protocol.createWeDo2PiezoStop(WeDo2Protocol.WEDO2_PORT_MAP.PIEZO);
+        await this._connection.send(WeDo2Protocol.WEDO2_CHARACTERISTICS.MOTOR_VALUE_WRITE, message);
+    }
+    /**
+     * Set sensor mode
+     */
+    async setSensorMode(portId, mode) {
+        const deviceInfo = this._ports.get(portId);
+        if (!deviceInfo) {
+            throw new Error(`Port ${portId} not found`);
+        }
+        const message = WeDo2Protocol.createWeDo2Subscribe(portId, deviceInfo.deviceType, mode, true);
+        await this._connection.send(WeDo2Protocol.WEDO2_CHARACTERISTICS.PORT_TYPE_WRITE, message);
+    }
+    /**
+     * Send raw command
+     */
+    async sendRaw(characteristicUUID, data) {
+        await this._connection.send(characteristicUUID, data);
+    }
+    // ========================================================================
+    // Private methods
+    // ========================================================================
+    _handleMessage(message) {
+        switch (message.kind) {
+            case "port":
+                this._handlePortInfo(message);
+                break;
+            case "sensor":
+                this._handleSensorValue(message);
+                break;
+            case "button":
+                this._handleButton(message);
+                break;
+            case "battery":
+                this._handleBattery(message);
+                break;
+        }
+    }
+    _handlePortInfo(message) {
+        const portId = message.portId;
+        const deviceType = message.deviceType;
+        if (deviceType !== types_1.DeviceType.UNKNOWN) {
+            const deviceInfo = {
+                portId,
+                deviceType: deviceType,
+            };
+            this._ports.set(portId, deviceInfo);
+            this.emit("attach", deviceInfo);
+        }
+        else {
+            const deviceInfo = this._ports.get(portId);
+            if (deviceInfo) {
+                this._ports.delete(portId);
+                this.emit("detach", portId);
+            }
+        }
+    }
+    _handleSensorValue(message) {
+        // Sensor value events are handled by device classes
+    }
+    _handleButton(message) {
+        const buttonState = message.pressed ? types_1.ButtonState.PRESSED : types_1.ButtonState.RELEASED;
+        this.emit("button", buttonState);
+    }
+    _handleBattery(message) {
+        this._properties.batteryLevel = message.level;
+        this.emit("batteryLevel", message.level);
+    }
+    _handleDisconnect() {
+        this._isConnected = false;
+        this._ports.clear();
+        this.emit("disconnect");
+    }
+}
+exports.WeDo2Hub = WeDo2Hub;
+// ============================================================================
+// Hub Factory
+// ============================================================================
+/**
+ * Create a hub instance based on the hub type
+ */
+function createHub(peripheral, hubType) {
+    switch (hubType) {
+        case types_1.HubType.WEDO2_SMART_HUB:
+            return new WeDo2Hub(peripheral);
+        case types_1.HubType.MOVE_HUB:
+            return new MoveHub(peripheral);
+        case types_1.HubType.TECHNIC_MEDIUM_HUB:
+            return new TechnicMediumHub(peripheral);
+        case types_1.HubType.REMOTE_CONTROL:
+            return new RemoteControl(peripheral);
+        case types_1.HubType.DUPLO_TRAIN_BASE:
+            return new DuploTrainBase(peripheral);
+        default:
+            return new LWP3Hub(peripheral, hubType);
+    }
+}
+// ============================================================================
+// Specialized Hub Classes
+// ============================================================================
+/**
+ * Move Hub (Boost) with built-in tilt sensor and motors
+ */
+class MoveHub extends LWP3Hub {
+    constructor(peripheral) {
+        super(peripheral, types_1.HubType.MOVE_HUB);
+    }
+    get motorAPort() { return 0; }
+    get motorBPort() { return 1; }
+    get tiltSensorPort() { return 58; }
+    get colorSensorPort() { return 59; }
+}
+exports.MoveHub = MoveHub;
+/**
+ * Technic Medium Hub with gyro and accelerometer
+ */
+class TechnicMediumHub extends LWP3Hub {
+    constructor(peripheral) {
+        super(peripheral, types_1.HubType.TECHNIC_MEDIUM_HUB);
+    }
+    get gyroPort() { return 99; }
+    get accelerometerPort() { return 97; }
+    get tiltSensorPort() { return 98; }
+}
+exports.TechnicMediumHub = TechnicMediumHub;
+/**
+ * Remote Control
+ */
+class RemoteControl extends LWP3Hub {
+    constructor(peripheral) {
+        super(peripheral, types_1.HubType.REMOTE_CONTROL);
+    }
+    get leftButtonPort() { return 0; }
+    get rightButtonPort() { return 1; }
+}
+exports.RemoteControl = RemoteControl;
+/**
+ * Duplo Train Base
+ */
+class DuploTrainBase extends LWP3Hub {
+    constructor(peripheral) {
+        super(peripheral, types_1.HubType.DUPLO_TRAIN_BASE);
+    }
+    get motorPort() { return 0; }
+    get colorSensorPort() { return 18; }
+    get speedometerPort() { return 19; }
+    get speakerPort() { return 1; }
+    async playSound(sound) {
+        const message = commands.duploTrainSound(this.speakerPort, sound);
+        await this._connection.send(message);
+    }
+}
+exports.DuploTrainBase = DuploTrainBase;
+//# sourceMappingURL=hub.js.map