node-poweredup 7.1.0 → 8.0.0

package/src/devices/colordistancesensor.ts

@@ -38,7 +38,7 @@ export class ColorDistanceSensor extends Device {
                     break;
                 }
                 if (message[4] <= 10) {
-                    let distance = Math.floor(message[4] * 25.4);
+                    let distance = Math.floor(message[4] * 25.4) - 20;
 
                     if (distance < 0) {
                         distance = 0;
@@ -54,6 +54,74 @@ export class ColorDistanceSensor extends Device {
                 }
                 break;
 
+            case Mode.DISTANCE_COUNT:
+                if (this.isWeDo2SmartHub) {
+                    break;
+                }
+                if (message.length !== 8) {
+                    // if mode of device has not changed to this._mode yet
+                    break;
+                }
+                const count = message.readUInt32LE(4);
+                /**
+                 * Emits when distance is reduced to less than 10 centimeters.
+                 * @event ColorDistanceSensor#distanceCount
+                 * @type {object}
+                 * @param {number} number of distance events.
+                 */
+                this.notify("distanceCount", { count });
+                break;
+
+            case Mode.REFLECT:
+                if (this.isWeDo2SmartHub) {
+                    break;
+                }
+                const reflect = message[4];
+                /**
+                 * Event measuring reflection change, emits when the sensor is activated.
+                 * @event ColorDistanceSensor#reflect
+                 * @type {object}
+                 * @param {number} percentage from 0 to 100.
+                 */
+                this.notify("reflect", { reflect });
+                break;
+
+            case Mode.AMBIENT:
+                if (this.isWeDo2SmartHub) {
+                    break;
+                }
+                const ambient = message[4];
+                /**
+                 * Event measuring abient light change, emits when the sensor is activated.
+                 * @event ColorDistanceSensor#ambient
+                 * @type {object}
+                 * @param {number} percentage from 0 to 100.
+                 */
+                this.notify("ambient", { ambient });
+                break;
+
+            case Mode.RGB_I:
+                if (this.isWeDo2SmartHub) {
+                    break;
+                }
+                if (message.length !== 10) {
+                    // if mode of device has not changed to this._mode yet
+                    break;
+                }
+                const red = message.readUInt16LE(4);
+                const green = message.readUInt16LE(6);
+                const blue = message.readUInt16LE(8);
+                /**
+                 * Emits when a color sensor is activated.
+                 * @event ColorDistanceSensor#rgbIntensity
+                 * @type {object}
+                 * @param {number} red
+                 * @param {number} green
+                 * @param {number} blue
+                 */
+                this.notify("rgbIntensity", { red, green, blue });
+                break;
+
             case Mode.COLOR_AND_DISTANCE:
                 if (this.isWeDo2SmartHub) {
                     break;
@@ -193,18 +261,40 @@ export class ColorDistanceSensor extends Device {
         });
     }
 
+    /**
+     * 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.
+     */
+    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();
+        });
+    }
 
     private _pfPowerToPWM (power: number) {
         return power & 15;
     }
 
-
 }
 
 export enum Mode {
     COLOR = 0x00,
     DISTANCE = 0x01,
+    DISTANCE_COUNT = 0x02,
+    REFLECT = 0x03,
+    AMBIENT = 0x04,
     LED = 0x05,
+    RGB_I = 0x06,
     PF_IR = 0x07,
     COLOR_AND_DISTANCE = 0x08
 }
