incyclist-devices 2.0.37 → 2.1.0

package/lib/serial/daum/premium/adapter.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -12,54 +35,58 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DaumPremiumControl = void 0;
 const gd_eventlog_1 = require("gd-eventlog");
 const device_1 = require("../../../types/device");
 const __1 = require("../..");
 const serial_interface_1 = require("../../serial-interface");
 const utils_1 = require("../../../utils/utils");
-const DaumAdapter_1 = __importDefault(require("../DaumAdapter"));
+const DaumAdapter_1 = __importStar(require("../DaumAdapter"));
 const comms_1 = __importDefault(require("./comms"));
-const daum_classic_1 = __importDefault(require("./modes/daum-classic"));
+const daum_premium_standard_1 = __importDefault(require("../../../modes/daum-premium-standard"));
 const PROTOCOL_NAME = "Daum Premium";
 const DAUM_PREMIUM_DEFAULT_PORT = 51955;
 const START_RETRY_TIMEOUT = 1500;
 const DEFAULT_GEAR = 10;
-const getBikeProps = (props) => {
-    const { host, port = DAUM_PREMIUM_DEFAULT_PORT, interface: ifaceName } = props;
-    let serial;
-    if (ifaceName && typeof ifaceName === 'string') {
-        serial = __1.SerialInterface.getInstance({ ifaceName });
-    }
-    else {
-        serial = props.interface;
-    }
-    if (!serial || !serial.binding)
-        throw new Error(`unknonwn interface: ${ifaceName}`);
-    if (serial.getName() === serial_interface_1.SerialInterfaceType.TCPIP) {
-        const path = `${host}:${port}`;
-        return { serial, path };
-    }
-    else {
-        const path = `${port}`;
-        return { serial, path };
+const START_RETRIES = 5;
+class DaumPremiumControl extends DaumAdapter_1.DaumControl {
+    getSupportedCyclingModes() {
+        const supported = super.getSupportedCyclingModes();
+        supported.push(daum_premium_standard_1.default);
+        return supported;
     }
-};
+}
+exports.DaumPremiumControl = DaumPremiumControl;
 class DaumPremiumAdapter extends DaumAdapter_1.default {
     constructor(settings, props) {
-        const logger = new gd_eventlog_1.EventLogger('DaumPremium');
-        const commProps = Object.assign(Object.assign({}, getBikeProps(settings)), { logger });
-        const bike = new comms_1.default(commProps);
         super(settings, props);
-        this._startRetryTimeout = START_RETRY_TIMEOUT;
-        this.bike = bike;
+        this.setControl(new DaumPremiumControl(this, props));
+        const logger = new gd_eventlog_1.EventLogger('DaumPremium');
+        const commProps = Object.assign(Object.assign({}, this.getBikeProps(settings)), { logger });
+        this.bike = new comms_1.default(commProps);
         this.logger = logger;
-        this.ignoreHrm = false;
-        this.ignorePower = false;
-        this.ignoreBike = false;
-        this.iv = undefined;
-        this.distanceInternal = undefined;
         this.initData();
     }
+    getBikeProps(props) {
+        const { host, port = DAUM_PREMIUM_DEFAULT_PORT, interface: ifaceName } = props;
+        let serial;
+        if (ifaceName && typeof ifaceName === 'string') {
+            serial = __1.SerialInterface.getInstance({ ifaceName });
+        }
+        else {
+            serial = props.interface;
+        }
+        if (!serial || !serial.binding)
+            throw new Error(`unknonwn interface: ${ifaceName}`);
+        if (serial.getName() === serial_interface_1.SerialInterfaceType.TCPIP) {
+            const path = `${host}:${port}`;
+            return { serial, path };
+        }
+        else {
+            const path = `${port}`;
+            return { serial, path };
+        }
+    }
     getName() {
         return 'Daum8i';
     }
@@ -71,9 +98,6 @@ class DaumPremiumAdapter extends DaumAdapter_1.default {
         }
         return super.getUniqueName();
     }
-    getPort() {
-        return this.bike.getPort();
-    }
     getInterface() {
         var _a;
         return (_a = this.bike) === null || _a === void 0 ? void 0 : _a.getInterface();
@@ -81,10 +105,6 @@ class DaumPremiumAdapter extends DaumAdapter_1.default {
     getProtocolName() {
         return PROTOCOL_NAME;
     }
-    getSerialInterface() {
-        var _a;
-        return (_a = this.bike) === null || _a === void 0 ? void 0 : _a.serial;
-    }
     isEqual(settings) {
         if (this.getInterface() === device_1.INTERFACE.TCPIP) {
             const as = this.settings;
@@ -100,72 +120,48 @@ class DaumPremiumAdapter extends DaumAdapter_1.default {
             return super.isEqual(settings);
         }
     }
-    getSupportedCyclingModes() {
-        const supported = super.getSupportedCyclingModes();
-        supported.push(daum_classic_1.default);
-        return supported;
-    }
-    check() {
+    performCheck() {
         return __awaiter(this, void 0, void 0, function* () {
             var info = {};
             return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
                 this.logEvent({ message: "checking device", port: this.getPort() });
                 try {
-                    yield this.bike.close();
+                    yield this.stop();
                     const connected = yield this.connect();
                     if (!connected)
                         resolve(false);
+                    this.stopped = false;
+                    this.started = false;
+                    this.paused = false;
                     info.deviceType = yield this.bike.getDeviceType();
                     info.version = yield this.bike.getProtocolVersion();
                     this.logEvent({ message: "checking device success", port: this.getPort(), info });
+                    this.pause();
                     resolve(true);
                 }
                 catch (err) {
-                    this.logEvent({ message: "checking device failed", port: this.getPort(), reason: err.message || err });
+                    this.logEvent({ message: "checking device failed", port: this.getPort(), reason: err.message });
                     resolve(false);
                 }
             }));
         });
     }
-    startRide(props = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'relaunch of device' });
-            try {
-                yield this.launch(props, true);
-                return true;
-            }
-            catch (err) {
-                this.logEvent({ message: 'start result: error', error: err.message });
-                throw err;
-            }
-        });
+    getStartRetries() {
+        return START_RETRIES;
     }
