incyclist-devices 1.4.48 → 1.4.51

package/lib/ble/fm.js

@@ -18,7 +18,15 @@ const ble_interface_1 = __importDefault(require("./ble-interface"));
 const Device_1 = __importDefault(require("../Device"));
 const gd_eventlog_1 = require("gd-eventlog");
 const power_meter_1 = __importDefault(require("../modes/power-meter"));
+const ble_st_mode_1 = __importDefault(require("./ble-st-mode"));
+const ble_erg_mode_1 = __importDefault(require("./ble-erg-mode"));
 const FTMS_CP = '2ad9';
+const cwABike = {
+    race: 0.35,
+    triathlon: 0.29,
+    mountain: 0.57
+};
+const cRR = 0.0036;
 const bit = (nr) => (1 << nr);
 const IndoorBikeDataFlag = {
     MoreData: bit(0),
@@ -79,6 +87,10 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
         this.features = undefined;
         this.hasControl = false;
         this.isCPSubscribed = false;
+        this.crr = 0.0033;
+        this.cw = 0.6;
+        this.windSpeed = 0;
+        this.wheelSize = 2100;
         this.data = {};
     }
     init() {
@@ -138,6 +150,12 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
         }
         return Object.assign(Object.assign({}, this.data), { raw: data.toString('hex') });
     }
+    setCrr(crr) { this.crr = crr; }
+    getCrr() { return this.crr; }
+    setCw(cw) { this.cw = cw; }
+    getCw() { return this.cw; }
+    setWindSpeed(windSpeed) { this.windSpeed = windSpeed; }
+    getWindSpeed() { return this.windSpeed; }
     parseIndoorBikeData(_data) {
         const data = Buffer.from(_data);
         const flags = data.readUInt16LE(0);
@@ -163,7 +181,7 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
             offset += 1;
             const dvHigh = data.readUInt16LE(offset);
             offset += 2;
-            this.data.totalDistance = dvHigh << 8 + dvLow;
+            this.data.totalDistance = (dvHigh << 8) + dvLow;
         }
         if (flags & IndoorBikeDataFlag.ResistanceLevelPresent) {
             this.data.resistanceLevel = data.readInt16LE(offset);
@@ -199,6 +217,43 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
         }
         return Object.assign(Object.assign({}, this.data), { raw: data.toString('hex') });
     }
+    parseFitnessMachineStatus(_data) {
+        const data = Buffer.from(_data);
+        const OpCode = data.readUInt8(0);
+        switch (OpCode) {
+            case 8:
+                this.data.targetPower = data.readInt16LE(1);
+                break;
+            case 6:
+                this.data.targetInclination = data.readInt16LE(1) / 10;
+                break;
+            case 4:
+                this.data.status = "STARTED";
+                break;
+            case 3:
+            case 2:
+                this.data.status = "STOPPED";
+                break;
+            case 20:
+                const spinDownStatus = data.readUInt8(1);
+                switch (spinDownStatus) {
+                    case 1:
+                        this.data.status = "SPIN DOWN REQUESTED";
+                        break;
+                    case 2:
+                        this.data.status = "SPIN DOWN SUCCESS";
+                        break;
+                    case 3:
+                        this.data.status = "SPIN DOWN ERROR";
+                        break;
+                    case 4:
+                        this.data.status = "STOP PEDALING";
+                        break;
+                    default: break;
+                }
+        }
+        return Object.assign(Object.assign({}, this.data), { raw: data.toString('hex') });
+    }
     getFitnessMachineFeatures() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.features)
