incyclist-devices 1.4.48 → 1.4.49

package/lib/ble/ble-device.d.ts

@@ -6,6 +6,13 @@ interface BleDeviceConstructProps extends BleDeviceProps {
     log?: boolean;
     logger?: EventLogger;
 }
+declare type CommandQueueItem = {
+    uuid: string;
+    data: Buffer;
+    resolve: any;
+    reject: any;
+    timeout: any;
+};
 export declare abstract class BleDevice extends BleDeviceClass {
     id: string;
     address: string;
@@ -19,6 +26,7 @@ export declare abstract class BleDevice extends BleDeviceClass {
     deviceInfo: BleDeviceInfo;
     isInitialized: boolean;
     subscribedCharacteristics: string[];
+    writeQueue: CommandQueueItem[];
     constructor(props?: BleDeviceConstructProps);
     logEvent(event: any): void;
     setInterface(ble: BleInterfaceClass): void;
@@ -32,8 +40,8 @@ export declare abstract class BleDevice extends BleDeviceClass {
     connect(props?: ConnectProps): Promise<boolean>;
     disconnect(): Promise<boolean>;
     abstract getProfile(): string;
-    abstract onData(characteristic: string, data: Buffer): void;
-    write(characteristicUuid: string, data: Buffer, withoutResponse?: boolean): Promise<boolean>;
+    onData(characteristic: string, data: Buffer): void;
+    write(characteristicUuid: string, data: Buffer, withoutResponse?: boolean): Promise<ArrayBuffer>;
     read(characteristicUuid: string): Promise<Uint8Array>;
     getDeviceInfo(): Promise<BleDeviceInfo>;
 }

package/lib/ble/ble-device.js

@@ -26,6 +26,7 @@ class BleDevice extends ble_1.BleDeviceClass {
         this.characteristics = [];
         this.subscribedCharacteristics = [];
         this.isInitialized = false;
+        this.writeQueue = [];
         if (props.peripheral) {
             const { id, address, advertisement, state } = props.peripheral;
             this.peripheral = props.peripheral;
@@ -103,6 +104,7 @@ class BleDevice extends ble_1.BleDeviceClass {
             return Promise.resolve(true);
         return this.getDeviceInfo().then(() => {
             this.emit('deviceInfo', this.deviceInfo);
+            this.logEvent(Object.assign({ message: 'ftms device init done' }, this.deviceInfo));
             this.isInitialized = true;
             return true;
         });
@@ -235,9 +237,20 @@ class BleDevice extends ble_1.BleDeviceClass {
             }
         });
     }
+    onData(characteristic, data) {
+        if (this.writeQueue.length > 0) {
+            const writeIdx = this.writeQueue.findIndex(i => i.uuid === characteristic.toLocaleLowerCase());
+            if (writeIdx !== -1) {
+                const writeItem = this.writeQueue[writeIdx];
+                this.writeQueue.splice(writeIdx, 1);
+                if (writeItem.resolve)
+                    writeItem.resolve(data);
+            }
+        }
+    }
     write(characteristicUuid, data, withoutResponse = false) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.subscribedCharacteristics.find(c => c === characteristicUuid) === undefined) {
+            if (!withoutResponse && this.subscribedCharacteristics.find(c => c === characteristicUuid) === undefined) {
                 const connector = this.ble.getConnector(this.peripheral);
                 connector.on(characteristicUuid, (uuid, data) => {
                     this.onData(uuid, data);
@@ -251,11 +264,18 @@ class BleDevice extends ble_1.BleDeviceClass {
                     reject(new Error('Characteristic not found'));
                     return;
                 }
+                if (withoutResponse) {
+                    characteristic.write(data, withoutResponse);
+                    resolve(new ArrayBuffer(0));
+                    return;
+                }
+                const writeId = this.writeQueue.length;
+                this.writeQueue.push({ uuid: characteristicUuid.toLocaleLowerCase(), data, resolve, reject, timeout: Date.now() + 1000 });
                 characteristic.write(data, withoutResponse, (err) => {
-                    if (err)
+                    if (err) {
+                        this.writeQueue.splice(writeId, 1);
                         reject(err);
-                    else
-                        resolve(true);
+                    }
                 });
             });
         });

package/lib/ble/ble-erg-mode.d.ts

@@ -1,18 +1,11 @@
 import CyclingMode, { CyclingModeProperty, IncyclistBikeData, UpdateRequest } from "../CyclingMode";
 import PowerBasedCyclingModeBase from "../modes/power-base";
 import { FmAdapter } from "./fm";
-export declare type ERGEvent = {
-    rpmUpdated?: boolean;
-    gearUpdated?: boolean;
-    starting?: boolean;
-    tsStart?: number;
-};
-export default class ERGCyclingMode extends PowerBasedCyclingModeBase implements CyclingMode {
+export default class BleERGCyclingMode extends PowerBasedCyclingModeBase implements CyclingMode {
     prevRequest: UpdateRequest;
     hasBikeUpdate: boolean;
     chain: number[];
     cassette: number[];
-    event: ERGEvent;
     constructor(adapter: FmAdapter, props?: any);
     getName(): string;
     getDescription(): string;

package/lib/ble/ble-erg-mode.js

@@ -13,11 +13,10 @@ const config = {
         { key: 'startPower', name: 'Starting Power', description: 'Initial power in Watts at start of training', type: CyclingMode_1.CyclingModeProperyType.Integer, default: 50, min: 25, max: 800 },
     ]
 };
-class ERGCyclingMode extends power_base_1.default {
+class BleERGCyclingMode extends power_base_1.default {
     constructor(adapter, props) {
         super(adapter, props);
         this.hasBikeUpdate = false;
-        this.event = {};
         this.initLogger('ERGMode');
     }
     getName() {
@@ -34,7 +33,7 @@ class ERGCyclingMode extends power_base_1.default {
     }
     getBikeInitRequest() {
         const startPower = this.getSetting('startPower');
-        return { targetPower: startPower };
+        return { slope: 0, targetPower: startPower };
     }
     sendBikeUpdate(request) {
         const getData = () => {
@@ -43,25 +42,18 @@ class ERGCyclingMode extends power_base_1.default {
             const { pedalRpm, slope, power, speed } = this.data;
             return { pedalRpm, slope, power, speed };
         };
-        this.logger.logEvent({ message: "processing update request", request, prev: this.prevRequest, data: getData(), event: this.event });
+        this.logger.logEvent({ message: "processing update request", request, prev: this.prevRequest, data: getData() });
         let newRequest = {};
         try {
             if (!request || request.reset || Object.keys(request).length === 0) {
                 this.prevRequest = {};
-                return request || {};
+                return request.reset ? { reset: true } : {};
             }
             const prevData = this.data || {};
             if (request.targetPower !== undefined) {
                 delete request.slope;
                 delete request.refresh;
             }
-            if (this.event.starting && request.targetPower === undefined) {
-                newRequest.targetPower = this.getSetting('startPower');
-                if (this.event.tsStart && Date.now() - this.event.tsStart > 5000) {
-                    delete this.event.starting;
-                    delete this.event.tsStart;
-                }
-            }
             if (request.refresh) {
                 delete request.refresh;
                 newRequest.targetPower = this.prevRequest.targetPower;
@@ -70,14 +62,12 @@ class ERGCyclingMode extends power_base_1.default {
                 if (!this.data)
                     this.data = {};
                 this.data.slope = request.slope;
+                delete request.slope;
             }
             if (request.maxPower !== undefined && request.minPower !== undefined && request.maxPower === request.minPower) {
                 request.targetPower = request.maxPower;
-            }
-            if (request.targetPower !== undefined) {
                 newRequest.targetPower = request.targetPower;
             }
-            delete request.slope;
             if (request.maxPower !== undefined) {
                 if (newRequest.targetPower !== undefined && newRequest.targetPower > request.maxPower) {
                     newRequest.targetPower = request.maxPower;
@@ -89,9 +79,8 @@ class ERGCyclingMode extends power_base_1.default {
                     newRequest.targetPower = request.minPower;
                 }
                 newRequest.minPower = request.minPower;
-            }
-            if (newRequest.targetPower !== undefined && prevData.power !== undefined && newRequest.targetPower === prevData.power) {
-                delete newRequest.targetPower;
+                if (prevData.power && prevData.power < request.minPower)
+                    newRequest.targetPower = request.minPower;
             }
             this.prevRequest = JSON.parse(JSON.stringify(request));
         }
@@ -106,11 +95,6 @@ class ERGCyclingMode extends power_base_1.default {
         const prevRequest = this.prevRequest || {};
         const data = this.data || {};
         const bikeType = this.getSetting('bikeType').toLowerCase();
-        delete this.event.rpmUpdated;
-        if (prevData === {} || prevData.speed === undefined || prevData.speed === 0) {
-            this.event.starting = true;
-            this.event.tsStart = Date.now();
-        }
         try {
             const rpm = bikeData.pedalRpm || 0;
             let power = bikeData.power || 0;
@@ -127,15 +111,12 @@ class ERGCyclingMode extends power_base_1.default {
             data.distanceInternal = Math.round(distanceInternal + distance);
             data.slope = slope;
             data.pedalRpm = rpm;
-            if (data.time !== undefined && !(this.event.starting && !bikeData.pedalRpm))
+            if (data.time !== undefined && data.speed > 0)
                 data.time += t;
             else
                 data.time = 0;
             data.heartrate = bikeData.heartrate;
             data.isPedalling = bikeData.isPedalling;
-            if (rpm && rpm !== prevData.pedalRpm) {
-                this.event.rpmUpdated = true;
-            }
         }
         catch (err) {
             this.logger.logEvent({ message: 'error', fn: 'updateData()', error: err.message || err });
@@ -145,4 +126,4 @@ class ERGCyclingMode extends power_base_1.default {
         return data;
     }
 }
-exports.default = ERGCyclingMode;
+exports.default = BleERGCyclingMode;

package/lib/ble/ble-st-mode.d.ts

@@ -1,18 +1,9 @@
 import CyclingMode, { CyclingModeProperty, IncyclistBikeData, UpdateRequest } from "../CyclingMode";
 import PowerBasedCyclingModeBase from "../modes/power-base";
 import { FmAdapter } from "./fm";
-export declare type ERGEvent = {
-    rpmUpdated?: boolean;
-    gearUpdated?: boolean;
-    starting?: boolean;
-    tsStart?: number;
-};
-export default class ERGCyclingMode extends PowerBasedCyclingModeBase implements CyclingMode {
+export default class FtmsCyclingMode extends PowerBasedCyclingModeBase implements CyclingMode {
     prevRequest: UpdateRequest;
     hasBikeUpdate: boolean;
-    chain: number[];
-    cassette: number[];
-    event: ERGEvent;
     constructor(adapter: FmAdapter, props?: any);
     getName(): string;
     getDescription(): string;

package/lib/ble/ble-st-mode.js

@@ -9,16 +9,14 @@ const config = {
     name: "Smart Trainer",
     description: "Calculates speed based on power and slope. Slope is set to the device",
     properties: [
-        { key: 'bikeType', name: 'Bike Type', description: '', type: CyclingMode_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain', 'Triathlon'], default: 'Race' },
-        { key: 'startPower', name: 'Starting Power', description: 'Initial power in Watts at start of training', type: CyclingMode_1.CyclingModeProperyType.Integer, default: 50, min: 25, max: 800 },
+        { key: 'bikeType', name: 'Bike Type', description: '', type: CyclingMode_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain', 'Triathlon'], default: 'Race' }
     ]
 };
-class ERGCyclingMode extends power_base_1.default {
+class FtmsCyclingMode extends power_base_1.default {
     constructor(adapter, props) {
         super(adapter, props);
         this.hasBikeUpdate = false;
-        this.event = {};
-        this.initLogger('ERGMode');
+        this.initLogger('FtmsMode');
     }
     getName() {
         return config.name;
@@ -33,71 +31,32 @@ class ERGCyclingMode extends power_base_1.default {
         return config.properties.find(p => p.name === name);
     }
     getBikeInitRequest() {
-        const startPower = this.getSetting('startPower');
-        return { targetPower: startPower };
+        return { slope: 0 };
     }
     sendBikeUpdate(request) {
         const getData = () => {
             if (!this.data)
                 return {};
-            const { pedalRpm, slope, power, speed } = this.data;
-            return { pedalRpm, slope, power, speed };
+            const { gear, pedalRpm, slope, power, speed } = this.data;
+            return { gear, pedalRpm, slope, power, speed };
         };
-        this.logger.logEvent({ message: "processing update request", request, prev: this.prevRequest, data: getData(), event: this.event });
+        const event = {};
+        if (this.data === undefined)
+            event.noData = true;
+        if (request.slope !== undefined && (event.noData || Math.abs(request.slope - this.data.slope) >= 0.1))
+            event.slopeUpdate = true;
+        if (this.prevRequest === undefined)
+            event.initialCall = true;
+        this.logger.logEvent({ message: "processing update request", request, prev: this.prevRequest, data: getData(), event });
         let newRequest = {};
-        try {
-            if (!request || request.reset || Object.keys(request).length === 0) {
-                this.prevRequest = {};
-                return request || {};
-            }
-            const prevData = this.data || {};
-            if (request.targetPower !== undefined) {
-                delete request.slope;
-                delete request.refresh;
-            }
-            if (this.event.starting && request.targetPower === undefined) {
-                newRequest.targetPower = this.getSetting('startPower');
-                if (this.event.tsStart && Date.now() - this.event.tsStart > 5000) {
-                    delete this.event.starting;
-                    delete this.event.tsStart;
-                }
-            }
-            if (request.refresh) {
-                delete request.refresh;
-                newRequest.targetPower = this.prevRequest.targetPower;
-            }
-            if (request.slope !== undefined) {
-                if (!this.data)
-                    this.data = {};
-                this.data.slope = request.slope;
-            }
-            if (request.maxPower !== undefined && request.minPower !== undefined && request.maxPower === request.minPower) {
-                request.targetPower = request.maxPower;
-            }
-            if (request.targetPower !== undefined) {
-                newRequest.targetPower = request.targetPower;
-            }
-            delete request.slope;
-            if (request.maxPower !== undefined) {
-                if (newRequest.targetPower !== undefined && newRequest.targetPower > request.maxPower) {
-                    newRequest.targetPower = request.maxPower;
-                }
-                newRequest.maxPower = request.maxPower;
-            }
-            if (request.minPower !== undefined) {
-                if (newRequest.targetPower !== undefined && newRequest.targetPower < request.minPower) {
-                    newRequest.targetPower = request.minPower;
-                }
-                newRequest.minPower = request.minPower;
-            }
-            if (newRequest.targetPower !== undefined && prevData.power !== undefined && newRequest.targetPower === prevData.power) {
-                delete newRequest.targetPower;
-            }
-            this.prevRequest = JSON.parse(JSON.stringify(request));
+        if (request.slope === undefined && request.refresh && this.prevRequest) {
+            return this.prevRequest;
         }
-        catch (err) {
-            this.logger.logEvent({ message: "error", fn: 'sendBikeUpdate()', error: err.message || err, stack: err.stack });
+        if (request.slope !== undefined) {
+            newRequest.slope = parseFloat(request.slope.toFixed(1));
+            this.data.slope = newRequest.slope;
         }
+        this.prevRequest = JSON.parse(JSON.stringify(newRequest));
         return newRequest;
     }
     updateData(bikeData) {
@@ -106,11 +65,6 @@ class ERGCyclingMode extends power_base_1.default {
         const prevRequest = this.prevRequest || {};
         const data = this.data || {};
         const bikeType = this.getSetting('bikeType').toLowerCase();
-        delete this.event.rpmUpdated;
-        if (prevData === {} || prevData.speed === undefined || prevData.speed === 0) {
-            this.event.starting = true;
-            this.event.tsStart = Date.now();
-        }
         try {
             const rpm = bikeData.pedalRpm || 0;
             let power = bikeData.power || 0;
@@ -127,15 +81,12 @@ class ERGCyclingMode extends power_base_1.default {
             data.distanceInternal = Math.round(distanceInternal + distance);
             data.slope = slope;
             data.pedalRpm = rpm;
-            if (data.time !== undefined && !(this.event.starting && !bikeData.pedalRpm))
+            if (data.time !== undefined)
                 data.time += t;
             else
                 data.time = 0;
             data.heartrate = bikeData.heartrate;
             data.isPedalling = bikeData.isPedalling;
-            if (rpm && rpm !== prevData.pedalRpm) {
-                this.event.rpmUpdated = true;
-            }
         }
         catch (err) {
             this.logger.logEvent({ message: 'error', fn: 'updateData()', error: err.message || err });
@@ -145,4 +96,4 @@ class ERGCyclingMode extends power_base_1.default {
         return data;
     }
 }
-exports.default = ERGCyclingMode;
+exports.default = FtmsCyclingMode;

package/lib/ble/fm.d.ts

@@ -31,6 +31,9 @@ declare type IndoorBikeData = {
     time?: number;
     remainingTime?: number;
     raw?: string;
+    targetPower?: number;
+    targetInclination?: number;
+    status?: string;
 };
 declare type IndoorBikeFeatures = {
     fitnessMachine: number;
@@ -43,6 +46,10 @@ export default class BleFitnessMachineDevice extends BleDevice {
     features: IndoorBikeFeatures;
     hasControl: boolean;
     isCPSubscribed: boolean;
+    crr: number;
+    cw: number;
+    windSpeed: number;
+    wheelSize: number;
     constructor(props?: any);
     init(): Promise<boolean>;
     onDisconnect(): void;
@@ -52,11 +59,25 @@ export default class BleFitnessMachineDevice extends BleDevice {
     isPower(): boolean;
     isHrm(): boolean;
     parseHrm(_data: Uint8Array): IndoorBikeData;
+    setCrr(crr: number): void;
+    getCrr(): number;
+    setCw(cw: number): void;
+    getCw(): number;
+    setWindSpeed(windSpeed: number): void;
+    getWindSpeed(): number;
     parseIndoorBikeData(_data: Uint8Array): IndoorBikeData;
+    parseFitnessMachineStatus(_data: Uint8Array): IndoorBikeData;
     getFitnessMachineFeatures(): Promise<IndoorBikeFeatures>;
     onData(characteristic: string, data: Buffer): void;
+    writeFtmsMessage(requestedOpCode: any, data: any): Promise<number>;
     requestControl(): Promise<boolean>;
-    setTargetPower(power: number): Promise<void>;
+    setTargetPower(power: number): Promise<boolean>;
+    setSlope(slope: any): Promise<boolean>;
+    setTargetInclination(inclination: number): Promise<boolean>;
+    setIndoorBikeSimulation(windSpeed: number, gradient: number, crr: number, cw: number): Promise<boolean>;
+    startRequest(): Promise<boolean>;
+    stopRequest(): Promise<boolean>;
+    PauseRequest(): Promise<boolean>;
     reset(): void;
 }
 export declare class FmAdapter extends DeviceAdapter {
@@ -66,7 +87,7 @@ export declare class FmAdapter extends DeviceAdapter {
     protocol: DeviceProtocol;
     paused: boolean;
     logger: EventLogger;
-    mode: CyclingMode;
+    cyclingMode: CyclingMode;
     distanceInternal: number;
     prevDataTS: number;
     constructor(device: BleDeviceClass, protocol: BleProtocol);
@@ -77,6 +98,8 @@ export declare class FmAdapter extends DeviceAdapter {
     getProfile(): string;
     getName(): string;
     getDisplayName(): string;
+    getSupportedCyclingModes(): Array<any>;
+    setCyclingMode(mode: string | CyclingMode, settings?: any): void;
     getCyclingMode(): CyclingMode;
     getDefaultCyclingMode(): CyclingMode;
     getPort(): string;

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,14 +273,42 @@ 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* () {
@@ -233,21 +316,109 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
                 return true;
             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;
+            }
             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');
+            if (!hasControl) {
+                this.logEvent({ message: 'setTargetPower failed', reason: 'control is disabled' });
+                return false;
+            }
             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();
+            if (!hasControl) {
+                this.logEvent({ message: 'setTargetInclination failed', reason: 'control is disabled' });
+                return false;
+            }
+            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,7 +437,7 @@ 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');
     }
     isBike() { return this.device.isBike(); }
@@ -287,13 +458,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';
@@ -363,6 +554,22 @@ class FmAdapter extends Device_1.default {
                 const bleDevice = yield this.ble.connectDevice(this.device);
                 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;
+                        }
+                    }
                     bleDevice.on('data', (data) => {
                         this.onDeviceData(data);
                     });
@@ -385,9 +592,15 @@ 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 requested = this.getCyclingMode().sendBikeUpdate(request);
+            if (requested.slope !== undefined) {
+                yield this.device.setSlope(requested.slope);
+            }
+            if (requested.targetPower !== undefined) {
+                yield this.device.setTargetPower(requested.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/modes/power-base.js

@@ -37,7 +37,6 @@ class PowerBasedCyclingModeBase extends CyclingMode_1.CyclingModeBase {
         let powerToMaintainSpeed = calculations_1.default.calculatePower(m, vPrev, slope, props);
         const powerDelta = powerToMaintainSpeed - power;
         const Ekin = EkinPrev - powerDelta * t;
-        console.log('~~~~ calculateSpeedAndDistance', Ekin, powerToMaintainSpeed, power, m, vPrev, slope);
         if (Ekin > 0) {
             const v = Math.sqrt(2 * Ekin / m);
             const speed = v * 3.6;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-devices",
-  "version": "1.4.48",
+  "version": "1.4.49",
   "dependencies": {
     "@serialport/parser-byte-length": "^9.0.1",
     "@serialport/parser-delimiter": "^9.0.1",