@@ -212,6 +302,10 @@ export enum Mode {
 export const ModeMap: {[event: string]: number} = {
     "color": Mode.COLOR,
     "distance": Mode.DISTANCE,
+    "distanceCount": Mode.DISTANCE_COUNT,
+    "reflect": Mode.REFLECT,
+    "ambient": Mode.AMBIENT,
+    "rgbIntensity": Mode.RGB_I,
     "colorAndDistance": Mode.COLOR_AND_DISTANCE
 };
 

package/src/devices/device.ts

@@ -168,6 +168,7 @@ export class Device extends EventEmitter {
     }
 
     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();

package/src/devices/technicmediumhubtiltsensor.ts

@@ -10,6 +10,9 @@ import * as Consts from "../consts";
  */
 export class TechnicMediumHubTiltSensor extends Device {
 
+    protected _impactThreshold: number = 10; // guess of default value
+    protected _impactHoldoff: number = 10; // guess of default value
+
     constructor (hub: IDeviceInterface, portId: number) {
         super(hub, portId, ModeMap, Consts.DeviceType.TECHNIC_MEDIUM_HUB_TILT_SENSOR);
     }
@@ -21,26 +24,95 @@ export class TechnicMediumHubTiltSensor extends Device {
             case Mode.TILT:
                 /**
                  * Emits when a tilt sensor is activated.
+                 *
                  * @event TechnicMediumHubTiltSensor#tilt
                  * @type {object}
                  * @param {number} x
                  * @param {number} y
                  * @param {number} z
                  */
-                const z = -message.readInt16LE(4);
+                let z = -message.readInt16LE(4);
                 const y = message.readInt16LE(6);
                 const x = message.readInt16LE(8);
+
+                // workaround for calibration problem or bug in technicMediumHub firmware 1.1.00.0000
+                if(y === 90 || y === -90) {
+                    z = Math.sign(y)*(z + 180);
+                    if(z > 180) z -= 360;
+                    if(z < -180) z += 360;
+                }
+
                 this.notify("tilt", { x, y, z });
                 break;
+
+            case Mode.IMPACT_COUNT:
+                if (message.length !== 8) {
+                    // if mode of device has not changed to this._mode yet
+                    break;
+                }
+                const count = message.readUInt32LE(4);
+                /**
+                 * Emits when proper acceleration is above threshold (e.g. on impact when being thrown to the ground).
+                 * @event TechnicMediumHubTiltSensor#impactCount
+                 * @type {object}
+                 * @param {number} number of impact events.
+                 */
+                this.notify("tiltCount", { count });
+                break;
         }
     }
 
+    /**
+     * Set the impact count value.
+     * @method TechnicMediumHubTiltSensor#setImpactCount
+     * @param {count} impact count between 0 and 2^32
+     * @returns {Promise} Resolved upon successful issuance of the command.
+     */
+    public setImpactCount (count: number) {
+        return new Promise<void>((resolve) => {
+            const payload = Buffer.alloc(4);
+	    payload.writeUInt32LE(count % 2**32);
+            // no need to subscribe, can be set in different mode
+            this.writeDirect(0x01, payload);
+            return resolve();
+        });
+    }
+
+    /**
+     * Set the impact threshold.
+     * @method TechnicMediumHubTiltSensor#setImpactThreshold
+     * @param {threshold} value between 1 and 127
+     * @returns {Promise} Resolved upon successful issuance of the command.
+     */
+    public setImpactThreshold (threshold: number) {
+        this._impactThreshold = threshold;
+        return new Promise<void>((resolve) => {
+            this.writeDirect(0x02, Buffer.from([this._impactThreshold, this._impactHoldoff]));
+            return resolve();
+        });
+    }
+
+    /**
+     * Set the impact holdoff time.
+     * @method TechnicMediumHubTiltSensor#setImpactHoldoff
+     * @param {holdoff} value between 1 and 127
+     * @returns {Promise} Resolved upon successful issuance of the command.
+     */
+    public setImpactHoldoff (holdoff: number) {
+        this._impactHoldoff = holdoff;
+        return new Promise<void>((resolve) => {
+            this.writeDirect(0x02, Buffer.from([this._impactThreshold, this._impactHoldoff]));
+            return resolve();
+        });
+    }
 }
 
 export enum Mode {
-    TILT = 0x00
+    TILT = 0x00,
+    IMPACT_COUNT = 0x01
 }
 
 export const ModeMap: {[event: string]: number} = {
-    "tilt": Mode.TILT
+    "tilt": Mode.TILT,
+    "impactCount": Mode.IMPACT_COUNT
 };

package/src/hubs/lpf2hub.ts

@@ -348,14 +348,13 @@ export class LPF2Hub extends BaseHub {
 
 
     private _parsePortAction (message: Buffer) {
+        for (let offset = 3; offset < message.length; offset += 2) {
+            const device = this._getDeviceByPortId(message[offset]);
 
-        const portId = message[3];
-        const device = this._getDeviceByPortId(portId);
-
-        if (device) {
-            device.finish(message[4]);
+            if (device) {
+                device.finish(message[offset+1]);
+            }
         }
-
     }
 
 

package/src/poweredup-node.ts

@@ -25,7 +25,10 @@ let wantScan = false;
 let discoveryEventAttached = false;
 
 const startScanning = () => {
-    noble.startScanning();
+    noble.startScanning([
+        Consts.BLEService.LPF2_HUB,
+        Consts.BLEService.WEDO2_SMART_HUB
+    ]);
 };
 
 noble.on("stateChange", (state: string) => {