incyclist-devices 1.4.92 → 1.4.94

package/lib/Device.d.ts

@@ -55,7 +55,8 @@ export default class IncyclistDevice implements DeviceAdapter {
     detected: boolean;
     selected: boolean;
     onDataFn: OnDeviceDataCallback;
-    constructor(proto: DeviceProtocol);
+    settings: any;
+    constructor(proto: DeviceProtocol, settings?: any);
     isBike(): boolean;
     isPower(): boolean;
     isHrm(): boolean;
@@ -66,7 +67,10 @@ export default class IncyclistDevice implements DeviceAdapter {
     getPort(): string;
     getProtocol(): DeviceProtocol;
     getProtocolName(): string | undefined;
+    getSupportedCyclingModes(): any[];
+    getDefaultCyclingMode(): CyclingMode;
     setCyclingMode(mode: CyclingMode | string, settings?: any): void;
+    getCyclingMode(): CyclingMode;
     setIgnoreHrm(ignore: any): void;
     setIgnorePower(ignore: any): void;
     setIgnoreBike(ignore: any): void;

package/lib/Device.js

@@ -4,11 +4,12 @@ exports.DEFAULT_USER_WEIGHT = exports.DEFAULT_BIKE_WEIGHT = void 0;
 exports.DEFAULT_BIKE_WEIGHT = 10;
 exports.DEFAULT_USER_WEIGHT = 75;
 class IncyclistDevice {
-    constructor(proto) {
+    constructor(proto, settings) {
         this.protocol = proto;
         this.detected = false;
         this.selected = false;
         this.onDataFn = undefined;
+        this.settings = settings || {};
     }
     isBike() { throw new Error('not implemented'); }
     isPower() { throw new Error('not implemented'); }
@@ -22,7 +23,30 @@ class IncyclistDevice {
     getProtocolName() {
         return this.protocol ? this.protocol.getName() : undefined;
     }
-    setCyclingMode(mode, settings) { }
+    getSupportedCyclingModes() { throw new Error('not implemented'); }
+    getDefaultCyclingMode() { throw new Error('not implemented'); }
+    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.settings.cyclingMode = new CyclingModeClass(this, settings);
+                return;
+            }
+            selectedMode = this.getDefaultCyclingMode();
+        }
+        else {
+            selectedMode = mode;
+        }
+        this.settings.cyclingMode = selectedMode;
+        this.settings.cyclingMode.setSettings(settings);
+    }
+    getCyclingMode() {
+        if (!this.settings.cyclingMode)
+            this.setCyclingMode(this.getDefaultCyclingMode());
+        return this.settings.cyclingMode;
+    }
     setIgnoreHrm(ignore) { }
     setIgnorePower(ignore) { }
     setIgnoreBike(ignore) { }

package/lib/ant/antpwr/pwr-adapter.d.ts

@@ -36,6 +36,7 @@ export default class AntFEAdapter extends AntAdapter {
     getDisplayName(): string;
     getCyclingMode(): CyclingMode;
     getDefaultCyclingMode(): CyclingMode;
+    getSupportedCyclingModes(): any[];
     onAttached(): void;
     getLogData(data: any, excludeList: any): any;
     onDeviceData(deviceData: AntPwrData): void;

package/lib/ant/antpwr/pwr-adapter.js

@@ -58,6 +58,9 @@ class AntFEAdapter extends AntAdapter_1.default {
     getDefaultCyclingMode() {
         return new power_meter_1.default(this);
     }
+    getSupportedCyclingModes() {
+        return [power_meter_1.default];
+    }
     onAttached() {
         this.logger.logEvent({ message: 'Device connected' });
         this.connected = true;

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

@@ -35,6 +35,7 @@ export declare abstract class BleDevice extends BleDeviceClass {
     workerIv: NodeJS.Timeout;
     prevMessages: MessageLog[];
     constructor(props?: BleDeviceConstructProps);
+    getServices(): string[];
     logEvent(event: any): void;
     setLogger(logger: EventLogger): void;
     setInterface(ble: BleInterfaceClass): void;
@@ -51,7 +52,7 @@ export declare abstract class BleDevice extends BleDeviceClass {
     disconnect(): Promise<boolean>;
     abstract getProfile(): string;
     checkForDuplicate(characteristic: string, data: Buffer): boolean;
-    onData(characteristic: string, data: Buffer): void;
+    onData(characteristic: string, _data: Buffer): boolean;
     timeoutCheck(): void;
     startWorker(): void;
     stopWorker(): void;

package/lib/ble/ble-device.js

@@ -47,13 +47,14 @@ class BleDevice extends ble_1.BleDeviceClass {
             this.logger = new gd_eventlog_1.EventLogger('BleDevice');
         }
     }
+    getServices() {
+        return this.services;
+    }
     logEvent(event) {
         if (this.logger) {
             this.logger.logEvent(event);
         }
-        if (process.env.BLE_DEBUG) {
-            console.log('~~~BLE:', event);
-        }
+        console.log('~~~BLE:', event);
     }
     setLogger(logger) {
         this.logger = logger;
@@ -80,8 +81,12 @@ class BleDevice extends ble_1.BleDeviceClass {
         this.state = "disconnected";
         if (!this.connectState.isDisconnecting) {
             this.peripheral.state = 'disconnected';
+            this.connectState.isConnecting = false;
             this.connectState.isConnected = false;
-            this.connect();
+            this.cleanupListeners();
+            this.subscribedCharacteristics = [];
+            this.ble.onDisconnect(this.peripheral);
+            this.connect({ reconnect: true });
         }
         this.emit('disconnected');
     }
@@ -128,6 +133,7 @@ class BleDevice extends ble_1.BleDeviceClass {
             this.connectState.isConnecting = true;
             try {
                 const connector = this.ble.getConnector(peripheral);
+                connector.on('disconnect', () => { this.onDisconnect(); });
                 yield connector.connect();
                 yield connector.initialize();
                 yield this.subscribeAll(connector);
@@ -156,9 +162,10 @@ class BleDevice extends ble_1.BleDeviceClass {
     }
     connect(props) {
         return __awaiter(this, void 0, void 0, function* () {
+            const { reconnect } = props || {};
             try {
-                this.logEvent({ message: 'connect', address: this.peripheral ? this.peripheral.address : this.address, state: this.connectState });
-                if (this.connectState.isConnecting) {
+                this.logEvent({ message: reconnect ? 'reconnect' : 'connect', address: this.peripheral ? this.peripheral.address : this.address, state: this.connectState });
+                if (!reconnect && this.connectState.isConnecting) {
                     yield this.waitForConnectFinished(CONNECT_WAIT_TIMEOUT);
                 }
                 if (this.connectState.isConnected) {
@@ -238,6 +245,8 @@ class BleDevice extends ble_1.BleDeviceClass {
             }
             if (!this.connectState.isConnecting && !this.connectState.isConnected) {
                 this.connectState.isDisconnecting = false;
+                this.connectState.isConnecting = false;
+                this.connectState.isConnected = false;
                 this.logEvent({ message: 'disconnect result: success', device: { id, name, address } });
                 return true;
             }
@@ -245,13 +254,17 @@ class BleDevice extends ble_1.BleDeviceClass {
                 this.cleanupListeners();
                 setTimeout(() => { this.connectState.isDisconnecting = false; }, 1000);
                 this.logEvent({ message: 'disconnect result: unclear - connect ongoing', device: { id, name, address } });
+                this.connectState.isConnecting = false;
+                this.connectState.isConnected = false;
                 return true;
             }
             if (this.connectState.isConnected) {
                 this.ble.removeConnectedDevice(this);
                 this.cleanupListeners();
-                setTimeout(() => { this.connectState.isDisconnecting = false; }, 1000);
                 this.logEvent({ message: 'disconnect result: success', device: { id, name, address } });
+                this.connectState.isDisconnecting = false;
+                this.connectState.isConnecting = false;
+                this.connectState.isConnected = false;
                 return true;
             }
         });
@@ -273,10 +286,11 @@ class BleDevice extends ble_1.BleDeviceClass {
         }
         return false;
     }
-    onData(characteristic, data) {
+    onData(characteristic, _data) {
+        const data = Buffer.from(_data);
         const isDuplicate = this.checkForDuplicate(characteristic, data);
         if (isDuplicate) {
-            return;
+            return false;
         }
         this.logEvent({ message: 'got data', characteristic, data: data.toString('hex'), writeQueue: this.writeQueue.length });
         if (this.writeQueue.length > 0) {
@@ -286,8 +300,10 @@ class BleDevice extends ble_1.BleDeviceClass {
                 this.writeQueue.splice(writeIdx, 1);
                 if (writeItem.resolve)
                     writeItem.resolve(data);
+                return false;
             }
         }
+        return true;
     }
     timeoutCheck() {
         const now = Date.now();
@@ -321,6 +337,8 @@ class BleDevice extends ble_1.BleDeviceClass {
     write(characteristicUuid, data, props) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
+                if (!this.isConnected())
+                    throw new Error('not connected');
                 const { withoutResponse, timeout } = props || {};
                 const connector = this.ble.getConnector(this.peripheral);
                 const isAlreadySubscribed = connector.isSubscribed(characteristicUuid);
@@ -380,6 +398,8 @@ class BleDevice extends ble_1.BleDeviceClass {
     }
     read(characteristicUuid) {
         return new Promise((resolve, reject) => {
+            if (!this.isConnected())
+                return reject(new Error('not connected'));
             const characteristic = this.characteristics.find(c => c.uuid === characteristicUuid || (0, ble_1.uuid)(c.uuid) === characteristicUuid);
             if (!characteristic) {
                 reject(new Error('Characteristic not found'));

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

@@ -67,6 +67,7 @@ export default class BleInterface extends BleInterfaceClass {
     getServicesFromDevice(device: BleDeviceClass): string[];
     waitForConnectFinished(timeout: any): Promise<unknown>;
     addPeripheralToCache(peripheral: any, props?: {}): void;
+    onDisconnect(peripheral: any): void;
     getConnector(peripheral: BlePeripheral): any;
     findPeripheral(peripheral: BlePeripheral | {
         id?: string;

package/lib/ble/ble-interface.js

@@ -290,6 +290,11 @@ class BleInterface extends ble_1.BleInterfaceClass {
         const connector = info && info.connector ? info.connector : new ble_peripheral_1.default(this, peripheral);
         this.peripheralCache.push(Object.assign({ address: peripheral.address, ts: Date.now(), peripheral, connector }, props));
     }
+    onDisconnect(peripheral) {
+        const idx = this.peripheralCache.findIndex(i => i.address === peripheral.address);
+        if (idx !== -1)
+            this.peripheralCache.splice(idx, 1);
+    }
     getConnector(peripheral) {
         const info = this.peripheralCache.find(i => i.address === peripheral.address);
         if (!info) {
@@ -411,7 +416,8 @@ class BleInterface extends ble_1.BleInterfaceClass {
                     if (devices && devices.length > 0) {
                         for (let i = 0; i < devices.length; i++) {
                             const idx = this.devices.push({ device: devices[i], isConnected: false }) - 1;
-                            yield devices[i].connect();
+                            if (!devices[i].isConnected())
+                                yield devices[i].connect();
                             this.devices[idx].isConnected = true;
                         }
                     }
@@ -558,14 +564,14 @@ class BleInterface extends ble_1.BleInterfaceClass {
                     });
                 };
                 const onPeripheralFound = (peripheral, fromCache = false) => __awaiter(this, void 0, void 0, function* () {
+                    if (!peripheral || !peripheral.advertisement || !peripheral.advertisement.localName || !peripheral.advertisement.serviceUuids || peripheral.advertisement.serviceUuids.length === 0)
+                        return;
                     if (fromCache)
                         this.logEvent({ message: 'adding from Cache', peripheral: peripheral.address });
                     else {
                         const { id, name, address, advertisement = {} } = peripheral;
                         this.logEvent({ message: 'BLE scan: found device', peripheral: { id, name, address, services: advertisement.serviceUuids } });
                     }
-                    if (!peripheral || !peripheral.advertisement || !peripheral.advertisement.serviceUuids || peripheral.advertisement.serviceUuids.length === 0)
-                        return;
                     if (peripheral.address === undefined || peripheral.address === '')
                         peripheral.address = peripheral.id;
                     const isPeripheralProcessed = peripheralsProcessed.find(p => p === peripheral.address) !== undefined;
@@ -638,7 +644,14 @@ class BleInterface extends ble_1.BleInterfaceClass {
                 this.peripheralCache.forEach(i => {
                     onPeripheralFound(i.peripheral, true);
                 });
-                bleBinding.startScanning([], true, (err) => {
+                let services = [];
+                if (scanForDevice) {
+                    if (props.requested instanceof ble_1.BleDeviceClass) {
+                        const device = props.requested;
+                        services = (device.getServices()) || [];
+                    }
+                }
+                bleBinding.startScanning(services, false, (err) => {
                     if (err) {
                         this.logEvent({ message: `${opStr} result: error`, requested: scanForDevice ? { name, address, profile } : undefined, error: err.message });
                         this.scanState.isScanning = false;

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

@@ -24,7 +24,7 @@ export default class BlePeripheralConnector {
     initialize(enforce?: boolean): Promise<void>;
     isSubscribed(characteristicUuid: string): boolean;
     subscribeAll(callback: (characteristicUuid: string, data: any) => void): Promise<string[]>;
-    subscribe(characteristicUuid: string): Promise<boolean>;
+    subscribe(characteristicUuid: string, timeout?: number): Promise<boolean>;
     onData(characteristicUuid: string, data: any): void;
     on(characteristicUuid: string, callback: (characteristicUuid: string, data: any) => void): void;
     off(characteristicUuid: string, callback: (characteristicUuid: string, data: any) => void): void;

package/lib/ble/ble-peripheral.js

@@ -22,7 +22,7 @@ class BlePeripheralConnector {
         this.emitter = new events_1.default();
         if (!this.peripheral || !this.ble)
             throw new Error('Illegal Arguments');
-        this.state = { isConnected: false, isConnecting: false, isInitialized: false, isInitializing: false, isSubscribing: false };
+        this.state = { subscribed: [], isConnected: false, isConnecting: false, isInitialized: false, isInitializing: false, isSubscribing: false };
         this.services = undefined;
         this.characteristics = undefined;
         this.logger = new gd_eventlog_1.EventLogger('BLE');
@@ -31,7 +31,9 @@ class BlePeripheralConnector {
         if (this.logger) {
             this.logger.logEvent(event);
         }
-        console.log('~~~BLE:', event);
+        if (process.env.BLE_DEBUG) {
+            console.log('~~~BLE:', event);
+        }
     }
     connect() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -40,9 +42,10 @@ class BlePeripheralConnector {
             this.logEvent({ message: 'connect', peripheral: this.peripheral.address, state: this.state });
             this.state.isConnecting = true;
             try {
+                this.peripheral.on('connect', () => { console.log('~~~ peripheral connected', this.peripheral); });
+                this.peripheral.on('disconnect', () => { this.onDisconnect(); });
                 if (!this.state.isConnected || (this.peripheral && this.peripheral.state !== 'connected')) {
                     yield this.peripheral.connectAsync();
-                    this.peripheral.once('disconnect', this.onDisconnect.bind(this));
                 }
                 this.state.isConnected = this.peripheral.state === 'connected';
             }
@@ -58,9 +61,12 @@ class BlePeripheralConnector {
         });
     }
     onDisconnect() {
+        this.peripheral.removeAllListeners('connect');
+        this.peripheral.removeAllListeners('disconnect');
         this.logEvent({ message: 'onDisconnected', peripheral: this.peripheral.address, state: this.state });
         this.state.isConnected = false;
-        this.reconnect();
+        this.state.isConnecting = false;
+        this.emitter.emit('disconnect');
     }
     initialize(enforce = false) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -108,7 +114,7 @@ class BlePeripheralConnector {
                         this.logEvent({ message: 'subscribe', peripheral: this.peripheral.address, characteristic: c.uuid, uuid: (0, ble_1.uuid)(c.uuid) });
                         if (this.state.subscribed.find(uuid => uuid === c.uuid) === undefined) {
                             try {
-                                yield this.subscribe(c.uuid);
+                                yield this.subscribe(c.uuid, 3000);
                                 subscribed.push(c.uuid);
                             }
                             catch (err) {
@@ -126,8 +132,8 @@ class BlePeripheralConnector {
             return subscribed;
         });
     }
-    subscribe(characteristicUuid) {
-        this.logEvent({ message: 'subscribe', characteristic: characteristicUuid, characteristics: this.characteristics.map(c => ({ characteristic: c.uuid, uuid: (0, ble_1.uuid)(c.uuid) })) });
+    subscribe(characteristicUuid, timeout) {
+        this.logEvent({ message: 'subscribe attempt', characteristic: characteristicUuid, characteristics: this.characteristics.map(c => ({ characteristic: c.uuid, uuid: (0, ble_1.uuid)(c.uuid) })) });
         return new Promise((resolve, reject) => {
             try {
                 const characteristic = this.characteristics.find(c => (0, ble_1.uuid)(c.uuid) === (0, ble_1.uuid)(characteristicUuid) || (0, ble_1.uuid)(c.uuid) === (0, ble_1.uuid)(characteristicUuid));
@@ -135,17 +141,21 @@ class BlePeripheralConnector {
                     reject(new Error('Characteristic not found'));
                     return;
                 }
-                this.logEvent({ message: 'subscribe', peripheral: this.peripheral.address, characteristic: characteristic.uuid, uuid: (0, ble_1.uuid)(characteristic.uuid) });
+                this.logEvent({ message: 'subscribe', peripheral: this.peripheral.address, characteristic: characteristic.uuid });
                 characteristic.removeAllListeners('data');
                 characteristic.on('data', (data, _isNotification) => {
                     this.onData((0, ble_1.uuid)(characteristicUuid), data);
                 });
-                const to = setTimeout(() => {
-                    this.logEvent({ message: 'subscribe result', characteristic: characteristicUuid, error: 'timeout' });
-                    reject(new Error('timeout'));
-                }, 3000);
+                let to;
+                if (timeout) {
+                    to = setTimeout(() => {
+                        this.logEvent({ message: 'subscribe result', characteristic: characteristicUuid, error: 'timeout' });
+                        reject(new Error('timeout'));
+                    }, timeout);
+                }
                 characteristic.subscribe((err) => {
-                    clearTimeout(to);
+                    if (to)
+                        clearTimeout(to);
                     this.logEvent({ message: 'subscribe result', characteristic: characteristicUuid, error: err });
                     if (err)
                         reject(err);

package/lib/ble/ble.d.ts

@@ -3,6 +3,7 @@ import EventEmitter from "events";
 import BlePeripheralConnector from "./ble-peripheral";
 export declare type ConnectProps = {
     timeout?: number;
+    reconnect?: boolean;
 };
 export interface BleDeviceIdentifier {
     id?: string;
@@ -42,6 +43,7 @@ export declare abstract class BleDeviceClass extends EventEmitter {
     abstract connect(props?: ConnectProps): Promise<boolean>;
     abstract disconnect(): Promise<boolean>;
     abstract getDeviceInfo(): Promise<BleDeviceInfo>;
+    abstract getServices(): string[];
     setCharacteristicUUIDs(uuids: string[]): void;
 }
 export interface BleWriteProps {
@@ -78,6 +80,7 @@ export declare abstract class BleInterfaceClass extends EventEmitter {
     abstract scan(props: ScanProps): Promise<BleDeviceClass[]>;
     abstract stopScan(): Promise<boolean>;
     abstract disconnect(): Promise<boolean>;
+    abstract onDisconnect(peripheral: BlePeripheral): void;
     abstract isScanning(): boolean;
     abstract addConnectedDevice(device: BleDeviceClass): void;
     abstract removeConnectedDevice(device: BleDeviceClass): void;

package/lib/ble/fm.d.ts

@@ -8,6 +8,7 @@ import { DeviceProtocol } from '../DeviceProtocol';
 import { EventLogger } from 'gd-eventlog';
 import CyclingMode from '../CyclingMode';
 import { IncyclistBikeData } from '../CyclingMode';
+import BlePeripheralConnector from './ble-peripheral';
 declare type PowerData = {
     instantaneousPower?: number;
     balance?: number;
@@ -25,7 +26,9 @@ export declare type IndoorBikeData = {
     resistanceLevel?: number;
     instantaneousPower?: number;
     averagePower?: number;
-    expendedEnergy?: number;
+    totalEnergy?: number;
+    energyPerHour?: number;
+    energyPerMinute?: number;
     heartrate?: number;
     metabolicEquivalent?: number;
     time?: number;
@@ -54,6 +57,7 @@ export default class BleFitnessMachineDevice extends BleDevice {
     constructor(props?: any);
     isMatching(characteristics: string[]): boolean;
     subscribeWriteResponse(cuuid: string): Promise<void>;
+    subscribeAll(conn?: BlePeripheralConnector): Promise<void>;
     init(): Promise<boolean>;
     onDisconnect(): void;
     getProfile(): string;
@@ -71,7 +75,7 @@ export default class BleFitnessMachineDevice extends BleDevice {
     parseIndoorBikeData(_data: Uint8Array): IndoorBikeData;
     parseFitnessMachineStatus(_data: Uint8Array): IndoorBikeData;
     getFitnessMachineFeatures(): Promise<IndoorBikeFeatures>;
-    onData(characteristic: string, data: Buffer): void;
+    onData(characteristic: string, data: Buffer): boolean;
     writeFtmsMessage(requestedOpCode: any, data: any, props?: BleWriteProps): Promise<number>;
     requestControl(): Promise<boolean>;
     setTargetPower(power: number): Promise<boolean>;

package/lib/ble/fm.js

@@ -93,6 +93,7 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
         this.windSpeed = 0;
         this.wheelSize = 2100;
         this.data = {};
+        this.services = BleFitnessMachineDevice.services;
     }
     isMatching(characteristics) {
         if (!characteristics)
@@ -125,13 +126,44 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
             }
         });
     }
+    subscribeAll(conn) {
+        return new Promise(resolve => {
+            const characteristics = [consts_1.INDOOR_BIKE_DATA, consts_1.FTMS_STATUS, consts_1.FTMS_CP];
+            const timeout = Date.now() + 5500;
+            const iv = setInterval(() => {
+                const subscriptionStatus = characteristics.map(c => this.subscribedCharacteristics.find(s => s === c) !== undefined);
+                const done = subscriptionStatus.filter(s => s === true).length === characteristics.length;
+                if (done || Date.now() > timeout) {
+                    clearInterval(iv);
+                    resolve();
+                }
+            }, 100);
+            try {
+                const connector = conn || this.ble.getConnector(this.peripheral);
+                for (let i = 0; i < characteristics.length; i++) {
+                    const c = characteristics[i];
+                    const isAlreadySubscribed = connector.isSubscribed(c);
+                    if (!isAlreadySubscribed) {
+                        connector.removeAllListeners(c);
+                        connector.on(c, (uuid, data) => {
+                            this.onData(uuid, data);
+                        });
+                        connector.subscribe(c);
+                        this.subscribedCharacteristics.push(c);
+                    }
+                }
+            }
+            catch (err) {
+                this.logEvent({ message: 'Error', fn: 'subscribeAll()', error: err.message, stack: err.stack });
+            }
+        });
+    }
     init() {
         const _super = Object.create(null, {
             initDevice: { get: () => super.initDevice }
         });
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                yield this.subscribeWriteResponse(consts_1.FTMS_CP);
                 yield _super.initDevice.call(this);
                 yield this.getFitnessMachineFeatures();
                 this.logEvent({ message: 'device info', deviceInfo: this.deviceInfo, features: this.features });
@@ -180,6 +212,7 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
             }
         }
         catch (err) {
+            this.logEvent({ message: 'error', fn: 'parseHrm()', error: err.message | err, stack: err.stack });
         }
         return Object.assign(Object.assign({}, this.data), { raw: `2a37:${data.toString('hex')}` });
     }
@@ -191,99 +224,113 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
     getWindSpeed() { return this.windSpeed; }
     parseIndoorBikeData(_data) {
         const data = Buffer.from(_data);
-        const flags = data.readUInt16LE(0);
-        let offset = 2;
-        if ((flags & IndoorBikeDataFlag.MoreData) === 0) {
-            this.data.speed = data.readUInt16LE(offset) / 100;
-            offset += 2;
-        }
-        if (flags & IndoorBikeDataFlag.AverageSpeedPresent) {
-            this.data.averageSpeed = data.readUInt16LE(offset) / 100;
-            offset += 2;
-        }
-        if (flags & IndoorBikeDataFlag.InstantaneousCadence) {
-            this.data.cadence = data.readUInt16LE(offset) / 2;
-            offset += 2;
-        }
-        if (flags & IndoorBikeDataFlag.AverageCadencePresent) {
-            this.data.averageCadence = data.readUInt16LE(offset) / 2;
-            offset += 2;
-        }
-        if (flags & IndoorBikeDataFlag.TotalDistancePresent) {
-            const dvLow = data.readUInt8(offset);
-            offset += 1;
-            const dvHigh = data.readUInt16LE(offset);
-            offset += 2;
-            this.data.totalDistance = (dvHigh << 8) + dvLow;
-        }
-        if (flags & IndoorBikeDataFlag.ResistanceLevelPresent) {
-            this.data.resistanceLevel = data.readInt16LE(offset);
-            offset += 2;
-        }
-        if (flags & IndoorBikeDataFlag.InstantaneousPowerPresent) {
-            this.data.instantaneousPower = data.readInt16LE(offset);
-            offset += 2;
-        }
-        if (flags & IndoorBikeDataFlag.AveragePowerPresent) {
-            this.data.averagePower = data.readInt16LE(offset);
-            offset += 2;
-        }
-        if (flags & IndoorBikeDataFlag.ExpendedEnergyPresent) {
-            this.data.expendedEnergy = data.readUInt16LE(offset);
-            offset += 2;
-        }
-        if (flags & IndoorBikeDataFlag.HeartRatePresent) {
-            this.data.heartrate = data.readUInt16LE(offset);
-            offset += 2;
-        }
-        if (flags & IndoorBikeDataFlag.MetabolicEquivalentPresent) {
-            this.data.metabolicEquivalent = data.readUInt16LE(offset) / 10;
-            offset += 2;
-        }
-        if (flags & IndoorBikeDataFlag.ElapsedTimePresent) {
-            this.data.time = data.readUInt16LE(offset);
-            offset += 2;
+        try {
+            const flags = data.readUInt16LE(0);
+            let offset = 2;
+            if ((flags & IndoorBikeDataFlag.MoreData) === 0) {
+                this.data.speed = data.readUInt16LE(offset) / 100;
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.AverageSpeedPresent) {
+                this.data.averageSpeed = data.readUInt16LE(offset) / 100;
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.InstantaneousCadence) {
+                this.data.cadence = data.readUInt16LE(offset) / 2;
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.AverageCadencePresent) {
+                this.data.averageCadence = data.readUInt16LE(offset) / 2;
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.TotalDistancePresent) {
+                const dvLow = data.readUInt8(offset);
+                offset += 1;
+                const dvHigh = data.readUInt16LE(offset);
+                offset += 2;
+                this.data.totalDistance = (dvHigh << 8) + dvLow;
+            }
+            if (flags & IndoorBikeDataFlag.ResistanceLevelPresent) {
+                this.data.resistanceLevel = data.readInt8(offset);
+                offset += 1;
+            }
+            if (flags & IndoorBikeDataFlag.InstantaneousPowerPresent) {
+                this.data.instantaneousPower = data.readInt16LE(offset);
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.AveragePowerPresent) {
+                this.data.averagePower = data.readInt16LE(offset);
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.ExpendedEnergyPresent) {
+                this.data.totalEnergy = data.readUInt16LE(offset);
+                offset += 2;
+                this.data.energyPerHour = data.readUInt16LE(offset);
+                offset += 2;
+                this.data.energyPerMinute = data.readUInt8(offset);
+                offset += 1;
+            }
+            if (flags & IndoorBikeDataFlag.HeartRatePresent) {
+                this.data.heartrate = data.readUInt8(offset);
+                offset += 1;
+            }
+            if (flags & IndoorBikeDataFlag.MetabolicEquivalentPresent) {
+                this.data.metabolicEquivalent = data.readUInt8(offset) / 10;
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.ElapsedTimePresent) {
+                this.data.time = data.readUInt16LE(offset);
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.RemainingTimePresent) {
+                this.data.remainingTime = data.readUInt16LE(offset);
+                offset += 2;
+            }
         }
-        if (flags & IndoorBikeDataFlag.RemainingTimePresent) {
-            this.data.remainingTime = data.readUInt16LE(offset);
-            offset += 2;
+        catch (err) {
+            this.logEvent({ message: 'error', fn: 'parseIndoorBikeData()', error: err.message | err, stack: err.stack });
         }
         return Object.assign(Object.assign({}, this.data), { raw: `2ad2:${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;
-                }
+        try {
+            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;
+                    }
+            }
+        }
+        catch (err) {
+            this.logEvent({ message: 'error', fn: 'parseFitnessMachineStatus()', error: err.message | err, stack: err.stack });
         }
         return Object.assign(Object.assign({}, this.data), { raw: `2ada:${data.toString('hex')}` });
     }
@@ -298,6 +345,7 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
                     const fitnessMachine = buffer.readUInt32LE(0);
                     const targetSettings = buffer.readUInt32LE(4);
                     this.features = { fitnessMachine, targetSettings };
+                    this.logEvent({ message: 'supported Features: ', fatures: this.features });
                 }
             }
             catch (err) {
@@ -306,7 +354,9 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
         });
     }
     onData(characteristic, data) {
-        super.onData(characteristic, data);
+        const hasData = super.onData(characteristic, data);
+        if (!hasData)
+            return false;
         const uuid = characteristic.toLocaleLowerCase();
         let res = undefined;
         switch (uuid) {
@@ -326,8 +376,11 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
             default:
                 break;
         }
-        if (res)
+        if (res) {
             this.emit('data', res);
+            return false;
+        }
+        return true;
     }
     writeFtmsMessage(requestedOpCode, data, props) {
         return __awaiter(this, void 0, void 0, function* () {

package/lib/ble/hrm.d.ts

@@ -20,7 +20,7 @@ export default class BleHrmDevice extends BleDevice {
     getProfile(): string;
     getServiceUUids(): string[];
     parseHrm(_data: Uint8Array): HrmData;
-    onData(characteristic: string, data: Buffer): void;
+    onData(characteristic: string, data: Buffer): boolean;
 }
 export declare class HrmAdapter extends DeviceAdapter {
     device: BleHrmDevice;

package/lib/ble/hrm.js

@@ -51,14 +51,15 @@ class BleHrmDevice extends ble_device_1.BleDevice {
         return { heartrate, rr, raw: data.toString('hex') };
     }
     onData(characteristic, data) {
-        super.onData(characteristic, data);
-        const isDuplicate = this.checkForDuplicate(characteristic, data);
-        if (isDuplicate)
+        const hasData = super.onData(characteristic, data);
+        if (!hasData)
             return;
         if (characteristic.toLocaleLowerCase() === '2a37') {
             const res = this.parseHrm(data);
             this.emit('data', res);
+            return false;
         }
+        return true;
     }
 }
 exports.default = BleHrmDevice;

package/lib/ble/pwr.d.ts

@@ -42,7 +42,7 @@ export default class BleCyclingPowerDevice extends BleDevice {
         time: any;
     };
     parsePower(_data: Uint8Array): PowerData;
-    onData(characteristic: string, data: Buffer): void;
+    onData(characteristic: string, data: Buffer): boolean;
     reset(): void;
 }
 export declare class PwrAdapter extends DeviceAdapter {
@@ -71,6 +71,7 @@ export declare class PwrAdapter extends DeviceAdapter {
     getDisplayName(): string;
     getCyclingMode(): CyclingMode;
     getDefaultCyclingMode(): CyclingMode;
+    getSupportedCyclingModes(): any[];
     getPort(): string;
     getWeight(): number;
     setIgnoreBike(ignore: any): void;

package/lib/ble/pwr.js

@@ -34,6 +34,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PwrAdapter = void 0;
 const ble_device_1 = require("./ble-device");
 const ble_interface_1 = __importDefault(require("./ble-interface"));
+const ble_1 = require("./ble");
 const Device_1 = __importStar(require("../Device"));
 const gd_eventlog_1 = require("gd-eventlog");
 const consts_1 = require("./consts");
@@ -138,14 +139,15 @@ class BleCyclingPowerDevice extends ble_device_1.BleDevice {
         return { instantaneousPower, balance, accTorque, rpm, time, raw: `2a63:${data.toString('hex')}` };
     }
     onData(characteristic, data) {
-        super.onData(characteristic, data);
-        const isDuplicate = this.checkForDuplicate(characteristic, data);
-        if (isDuplicate)
-            return;
-        if (characteristic.toLocaleLowerCase() === consts_1.CSP_MEASUREMENT) {
+        const hasData = super.onData(characteristic, data);
+        if (!hasData)
+            return false;
+        if ((0, ble_1.matches)(characteristic, consts_1.CSP_MEASUREMENT)) {
             const res = this.parsePower(data);
             this.emit('data', res);
+            return false;
         }
+        return true;
     }
     reset() {
         this.instantaneousPower = undefined;
@@ -201,6 +203,9 @@ class PwrAdapter extends Device_1.default {
     getDefaultCyclingMode() {
         return new power_meter_1.default(this);
     }
+    getSupportedCyclingModes() {
+        return [power_meter_1.default];
+    }
     getPort() {
         return 'ble';
     }

package/lib/ble/tacx.d.ts

@@ -63,7 +63,7 @@ export default class TacxAdvancedFitnessMachineDevice extends BleFitnessMachineD
     parseTrainerData(data: Buffer): BleFeBikeData;
     parseProductInformation(data: Buffer): BleFeBikeData;
     parseFECMessage(_data: Buffer): BleFeBikeData;
-    onData(characteristic: string, data: Buffer): any;
+    onData(characteristic: string, data: Buffer): boolean;
     getChecksum(message: any[]): number;
     buildMessage(payload?: number[], msgID?: number): Buffer;
     sendMessage(message: Buffer): Promise<boolean>;

package/lib/ble/tacx.js

@@ -164,10 +164,10 @@ class TacxAdvancedFitnessMachineDevice extends fm_1.default {
         return { rpm, time: this.timeOffset + c.time };
     }
     parseCSC(_data, logOnly = false) {
-        this.logEvent({ message: 'BLE CSC message', data: _data.toString('hex') });
+        const data = Buffer.from(_data);
+        this.logEvent({ message: 'BLE CSC message', data: data.toString('hex') });
         if (logOnly)
             return this.data;
-        const data = Buffer.from(_data);
         let offset = 0;
         const flags = data.readUInt8(offset);
         offset++;
@@ -187,10 +187,10 @@ class TacxAdvancedFitnessMachineDevice extends fm_1.default {
         return this.data;
     }
     parsePower(_data, logOnly = false) {
-        this.logEvent({ message: 'BLE CSP message', data: _data.toString('hex') });
+        const data = Buffer.from(_data);
+        this.logEvent({ message: 'BLE CSP message', data: data.toString('hex') });
         if (logOnly)
             return this.data;
-        const data = Buffer.from(_data);
         try {
             let offset = 4;
             const flags = data.readUInt16LE(0);

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

@@ -70,7 +70,7 @@ export default class WahooAdvancedFitnessMachineDevice extends BleFitnessMachine
         time: any;
     };
     parsePower(_data: Buffer): IndoorBikeData;
-    onData(characteristic: string, data: Buffer): void;
+    onData(characteristic: string, data: Buffer): boolean;
     writeWahooFtmsMessage(requestedOpCode: number, data: Buffer, props?: BleWriteProps): Promise<boolean>;
     requestControl(): Promise<boolean>;
     setPowerAdjusting(): void;

package/lib/ble/wahoo-kickr.js

@@ -170,7 +170,9 @@ class WahooAdvancedFitnessMachineDevice extends fm_1.default {
         return { instantaneousPower, cadence, time, raw: data.toString('hex') };
     }
     onData(characteristic, data) {
-        super.onData(characteristic, data);
+        const hasData = super.onData(characteristic, data);
+        if (!hasData)
+            return false;
         const uuid = characteristic.toLowerCase();
         let res = undefined;
         switch (uuid) {
@@ -190,8 +192,11 @@ class WahooAdvancedFitnessMachineDevice extends fm_1.default {
                 this.logEvent({ message: 'data', uuid, data: data.toString('hex') });
                 break;
         }
-        if (res)
+        if (res) {
             this.emit('data', res);
+            return false;
+        }
+        return true;
     }
     writeWahooFtmsMessage(requestedOpCode, data, props) {
         return __awaiter(this, void 0, void 0, function* () {

package/lib/kettler/ergo-racer/ERGCyclingMode.d.ts

@@ -0,0 +1,24 @@
+import CyclingMode, { CyclingModeProperty, IncyclistBikeData, UpdateRequest } from '../../CyclingMode';
+import KettlerAdapter from "./adapter";
+import PowerBasedCyclingModeBase from '../../modes/power-base';
+export declare type ERGEvent = {
+    rpmUpdated?: boolean;
+    gearUpdated?: boolean;
+    starting?: boolean;
+    tsStart?: number;
+};
+export default class ERGCyclingMode extends PowerBasedCyclingModeBase implements CyclingMode {
+    prevRequest: UpdateRequest;
+    hasBikeUpdate: boolean;
+    chain: number[];
+    cassette: number[];
+    event: ERGEvent;
+    constructor(adapter: KettlerAdapter, props?: any);
+    getName(): string;
+    getDescription(): string;
+    getProperties(): CyclingModeProperty[];
+    getProperty(name: string): CyclingModeProperty;
+    getBikeInitRequest(): UpdateRequest;
+    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
+    updateData(bikeData: IncyclistBikeData): any;
+}

package/lib/kettler/ergo-racer/ERGCyclingMode.js

@@ -0,0 +1,144 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const CyclingMode_1 = require("../../CyclingMode");
+const power_base_1 = __importDefault(require("../../modes/power-base"));
+const MIN_SPEED = 10;
+const config = {
+    name: "ERG",
+    description: "Calculates speed based on power and slope. Power is either set by a workout",
+    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 },
+    ]
+};
+class ERGCyclingMode extends power_base_1.default {
+    constructor(adapter, props) {
+        super(adapter, props);
+        this.hasBikeUpdate = false;
+        this.event = {};
+        this.initLogger('ERGMode');
+    }
+    getName() {
+        return config.name;
+    }
+    getDescription() {
+        return config.description;
+    }
+    getProperties() {
+        return config.properties;
+    }
+    getProperty(name) {
+        return config.properties.find(p => p.name === name);
+    }
+    getBikeInitRequest() {
+        const startPower = this.getSetting('startPower');
+        return { targetPower: startPower };
+    }
+    sendBikeUpdate(request) {
+        const getData = () => {
+            if (!this.data)
+                return {};
+            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() });
+        let newRequest = {};
+        try {
+            if (!request || request.reset || Object.keys(request).length === 0) {
+                this.prevRequest = {};
+                return request.reset ? { reset: true } : {};
+            }
+            const prevData = this.data || {};
+            if (request.targetPower !== undefined) {
+                delete request.slope;
+                delete request.refresh;
+            }
+            if (request.refresh) {
+                delete request.refresh;
+                if (this.prevRequest)
+                    newRequest.targetPower = this.prevRequest.targetPower;
+                else {
+                    this.prevRequest = this.getBikeInitRequest();
+                    newRequest.targetPower = this.prevRequest.targetPower;
+                }
+            }
+            if (request.slope !== undefined) {
+                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;
+                newRequest.targetPower = request.targetPower;
+            }
+            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 (prevData.power && prevData.power < request.minPower)
+                    newRequest.targetPower = request.minPower;
+            }
+            if (!newRequest.targetPower && newRequest.maxPower && prevData.power > newRequest.maxPower) {
+                newRequest.targetPower = newRequest.maxPower;
+            }
+            if (!newRequest.targetPower && newRequest.minPower && prevData.power < newRequest.minPower) {
+                newRequest.targetPower = newRequest.minPower;
+            }
+            this.prevRequest = JSON.parse(JSON.stringify(request));
+        }
+        catch (err) {
+            this.logger.logEvent({ message: "error", fn: 'sendBikeUpdate()', error: err.message || err, stack: err.stack });
+        }
+        return newRequest;
+    }
+    updateData(bikeData) {
+        const prevData = JSON.parse(JSON.stringify(this.data || {}));
+        const prevSpeed = prevData.speed;
+        const prevRequest = this.prevRequest || {};
+        const data = this.data || {};
+        const bikeType = this.getSetting('bikeType').toLowerCase();
+        try {
+            let power = bikeData.power || 0;
+            const slope = (prevData.slope !== undefined ? prevData.slope : prevRequest.slope || 0);
+            const distanceInternal = prevData.distanceInternal || 0;
+            const m = this.getWeight();
+            const t = this.getTimeSinceLastUpdate();
+            const { speed, distance } = this.calculateSpeedAndDistance(power, slope, m, t, { bikeType });
+            if (power === 0 && speed < MIN_SPEED) {
+                data.speed = Math.round(prevData.speed - 1) < 0 ? 0 : Math.round(prevData.speed - 1);
+                data.distanceInternal = distanceInternal + data.speed / 3.6 * t;
+            }
+            else {
+                data.speed = (power === 0 && speed < MIN_SPEED) ? 0 : speed;
+                data.distanceInternal = (power === 0 && speed < MIN_SPEED) ? distanceInternal : distanceInternal + distance;
+            }
+            data.power = Math.round(power);
+            data.slope = slope;
+            data.pedalRpm = bikeData.pedalRpm || 0;
+            if (data.time !== undefined && data.speed > 0)
+                data.time += t;
+            else
+                data.time = 0;
+            data.heartrate = bikeData.heartrate;
+            data.isPedalling = bikeData.isPedalling;
+        }
+        catch (err) {
+            this.logger.logEvent({ message: 'error', fn: 'updateData()', error: err.message || err });
+        }
+        this.logger.logEvent({ message: "updateData result", data, bikeData, prevRequest, prevSpeed });
+        this.data = data;
+        return data;
+    }
+}
+exports.default = ERGCyclingMode;

package/lib/kettler/ergo-racer/adapter.d.ts

@@ -28,7 +28,6 @@ export interface KettlerDeviceSettings extends DeviceSettings {
 }
 export default class KettlerRacerAdapter extends DeviceAdapterBase implements DeviceAdapter, Bike {
     private id;
-    private settings;
     private ignoreHrm;
     private ignoreBike;
     private ignorePower;
@@ -43,7 +42,7 @@ export default class KettlerRacerAdapter extends DeviceAdapterBase implements De
     private requestBusy;
     private comms;
     private prevDistance;
-    constructor(protocol: DeviceProtocol, settings: DeviceSettings);
+    constructor(protocol: DeviceProtocol, settings: KettlerDeviceSettings);
     isBike(): boolean;
     isPower(): boolean;
     isHrm(): boolean;
@@ -96,8 +95,6 @@ export default class KettlerRacerAdapter extends DeviceAdapterBase implements De
     waitForOpened(retries?: boolean): Promise<boolean>;
     waitForClosed(): Promise<boolean>;
     getSupportedCyclingModes(): any[];
-    setCyclingMode(mode: CyclingMode | string, settings?: any): void;
-    getCyclingMode(): CyclingMode;
     getDefaultCyclingMode(): CyclingMode;
     setUserSettings(userSettings: any): void;
     setBikeSettings(bikeSettings: any): void;

package/lib/kettler/ergo-racer/adapter.js

@@ -36,12 +36,12 @@ const gd_eventlog_1 = require("gd-eventlog");
 const comms_1 = __importDefault(require("../comms"));
 const utils_1 = require("../../utils");
 const power_meter_1 = __importDefault(require("../../modes/power-meter"));
+const ERGCyclingMode_1 = __importDefault(require("./ERGCyclingMode"));
 class KettlerRacerAdapter extends Device_1.default {
     constructor(protocol, settings) {
-        super(protocol);
+        super(protocol, settings);
         this.requests = [];
         this.logger = new gd_eventlog_1.EventLogger('KettlerRacer');
-        this.settings = settings;
         this.ignoreHrm = false;
         this.ignorePower = false;
         this.ignoreBike = false;
@@ -624,32 +624,10 @@ class KettlerRacerAdapter extends Device_1.default {
         });
     }
     getSupportedCyclingModes() {
-        return [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.settings.cyclingMode = new CyclingModeClass(this, settings);
-                return;
-            }
-            selectedMode = this.getDefaultCyclingMode();
-        }
-        else {
-            selectedMode = mode;
-        }
-        this.settings.cyclingMode = selectedMode;
-        this.settings.cyclingMode.setSettings(settings);
-    }
-    getCyclingMode() {
-        if (!this.settings.cyclingMode)
-            this.setCyclingMode(this.getDefaultCyclingMode());
-        return this.settings.cyclingMode;
+        return [power_meter_1.default, ERGCyclingMode_1.default];
     }
     getDefaultCyclingMode() {
-        return new power_meter_1.default(this);
+        return new ERGCyclingMode_1.default(this);
     }
     setUserSettings(userSettings) {
         this.settings.userSettings = userSettings;

package/package.json

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