-    start(props = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'initial start of device' });
-            try {
-                yield this.launch(props, false);
-                return true;
-            }
-            catch (err) {
-                this.logEvent({ message: 'start result: error', error: err.message });
-                throw err;
-            }
-        });
+    getStartRetryTimeout() {
+        return START_RETRY_TIMEOUT;
     }
-    launch(props = {}, isRelaunch = false) {
+    performStart(props = {}, _isRelaunch = false) {
         return __awaiter(this, void 0, void 0, function* () {
-            const isPaused = this.isPaused() !== false;
             this.setBikeProps(props);
-            const user = this.user;
-            const { route, onStatusUpdate, gear } = props;
-            var info = {};
             this.initData();
             yield this.stop();
-            return (0, utils_1.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () {
+            var info = {};
+            yield (0, utils_1.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () {
                 try {
-                    const connected = yield this.connect();
-                    if (!connected)
+                    info.connected = yield this.connect();
+                    if (!info.connected)
                         throw new Error('not connected');
                     if (!info.deviceType) {
                         info.deviceType = yield this.bike.getDeviceType();
@@ -173,7 +169,9 @@ class DaumPremiumAdapter extends DaumAdapter_1.default {
                     if (!info.version) {
                         info.version = yield this.bike.getProtocolVersion();
                     }
-                    if (this.getCyclingMode().getModeProperty('eppSupport')) {
+                    const user = this.getUser();
+                    const { route, onStatusUpdate, gear } = props;
+                    if (this.requiresProgramUpload()) {
                         const bikeType = this.getCyclingMode().getSetting('bikeType');
                         if (!info.upload) {
                             info.upload = yield this.bike.programUpload(bikeType, route, onStatusUpdate);
@@ -197,33 +195,38 @@ class DaumPremiumAdapter extends DaumAdapter_1.default {
                     return;
                 }
                 catch (err) {
-                    if (!info.deviceType) {
+                    if (info.connected && !info.deviceType) {
                         yield (0, utils_1.sleep)(500);
                         yield this.reconnect();
                     }
-                    throw (new Error(`could not start device, reason:${err.message}`));
+                    throw (err);
                 }
-            }), 5, this._startRetryTimeout)
-                .then(() => {
-                this.stopped = false;
-                this.paused = false;
-                if (isPaused)
-                    this.resume();
-                this.startUpdatePull();
-                return true;
-            });
+            }), this.getStartRetries(), this.getStartRetryTimeout());
+            this.stopped = false;
+            this.paused = false;
+            this.started = true;
+            this.startUpdatePull();
+            return true;
         });
     }
+    requiresProgramUpload() {
+        if (!this.getCyclingMode())
+            return false;
+        return this.getCyclingMode().getModeProperty('eppSupport');
+    }
     getCurrentBikeData() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.bike.isConnected()) {
-                const connected = yield this.bike.connect();
-                if (!connected)
-                    throw new Error('not connected');
-            }
+            yield this.verifyConnection();
             return this.getBike().getTrainingData();
         });
     }
+    getDeviceInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deviceType = yield this.bike.getDeviceType();
+            const version = yield this.bike.getProtocolVersion();
+            return { deviceType, version };
+        });
+    }
 }
 DaumPremiumAdapter.NAME = PROTOCOL_NAME;
 exports.default = DaumPremiumAdapter;

