.drone.yml

@@ -1,23 +0,0 @@
-pipeline:
-
-  install:
-    image: node:20.12.2
-    commands:
-      - apt-get update
-      - apt-get install -y bluetooth bluez libbluetooth-dev libudev-dev
-      - git submodule update --init --recursive
-      - npm install
-
-  build:
-    image: node:20.12.2
-    commands:
-      - npm run all
-
-  publish:
-    image: plugins/npm
-    username: nathankellenicki
-    token:
-      from_secret: NPM_TOKEN
-    when:
-      ref:
-        - refs/tags/v*

.gitignore

@@ -2,4 +2,3 @@ node_modules/
 dist/
 .vscode/
 *.tgz
-**/.DS_store

.jsdoc.json

@@ -1,40 +0,0 @@
-{
-    "tags": {
-        "allowUnknownTags": true,
-        "dictionaries": ["jsdoc"]
-    },
-    "source": {
-        "include": [ "README.md", "dist/node" ],
-        "includePattern": ".js$"
-    },
-    "plugins": ["plugins/markdown"],
-    "templates": {
-        "referenceTitle": "node-poweredup Reference",
-        "logoFile": "",
-        "cleverLinks": false,
-        "monospaceLinks": false,
-        "dateFormat": "ddd MMM Do YYYY",
-        "outputSourceFiles": true,
-        "outputSourcePath": true,
-        "systemName": "node-poweredup",
-        "footer": "",
-        "copyright": "node-poweredup by Nathan Kellenicki licensed under the MIT license.",
-        "navType": "vertical",
-        "theme": "simplex",
-        "linenums": true,
-        "collapseSymbols": false,
-        "inverseNav": true,
-        "protocol": "html://",
-        "methodHeadingReturns": false
-    },
-    "markdown": {
-        "parser": "gfm",
-        "hardwrap": true
-    },
-    "opts": {
-        "destination": "./docs/",
-        "encoding": "utf8",
-        "private": true,
-        "recurse": true
-    }
-}

.npmignore

@@ -1,5 +1,17 @@
+boostmovehub.ts
+consts.ts
+duplotrainbase.ts
+hub.ts
+index.ts
+lpf2hub.ts
+port.ts
+poweredup.ts
+puphub.ts
+pupremote.ts
 package-lock.json
 tsconfig.json
 tslint.json
+utils.ts
+wedo2smarthub.ts
 .vscode/
 examples/

ABOUT.md

