node-poweredup 10.0.0 → 10.1.0

package/src/devices/device.ts

@@ -1,9 +1,14 @@
 import { EventEmitter } from "events";
 
 import { IDeviceInterface } from "../interfaces.js";
+import { PortOutputCommand } from "../portoutputcommand.js";
+import { PortOutputSleep } from "../portoutputsleep.js";
 
 import * as Consts from "../consts.js";
 
+import Debug = require("debug");
+const debug = Debug("device");
+
 /**
  * @class Device
  * @extends EventEmitter
@@ -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/duplotrainbasespeaker.ts

@@ -17,24 +17,21 @@ export class DuploTrainBaseSpeaker extends Device {
     /**
      * Play a built-in train sound.
      * @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.
      * @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/hubled.ts

@@ -19,22 +19,22 @@ export class HubLED extends Device {
     /**
      * Set the color of the LED on the Hub via a color value.
      * @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]));
+        }
     }
 
 
@@ -43,19 +43,19 @@ export class HubLED extends Device {
      * @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

@@ -20,16 +20,12 @@ export class Light extends Device {
     /**
      * Set the light brightness.
      * @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);
     }
 
 
@@ -38,18 +34,15 @@ export class Light extends Device {
      * @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/piezobuzzer.ts

@@ -20,15 +20,15 @@ export class PiezoBuzzer extends Device {
      * Play a tone on the Hub's in-built buzzer
      * @param {number} frequency
      * @param {number} time How long the tone should play for (in milliseconds).
-     * @returns {Promise} Resolved upon successful completion of command (ie. once the tone has finished playing).
+     * @returns {Promise<CommandFeedback>} Resolved upon completion of command (i.e. once the tone has finished playing).
      */
     public playTone (frequency: number, time: number) {
-        return new Promise((resolve) => {
+        return new Promise<Consts.CommandFeedback>((resolve) => {
             const data = Buffer.from([0x05, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00]);
             data.writeUInt16LE(frequency, 3);
             data.writeUInt16LE(time, 5);
             this.send(data, Consts.BLECharacteristic.WEDO2_MOTOR_VALUE_WRITE);
-            global.setTimeout(resolve, time);
+            global.setTimeout(() => {return resolve(Consts.CommandFeedback.FEEDBACK_DISABLED)}, time);
         });
     }
 

package/src/devices/tachomotor.ts

@@ -63,24 +63,28 @@ export class TachoMotor extends BasicMotor {
     /**
      * Set the global acceleration time
      * @param {number} time How long acceleration should last (in milliseconds).
-     * @returns {Promise} Resolved upon successful completion of command (ie. once the motor is finished).
+     * @param {number} profile 0 by default
+     * @param {boolean} [interrupt=false] If true, previous commands are discarded.
+     * @returns {Promise<CommandFeedback>} Resolved upon completion of command (i.e. once the motor is finished).
      */
-    public setAccelerationTime (time: number, profile: number = 0x00) {
-        const message = Buffer.from([0x81, this.portId, 0x11, 0x05, 0x00, 0x00, profile]);
-        message.writeUInt16LE(time, 4);
-        this.send(message);
+    public setAccelerationTime (time: number, profile: number = 0x00, interrupt: boolean = false) {
+        const message = Buffer.from([0x05, 0x00, 0x00, profile]);
+        message.writeUInt16LE(time, 1);
+        return this.sendPortOutputCommand(message, interrupt);
     }
 
 
     /**
      * Set the global deceleration time
      * @param {number} time How long deceleration should last (in milliseconds).
-     * @returns {Promise} Resolved upon successful completion of command (ie. once the motor is finished).
+     * @param {number} profile 0 by default
+     * @param {boolean} [interrupt=false] If true, previous commands are discarded.
+     * @returns {Promise<CommandFeedback>} Resolved upon completion of command (i.e. once the motor is finished).
      */
-    public setDecelerationTime (time: number, profile: number = 0x00) {
-        const message = Buffer.from([0x81, this.portId, 0x11, 0x06, 0x00, 0x00, profile]);
-        message.writeUInt16LE(time, 4);
-        this.send(message);
+    public setDecelerationTime (time: number, profile: number = 0x00, interrupt: boolean = true) {
+        const message = Buffer.from([0x06, 0x00, 0x00, profile]);
+        message.writeUInt16LE(time, 1);
+        return this.sendPortOutputCommand(message, interrupt);
     }
 
 
@@ -88,72 +92,62 @@ export class TachoMotor extends BasicMotor {
      * Set the motor speed.
      * @param {number} speed 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 motor should run for (in milliseconds).
-     * @returns {Promise} Resolved upon successful issuance of the command.
+     * @param {boolean} [interrupt=false] If true, previous commands are discarded.
+     * @returns {Promise<CommandFeedback>} Resolved upon completion of command (i.e. once the motor is finished).
      */
-    public setSpeed (speed: [number, number] | number, time: number | undefined) {
+    public setSpeed (speed: [number, number] | number, time: number | undefined, interrupt: boolean = false) {
         if (!this.isVirtualPort && speed instanceof Array) {
             throw new Error("Only virtual ports can accept multiple speeds");
         }
         if (this.isWeDo2SmartHub) {
             throw new Error("Motor speed is not available on the WeDo 2.0 Smart Hub");
         }
-        this.cancelEventTimer();
-        return new Promise<void>((resolve) => {
-            if (speed === undefined || speed === null) {
-                speed = 100;
+        if (speed === undefined || speed === null) {
+            speed = 100;
+        }
+        let message;
+        if (time !== undefined) {
+            if (speed instanceof Array) {
+                message = Buffer.from([0x0a, 0x00, 0x00, mapSpeed(speed[0]), mapSpeed(speed[1]), this._maxPower, this._brakeStyle, this.useProfile()]);
+            } else {
+                message = Buffer.from([0x09, 0x00, 0x00, mapSpeed(speed), this._maxPower, this._brakeStyle, this.useProfile()]);
             }
-            let message;
-            if (time !== undefined) {
-                if (speed instanceof Array) {
-                    message = Buffer.from([0x81, this.portId, 0x11, 0x0a, 0x00, 0x00, mapSpeed(speed[0]), mapSpeed(speed[1]), this._maxPower, this._brakeStyle, this.useProfile()]);
-                } else {
-                    message = Buffer.from([0x81, this.portId, 0x11, 0x09, 0x00, 0x00, mapSpeed(speed), this._maxPower, this._brakeStyle, this.useProfile()]);
-                }
-                message.writeUInt16LE(time, 4);
+            message.writeUInt16LE(time, 1);
+        } else {
+            if (speed instanceof Array) {
+                message = Buffer.from([0x08, mapSpeed(speed[0]), mapSpeed(speed[1]), this._maxPower, this.useProfile()]);
             } else {
-                if (speed instanceof Array) {
-                    message = Buffer.from([0x81, this.portId, 0x11, 0x08, mapSpeed(speed[0]), mapSpeed(speed[1]), this._maxPower, this.useProfile()]);
-                } else {
-                    message = Buffer.from([0x81, this.portId, 0x11, 0x07, mapSpeed(speed), this._maxPower, this.useProfile()]);
-                }
+                message = Buffer.from([0x07, mapSpeed(speed), this._maxPower, this.useProfile()]);
             }
-            this.send(message);
-            this._finishedCallbacks.push(() => {
-                return resolve();
-            });
-        });
+        }
+        return this.sendPortOutputCommand(message, interrupt);
     }
 
     /**
      * Rotate a motor by a given amount of degrees.
      * @param {number} degrees How much the motor should be rotated (in degrees).
      * @param {number} [speed=100] For forward, a value between 1 - 100 should be set. For reverse, a value between -1 to -100.
-     * @returns {Promise} Resolved upon successful completion of command (ie. once the motor is finished).
+     * @param {boolean} [interrupt=false] If true, previous commands are discarded.
+     * @returns {Promise<CommandFeedback>} Resolved upon completion of command (i.e. once the motor is finished).
      */
-    public rotateByDegrees (degrees: number, speed: [number, number] | number) {
+    public rotateByDegrees (degrees: number, speed: [number, number] | number, interrupt: boolean = false) {
         if (!this.isVirtualPort && speed instanceof Array) {
             throw new Error("Only virtual ports can accept multiple speeds");
         }
         if (this.isWeDo2SmartHub) {
             throw new Error("Rotation is not available on the WeDo 2.0 Smart Hub");
         }
-        this.cancelEventTimer();
-        return new Promise<void>((resolve) => {
-            if (speed === undefined || speed === null) {
-                speed = 100;
-            }
-            let message;
-            if (speed instanceof Array) {
-                message = Buffer.from([0x81, this.portId, 0x11, 0x0c, 0x00, 0x00, 0x00, 0x00, mapSpeed(speed[0]), mapSpeed(speed[1]), this._maxPower, this._brakeStyle, this.useProfile()]);
-            } else {
-                message = Buffer.from([0x81, this.portId, 0x11, 0x0b, 0x00, 0x00, 0x00, 0x00, mapSpeed(speed), this._maxPower, this._brakeStyle, this.useProfile()]);
-            }
-            message.writeUInt32LE(degrees, 4);
-            this.send(message);
-            this._finishedCallbacks.push(() => {
-                return resolve();
-            });
-        });
+        if (speed === undefined || speed === null) {
+            speed = 100;
+        }
+        let message;
+        if (speed instanceof Array) {
+            message = Buffer.from([0x0c, 0x00, 0x00, 0x00, 0x00, mapSpeed(speed[0]), mapSpeed(speed[1]), this._maxPower, this._brakeStyle, this.useProfile()]);
+        } else {
+            message = Buffer.from([0x0b, 0x00, 0x00, 0x00, 0x00, mapSpeed(speed), this._maxPower, this._brakeStyle, this.useProfile()]);
+        }
+        message.writeUInt32LE(degrees, 1);
+        return this.sendPortOutputCommand(message, interrupt);
     }
 
 

package/src/devices/technic3x3colorlightmatrix.ts

@@ -21,35 +21,32 @@ export class Technic3x3ColorLightMatrix extends Device {
     /**
      * Set the LED matrix, one color per LED
      * @param {Color[] | Color} colors Array of 9 colors, 9 Color objects, or a single color
-     * @returns {Promise} Resolved upon successful issuance of the command.
+     * @returns {Promise<CommandFeedback>} Resolved upon completion of command.
      */
     public setMatrix (colors: number[] | number) {
-        return new Promise<void>((resolve) => {
-            this.subscribe(Mode.PIX_0);
-            const colorArray = new Array(9);
-            for (let i = 0; i < colorArray.length; i++) {
-                if (typeof colors ===  'number') {
-                    // @ts-ignore
-                    colorArray[i] = colors + (10 << 4);
-                }
+        this.subscribe(Mode.PIX_0);
+        const colorArray = new Array(9);
+        for (let i = 0; i < colorArray.length; i++) {
+            if (typeof colors ===  'number') {
                 // @ts-ignore
-                if (colors[i] instanceof Color) {
-                    // @ts-ignore
-                    colorArray[i] = colors[i].toValue();
-                }
+                colorArray[i] = colors + (10 << 4);
+            }
+            // @ts-ignore
+            if (colors[i] instanceof Color) {
                 // @ts-ignore
-                if (colors[i] === Consts.Color.NONE) {
-                    colorArray[i] = Consts.Color.NONE;
-                }
+                colorArray[i] = colors[i].toValue();
+            }
+            // @ts-ignore
+            if (colors[i] === Consts.Color.NONE) {
+                colorArray[i] = Consts.Color.NONE;
+            }
+            // @ts-ignore
+            if (colors[i] <= 10) {
                 // @ts-ignore
-                if (colors[i] <= 10) {
-                    // @ts-ignore
-                    colorArray[i] = colors[i] + (10 << 4); // If a raw color value, set it to max brightness (10)
-                }
+                colorArray[i] = colors[i] + (10 << 4); // If a raw color value, set it to max brightness (10)
             }
-            this.writeDirect(Mode.PIX_0, Buffer.from(colorArray));
-            return resolve();
-        });
+        }
+        return this.writeDirect(Mode.PIX_0, Buffer.from(colorArray));
     }