package/lib/serial/daum/premium/comms.d.ts

@@ -6,7 +6,8 @@ import { OnDeviceStartCallback } from "./types";
 import SerialPortComms from "../../comms";
 import { DaumPremiumCommsState, DaumPremiumRequest, ResponseObject } from "./types";
 import { IncyclistBikeData } from "../../..";
-export default class Daum8i extends SerialPortComms<DaumPremiumCommsState, DaumPremiumRequest, ResponseObject> {
+import DaumSerialComms from "../types";
+export default class Daum8i extends SerialPortComms<DaumPremiumCommsState, DaumPremiumRequest, ResponseObject> implements DaumSerialComms {
     validatePath(path: string): string;
     getDefaultLoggerName(): string;
     getAckTimeoutValue(): number;
@@ -23,6 +24,8 @@ export default class Daum8i extends SerialPortComms<DaumPremiumCommsState, DaumP
     write(buffer: Buffer, ackExpected?: boolean): Promise<void>;
     sendACK(logPayload: any): Promise<void>;
     sendNAK(logPayload: any): Promise<void>;
+    setTargetPower(power: number): Promise<void>;
+    setTargetSlope(_slope: number): Promise<void>;
     getProtocolVersion(): Promise<string>;
     getDashboardVersion(): Promise<string>;
     getDeviceType(): Promise<string>;

package/lib/serial/daum/premium/comms.js

@@ -12,12 +12,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const constants_1 = require("../constants");
+const consts_1 = require("../consts");
 const utils_1 = require("./utils");
 const types_1 = require("./types");
 const utils_2 = require("../../../utils/utils");
 const comms_1 = __importDefault(require("../../comms"));
-const consts_1 = require("./consts");
+const consts_2 = require("./consts");
 class Daum8i extends comms_1.default {
     validatePath(path) {
         return (0, utils_1.validatePath)(path);
@@ -26,10 +26,10 @@ class Daum8i extends comms_1.default {
         return 'DaumPremium';
     }
     getAckTimeoutValue() {
-        return consts_1.DEFAULT_ACK_TIMEOUT;
+        return consts_2.DEFAULT_ACK_TIMEOUT;
     }
     getTimeoutValue() {
-        return consts_1.DEFAULT_TIMEOUT;
+        return consts_2.DEFAULT_TIMEOUT;
     }
     onConnected() {
         this.sp.on('data', this.onData.bind(this));
@@ -280,6 +280,14 @@ class Daum8i extends comms_1.default {
             yield this.write(Buffer.from([0x15]), false);
         });
     }
+    setTargetPower(power) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.setPower(power);
+        });
+    }
+    setTargetSlope(_slope) {
+        return;
+    }
     getProtocolVersion() {
         return __awaiter(this, void 0, void 0, function* () {
             const data = yield this.sendStrCommand('getProtocolVersion', 'V00');
@@ -312,11 +320,11 @@ class Daum8i extends comms_1.default {
             const str = yield this.sendStrCommand('getActualBikeType', 'M72');
             let deviceType;
             if (str === '0')
-                deviceType = constants_1.ACTUAL_BIKE_TYPE.ALLROUND;
+                deviceType = consts_1.ACTUAL_BIKE_TYPE.ALLROUND;
             else if (str === '1')
-                deviceType = constants_1.ACTUAL_BIKE_TYPE.RACE;
+                deviceType = consts_1.ACTUAL_BIKE_TYPE.RACE;
             else if (str === '2')
-                deviceType = constants_1.ACTUAL_BIKE_TYPE.MOUNTAIN;
+                deviceType = consts_1.ACTUAL_BIKE_TYPE.MOUNTAIN;
             else {
                 throw (new Error(`unknown actual device type ${typeof str === 'string' ? (0, utils_1.ascii)(str.charAt(0)) : str}`));
             }
@@ -328,16 +336,16 @@ class Daum8i extends comms_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             let bikeType;
             switch (actualBikeType) {
-                case constants_1.ACTUAL_BIKE_TYPE.ALLROUND:
+                case consts_1.ACTUAL_BIKE_TYPE.ALLROUND:
                     bikeType = '0';
                     break;
-                case constants_1.ACTUAL_BIKE_TYPE.RACE:
+                case consts_1.ACTUAL_BIKE_TYPE.RACE:
                     bikeType = '1';
                     break;
-                case constants_1.ACTUAL_BIKE_TYPE.TRIATHLON:
+                case consts_1.ACTUAL_BIKE_TYPE.TRIATHLON:
                     bikeType = '1';
                     break;
-                case constants_1.ACTUAL_BIKE_TYPE.MOUNTAIN:
+                case consts_1.ACTUAL_BIKE_TYPE.MOUNTAIN:
                     bikeType = '2';
                     break;
                 default:
@@ -346,11 +354,11 @@ class Daum8i extends comms_1.default {
             const str = yield this.sendStrCommand('setActualBikeType', `M72${bikeType}`);
             let deviceType;
             if (str === '0')
-                deviceType = constants_1.ACTUAL_BIKE_TYPE.ALLROUND;
+                deviceType = consts_1.ACTUAL_BIKE_TYPE.ALLROUND;
             else if (str === '1')
-                deviceType = constants_1.ACTUAL_BIKE_TYPE.RACE;
+                deviceType = consts_1.ACTUAL_BIKE_TYPE.RACE;
             else if (str === '2')
-                deviceType = constants_1.ACTUAL_BIKE_TYPE.MOUNTAIN;
+                deviceType = consts_1.ACTUAL_BIKE_TYPE.MOUNTAIN;
             else
                 throw (new Error('unknown actual device type'));
             this.actualBikeType = deviceType;
@@ -454,7 +462,7 @@ class Daum8i extends comms_1.default {
             const epp = route ? (0, utils_1.routeToEpp)(route) : undefined;
             const eppLength = epp ? epp.length : 0;
             const bikeTypeVal = (0, utils_1.getBikeType)(bikeType);
-            const wBits = route.lapMode ? consts_1.DS_BITS_ENDLESS_RACE : consts_1.DS_BITS_OFF;
+            const wBits = route.lapMode ? consts_2.DS_BITS_ENDLESS_RACE : consts_2.DS_BITS_OFF;
             payload.writeInt32LE(0, 0);
             payload.writeInt8(bikeTypeVal, 4);
             payload.writeInt8(0, 5);
@@ -484,7 +492,7 @@ class Daum8i extends comms_1.default {
             const remaining = epp.length - offset;
             if (remaining <= 0)
                 return Promise.resolve(true);
-            const size = remaining > consts_1.MAX_DATA_BLOCK_SIZE ? consts_1.MAX_DATA_BLOCK_SIZE : remaining;
+            const size = remaining > consts_2.MAX_DATA_BLOCK_SIZE ? consts_2.MAX_DATA_BLOCK_SIZE : remaining;
             const payload = Buffer.alloc(size + 8);
             payload.writeInt32LE(size, 0);
             payload.writeInt32LE(offset, 4);
@@ -545,7 +553,7 @@ class Daum8i extends comms_1.default {
                         done = true;
                     while (success && !done) {
                         success = yield this.programUploadSendBlock(epp, offset);
-                        offset += consts_1.MAX_DATA_BLOCK_SIZE;
+                        offset += consts_2.MAX_DATA_BLOCK_SIZE;
                         done = offset >= epp.length;
                         if (onStatusUpdate)
                             onStatusUpdate(done ? epp.length : offset, epp.length);

package/lib/serial/daum/premium/mock.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { MockBindingInterface, MockPortBinding, CreatePortOptions } from '@serialport/binding-mock';
 import { BindingInterface } from '@serialport/bindings-interface';
 import { User } from '../../../types/user';
@@ -60,6 +61,7 @@ export declare class Daum8MockSimulator {
     person: User;
     program: Program;
     data: trainingData;
+    openHandles: Array<NodeJS.Timeout>;
     _isSimulateACKTimeout: boolean;
     _isSimulateCheckSumError: boolean;
     _isSimulateReservedError: boolean;
@@ -71,6 +73,8 @@ export declare class Daum8MockSimulator {
     simulateReservedError(): void;
     onNAK(): void;
     onACK(): void;
+    addHandle(handle: NodeJS.Timeout): void;
+    cleanup(): void;
 }
 export declare function parseProgramListNewData(buffer: Buffer): Program;
 export declare class Daum8iMockBinding extends MockPortBinding {

package/lib/serial/daum/premium/mock.js

@@ -101,6 +101,7 @@ class Daum8MockSimulator {
         this.loadControl = 1;
         this.person = { weight: 75, length: 180, age: 30, sex: user_1.Gender.MALE };
         this.data = DEFAULT_TRAINING_DATA;
+        this.openHandles = [];
         this._isSimulateACKTimeout = false;
         this._isSimulateCheckSumError = false;
         this._isSimulateReservedError = false;
@@ -121,6 +122,12 @@ class Daum8MockSimulator {
     }
     onNAK() { }
     onACK() { }
+    addHandle(handle) {
+        this.openHandles.push(handle);
+    }
+    cleanup() {
+        this.openHandles.forEach(to => { clearTimeout(to); });
+    }
 }
 exports.Daum8MockSimulator = Daum8MockSimulator;
 function parseProgramListNewData(buffer) {
@@ -174,7 +181,8 @@ class Daum8iMockBinding extends binding_mock_1.MockPortBinding {
                     this.simulator._isSimulateACKTimeout = false;
                 }
                 else {
-                    setTimeout(() => { this.processData(buffer); }, 5);
+                    const to = setTimeout(() => { this.processData(buffer); }, 5);
+                    this.simulator.addHandle(to);
                 }
                 this.writeOperation = null;
             }))();
@@ -230,12 +238,13 @@ class Daum8iMockBinding extends binding_mock_1.MockPortBinding {
                 else if (c === 0x15) {
                     this.simulator.onNAK();
                     if (this.prevCommand) {
-                        const to = this.simulator.timeoutNAKRetry || 1000;
-                        setTimeout(() => {
+                        const toVal = this.simulator.timeoutNAKRetry || 1000;
+                        const to = setTimeout(() => {
                             this.emitData(this.prevCommand);
                             this.waitingForCommand = false;
                             this.waitingForAck = true;
-                        }, to);
+                        }, toVal);
+                        this.simulator.addHandle(to);
                     }
                 }
             }
@@ -294,7 +303,8 @@ class Daum8iMockBinding extends binding_mock_1.MockPortBinding {
         if (payload.length > 0) {
             const power = Number(payload.toString());
             this.simulator.power = power;
-            setTimeout(() => { this.simulator.currentPower = power; }, 1000);
+            const to = setTimeout(() => { this.simulator.currentPower = power; }, 1000);
+            this.simulator.addHandle(to);
         }
         this.emitData(this.createResponse('S23', Buffer.from(this.simulator.power.toString())));
     }

package/lib/serial/daum/types.d.ts

@@ -0,0 +1,11 @@
+export default abstract class DaumSerialComms {
+    serial: any;
+    abstract getPort(): string;
+    abstract pauseLogging(): void;
+    abstract resumeLogging(): void;
+    abstract isConnected(): boolean;
+    abstract connect(): Promise<boolean>;
+    abstract close(): Promise<boolean>;
+    abstract setTargetSlope(slope: number): Promise<void>;
+    abstract setTargetPower(power: number): Promise<void>;
+}

package/lib/serial/daum/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class DaumSerialComms {
+}
+exports.default = DaumSerialComms;

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

@@ -2,10 +2,12 @@ import { DeviceProperties } from "../../../types/device";
 import { EventLogger } from "gd-eventlog";
 import SerialComms from "../comms";
 import { Command } from "../../../types/command";
-import CyclingMode, { IncyclistBikeData } from "../../../modes/cycling-mode";
+import ICyclingMode, { CyclingMode, IncyclistBikeData } from "../../../modes/types";
 import { SerialDeviceSettings, SerialIncyclistDevice } from "../../adapter";
 import { DeviceData } from "../../../types/data";
 import SerialInterface from "../../serial-interface";
+import { ControllableDevice } from "../../../base/adpater";
+import { IncyclistDeviceAdapter } from "../../../types/adapter";
 export interface KettlerRacerCommand extends Command {
 }
 export interface KettlerExtendedBikeData {
@@ -21,11 +23,13 @@ export interface KettlerBikeData {
     time: number;
     power: number;
 }
-export default class KettlerRacerAdapter extends SerialIncyclistDevice {
+export declare class KettlerControl<P extends DeviceProperties> extends ControllableDevice<P> {
+    getSupportedCyclingModes(): Array<typeof CyclingMode>;
+    getDefaultCyclingMode(): ICyclingMode;
+    sendInitCommands(): Promise<boolean>;
+}
+export default class KettlerRacerAdapter extends SerialIncyclistDevice<KettlerControl<DeviceProperties>, DeviceProperties> {
     private id;
-    private ignoreHrm;
-    private ignoreBike;
-    private ignorePower;
     private iv;
     private requests;
     private data;
@@ -40,7 +44,7 @@ export default class KettlerRacerAdapter extends SerialIncyclistDevice {
     isPower(): boolean;
     isHrm(): boolean;
     getProtocolName(): string;
-    isSame(device: SerialIncyclistDevice): boolean;
+    isSame(device: IncyclistDeviceAdapter): boolean;
     setID(id: any): void;
     getID(): string;
     getName(): string;
@@ -84,6 +88,4 @@ export default class KettlerRacerAdapter extends SerialIncyclistDevice {
     close(): Promise<boolean>;
     waitForOpened(retries?: boolean): Promise<boolean>;
     waitForClosed(): Promise<boolean>;
-    getSupportedCyclingModes(): any[];
-    getDefaultCyclingMode(): CyclingMode;
 }

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

@@ -12,14 +12,30 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.KettlerControl = void 0;
 const gd_eventlog_1 = require("gd-eventlog");
 const comms_1 = __importDefault(require("../comms"));
 const utils_1 = require("../../../utils/utils");
 const power_meter_1 = __importDefault(require("../../../modes/power-meter"));
-const erg_1 = __importDefault(require("./modes/erg"));
+const kettler_erg_1 = __importDefault(require("../../../modes/kettler-erg"));
 const adapter_1 = require("../../adapter");
 const capabilities_1 = require("../../../types/capabilities");
+const adpater_1 = require("../../../base/adpater");
 const PROTOCOL_NAME = 'Kettler Racer';
+class KettlerControl extends adpater_1.ControllableDevice {
+    getSupportedCyclingModes() {
+        return [power_meter_1.default, kettler_erg_1.default];
+    }
+    getDefaultCyclingMode() {
+        return new kettler_erg_1.default(this.adapter);
+    }
+    sendInitCommands() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return true;
+        });
+    }
+}
+exports.KettlerControl = KettlerControl;
 class KettlerRacerAdapter extends adapter_1.SerialIncyclistDevice {
     constructor(settings, props) {
         super(settings, props);
@@ -566,11 +582,5 @@ class KettlerRacerAdapter extends adapter_1.SerialIncyclistDevice {
             }
         });
     }
-    getSupportedCyclingModes() {
-        return [power_meter_1.default, erg_1.default];
-    }
-    getDefaultCyclingMode() {
-        return new erg_1.default(this);
-    }
 }
 exports.default = KettlerRacerAdapter;

package/lib/serial/serial-interface.js

@@ -78,7 +78,6 @@ class SinglePathScanner {
                         if (found) {
                             this.isFound = true;
                             const name = adapter.getName();
-                            yield adapter.close();
                             resolve(Object.assign(Object.assign({}, adapterSettings), { name }));
                         }
                         yield (0, utils_1.sleep)(100);
@@ -321,7 +320,7 @@ class SerialInterface extends events_1.default {
                         const adapter = adapter_factory_1.default.getInstance().createInstance(device);
                         const path = adapter.getPort();
                         this.inUse.push(path);
-                        yield adapter.stop();
+                        yield adapter.pause();
                         detected.push(device);
                         this.emit('device', device);
                     }