@@ -218,36 +273,148 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
         });
     }
     onData(characteristic, data) {
-        if (characteristic.toLocaleLowerCase() === '2ad2') {
-            const res = this.parseIndoorBikeData(data);
-            this.emit('data', res);
+        super.onData(characteristic, data);
+        const uuid = characteristic.toLocaleLowerCase();
+        let res = undefined;
+        switch (uuid) {
+            case '2ad2':
+                res = this.parseIndoorBikeData(data);
+                break;
+            case '2a37':
+                res = this.parseHrm(data);
+                break;
+            case '2ada':
+                res = this.parseFitnessMachineStatus(data);
+                break;
+            default:
+                break;
         }
-        if (characteristic.toLocaleLowerCase() === '2a37') {
-            const res = this.parseHrm(data);
+        if (res)
             this.emit('data', res);
-        }
+    }
+    writeFtmsMessage(requestedOpCode, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const res = yield this.write(FTMS_CP, data);
+                const responseData = Buffer.from(res);
+                const opCode = responseData.readUInt8(0);
+                const request = responseData.readUInt8(1);
+                const result = responseData.readUInt8(2);
+                if (opCode !== 128 || request !== requestedOpCode)
+                    throw new Error('Illegal response ');
+                return result;
+            }
+            catch (err) {
+                this.logEvent({ message: 'writeFtmsMessage failed', opCode: requestedOpCode, reason: err.message });
+                return 4;
+            }
+        });
     }
     requestControl() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.hasControl)
                 return true;
+            this.logEvent({ message: 'requestControl' });
             const data = Buffer.alloc(1);
             data.writeUInt8(0, 0);
-            const success = yield this.write(FTMS_CP, data);
-            if (success)
+            const res = yield this.writeFtmsMessage(0, data);
+            if (res === 1) {
                 this.hasControl = true;
+            }
+            else {
+                this.logEvent({ message: 'requestControl failed' });
+            }
             return this.hasControl;
         });
     }
     setTargetPower(power) {
         return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'setTargetPower', power, skip: (this.data.targetPower !== undefined && this.data.targetPower === power) });
+            if (this.data.targetPower !== undefined && this.data.targetPower === power)
+                return true;
             const hasControl = yield this.requestControl();
-            if (!hasControl)
-                throw new Error('setTargetPower not possible - control is disabled');
             const data = Buffer.alloc(3);
             data.writeUInt8(5, 0);
             data.writeInt16LE(Math.round(power), 1);
