incyclist-devices 1.5.38 → 2.0.0

package/lib/antv2/{fe.js → fe/adapter.js}

@@ -12,64 +12,65 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const ant_device_1 = __importDefault(require("./ant-device"));
-const utils_1 = require("../ant/utils");
+const adapter_1 = require("../adapter");
+const utils_1 = require("../utils");
 const gd_eventlog_1 = require("gd-eventlog");
-const ant_fe_st_mode_1 = __importDefault(require("../ant/antfe/ant-fe-st-mode"));
-const ant_fe_erg_mode_1 = __importDefault(require("../ant/antfe/ant-fe-erg-mode"));
-const ant_fe_adv_st_mode_1 = __importDefault(require("../ant/antfe/ant-fe-adv-st-mode"));
-const utils_2 = require("../utils");
-const DEFAULT_USER_WEIGHT = 75;
-const DEFAULT_BIKE_WEIGHT = 10;
+const ant_fe_st_mode_1 = __importDefault(require("../modes/ant-fe-st-mode"));
+const ant_fe_erg_mode_1 = __importDefault(require("../modes/ant-fe-erg-mode"));
+const ant_fe_adv_st_mode_1 = __importDefault(require("../modes/ant-fe-adv-st-mode"));
+const utils_2 = require("../../utils/utils");
+const sensor_factory_1 = __importDefault(require("../sensor-factory"));
+const capabilities_1 = require("../../types/capabilities");
+const adpater_1 = require("../../base/adpater");
 const DEFAULT_BIKE_WEIGHT_MOUNTAIN = 14.5;
 const MAX_RETRIES = 3;
