node-poweredup 9.0.0 → 10.1.0

package/src/devices/colordistancesensor.ts

@@ -1,9 +1,9 @@
-import { Device } from "./device";
+import { Device } from "./device.js";
 
-import { IDeviceInterface } from "../interfaces";
+import { IDeviceInterface } from "../interfaces.js";
 
-import * as Consts from "../consts";
-import { parseColor } from "../utils";
+import * as Consts from "../consts.js";
+import { parseColor } from "../utils.js";
 
 /**
  * @class ColorDistanceSensor
@@ -157,9 +157,8 @@ export class ColorDistanceSensor extends Device {
      * Switches the IR receiver into extended channel mode. After setting this, use channels 5-8 instead of 1-4 for this receiver.
      *
      * NOTE: Calling this with channel 5-8 with switch off extended channel mode for this receiver.
-     * @method ColorDistanceSensor#setPFExtendedChannel
      * @param {number} channel Channel number, between 1-8
-     * @returns {Promise} Resolved upon successful issuance of the command.
+     * @returns {Promise<CommandFeedback>} Resolved upon completion of the command.
      */
     public setPFExtendedChannel (channel: number) {
         let address = 0;
@@ -177,11 +176,10 @@ export class ColorDistanceSensor extends Device {
 
     /**
      * Set the power of a Power Functions motor via IR
-     * @method ColorDistanceSensor#setPFPower
      * @param {number} channel Channel number, between 1-4
      * @param {string} output Outport port, "RED" (A) or "BLUE" (B)
      * @param {number} power -7 (full reverse) to 7 (full forward). 0 is stop. 8 is brake.
-     * @returns {Promise} Resolved upon successful issuance of the command.
+     * @returns {Promise<CommandFeedback>} Resolved upon completion of the command.
      */
     public setPFPower (channel: number, output: Output, power: number) {
         let address = 0;
@@ -201,11 +199,10 @@ export class ColorDistanceSensor extends Device {
      * Start Power Functions motors running via IR
      *
      * NOTE: This command is designed for bang-bang style operation. To keep the motors running, the sensor needs to be within range of the IR receiver constantly.
-     * @method ColorDistanceSensor#startPFMotors
-     * @param {Buffer} channel Channel number, between 1-4
-     * @param {Buffer} powerA -7 (full reverse) to 7 (full forward). 0 is stop. 8 is brake.
-     * @param {Buffer} powerB -7 (full reverse) to 7 (full forward). 0 is stop. 8 is brake.
-     * @returns {Promise} Resolved upon successful issuance of the command.
+     * @param {number} channel Channel number, between 1-4
+     * @param {number} powerBlue -7 (full reverse) to 7 (full forward). 0 is stop. 8 is brake.
+     * @param {number} powerRed -7 (full reverse) to 7 (full forward). 0 is stop. 8 is brake.
+     * @returns {Promise<CommandFeedback>} Resolved upon completion of the command.
      */
     public startPFMotors (channel: number, powerBlue: number, powerRed: number) {
         let address = 0;
@@ -223,9 +220,8 @@ export class ColorDistanceSensor extends Device {
 
     /**
      * Send a raw Power Functions IR command
-     * @method ColorDistanceSensor#sendPFIRMessage
      * @param {Buffer} message 2 byte payload making up a Power Functions protocol command. NOTE: Only specify nibbles 1-3, nibble 4 should be zeroed.
-     * @returns {Promise} Resolved upon successful issuance of the command.
+     * @returns {Promise<CommandFeedback>} Resolved upon completion of the command.
      */
     public sendPFIRMessage (message: Buffer) {
         if (this.isWeDo2SmartHub) {
@@ -242,43 +238,35 @@ export class ColorDistanceSensor extends Device {
 
     /**
      * Set the color of the LED on the sensor via a color value.
-     * @method ColorDistanceSensor#setColor
      * @param {Color} color
-     * @returns {Promise} Resolved upon successful issuance of the command.
+     * @returns {Promise<CommandFeedback>} Resolved upon completion of the command.
      */
     public setColor (color: number | boolean) {
-        return new Promise<void>((resolve) => {
-            if (color === false) {
-                color = 0;
-            }
-            if (this.isWeDo2SmartHub) {
-                throw new Error("Setting LED color is not available on the WeDo 2.0 Smart Hub");
-            } else {
-                this.subscribe(Mode.LED);
-                this.writeDirect(0x05, Buffer.from([color as number]));
-            }
-            return resolve();
-        });
+        if (color === false) {
+            color = 0;
+        }
+        if (this.isWeDo2SmartHub) {
+            throw new Error("Setting LED color is not available on the WeDo 2.0 Smart Hub");
+        } else {
+            this.subscribe(Mode.LED);
+            return this.writeDirect(0x05, Buffer.from([color as number]));
+        }
     }
 
     /**
      * Set the distance count value.
-     * @method ColorDistanceSensor#setDistanceCount
-     * @param {count} distance count between 0 and 2^32
-     * @returns {Promise} Resolved upon successful issuance of the command.
+     * @param {number} count distance count between 0 and 2^32
+     * @returns {Promise<CommandFeedback>} Resolved upon completion of the command.
      */
     public setDistanceCount (count: number) {
-        return new Promise<void>((resolve) => {
-            if (this.isWeDo2SmartHub) {
-                throw new Error("Setting distance count is not available on the WeDo 2.0 Smart Hub");
-            } else {
-		const payload = Buffer.alloc(4);
-		payload.writeUInt32LE(count % 2**32);
-                // no need to subscribe, can be set in different mode
-                this.writeDirect(0x02, payload);
-            }
-            return resolve();
-        });
+        if (this.isWeDo2SmartHub) {
+            throw new Error("Setting distance count is not available on the WeDo 2.0 Smart Hub");
+        } else {
+            const payload = Buffer.alloc(4);
+            payload.writeUInt32LE(count % 2**32);
+            // no need to subscribe, can be set in different mode
+            return this.writeDirect(0x02, payload);
+        }
     }
 
     private _pfPowerToPWM (power: number) {

package/src/devices/currentsensor.ts

@@ -1,8 +1,8 @@
-import { Device } from "./device";
+import { Device } from "./device.js";
 
-import { IDeviceInterface } from "../interfaces";
+import { IDeviceInterface } from "../interfaces.js";
 
-import * as Consts from "../consts";
+import * as Consts from "../consts.js";
 
 /**
  * @class CurrentSensor

package/src/devices/device.ts

@@ -1,8 +1,13 @@
 import { EventEmitter } from "events";
 
-import { IDeviceInterface } from "../interfaces";
+import { IDeviceInterface } from "../interfaces.js";
+import { PortOutputCommand } from "../portoutputcommand.js";
+import { PortOutputSleep } from "../portoutputsleep.js";
 
-import * as Consts from "../consts";
+import * as Consts from "../consts.js";
+
+import Debug = require("debug");
+const debug = Debug("device");
 
 /**
  * @class Device
@@ -14,8 +19,9 @@ export class Device extends EventEmitter {
     public values: {[event: string]: any} = {};
 
     protected _mode: number | undefined;
-    protected _busy: boolean = false;
-    protected _finishedCallbacks: (() => void)[] = [];
+    protected _bufferLength: number = 0;
+    protected _nextPortOutputCommands: (PortOutputCommand | PortOutputSleep)[] = [];
+    protected _transmittedPortOutputCommands: PortOutputCommand[] = [];
 
     private _hub: IDeviceInterface;
     private _portId: number;
@@ -25,7 +31,6 @@ export class Device extends EventEmitter {
 
     private _isWeDo2SmartHub: boolean;
     private _isVirtualPort: boolean = false;
-    private _eventTimer: NodeJS.Timeout | null = null;
 
     constructor (hub: IDeviceInterface, portId: number, modeMap: {[event: string]: number} = {}, type: Consts.DeviceType = Consts.DeviceType.UNKNOWN) {
         super();
@@ -126,11 +131,11 @@ export class Device extends EventEmitter {
         return this._isVirtualPort;
     }
 
-    public writeDirect (mode: number, data: Buffer) {
+    public writeDirect (mode: number, data: Buffer, interrupt: boolean = false) {
         if (this.isWeDo2SmartHub) {
-            return this.send(Buffer.concat([Buffer.from([this.portId, 0x01, 0x02]), data]), Consts.BLECharacteristic.WEDO2_MOTOR_VALUE_WRITE);
+            return this.send(Buffer.concat([Buffer.from([this.portId, 0x01, 0x02]), data]), Consts.BLECharacteristic.WEDO2_MOTOR_VALUE_WRITE).then(() => { return Consts.CommandFeedback.FEEDBACK_DISABLED; });
         } else {
-            return this.send(Buffer.concat([Buffer.from([0x81, this.portId, 0x11, 0x51, mode]), data]), Consts.BLECharacteristic.LPF2_ALL);
+            return this.sendPortOutputCommand(Buffer.concat([Buffer.from([0x51, mode]), data]), interrupt);
         }
     }
 
@@ -142,7 +147,6 @@ export class Device extends EventEmitter {
     public subscribe (mode: number) {
         this._ensureConnected();
         if (mode !== this._mode) {
-            this._mode = mode;
             this.hub.subscribe(this.portId, this.type, mode);
         }
     }
@@ -167,26 +171,180 @@ export class Device extends EventEmitter {
         this.send(Buffer.from([0x21, this.portId, 0x00]));
     }
 
-    public finish (message: number) {
-        if((message & 0x10) === 0x10) return; // "busy/full"
-        this._busy = (message & 0x01) === 0x01;
-        while(this._finishedCallbacks.length > Number(this._busy)) {
-            const callback = this._finishedCallbacks.shift();
-            if(callback) {
-                 callback();
+    public setMode (mode: number) {
+        this._mode = mode;
+    }
+
+    protected transmitNextPortOutputCommand() {
+        if(!this.connected) {
+            this._transmittedPortOutputCommands.forEach(command => command.resolve(Consts.CommandFeedback.FEEDBACK_MISSING));
+            this._transmittedPortOutputCommands = [];
+            this._nextPortOutputCommands.forEach(command => command.resolve(Consts.CommandFeedback.TRANSMISSION_DISCARDED));
+            this._nextPortOutputCommands = [];
+            return;
+        }
+        if(!this._nextPortOutputCommands.length) return;
+        const nextCommand = this._nextPortOutputCommands[0];
+        if(nextCommand instanceof PortOutputSleep) {
+            if(nextCommand.state === Consts.CommandFeedback.EXECUTION_PENDING) {
+                nextCommand.state = Consts.CommandFeedback.EXECUTION_BUSY;
+                debug("sleep command ", nextCommand.duration);
+                setTimeout(() => {
+                    if(nextCommand.state !== Consts.CommandFeedback.EXECUTION_BUSY) return;
+                    const command = this._nextPortOutputCommands.shift();
+                    if(command) command.resolve(Consts.CommandFeedback.EXECUTION_COMPLETED);
+                    this.transmitNextPortOutputCommand();
+                }, nextCommand.duration);
             }
+            return;
+        }
+        if(this._bufferLength !== this._transmittedPortOutputCommands.length) return;
+        if(this._bufferLength < 2 || nextCommand.interrupt) {
+            if(nextCommand.state === Consts.CommandFeedback.TRANSMISSION_PENDING) {
+                nextCommand.state = Consts.CommandFeedback.TRANSMISSION_BUSY;
+                debug("transmit command ", nextCommand.startupAndCompletion, nextCommand.data);
+                this.send(Buffer.concat([Buffer.from([0x81, this.portId, nextCommand.startupAndCompletion]), nextCommand.data])).then(() => {
+                    if(nextCommand.state !== Consts.CommandFeedback.TRANSMISSION_BUSY) return;
+                    const command = this._nextPortOutputCommands.shift();
+                    if(command instanceof PortOutputCommand) this._transmittedPortOutputCommands.push(command);
+                });
+                this.transmitNextPortOutputCommand(); // if the next command is PortOutputSleep this starts sleep timeout
+                // one could start a timer here to ensure finish function is called
+            }
+        }
+    }
+
+    public sendPortOutputCommand(data: Buffer, interrupt: boolean = false) {
+        if (this.isWeDo2SmartHub) {
+            throw new Error("PortOutputCommands are not available on the WeDo 2.0 Smart Hub");
+            return;
+        }
+        const command = new PortOutputCommand(data, interrupt);
+        if(interrupt) {
+            this._nextPortOutputCommands.forEach(command => {
+                if(command.state !== Consts.CommandFeedback.TRANSMISSION_BUSY) {
+                    command.resolve(Consts.CommandFeedback.TRANSMISSION_DISCARDED);
+                }
+            });
+            this._nextPortOutputCommands = this._nextPortOutputCommands.filter(command => command.state === Consts.CommandFeedback.TRANSMISSION_BUSY);
         }
+        this._nextPortOutputCommands.push(command);
+        process.nextTick(() => this.transmitNextPortOutputCommand());
+        return command.promise;
     }
 
-    public setEventTimer (timer: NodeJS.Timeout) {
-        this._eventTimer = timer;
+    public addPortOutputSleep(duration: number) {
+        const command = new PortOutputSleep(duration);
+        this._nextPortOutputCommands.push(command);
+        process.nextTick(() => this.transmitNextPortOutputCommand());
+        return command.promise;
     }
 
-    public cancelEventTimer () {
-        if (this._eventTimer) {
-            clearTimeout(this._eventTimer);
-            this._eventTimer = null;
+    public finish (message: number) {
+        debug("recieved command feedback ", message);
+        if((message & 0x08) === 0x08) this._bufferLength = 0;
+        else if((message & 0x01) === 0x01) this._bufferLength = 1;
+        else if((message & 0x10) === 0x10) this._bufferLength = 2;
+        const completed = ((message & 0x02) === 0x02);
+        const discarded = ((message & 0x04) === 0x04);
+
+        switch(this._transmittedPortOutputCommands.length) {
+            case 0:
+                break;
+            case 1:
+                if(!this._bufferLength && completed && !discarded) {
+                    this._complete();
+                }
+                else if(!this._bufferLength && !completed && discarded) {
+                    this._discard();
+                }
+                else if(this._bufferLength && !completed && !discarded) {
+                    this._busy();
+                }
+                else {
+                    this._missing();
+                }
+                break;
+            case 2:
+                if(!this._bufferLength && completed && discarded) {
+                    this._discard();
+                    this._complete();
+                }
+                else if(!this._bufferLength && completed && !discarded) {
+                    this._complete();
+                    this._complete();
+                }
+                else if(!this._bufferLength && !completed && discarded) {
+                    this._discard();
+                    this._discard();
+                }
+                else if(this._bufferLength === 1 && completed && !discarded) {
+                    this._complete();
+                    this._busy();
+                }
+                else if(this._bufferLength === 1 && !completed && discarded) {
+                    this._discard();
+                    this._busy();
+                }
+                else if(this._bufferLength === 1 && completed && discarded) {
+                    this._missing();
+                    this._busy();
+                }
+                else if(this._bufferLength === 2 && !completed && !discarded) {
+                    this._busy();
+                    this._pending();
+                }
+                else {
+                    this._missing();
+                    this._missing();
+                }
+                break;
+            case 3:
+                if(!this._bufferLength && completed && discarded) {
+                    this._discard();
+                    this._discard();
+                    this._complete();
+                }
+                else if(!this._bufferLength && completed && !discarded) {
+                    this._complete();
+                    this._complete();
+                    this._complete();
+                }
+                else if(!this._bufferLength && !completed && discarded) {
+                    this._discard();
+                    this._discard();
+                    this._discard();
+                }
+                else if(this._bufferLength === 1 && completed && discarded) {
+                    this._discard();
+                    this._complete();
+                    this._busy();
+                }
+                else if(this._bufferLength === 1 && completed && !discarded) {
+                    this._complete();
+                    this._complete();
+                    this._busy();
+                }
+                else if(this._bufferLength === 1 && !completed && discarded) {
+                    this._discard();
+                    this._discard();
+                    this._busy();
+                }
+                else if(this._bufferLength === 1 && !completed && !discarded) {
+                    this._missing();
+                    this._missing();
+                    this._busy();
+                }
+                // third command can only be interrupt, if this._bufferLength === 2 it was queued
+                else {
+                    this._missing();
+                    this._missing();
+                    this._missing();
+                }
+                break;
         }
+
+        this.transmitNextPortOutputCommand();
     }
 
     private _ensureConnected () {
@@ -195,4 +353,24 @@ export class Device extends EventEmitter {
         }
     }
 
+    private _complete () {
+        const command = this._transmittedPortOutputCommands.shift();
+        if(command) command.resolve(Consts.CommandFeedback.EXECUTION_COMPLETED);
+    }
+    private _discard () {
+        const command = this._transmittedPortOutputCommands.shift();
+        if(command) command.resolve(Consts.CommandFeedback.EXECUTION_DISCARDED);
+    }
+    private _missing () {
+        const command = this._transmittedPortOutputCommands.shift();
+        if(command) command.resolve(Consts.CommandFeedback.FEEDBACK_MISSING);
+    }
+    private _busy () {
+        const command = this._transmittedPortOutputCommands[0];
+        if(command) command.state = Consts.CommandFeedback.EXECUTION_BUSY;
+    }
+    private _pending () {
+        const command = this._transmittedPortOutputCommands[1];
+        if(command) command.state = Consts.CommandFeedback.EXECUTION_PENDING;
+    }
 }

package/src/devices/duplotrainbasecolorsensor.ts

@@ -1,9 +1,9 @@
-import { Device } from "./device";
+import { Device } from "./device.js";
 
-import { IDeviceInterface } from "../interfaces";
+import { IDeviceInterface } from "../interfaces.js";
 
-import * as Consts from "../consts";
-import { parseColor } from "../utils";
+import * as Consts from "../consts.js";
+import { parseColor } from "../utils.js";
 
 /**
  * @class DuploTrainBaseColorSensor

package/src/devices/duplotrainbasemotor.ts

@@ -1,8 +1,8 @@
-import { BasicMotor } from "./basicmotor";
+import { BasicMotor } from "./basicmotor.js";
 
-import { IDeviceInterface } from "../interfaces";
+import { IDeviceInterface } from "../interfaces.js";
 
-import * as Consts from "../consts";
+import * as Consts from "../consts.js";
 
 /**
  * @class DuploTrainBaseMotor

package/src/devices/duplotrainbasespeaker.ts

@@ -1,8 +1,8 @@
-import { Device } from "./device";
+import { Device } from "./device.js";
 
-import { IDeviceInterface } from "../interfaces";
+import { IDeviceInterface } from "../interfaces.js";
 
-import * as Consts from "../consts";
+import * as Consts from "../consts.js";
 
 /**
  * @class DuploTrainBaseSpeaker
@@ -16,27 +16,22 @@ export class DuploTrainBaseSpeaker extends Device {
 
     /**
      * Play a built-in train sound.
-     * @method DuploTrainBaseSpeaker#playSound
      * @param {DuploTrainBaseSound} sound
-     * @returns {Promise} Resolved upon successful issuance of the command.
+     * @returns {Promise<CommandFeedback>} Resolved upon completion of command.
      */
     public playSound (sound: Consts.DuploTrainBaseSound) {
-        return new Promise<void>((resolve) => {
-            this.subscribe(Mode.SOUND);
-            this.writeDirect(0x01, Buffer.from([sound]));
-            return resolve();
-        });
+        this.subscribe(Mode.SOUND);
+        return this.writeDirect(0x01, Buffer.from([sound]));
     }
 
     /**
      * Play a built-in system tone.
-     * @method DuploTrainBaseSpeaker#playTone
      * @param {number} tone
-     * @returns {Promise} Resolved upon successful issuance of the command.
+     * @returns {Promise<CommandFeedback>} Resolved upon completion of command.
      */
     public playTone (tone: number) {
         this.subscribe(Mode.TONE);
-        this.writeDirect(0x02, Buffer.from([tone]));
+        return this.writeDirect(0x02, Buffer.from([tone]));
     }
 
 }

package/src/devices/duplotrainbasespeedometer.ts

@@ -1,8 +1,8 @@
-import { Device } from "./device";
+import { Device } from "./device.js";
 
-import { IDeviceInterface } from "../interfaces";
+import { IDeviceInterface } from "../interfaces.js";
 
-import * as Consts from "../consts";
+import * as Consts from "../consts.js";
 
 /**
  * @class DuploTraniBaseSpeedometer

package/src/devices/hubled.ts

@@ -1,8 +1,8 @@
-import { Device } from "./device";
+import { Device } from "./device.js";
 
-import { IDeviceInterface } from "../interfaces";
+import { IDeviceInterface } from "../interfaces.js";
 
-import * as Consts from "../consts";
+import * as Consts from "../consts.js";
 
 /**
  * @class HubLED
@@ -18,46 +18,44 @@ export class HubLED extends Device {
 
     /**
      * Set the color of the LED on the Hub via a color value.
-     * @method HubLED#setColor
      * @param {Color} color
-     * @returns {Promise} Resolved upon successful issuance of the command.
+     * @returns {Promise<CommandFeedback>} Resolved upon completion of command.
      */
     public setColor (color: number | boolean) {
-        return new Promise<void>((resolve) => {
-            if (typeof color === "boolean") {
-                color = 0;
-            }
-            if (this.isWeDo2SmartHub) {
+        if (typeof color === "boolean") {
+            color = 0;
+        }
+        if (this.isWeDo2SmartHub) {
+            return new Promise<Consts.CommandFeedback>((resolve) => {
                 this.send(Buffer.from([0x06, 0x17, 0x01, 0x01]), Consts.BLECharacteristic.WEDO2_PORT_TYPE_WRITE);
-                this.send(Buffer.from([0x06, 0x04, 0x01, color]), Consts.BLECharacteristic.WEDO2_MOTOR_VALUE_WRITE);
-            } else {
-                this.subscribe(Mode.COLOR);
-                this.writeDirect(0x00, Buffer.from([color]));
-            }
-            return resolve();
-        });
+                this.send(Buffer.from([0x06, 0x04, 0x01, Number(color)]), Consts.BLECharacteristic.WEDO2_MOTOR_VALUE_WRITE);
+                return resolve(Consts.CommandFeedback.FEEDBACK_DISABLED);
+            })
+        } else {
+            this.subscribe(Mode.COLOR);
+            return this.writeDirect(0x00, Buffer.from([color]));
+        }
     }
 
 
     /**
      * Set the color of the LED on the Hub via RGB values.
-     * @method HubLED#setRGB
      * @param {number} red
      * @param {number} green
      * @param {number} blue
-     * @returns {Promise} Resolved upon successful issuance of the command.
+     * @returns {Promise<CommandFeedback>} Resolved upon completion of command.
      */
     public setRGB (red: number, green: number, blue: number) {
-        return new Promise<void>((resolve) => {
-            if (this.isWeDo2SmartHub) {
+        if (this.isWeDo2SmartHub) {
+            return new Promise<Consts.CommandFeedback>((resolve) => {
                 this.send(Buffer.from([0x06, 0x17, 0x01, 0x02]), Consts.BLECharacteristic.WEDO2_PORT_TYPE_WRITE);
                 this.send(Buffer.from([0x06, 0x04, 0x03, red, green, blue]), Consts.BLECharacteristic.WEDO2_MOTOR_VALUE_WRITE);
-            } else {
-                this.subscribe(Mode.RGB);
-                this.writeDirect(0x01, Buffer.from([red, green, blue]));
-            }
-            return resolve();
-        });
+                resolve(Consts.CommandFeedback.FEEDBACK_DISABLED);
+            });
+        } else {
+            this.subscribe(Mode.RGB);
+            return this.writeDirect(0x01, Buffer.from([red, green, blue]));
+        }
     }
 
 

package/src/devices/light.ts

@@ -1,9 +1,9 @@
-import { Device } from "./device";
+import { Device } from "./device.js";
 
-import { IDeviceInterface } from "../interfaces";
+import { IDeviceInterface } from "../interfaces.js";
 
-import * as Consts from "../consts";
-import { calculateRamp } from "../utils";
+import * as Consts from "../consts.js";
+import { calculateRamp } from "../utils.js";
 
 /**
  * @class Light
@@ -19,39 +19,30 @@ export class Light extends Device {
 
     /**
      * Set the light brightness.
-     * @method Light#setBrightness
      * @param {number} brightness Brightness value between 0-100 (0 is off)
-     * @returns {Promise} Resolved upon successful completion of command.
+     * @param {number} brightness Brightness value between 0-100 (0 is off)
+     * @param {boolean} [interrupt=false] If true, previous commands are discarded.
+     * @returns {Promise<CommandFeedback>} Resolved upon completion of command.
      */
-    public setBrightness (brightness: number, interrupt: boolean = true) {
-        if (interrupt) {
-            this.cancelEventTimer();
-        }
-        return new Promise<void>((resolve) => {
-            this.writeDirect(0x00, Buffer.from([brightness]));
-            return resolve();
-        });
+    public setBrightness (brightness: number, interrupt: boolean = false) {
+        return this.writeDirect(0x00, Buffer.from([brightness]), interrupt);
     }
 
 
     /**
      * Ramp the light brightness.
-     * @method Light#rampBrightness
      * @param {number} fromBrightness Brightness value between 0-100 (0 is off)
      * @param {number} toBrightness Brightness value between 0-100 (0 is off)
      * @param {number} time How long the ramp should last (in milliseconds).
-     * @returns {Promise} Resolved upon successful completion of command.
+     * @returns {Promise<CommandFeedback>} Resolved upon completion of command.
      */
     public rampBrightness (fromBrightness: number, toBrightness: number, time: number) {
-        this.cancelEventTimer();
-        return new Promise((resolve) => {
-            calculateRamp(this, fromBrightness, toBrightness, time)
-            .on("changePower", (power) => {
-                this.setBrightness(power, false);
-            })
-            .on("finished", resolve);
+        const powerValues = calculateRamp(fromBrightness, toBrightness, time);
+        powerValues.forEach(value => {
+            this.setBrightness(value);
+            this.addPortOutputSleep(Math.round(time/powerValues.length));
         });
+        return this.setBrightness(toBrightness);
     }
 
-
 }

package/src/devices/marioaccelerometer.ts

@@ -1,8 +1,8 @@
-import { Device } from "./device";
+import { Device } from "./device.js";
 
-import { IDeviceInterface } from "../interfaces";
+import { IDeviceInterface } from "../interfaces.js";
 
-import * as Consts from "../consts";
+import * as Consts from "../consts.js";
 
 /**
  * @class MarioAccelerometer