-            const res = yield this.write(FTMS_CP, data);
+            const res = yield this.writeFtmsMessage(5, data);
+            return (res === 1);
+        });
+    }
+    setSlope(slope) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'setSlope', slope });
+            const { windSpeed, crr, cw } = this;
+            return yield this.setIndoorBikeSimulation(windSpeed, slope, crr, cw);
+        });
+    }
+    setTargetInclination(inclination) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.data.targetInclination !== undefined && this.data.targetInclination === inclination)
+                return true;
+            const hasControl = yield this.requestControl();
+            if (!hasControl) {
+                this.logEvent({ message: 'setTargetInclination failed', reason: 'control is disabled' });
+                return false;
+            }
+            const data = Buffer.alloc(3);
+            data.writeUInt8(3, 0);
+            data.writeInt16LE(Math.round(inclination * 10), 1);
+            const res = yield this.writeFtmsMessage(3, data);
+            return (res === 1);
+        });
+    }
+    setIndoorBikeSimulation(windSpeed, gradient, crr, cw) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hasControl = yield this.requestControl();
+            const data = Buffer.alloc(7);
+            data.writeUInt8(17, 0);
+            data.writeInt16LE(Math.round(windSpeed * 1000), 1);
+            data.writeInt16LE(Math.round(gradient * 100), 3);
+            data.writeUInt8(Math.round(crr * 10000), 5);
+            data.writeUInt8(Math.round(cw * 100), 6);
+            const res = yield this.writeFtmsMessage(17, data);
+            return (res === 1);
+        });
+    }
+    startRequest() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hasControl = yield this.requestControl();
+            if (!hasControl) {
+                this.logEvent({ message: 'startRequest failed', reason: 'control is disabled' });
+                return false;
+            }
+            const data = Buffer.alloc(1);
+            data.writeUInt8(7, 0);
+            const res = yield this.writeFtmsMessage(7, data);
+            return (res === 1);
+        });
+    }
+    stopRequest() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hasControl = yield this.requestControl();
+            if (!hasControl) {
+                this.logEvent({ message: 'stopRequest failed', reason: 'control is disabled' });
+                return false;
+            }
+            const data = Buffer.alloc(2);
+            data.writeUInt8(8, 0);
+            data.writeUInt8(1, 1);
+            const res = yield this.writeFtmsMessage(8, data);
+            return (res === 1);
+        });
+    }
+    PauseRequest() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hasControl = yield this.requestControl();
+            if (!hasControl) {
+                this.logEvent({ message: 'PauseRequest failed', reason: 'control is disabled' });
+                return false;
+            }
+            const data = Buffer.alloc(2);
+            data.writeUInt8(8, 0);
+            data.writeUInt8(2, 1);
+            const res = yield this.writeFtmsMessage(8, data);
+            return (res === 1);
         });
     }
     reset() {
@@ -266,8 +433,10 @@ class FmAdapter extends Device_1.default {
         this.distanceInternal = 0;
         this.device = device;
         this.ble = protocol.ble;
-        this.mode = this.getDefaultCyclingMode();
+        this.cyclingMode = this.getDefaultCyclingMode();
         this.logger = new gd_eventlog_1.EventLogger('BLE-FM');
+        if (this.device)
+            this.device.setLogger(this.logger);
     }
     isBike() { return this.device.isBike(); }
     isHrm() { return this.device.isHrm(); }
@@ -287,13 +456,33 @@ class FmAdapter extends Device_1.default {
     getDisplayName() {
         return this.getName();
     }
+    getSupportedCyclingModes() {
+        return [ble_st_mode_1.default, ble_erg_mode_1.default, power_meter_1.default];
+    }
+    setCyclingMode(mode, settings) {
+        let selectedMode;
+        if (typeof mode === 'string') {
+            const supported = this.getSupportedCyclingModes();
+            const CyclingModeClass = supported.find(M => { const m = new M(this); return m.getName() === mode; });
+            if (CyclingModeClass) {
+                this.cyclingMode = new CyclingModeClass(this, settings);
+                return;
+            }
+            selectedMode = this.getDefaultCyclingMode();
+        }
+        else {
+            selectedMode = mode;
+        }
+        this.cyclingMode = selectedMode;
+        this.cyclingMode.setSettings(settings);
+    }
     getCyclingMode() {
-        if (!this.mode)
-            this.mode = this.getDefaultCyclingMode();
-        return this.mode;
+        if (!this.cyclingMode)
+            this.cyclingMode = this.getDefaultCyclingMode();
+        return this.cyclingMode;
     }
     getDefaultCyclingMode() {
-        return new power_meter_1.default(this);
+        return new ble_st_mode_1.default(this);
     }
     getPort() {
         return 'ble';
@@ -361,8 +550,27 @@ class FmAdapter extends Device_1.default {
                 yield this.ble.stopScan();
             try {
                 const bleDevice = yield this.ble.connectDevice(this.device);
+                bleDevice.setLogger(this.logger);
                 if (bleDevice) {
                     this.device = bleDevice;
+                    const mode = this.getCyclingMode();
+                    if (mode && mode.getSetting('bikeType')) {
+                        const bikeType = mode.getSetting('bikeType').toLowerCase();
+                        this.device.setCrr(cRR);
+                        switch (bikeType) {
+                            case 'race':
+                                this.device.setCw(cwABike.race);
+                                break;
+                            case 'triathlon':
+                                this.device.setCw(cwABike.triathlon);
+                                break;
+                            case 'mountain':
+                                this.device.setCw(cwABike.mountain);
+                                break;
+                        }
+                    }
+                    const startRequest = this.getCyclingMode().getBikeInitRequest();
+                    yield this.sendUpdate(startRequest);
                     bleDevice.on('data', (data) => {
                         this.onDeviceData(data);
                     });
@@ -385,9 +593,16 @@ class FmAdapter extends Device_1.default {
     }
     sendUpdate(request) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.paused)
+            if (this.paused || !this.device)
                 return;
-            this.getCyclingMode().sendBikeUpdate(request);
+            const update = this.getCyclingMode().sendBikeUpdate(request);
+            this.logger.logEvent({ message: 'send bike update requested', profile: this.getProfile(), update, request });
+            if (update.slope !== undefined) {
+                yield this.device.setSlope(update.slope);
+            }
+            if (update.targetPower !== undefined) {
+                yield this.device.setTargetPower(update.targetPower);
+            }
         });
     }
     pause() { this.paused = true; return Promise.resolve(true); }

package/lib/ble/hrm.js

@@ -51,6 +51,7 @@ class BleHrmDevice extends ble_device_1.BleDevice {
         return { heartrate, rr, raw: data.toString('hex') };
     }
     onData(characteristic, data) {
+        super.onData(characteristic, data);
         if (characteristic.toLocaleLowerCase() === '2a37') {
             const res = this.parseHrm(data);
             this.emit('data', res);

package/lib/ble/pwr.js

@@ -109,6 +109,7 @@ class BleCyclingPowerDevice extends ble_device_1.BleDevice {
         return { instantaneousPower, balance, accTorque, rpm, time, raw: data.toString('hex') };
     }
     onData(characteristic, data) {
+        super.onData(characteristic, data);
         if (characteristic.toLocaleLowerCase() === '2a63') {
             const res = this.parsePower(data);
             this.emit('data', res);

package/lib/ble/wahoo-kickr.d.ts

@@ -0,0 +1,73 @@
+/// <reference types="node" />
+import BleProtocol from './incyclist-protocol';
+import { BleDeviceClass } from './ble';
+import DeviceAdapter from '../Device';
+import BleFitnessMachineDevice, { FmAdapter } from './fm';
+declare type IndoorBikeData = {
+    speed?: number;
+    averageSpeed?: number;
+    cadence?: number;
+    averageCadence?: number;
+    totalDistance?: number;
+    resistanceLevel?: number;
+    instantaneousPower?: number;
+    averagePower?: number;
+    expendedEnergy?: number;
+    heartrate?: number;
+    metabolicEquivalent?: number;
+    time?: number;
+    remainingTime?: number;
+    raw?: string;
+    targetPower?: number;
+    targetInclination?: number;
+    status?: string;
+};
+declare type CrankData = {
+    revolutions?: number;
+    time?: number;
+    cntUpdateMissing?: number;
+};
+export default class WahooAdvancedFitnessMachineDevice extends BleFitnessMachineDevice {
+    static services: string[];
+    static characteristics: string[];
+    prevCrankData: CrankData;
+    currentCrankData: CrankData;
+    timeOffset: number;
+    tsPrevWrite: any;
+    constructor(props?: any);
+    init(): Promise<boolean>;
+    getProfile(): string;
+    getServiceUUids(): string[];
+    isBike(): boolean;
+    isPower(): boolean;
+    isHrm(): boolean;
+    parseCrankData(crankData: any): {
+        rpm: number;
+        time: any;
+    };
+    parsePower(_data: Buffer): IndoorBikeData;
+    onData(characteristic: string, data: Buffer): void;
+    writeWahooFtmsMessage(requestedOpCode: number, data: Buffer): Promise<boolean>;
+    requestControl(): Promise<boolean>;
+    setPowerAdjusting(): void;
+    isPowerAdjusting(): boolean;
+    setErgMode(power: number): Promise<boolean>;
+    setSimMode(weight: number, crr: number, cw: number): Promise<boolean>;
+    setSimCRR(crr: number): Promise<boolean>;
+    setSimWindResistance(cw: number): Promise<boolean>;
+    setSimGrade(slope: number): Promise<boolean>;
+    setSimWindSpeed(v: number): Promise<boolean>;
+    setTargetPower(power: number): Promise<boolean>;
+    setSlope(slope: any): Promise<boolean>;
+    reset(): void;
+}
+export declare class WahooAdvancedFmAdapter extends FmAdapter {
+    device: WahooAdvancedFitnessMachineDevice;
+    constructor(device: BleDeviceClass, protocol: BleProtocol);
+    isSame(device: DeviceAdapter): boolean;
+    getProfile(): string;
+    start(props?: any): Promise<any>;
+    pause(): Promise<boolean>;
+    resume(): Promise<boolean>;
+}
+export {};