-class AntFEAdapter extends ant_device_1.default {
-    constructor(sensor, protocol) {
-        super(sensor, protocol);
-        this.started = false;
+class AntFEAdapter extends adapter_1.ControllableAntAdapter {
+    constructor(settings, props) {
+        if (settings.protocol && settings.profile !== AntFEAdapter.INCYCLIST_PROFILE_NAME)
+            throw new Error('Incorrect Profile');
+        if (!settings.protocol && settings.profile !== AntFEAdapter.ANT_PROFILE_NAME)
+            throw new Error('Incorrect Profile');
+        super(settings, props);
         this.deviceData = {
-            DeviceID: sensor.getDeviceID()
+            DeviceID: this.sensor.getDeviceID()
         };
         this.dataMsgCount = 0;
         this.logger = new gd_eventlog_1.EventLogger('Ant+FE');
         this.isReconnecting = false;
+        this.startProps = {};
+        this.capabilities = [
+            capabilities_1.IncyclistCapability.Power, capabilities_1.IncyclistCapability.Speed, capabilities_1.IncyclistCapability.Cadence,
+            capabilities_1.IncyclistCapability.Control
+        ];
+    }
+    createSensor(settings) {
+        const sensor = sensor_factory_1.default.create(AntFEAdapter.ANT_PROFILE_NAME, Number(settings.deviceID));
+        return sensor;
     }
-    isBike() { return true; }
-    isHrm() { return false; }
-    isPower() { return true; }
     getName() {
+        if (this.settings.name)
+            return this.settings.name;
         const deviceID = this.sensor.getDeviceID();
         return `Ant+FE ${deviceID}`;
     }
-    getDisplayName() {
+    getUniqueName() {
+        if (this.settings.name)
+            return this.settings.name;
         const { DeviceID, ManId } = this.deviceData;
-        return `${(0, utils_1.getBrand)(ManId)} FE ${DeviceID}`;
+        const brand = (0, utils_1.getBrand)(ManId);
+        if (brand)
+            return `${brand} FE ${DeviceID}`;
+        else
+            return `${this.getName()}`;
+    }
+    getDisplayName() {
+        const { InstantaneousPower } = this.deviceData;
+        const pwrStr = InstantaneousPower ? ` (${InstantaneousPower})` : '';
+        return `${this.getUniqueName()}${pwrStr}`;
     }
     getSupportedCyclingModes() {
         return [ant_fe_st_mode_1.default, ant_fe_erg_mode_1.default, ant_fe_adv_st_mode_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.cyclingMode)
-            this.cyclingMode = this.getDefaultCyclingMode();
-        return this.cyclingMode;
-    }
     getDefaultCyclingMode() {
         return new ant_fe_st_mode_1.default(this);
     }
@@ -80,17 +81,17 @@ class AntFEAdapter extends ant_device_1.default {
         });
         return logData;
     }
-    sendUpdate(request) {
+    sendUpdate(request, forced = false) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.paused || this.isReconnecting)
+            if ((this.paused || this.isReconnecting) && !forced)
+                return;
+            let isReset = request.reset && Object.keys(request).length === 1;
+            const update = isReset ? this.getCyclingMode().getBikeInitRequest() : this.getCyclingMode().sendBikeUpdate(request);
+            if (!update)
                 return;
-            const update = this.getCyclingMode().sendBikeUpdate(request);
             this.logger.logEvent({ message: 'send bike update requested', update, request });
             try {
                 const fe = this.sensor;
-                const isReset = (!update || update.reset || Object.keys(update).length === 0);
-                if (isReset)
-                    yield fe.sendTrackResistance(0);
                 if (update.slope !== undefined) {
                     yield fe.sendTrackResistance(update.slope);
                 }
@@ -112,30 +113,32 @@ class AntFEAdapter extends ant_device_1.default {
     onDeviceData(deviceData) {
         this.dataMsgCount++;
         this.lastDataTS = Date.now();
-        if (!this.started || this.isStopped())
+        super.onDeviceData(deviceData);
+        if (!this.started || this.isStopped() || this.paused)
             return;
-        this.deviceData = deviceData;
-        if (this.dataMsgCount === 1) {
+        if (!this.ivDataTimeout && this.dataMsgCount > 0) {
             this.startDataTimeoutCheck();
         }
         try {
             const logData = this.getLogData(deviceData, ['PairedDevices', 'RawData']);
             this.logger.logEvent({ message: 'onDeviceData', data: logData });
-            if (this.onDataFn && !(this.ignoreHrm && this.ignoreBike && this.ignorePower) && !this.paused) {
-                if (!this.lastUpdate || (Date.now() - this.lastUpdate) > this.updateFrequency) {
-                    let incyclistData = this.mapData(deviceData);
-                    incyclistData = this.getCyclingMode().updateData(incyclistData);
-                    const data = this.transformData(incyclistData);
-                    this.onDataFn(data);
-                    this.lastUpdate = Date.now();
-                }
-            }
+            if (!this.canSendUpdate())
+                return;
+            let incyclistData = this.mapToCycleModeData(deviceData);
+            incyclistData = this.getCyclingMode().updateData(incyclistData);
+            this.data = this.transformData(incyclistData);
+            this.emitData(this.data);
         }
         catch (err) {
             this.logger.logEvent({ message: 'error', fn: 'onDeviceData()', error: err.message || err, stack: err.stack });
         }
     }
-    mapData(deviceData) {
+    canSendUpdate() {
+        if (!this.hasDataListeners() || this.paused)
+            return false;
+        return super.canSendUpdate();
+    }
+    mapToCycleModeData(deviceData) {
         const data = {
             isPedalling: false,
             power: 0,
@@ -172,25 +175,20 @@ class AntFEAdapter extends ant_device_1.default {
             distance,
             timestamp: Date.now()
         };
-        if (this.ignorePower) {
-            delete data.power;
-            delete data.cadence;
-        }
-        if (this.ignoreBike) {
-            data = { heartrate: data.heartrate };
-        }
-        if (this.ignoreHrm || !this.isHrm())
-            delete data.heartrate;
         return data;
     }
     start(props) {
-        const _super = Object.create(null, {
-            start: { get: () => super.start }
-        });
         return __awaiter(this, void 0, void 0, function* () {
-            _super.start.call(this, props);
+            const wasPaused = this.paused;
+            this.paused = false;
+            if (this.started && !wasPaused) {
+                return true;
+            }
+            const connected = yield this.connect();
+            if (!connected)
+                throw new Error(`could not start device, reason:could not connect`);
             this.startProps = props;
-            this.logger.logEvent({ message: 'starting device', props, isStarted: this.started, isReconnecting: this.isReconnecting });
+            this.logEvent({ message: 'starting device', props, isStarted: this.started, isReconnecting: this.isReconnecting });
             const opts = props || {};
             const { args = {}, user = {} } = opts;
             return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
@@ -216,8 +214,10 @@ class AntFEAdapter extends ant_device_1.default {
                 while (!success && retry < MAX_RETRIES) {
                     retry++;
                     if (!this.started) {
+                        this.logger.logEvent({ message: 'start sensor', props });
                         this.started = yield this.ant.startSensor(this.sensor, this.onDeviceData.bind(this));
                         if (this.started) {
+                            this.logger.logEvent({ message: 'sensor started', props });
                             startSuccess++;
                         }
                         if (this.started && startSuccess === 1) {
@@ -231,7 +231,7 @@ class AntFEAdapter extends ant_device_1.default {
                                 }
                                 catch (_a) { }
                                 this.started = false;
-                                return reject(new Error(`could not start device, reason: ${err.message}`));
+                                return reject(new Error('could not start device, reason:timeout'));
                             }
                         }
                         status = { userSent: false, slopeSent: false };
@@ -245,11 +245,26 @@ class AntFEAdapter extends ant_device_1.default {
                             const fe = this.sensor;
                             const mode = this.getCyclingMode();
                             const bikeType = mode ? mode.getSetting('bikeType').toLowerCase() : 'race';
-                            const defaultBikeWeight = bikeType === 'mountain' ? DEFAULT_BIKE_WEIGHT_MOUNTAIN : DEFAULT_BIKE_WEIGHT;
-                            const userWeight = args.userWeight || user.weight || DEFAULT_USER_WEIGHT;
+                            const defaultBikeWeight = bikeType === 'mountain' ? DEFAULT_BIKE_WEIGHT_MOUNTAIN : adpater_1.DEFAULT_BIKE_WEIGHT;
+                            const userWeight = args.userWeight || user.weight || adpater_1.DEFAULT_USER_WEIGHT;
                             const bikeWeight = args.bikeWeight || defaultBikeWeight;
                             status.userSent = status.userSent || (yield fe.sendUserConfiguration(userWeight, bikeWeight, args.wheelDiameter, args.gearRatio));
-                            status.slopeSent = status.slopeSent || (yield fe.sendTrackResistance(0.0));
+                            if (!status.slopeSent) {
+                                const startRequest = this.getCyclingMode().getBikeInitRequest();
+                                if (startRequest) {
+                                    if (startRequest.targetPower !== undefined && startRequest.targetPower !== null) {
+                                        status.slopeSent = yield fe.sendTargetPower(startRequest.targetPower);
+                                    }
+                                    else if (startRequest.slope !== undefined && startRequest.slope !== null) {
+                                        status.slopeSent = yield fe.sendTrackResistance(startRequest.slope);
+                                    }
+                                    else
+                                        status.slopeSent = true;
+                                }
+                                else {
+                                    status.slopeSent = yield fe.sendTrackResistance(0.0);
+                                }
+                            }
                         }
                         catch (err) {
                             this.logger.logEvent({ message: 'sending FE message error', error: err.message });
@@ -288,19 +303,6 @@ class AntFEAdapter extends ant_device_1.default {
         const fe = this.sensor;
         fe.setSendTimeout(5000);
     }
-    stop() {
-        const _super = Object.create(null, {
-            stop: { get: () => super.stop }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'stopping device' });
-            let stopped = yield this.ant.stopSensor(this.sensor);
-            this.started = false;
-            yield _super.stop.call(this);
-            this.logger.logEvent({ message: 'stopping device done', success: stopped });
-            return stopped;
-        });
-    }
     reconnect() {
         return __awaiter(this, void 0, void 0, function* () {
             this.logger.logEvent({ message: 'reconnect to device' });
@@ -320,5 +322,19 @@ class AntFEAdapter extends ant_device_1.default {
             }
         });
     }
+    setCyclingMode(mode, settings) {
+        const modeChange = this.cyclingMode.getName() !== mode;
+        super.setCyclingMode(mode, settings);
+        console.log('~~~ setCyclingMode', mode, modeChange, this.started, this.stopped, this.paused, this.isReconnecting, this.data);
+        if (modeChange && this.started && !this.stopped) {
+            if (this.getCyclingMode() instanceof ant_fe_erg_mode_1.default) {
+                const power = this.data.power;
+                const request = power ? { targetPower: power } : this.getCyclingMode().getBikeInitRequest();
+                this.sendUpdate(request, true);
+            }
+        }
+    }
 }
 exports.default = AntFEAdapter;
+AntFEAdapter.INCYCLIST_PROFILE_NAME = 'Smart Trainer';
+AntFEAdapter.ANT_PROFILE_NAME = 'FE';

package/lib/antv2/fe/index.d.ts

@@ -0,0 +1,2 @@
+import AntFEAdapter from './adapter';
+export default AntFEAdapter;

package/lib/antv2/fe/index.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const adapter_1 = __importDefault(require("./adapter"));
+exports.default = adapter_1.default;

package/lib/antv2/hr/adapter.d.ts

@@ -0,0 +1,15 @@
+import { HeartRateSensorState, ISensor, Profile } from "incyclist-ant-plus";
+import AntAdapter from "../adapter";
+import { AntDeviceProperties, AntDeviceSettings, LegacyProfile } from "../types";
+export default class AntHrAdapter extends AntAdapter {
+    static INCYCLIST_PROFILE_NAME: LegacyProfile;
+    static ANT_PROFILE_NAME: Profile;
+    constructor(settings: AntDeviceSettings, props?: AntDeviceProperties);
+    createSensor(settings: AntDeviceSettings): ISensor;
+    getName(): string;
+    getUniqueName(): string;
+    getDisplayName(): string;
+    onDeviceData(deviceData: HeartRateSensorState): void;
+    mapData(deviceData: HeartRateSensorState): void;
+    hasData(): boolean;
+}

package/lib/antv2/hr/adapter.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const adapter_1 = __importDefault(require("../adapter"));
+const utils_1 = require("../utils");
+const gd_eventlog_1 = require("gd-eventlog");
+const sensor_factory_1 = __importDefault(require("../sensor-factory"));
+const capabilities_1 = require("../../types/capabilities");
+class AntHrAdapter extends adapter_1.default {
+    constructor(settings, props) {
+        if (settings.protocol && settings.profile !== AntHrAdapter.INCYCLIST_PROFILE_NAME)
+            throw new Error('Incorrect Profile');
+        if (!settings.protocol && settings.profile !== AntHrAdapter.ANT_PROFILE_NAME)
+            throw new Error('Incorrect Profile');
+        super(settings, props);
+        this.deviceData = {
+            DeviceID: this.sensor.getDeviceID()
+        };
+        this.logger = new gd_eventlog_1.EventLogger('Ant+Hrm');
+        this.capabilities = [capabilities_1.IncyclistCapability.HeartRate];
+    }
+    createSensor(settings) {
+        return sensor_factory_1.default.create(AntHrAdapter.ANT_PROFILE_NAME, Number(settings.deviceID));
+    }
+    getName() {
+        if (this.settings.name)
+            return this.settings.name;
+        const deviceID = this.sensor.getDeviceID();
+        return `Ant+HR ${deviceID}`;
+    }
+    getUniqueName() {
+        if (this.settings.name)
+            return this.settings.name;
+        const { DeviceID, ManId } = this.deviceData;
+        const brand = (0, utils_1.getBrand)(ManId);
+        if (brand)
+            return `${brand} HR ${DeviceID}`;
+        else
+            return `${this.getName()}`;
+    }
+    getDisplayName() {
+        const { ComputedHeartRate } = this.deviceData;
+        const hrmStr = ComputedHeartRate ? ` (${ComputedHeartRate})` : '';
+        return `${this.getUniqueName()}${hrmStr}`;
+    }
+    onDeviceData(deviceData) {
+        this.dataMsgCount++;
+        this.lastDataTS = Date.now();
+        super.onDeviceData(deviceData);
+        if (!this.started)
+            return;
+        if (!this.ivDataTimeout)
+            this.startDataTimeoutCheck();
+        try {
+            if (!this.canSendUpdate())
+                return;
+            this.logEvent({ message: 'onDeviceData', data: deviceData });
+            this.mapData(deviceData);
+            this.emitData(this.data);
+        }
+        catch (err) {
+        }
+    }
+    mapData(deviceData) {
+        if (deviceData.ComputedHeartRate)
+            this.data.heartrate = deviceData.ComputedHeartRate;
+    }
+    hasData() {
+        return this.deviceData.ComputedHeartRate !== undefined && this.deviceData.ComputedHeartRate !== null;
+    }
+}
+exports.default = AntHrAdapter;
+AntHrAdapter.INCYCLIST_PROFILE_NAME = 'Heartrate Monitor';
+AntHrAdapter.ANT_PROFILE_NAME = 'HR';

package/lib/antv2/hr/index.d.ts

@@ -0,0 +1,2 @@
+import AntHrAdapter from './adapter';
+export default AntHrAdapter;

package/lib/antv2/hr/index.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const adapter_1 = __importDefault(require("./adapter"));
+exports.default = adapter_1.default;

package/lib/antv2/index.d.ts

@@ -0,0 +1,7 @@
+import AntPwrAdapter from "./pwr";
+import AntFEAdapter from "./fe";
+import AntHrAdapter from "./hr";
+import AntAdapterFactory from "./adapter-factory";
+import AntInterface, { AntInterfaceProps } from "./ant-interface";
+import { AntDeviceSettings, AntScanProps } from "./types";
+export { AntAdapterFactory, AntFEAdapter, AntHrAdapter, AntPwrAdapter, AntDeviceSettings, AntScanProps, AntInterface, AntInterfaceProps };

package/lib/antv2/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AntInterface = exports.AntPwrAdapter = exports.AntHrAdapter = exports.AntFEAdapter = exports.AntAdapterFactory = void 0;
+const pwr_1 = __importDefault(require("./pwr"));
+exports.AntPwrAdapter = pwr_1.default;
+const fe_1 = __importDefault(require("./fe"));
+exports.AntFEAdapter = fe_1.default;
+const hr_1 = __importDefault(require("./hr"));
+exports.AntHrAdapter = hr_1.default;
+const adapter_factory_1 = __importDefault(require("./adapter-factory"));
+exports.AntAdapterFactory = adapter_factory_1.default;
+const ant_interface_1 = __importDefault(require("./ant-interface"));
+exports.AntInterface = ant_interface_1.default;
+const af = adapter_factory_1.default.getInstance();
+af.register('PWR', 'Power Meter', pwr_1.default);
+af.register('HR', 'Heartrate Monitor', hr_1.default);
+af.register('FE', 'Smart Trainer', fe_1.default);

package/lib/antv2/modes/ant-fe-adv-st-mode.d.ts

@@ -0,0 +1,9 @@
+import FtmsCyclingMode from "../../modes/ble-st-mode";
+import { UpdateRequest } from "../../modes/cycling-mode";
+import { IncyclistDeviceAdapter } from "../../types/adapter";
+export default class AntAdvSimCyclingMode extends FtmsCyclingMode {
+    constructor(adapter: IncyclistDeviceAdapter, props?: any);
+    getName(): string;
+    getDescription(): string;
+    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
+}

package/lib/{ant/antfe → antv2/modes}/ant-fe-adv-st-mode.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const ble_st_mode_1 = __importDefault(require("../../ble/ble-st-mode"));
+const ble_st_mode_1 = __importDefault(require("../../modes/ble-st-mode"));
 const MAX_DEVIATION = 10;
 class AntAdvSimCyclingMode extends ble_st_mode_1.default {
     constructor(adapter, props) {

package/lib/antv2/modes/ant-fe-erg-mode.d.ts

@@ -0,0 +1,6 @@
+import BleERGCyclingMode from "../../modes/ble-erg-mode";
+import { IncyclistDeviceAdapter } from "../../types/adapter";
+export default class AntFeERGCyclingMode extends BleERGCyclingMode {
+    static isERG: boolean;
+    constructor(adapter: IncyclistDeviceAdapter, props?: any);
+}

package/lib/{ant/antfe → antv2/modes}/ant-fe-erg-mode.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const ble_erg_mode_1 = __importDefault(require("../../ble/ble-erg-mode"));
+const ble_erg_mode_1 = __importDefault(require("../../modes/ble-erg-mode"));
 class AntFeERGCyclingMode extends ble_erg_mode_1.default {
     constructor(adapter, props) {
         super(adapter, props);

package/lib/antv2/modes/ant-fe-st-mode.d.ts

@@ -0,0 +1,5 @@
+import FtmsCyclingMode from "../../modes/ble-st-mode";
+import { IncyclistDeviceAdapter } from "../../types/adapter";
+export default class AntStCyclingMode extends FtmsCyclingMode {
+    constructor(adapter: IncyclistDeviceAdapter, props?: any);
+}

package/lib/{ant/antfe → antv2/modes}/ant-fe-st-mode.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const ble_st_mode_1 = __importDefault(require("../../ble/ble-st-mode"));
+const ble_st_mode_1 = __importDefault(require("../../modes/ble-st-mode"));
 class AntStCyclingMode extends ble_st_mode_1.default {
     constructor(adapter, props) {
         super(adapter, props);

package/lib/antv2/pwr/adapter.d.ts

@@ -0,0 +1,24 @@
+import { ISensor, Profile } from "incyclist-ant-plus";
+import { ControllableAntAdapter } from "../adapter";
+import CyclingMode, { IncyclistBikeData } from '../../modes/cycling-mode';
+import { AntDeviceProperties, AntDeviceSettings, LegacyProfile } from "../types";
+import { DeviceData } from "../../types/data";
+export default class AntPwrAdapter extends ControllableAntAdapter {
+    static INCYCLIST_PROFILE_NAME: LegacyProfile;
+    static ANT_PROFILE_NAME: Profile;
+    protected distanceInternal?: number;
+    constructor(settings: AntDeviceSettings, props?: AntDeviceProperties);
+    createSensor(settings: AntDeviceSettings): ISensor;
+    getName(): string;
+    getUniqueName(): string;
+    getDisplayName(): string;
+    getDefaultCyclingMode(): CyclingMode;
+    getSupportedCyclingModes(): any[];
+    getLogData(data: any, excludeList: any): any;
+    onDeviceData(deviceData: any): void;
+    canSendUpdate(): boolean;
+    sendUpdate(request: any): void;
+    mapData(deviceData: any): IncyclistBikeData;
+    transformData(bikeData: IncyclistBikeData): DeviceData;
+    hasData(): boolean;
+}