@@ -0,0 +1,79 @@
+# **node-poweredup** - A Node.js module to interface with LEGO Powered UP components.
+
+### Introduction
+
+LEGO Powered UP is the successor to Power Functions, the system for adding electronics to LEGO models. Powered UP is a collection of ranges - starting with LEGO WeDo 2.0 released in 2016, LEGO Boost released in 2017, and LEGO Powered UP released in 2018. It also includes the 2018 Duplo App-Controlled Train sets.
+
+Powered UP has a few improvements over Power Functions:
+
+1. The use of Bluetooth Low Energy makes it easy to control from a computer, and even write code for.
+
+2. The ability to use sensors to react to events happening in the real world opens up a whole new world of possibilities.
+
+3. As Powered UP hubs and remotes pair with each other, the system allows for a near unlimited number of independently controlled models in the same room. Power Functions was limited to 8 due to the use of infra-red for communication.
+
+### Installation
+
+Node.js v8.0 required.
+
+```javascript
+npm install node-poweredup --save
+```
+
+node-poweredup uses the Noble BLE library by Sandeep Mistry. On macOS everything should function out of the box. On Linux and Windows there are [certain dependencies which may need installed first](https://github.com/noble/noble#prerequisites).
+
+Note: node-poweredup has been tested on macOS 10.13 and Debian/Raspbian on the Raspberry Pi 3 Model B.
+
+### Compatibility
+
+While most Powered UP components and Hubs are compatible with each other, there are exceptions. For example, there is limited backwards compatibility between newer components and the WeDo 2.0 Smart Hub. However WeDo 2.0 components are fully forwards compatible with newer Hubs.
+
+| Name                            | Type          | WeDo 2.0 Smart Hub | Boost Move Hub | Powered UP Hub | Availability |
+| ------------------------------- | ------------- | ------------------ | -------------- | -------------- | ------------ |
+| WeDo 2.0 Tilt Sensor            | Sensor        |         Yes        |       Yes      |       Yes      | <a href="https://brickset.com/sets/45300-1/">45300</a> |
+| WeDo 2.0 Motion Sensor          | Sensor        |         Yes        |       Yes      |       Yes      | <a href="https://brickset.com/sets/45300-1/">45300</a> |
+| WeDo 2.0 Medium Motor           | Motor         |         Yes        |       Yes      |       Yes      | <a href="https://brickset.com/sets/45300-1/">45300</a><br /> <a href="https://brickset.com/sets/76112-1/">76112</a> |
+| Boost Color and Distance Sensor | Sensor        |     *Partial*    |       Yes      |       Yes      | <a href="https://brickset.com/sets/17101-1/">17101</a> |
+| Boost Tacho Motor  | Motor/Sensor  |     *Partial*    |       Yes      |       *Partial*      | <a href="https://brickset.com/sets/17101-1/">17101</a> |
+| Powered UP Train Motor          | Motor         |         Yes        |       Yes      |       Yes      | <a href="https://brickset.com/sets/60197-1/">60197</a><br /><a href="https://brickset.com/sets/60198-1/">60198</a> |
+| Powered UP LED Lights           | Light         |       Yes      |     Yes    |     Yes    | <a href="https://brickset.com/sets/88005-1/">88005</a> |
+
+
+### Known Issues and Limitations
+
+* The Boost Color and Distance sensor only works in color mode with the WeDo 2.0 Smart Hub.
+
+* When used with the WeDo 2.0 Smart Hub, the Boost Tacho Motor does not support rotating the motor by angle.
+
+* When used with the Powered UP Hub, the Boost Tacho Motor does not support rotating the motor by angle. It also does not support rotation detection.
+
+* Plugging two Boost Tacho Motors into the Powered UP Hub will crash the Hub (This requires a firmware update from LEGO to fix).
+
+### Usage
+
+```javascript
+const PoweredUP = require("node-poweredup");
+const poweredUP = new PoweredUP.PoweredUP();
+
+poweredUP.on("discover", async (hub) => { // Wait to discover a Hub
+    await hub.connect(); // Connect to the Hub
+    await hub.sleep(3000); // Sleep for 3 seconds before starting
+
+    while (true) { // Repeat indefinitely
+        hub.setMotorSpeed("B", 75); // Start a motor attached to port B to run a 3/4 speed (75) indefinitely
+        await hub.setMotorSpeed("A", 100,  2000); // Run a motor attached to port A for 2 seconds at maximum speed (100) then stop
+        await hub.sleep(1000); // Do nothing for 1 second
+        await hub.setMotorSpeed("A", -50,  1000); // Run a motor attached to port A for 1 second at 1/2 speed in reverse (-50) then stop
+        await hub.sleep(1000); // Do nothing for 1 second
+    }
+});
+
+poweredUP.scan(); // Start scanning for Hubs
+```
+
+More examples are available in the "examples" directory.
+
+### Credits
+
+Thanks go to Jorge Pereira ([@JorgePe](https://github.com/JorgePe)), Sebastian Raff ([@hobbyquaker](https://github.com/hobbyquaker)), Valentin Heun ([@vheun](https://github.com/vheun)), Johan Korten ([@jakorten](https://github.com/jakorten)), and Andrey Pokhilko ([@undera](https://github.com/undera)) for their various works, contributions, and assistance on figuring out the LEGO Boost, WeDo 2.0, and Powered UP protocols.
+

abandonware-noble.d.ts

@@ -1,129 +0,0 @@
-declare module "@abandonware/noble" {
-    // Type definitions for noble
-    // Project: https://github.com/sandeepmistry/noble
-    // Definitions by: Seon-Wook Park <https://github.com/swook>
-    //                 Shantanu Bhadoria <https://github.com/shantanubhadoria>
-    //                 Luke Libraro <https://github.com/lukel99>
-    //                 Dan Chao <https://github.com/bioball>
-    //                 Michal Lower <https://github.com/keton>
-    //                 Rob Moran <https://github.com/thegecko>
-    // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-    /// <reference types="node" />
-
-    import events = require("events");
-
-    export function startScanning(callback?: (error?: Error) => void): void;
-    export function startScanning(serviceUUIDs: string[], callback?: (error?: Error) => void): void;
-    export function startScanning(serviceUUIDs: string[], allowDuplicates: boolean, callback?: (error?: Error) => void): void;
-    export function stopScanning(callback?: () => void): void;
-
-    export function on(event: "stateChange", listener: (state: string) => void): events.EventEmitter;
-    export function on(event: "scanStart", listener: () => void): events.EventEmitter;
-    export function on(event: "scanStop", listener: () => void): events.EventEmitter;
-    export function on(event: "discover", listener: (peripheral: Peripheral) => void): events.EventEmitter;
-    export function on(event: string, listener: Function): events.EventEmitter;
-
-    export function removeListener(event: "stateChange", listener: (state: string) => void): events.EventEmitter;
-    export function removeListener(event: "scanStart", listener: () => void): events.EventEmitter;
-    export function removeListener(event: "scanStop", listener: () => void): events.EventEmitter;
-    export function removeListener(event: "discover", listener: (peripheral: Peripheral) => void): events.EventEmitter;
-    export function removeListener(event: string, listener: Function): events.EventEmitter;
-
-    export var state:string;
-
-    export class Peripheral extends events.EventEmitter {
-        id:            string;
-        uuid:          string;
-        address:       string;
-        addressType:   string;
-        connectable:   boolean;
-        advertisement: Advertisement;
-        rssi:          number;
-        services:      Service[];
-        state:         'error' | 'connecting' | 'connected' | 'disconnecting' | 'disconnected';
-
-        connect(callback?: (error: string) => void): void;
-        disconnect(callback?: () => void): void;
-        updateRssi(callback?: (error: string, rssi: number) => void): void;
-        discoverServices(serviceUUIDs: string[], callback?: (error: string, services: Service[]) => void): void;
-        discoverAllServicesAndCharacteristics(callback?: (error: string, services: Service[], characteristics: Characteristic[]) => void): void;
-        discoverSomeServicesAndCharacteristics(serviceUUIDs: string[], characteristicUUIDs: string[], callback?: (error: string, services: Service[], characteristics: Characteristic[]) => void): void;
-
-        readHandle(handle: Buffer, callback: (error: string, data: Buffer) => void): void;
-        writeHandle(handle: Buffer, data: Buffer, withoutResponse: boolean, callback: (error: string) => void): void;
-        toString(): string;
-
-        on(event: "connect", listener: (error: string) => void): this;
-        on(event: "disconnect", listener: (error: string) => void): this;
-        on(event: "rssiUpdate", listener: (rssi: number) => void): this;
-        on(event: "servicesDiscover", listener: (services: Service[]) => void): this;
-        on(event: string, listener: Function): this;
-    }
-
-    export interface Advertisement {
-        localName: string;
-        serviceData: {
-            uuid: string,
-            data: Buffer
-        };
-        txPowerLevel: number;
-        manufacturerData: Buffer;
-        serviceUuids: string[];
-    }
-
-    export class Service extends events.EventEmitter {
-        uuid: string;
-        name: string;
-        type: string;
-        includedServiceUuids: string[];
-        characteristics: Characteristic[];
-
-        discoverIncludedServices(serviceUUIDs: string[], callback?: (error: string, includedServiceUuids: string[]) => void): void;
-        discoverCharacteristics(characteristicUUIDs: string[], callback?: (error: string, characteristics: Characteristic[]) => void): void;
-        toString(): string;
-
-        on(event: "includedServicesDiscover", listener: (includedServiceUuids: string[]) => void): this;
-        on(event: "characteristicsDiscover", listener: (characteristics: Characteristic[]) => void): this;
-        on(event: string, listener: Function): this;
-    }
-
-    export class Characteristic extends events.EventEmitter {
-        uuid: string;
-        name: string;
-        type: string;
-        properties: string[];
-        descriptors: Descriptor[];
-
-        read(callback?: (error: string, data: Buffer) => void): void;
-        write(data: Buffer, notify: boolean, callback?: (error: string) => void): void;
-        broadcast(broadcast: boolean, callback?: (error: string) => void): void;
-        notify(notify: boolean, callback?: (error: string) => void): void;
-        discoverDescriptors(callback?: (error: string, descriptors: Descriptor[]) => void): void;
-        toString(): string;
-        subscribe(callback?: (error: string) => void): void;
-        unsubscribe(callback?: (error: string) => void): void;
-
-        on(event: "read", listener: (data: Buffer, isNotification: boolean) => void): this;
-        on(event: "write", withoutResponse: boolean, listener: (error: string) => void): this;
-        on(event: "broadcast", listener: (state: string) => void): this;
-        on(event: "notify", listener: (state: string) => void): this;
-        on(event: "descriptorsDiscover", listener: (descriptors: Descriptor[]) => void): this;
-        on(event: string, listener: Function): this;
-        on(event: string, option: boolean, listener: Function): this;
-    }
-
-    export class Descriptor extends events.EventEmitter {
-        uuid: string;
-        name: string;
-        type: string;
-
-        readValue(callback?: (error: string, data: Buffer) => void): void;
-        writeValue(data: Buffer, callback?: (error: string) => void): void;
-        toString(): string;
-
-        on(event: "valueRead", listener: (error: string, data: Buffer) => void): this;
-        on(event: "valueWrite", listener: (error: string) => void): this;
-        on(event: string, listener: Function): this;
-    }
-}

boostmovehub.ts

@@ -0,0 +1,223 @@
+import { Peripheral } from "noble";
+
+import { LPF2Hub } from "./lpf2hub";
+import { Port } from "./port";
+
+import * as Consts from "./consts";
+
+import Debug = require("debug");
+const debug = Debug("boostmovehub");
+
+
+/**
+ * The BoostMoveHub is emitted if the discovered device is a Boost Move Hub.
+ * @class BoostMoveHub
+ * @extends LPF2Hub
+ * @extends Hub
+ */
+export class BoostMoveHub extends LPF2Hub {
+
+
+    // We set JSDoc to ignore these events as a Boost Move Hub will never emit them.
+
+    /**
+     * @event BoostMoveHub#speed
+     * @ignore
+     */
+
+
+    public static IsBoostMoveHub (peripheral: Peripheral) {
+        return (peripheral.advertisement.serviceUuids.indexOf(Consts.BLEServices.LPF2_HUB.replace(/-/g, "")) >= 0 && peripheral.advertisement.manufacturerData[3] === Consts.BLEManufacturerData.BOOST_MOVE_HUB_ID);
+    }
+
+
+    constructor (peripheral: Peripheral, autoSubscribe: boolean = true) {
+        super(peripheral, autoSubscribe);
+        this.type = Consts.Hubs.BOOST_MOVE_HUB;
+        this._ports = {
+            "A": new Port("A", 55),
+            "B": new Port("B", 56),
+            "AB": new Port("AB", 57),
+            "TILT": new Port("TILT", 58),
+            "C": new Port("C", 1),
+            "D": new Port("D", 2)
+        };
+        debug("Discovered Boost Move Hub");
+    }
+
+
+    public connect () {
+        return new Promise(async (resolve, reject) => {
+            debug("Connecting to Boost Move Hub");
+            await super.connect();
+            debug("Connect completed");
+            return resolve();
+        });
+    }
+
+
+    /**
+     * Set the motor speed on a given port.
+     * @method BoostMoveHub#setMotorSpeed
+     * @param {string} port
+     * @param {number | Array.<number>} speed For forward, a value between 1 - 100 should be set. For reverse, a value between -1 to -100. Stop is 0. If you are specifying port AB to control both motors, you can optionally supply a tuple of speeds.
+     * @param {number} [time] How long to activate the motor for (in milliseconds). Leave empty to turn the motor on indefinitely.
+     * @returns {Promise} Resolved upon successful completion of command. If time is specified, this is once the motor is finished.
+     */
+    public setMotorSpeed (port: string, speed: number | [number, number], time?: number | boolean) {
+        const portObj = this._portLookup(port);
+        if (portObj.id !== "AB" && speed instanceof Array) {
+            throw new Error(`Port ${portObj.id} can only accept a single speed`);
+        }
+        let cancelEventTimer = true;
+        if (typeof time === "boolean") {
+            if (time === true) {
+                cancelEventTimer = false;
+            }
+            time = undefined;
+        }
+        if (cancelEventTimer) {
+            portObj.cancelEventTimer();
+        }
+        return new Promise((resolve, reject) => {
+            if (time && typeof time === "number") {
+
+                if (portObj.type === Consts.Devices.BOOST_TACHO_MOTOR || portObj.type === Consts.Devices.BOOST_MOVE_HUB_MOTOR) {
+                    portObj.busy = true;
+                    let data = null;
+                    if (portObj.id === "AB") {
+                        data = Buffer.from([0x81, portObj.value, 0x11, 0x0a, 0x00, 0x00, this._mapSpeed(speed instanceof Array ? speed[0] : speed), this._mapSpeed(speed instanceof Array ? speed[1] : speed), 0x64, 0x7f, 0x03]);
+                    } else {
+                        // @ts-ignore: The type of speed is properly checked at the start
+                        data = Buffer.from([0x81, portObj.value, 0x11, 0x09, 0x00, 0x00, this._mapSpeed(speed), 0x64, 0x7f, 0x03]);
+                    }
+                    data.writeUInt16LE(time > 65535 ? 65535 : time, 4);
+                    this._writeMessage(Consts.BLECharacteristics.LPF2_ALL, data);
+                    portObj.finished = () => {
+                        return resolve();
+                    };
+                } else {
+                    // @ts-ignore: The type of speed is properly checked at the start
+                    const data = Buffer.from([0x81, portObj.value, 0x11, 0x51, 0x00, this._mapSpeed(speed)]);
+                    this._writeMessage(Consts.BLECharacteristics.LPF2_ALL, data);
+                    const timeout = global.setTimeout(() => {
+                        const data = Buffer.from([0x81, portObj.value, 0x11, 0x51, 0x00, 0x00]);
+                        this._writeMessage(Consts.BLECharacteristics.LPF2_ALL, data);
+                        return resolve();
+                    // @ts-ignore: The type of time is properly checked at the start
+                    }, time);
+                    portObj.setEventTimer(timeout);
+                }
+
+            } else {
+
+                if (portObj.type === Consts.Devices.BOOST_TACHO_MOTOR || portObj.type === Consts.Devices.BOOST_MOVE_HUB_MOTOR) {
+                    portObj.busy = true;
+                    let data = null;
+                    if (portObj.id === "AB") {
+                        data = Buffer.from([0x81, portObj.value, 0x11, 0x02, this._mapSpeed(speed instanceof Array ? speed[0] : speed), this._mapSpeed(speed instanceof Array ? speed[1] : speed), 0x64, 0x7f, 0x03]);
+                    } else {
+                        // @ts-ignore: The type of speed is properly checked at the start
+                        data = Buffer.from([0x81, portObj.value, 0x11, 0x01, this._mapSpeed(speed), 0x64, 0x7f, 0x03]);
+                    }
+                    this._writeMessage(Consts.BLECharacteristics.LPF2_ALL, data);
+                    portObj.finished = () => {
+                        return resolve();
+                    };
+                } else {
+                    // @ts-ignore: The type of speed is properly checked at the start
+                    const data = Buffer.from([0x81, portObj.value, 0x11, 0x51, 0x00, this._mapSpeed(speed)]);
+                    this._writeMessage(Consts.BLECharacteristics.LPF2_ALL, data);
+                }
+
+            }
+        });
+    }
+
+
+    /**
+     * Ramp the motor speed on a given port.
+     * @method BoostMoveHub#rampMotorSpeed
+     * @param {string} port
+     * @param {number} fromSpeed For forward, a value between 1 - 100 should be set. For reverse, a value between -1 to -100. Stop is 0.
+     * @param {number} toSpeed For forward, a value between 1 - 100 should be set. For reverse, a value between -1 to -100. Stop is 0.
+     * @param {number} time How long the ramp should last (in milliseconds).
+     * @returns {Promise} Resolved upon successful completion of command.
+     */
+    public rampMotorSpeed (port: string, fromSpeed: number, toSpeed: number, time: number) {
+        const portObj = this._portLookup(port);
+        portObj.cancelEventTimer();
+        return new Promise((resolve, reject) => {
+            this._calculateRamp(fromSpeed, toSpeed, time, portObj)
+            .on("changeSpeed", (speed) => {
+                this.setMotorSpeed(port, speed, true);
+            })
+            .on("finished", resolve);
+        });
+    }
+
+
+    /**
+     * Rotate a motor by a given angle.
+     * @method BoostMoveHub#setMotorAngle
+     * @param {string} port
+     * @param {number} angle How much the motor should be rotated (in degrees).
+     * @param {number | Array.<number>} [speed=100] For forward, a value between 1 - 100 should be set. For reverse, a value between -1 to -100. Stop is 0. If you are specifying port AB to control both motors, you can optionally supply a tuple of speeds.
+     * @returns {Promise} Resolved upon successful completion of command (ie. once the motor is finished).
+     */
+    public setMotorAngle (port: string, angle: number, speed: number | [number, number] = 100) {
+        const portObj = this._portLookup(port);
+        if (!(portObj.type === Consts.Devices.BOOST_TACHO_MOTOR || portObj.type === Consts.Devices.BOOST_MOVE_HUB_MOTOR)) {
+            throw new Error("Angle rotation is only available when using a Boost Tacho Motor or Boost Move Hub Motor");
+        }
+        if (portObj.id !== "AB" && speed instanceof Array) {
+            throw new Error(`Port ${portObj.id} can only accept a single speed`);
+        }
+        portObj.cancelEventTimer();
+        return new Promise((resolve, reject) => {
+            portObj.busy = true;
+            let data = null;
+            if (portObj.id === "AB") {
+                data = Buffer.from([0x81, portObj.value, 0x11, 0x0c, 0x00, 0x00, 0x00, 0x00, this._mapSpeed(speed instanceof Array ? speed[0] : speed), this._mapSpeed(speed instanceof Array ? speed[1] : speed), 0x64, 0x7f, 0x03]);
+            } else {
+                // @ts-ignore: The type of speed is properly checked at the start
+                data = Buffer.from([0x81, portObj.value, 0x11, 0x0b, 0x00, 0x00, 0x00, 0x00, this._mapSpeed(speed), 0x64, 0x7f, 0x03]);
+            }
+            data.writeUInt32LE(angle, 4);
+            this._writeMessage(Consts.BLECharacteristics.LPF2_ALL, data);
+            portObj.finished = () => {
+                return resolve();
+            };
+        });
+    }
+
+
+    /**
+     * Set the light brightness on a given port.
+     * @method BoostMoveHub#setLightBrightness
+     * @param {string} port
+     * @param {number} brightness Brightness value between 0-100 (0 is off)
+     * @param {number} [time] How long to turn the light on (in milliseconds). Leave empty to turn the light on indefinitely.
+     * @returns {Promise} Resolved upon successful completion of command. If time is specified, this is once the light is turned off.
+     */
+    public setLightBrightness (port: string, brightness: number, time?: number) {
+        const portObj = this._portLookup(port);
+        portObj.cancelEventTimer();
+        return new Promise((resolve, reject) => {
+            const data = Buffer.from([0x81, portObj.value, 0x11, 0x51, 0x00, brightness]);
+            this._writeMessage(Consts.BLECharacteristics.LPF2_ALL, data);
+            if (time) {
+                const timeout = global.setTimeout(() => {
+                    const data = Buffer.from([0x81, portObj.value, 0x11, 0x51, 0x00, 0x00]);
+                    this._writeMessage(Consts.BLECharacteristics.LPF2_ALL, data);
+                    return resolve();
+                }, time);
+                portObj.setEventTimer(timeout);
+            } else {
+                return resolve();
+            }
+        });
+    }
+
+
+}

consts.ts

@@ -0,0 +1,90 @@
+export enum Hubs {
+    UNKNOWN = 0,
+    WEDO2_SMART_HUB = 1,
+    BOOST_MOVE_HUB = 2,
+    POWERED_UP_HUB = 3,
+    POWERED_UP_REMOTE = 4,
+    DUPLO_TRAIN_HUB = 5
+}
+
+
+export enum Devices {
+    UNKNOWN = 0,
+    BASIC_MOTOR = 1,
+    TRAIN_MOTOR = 2,
+    LED_LIGHTS = 8,
+    BOOST_LED = 22,
+    WEDO2_TILT = 34,
+    WEDO2_DISTANCE = 35,
+    BOOST_DISTANCE = 37,
+    BOOST_TACHO_MOTOR = 38,
+    BOOST_MOVE_HUB_MOTOR = 39,
+    BOOST_TILT = 40,
+    DUPLO_TRAIN_BASE_MOTOR = 41,
+    DUPLO_TRAIN_BASE_SPEAKER = 42,
+    DUPLO_TRAIN_BASE_COLOR = 43,
+    DUPLO_TRAIN_BASE_SPEEDOMETER = 44,
+    POWERED_UP_REMOTE_BUTTON = 55
+}
+
+
+export enum Colors {
+    BLACK = 0,
+    PINK = 1,
+    PURPLE = 2,
+    BLUE = 3,
+    LIGHT_BLUE = 4,
+    CYAN = 5,
+    GREEN = 6,
+    YELLOW = 7,
+    ORANGE = 8,
+    RED = 9,
+    WHITE = 10,
+    NONE = 255
+}
+
+
+export enum ButtonStates {
+    PRESSED = 0,
+    RELEASED = 1,
+    UP = 2,
+    DOWN = 3,
+    STOP = 4
+}
+
+
+export enum DuploTrainBaseSounds {
+    STATION_DEPARTURE = 5,
+    WATER_REFILL = 7,
+    HORN = 9
+}
+
+
+export enum BLEManufacturerData {
+    BOOST_MOVE_HUB_ID = 64,
+    POWERED_UP_HUB_ID = 65,
+    POWERED_UP_REMOTE_ID = 66,
+    DUPLO_TRAIN_HUB_ID = 32
+}
+
+
+export enum BLEServices {
+    WEDO2_SMART_HUB = "00001523-1212-efde-1523-785feabcd123",
+    LPF2_HUB = "00001623-1212-efde-1623-785feabcd123"
+}
+
+
+export enum BLECharacteristics {
+    WEDO2_BATTERY = "2a19",
+    WEDO2_BUTTON = "00001526-1212-efde-1523-785feabcd123", // "1526"
+    WEDO2_PORT_TYPE = "00001527-1212-efde-1523-785feabcd123", // "1527" // Handles plugging and unplugging of devices on WeDo 2.0 Smart Hub
+    WEDO2_LOW_VOLTAGE_ALERT = "00001528-1212-efde-1523-785feabcd123", // "1528"
+    WEDO2_HIGH_CURRENT_ALERT = "00001529-1212-efde-1523-785feabcd123", // "1529"
+    WEDO2_LOW_SIGNAL_ALERT = "0000152a-1212-efde-1523-785feabcd123", // "152a"
+    WEDO2_SENSOR_VALUE = "00001560-1212-efde-1523-785feabcd123", // "1560"
+    WEDO2_VALUE_FORMAT = "00001561-1212-efde-1523-785feabcd123", // "1561"
+    WEDO2_PORT_TYPE_WRITE = "00001563-1212-efde-1523-785feabcd123", // "1563"
+    WEDO2_MOTOR_VALUE_WRITE = "00001565-1212-efde-1523-785feabcd123", // "1565"
+    WEDO2_NAME_ID = "00001524-1212-efde-1523-785feabcd123", // "1524"
+    LPF2_ALL = "00001624-1212-efde-1623-785feabcd123"
+}