incyclist-devices 2.0.38 → 2.1.0

package/lib/serial/daum/classic/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,205 +35,101 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DaumClassicControl = void 0;
 const gd_eventlog_1 = require("gd-eventlog");
 const utils_1 = require("../../../utils/utils");
-const DaumAdapter_1 = __importDefault(require("../DaumAdapter"));
-const daum_classic_1 = __importDefault(require("./modes/daum-classic"));
+const DaumAdapter_1 = __importStar(require("../DaumAdapter"));
+const daum_classic_standard_1 = __importDefault(require("../../../modes/daum-classic-standard"));
 const comms_1 = __importDefault(require("./comms"));
 const serial_interface_1 = __importDefault(require("../../serial-interface"));
 const PROTOCOL_NAME = "Daum Classic";
 const DEFAULT_GEAR = 10;
-const getBikeProps = (props) => {
-    const { port, interface: ifaceName } = props;
-    let serial;
-    if (ifaceName && typeof ifaceName === 'string') {
-        serial = serial_interface_1.default.getInstance({ ifaceName });
+class DaumClassicControl extends DaumAdapter_1.DaumControl {
+    getSupportedCyclingModes() {
+        const supported = super.getSupportedCyclingModes();
+        supported.push(daum_classic_standard_1.default);
+        return supported;
     }
-    else {
-        serial = props.interface;
+    getDefaultCyclingMode() {
+        return new daum_classic_standard_1.default(this.adapter);
     }
-    if (!serial || !serial.binding)
-        throw new Error(`unknonwn interface: ${ifaceName}`);
-    const path = `${port}`;
-    return { serial, path };
-};
+}
+exports.DaumClassicControl = DaumClassicControl;
 class DaumClassicAdapter extends DaumAdapter_1.default {
     constructor(settings, props) {
         super(settings, props);
+        this.setControl(new DaumClassicControl(this, props));
         const logger = new gd_eventlog_1.EventLogger('DaumClassic');
-        const commProps = Object.assign(Object.assign({}, getBikeProps(settings)), { logger });
+        const commProps = Object.assign(Object.assign({}, this.getBikeProps(settings)), { logger });
         this.bike = new comms_1.default(commProps);
         this.logger = logger;
         this.name = PROTOCOL_NAME;
-        this.ignoreHrm = false;
-        this.ignorePower = false;
-        this.ignoreBike = false;
-        this.stopped = false;
-        this.started = false;
-        this.paused = undefined;
-        this.iv = undefined;
-        this.distanceInternal = undefined;
-        this.startPromise = undefined;
-        this.checkPromise = undefined;
         this.initData();
     }
-    setID(id) {
-        this.id = id;
-    }
-    getID() {
-        return this.id;
+    getBikeProps(props) {
+        const { port, interface: ifaceName } = props;
+        let serial;
+        if (ifaceName && typeof ifaceName === 'string') {
+            serial = serial_interface_1.default.getInstance({ ifaceName });
+        }
+        else {
+            serial = props.interface;
+        }
+        if (!serial || !serial.binding)
+            throw new Error(`unknonwn interface: ${ifaceName}`);
+        const path = `${port}`;
+        return { serial, path };
     }
     getName() {
         return this.name;
     }
     setName(name) {
-        this.name = name || PROTOCOL_NAME;
-    }
-    getPort() {
-        return this.bike.getPort();
+        this.name = name;
     }
     getProtocolName() {
         return PROTOCOL_NAME;
     }
-    getSupportedCyclingModes() {
-        const supported = super.getSupportedCyclingModes();
-        supported.push(daum_classic_1.default);
-        return supported;
-    }
-    getDefaultCyclingMode() {
-        return new daum_classic_1.default(this);
-    }
-    getSerialInterface() {
-        var _a;
-        return (_a = this.bike) === null || _a === void 0 ? void 0 : _a.serial;
-    }
-    check() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.isStopped())
-                return false;
-            if (this.checkPromise) {
-                this.logEvent({ message: "waiting for previous check device", port: this.getPort() });
-                try {
-                    yield this.checkPromise;
-                }
-                catch (_a) { }
-                this.logEvent({ message: "previous check device completed", port: this.getPort() });
-                this.checkPromise = undefined;
-            }
-            this.checkPromise = this.performCheck();
-            try {
-                const res = yield this.checkPromise;
-                this.checkPromise = undefined;
-                return res;
-            }
-            catch (err) {
-                this.checkPromise = undefined;
-                throw err;
-            }
-        });
-    }
     performCheck() {
         return __awaiter(this, void 0, void 0, function* () {
             var info = {};
-            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            const check = new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
                 this.logEvent({ message: "checking device", port: this.getPort() });
-                const iv = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                    this.logEvent({ message: "checking device failed", port: this.getPort(), reason: 'timeout' });
-                    resolve(false);
-                }), 5000);
                 try {
-                    const connected = yield this.connect();
+                    yield this.stop();
+                    const connected = yield (0, utils_1.waitWithTimeout)(this.connect(), 5000, () => {
+                        this.logEvent({ message: "checking device failed", port: this.getPort(), reason: 'timeout' });
+                    });
                     if (!connected) {
-                        clearTimeout(iv);
                         resolve(false);
                         return;
                     }
-                    const address = (yield this.bike.getAddress()) || {};
-                    info.bikeNo = address.bike;
-                    const version = (yield this.bike.getVersion()) || {};
-                    info.serialNo = version.serialNo;
-                    info.cockpit = version.cockpit;
+                    this.stopped = false;
+                    const address = yield this.bike.getAddress();
+                    info.bikeNo = address === null || address === void 0 ? void 0 : address.bike;
+                    const version = yield this.bike.getVersion();
+                    info.serialNo = version === null || version === void 0 ? void 0 : version.serialNo;
+                    info.cockpit = version === null || version === void 0 ? void 0 : version.cockpit;
                     this.setName('Daum ' + info.cockpit);
-                    this.setID(info.serialNo);
-                    clearTimeout(iv);
+                    this.pause();
+                    this.started = false;
                     this.logEvent({ message: "checking device success", port: this.getPort(), info });
                     resolve(true);
                 }
                 catch (err) {
-                    clearTimeout(iv);
-                    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;
-            }
-        });
-    }
-    start(props = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const isRelaunch = this.started;
-            const message = isRelaunch ? 'relaunch of device' : 'initial start of device';
-            this.logEvent({ message });
-            try {
-                yield this.launch(props, isRelaunch);
-                return true;
-            }
-            catch (err) {
-                this.logEvent({ message: 'start result: error', error: err.message });
-                throw err;
-            }
-        });
-    }
-    launch(props, isRelaunch = false) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!this.startPromise) {
-                    if (isRelaunch) {
-                        yield this.stop();
-                        this.bike.resumeLogging();
-                    }
-                    this.startPromise = this.performStart(props, isRelaunch);
-                }
-                else {
-                    this.logEvent({ message: 'start already ongoing' });
-                }
-                yield this.startPromise;
-                this.startPromise = undefined;
-                if (!isRelaunch) {
-                    try {
-                        const version = yield this.bike.getVersion();
-                        const { serialNo, cockpit } = version || {};
-                        this.logEvent({ message: 'device info', deviceInfo: { serialNo, cockpit } });
-                    }
-                    catch (_a) { }
-                }
-                this.logEvent({ message: 'start result: success' });
-                this.started = true;
-                return true;
-            }
-            catch (err) {
-                this.logEvent({ message: 'start result: error', error: err.message });
-                this.startPromise = undefined;
-                this.started = false;
-                throw new Error(`could not start device, reason:${err.message}`);
-            }
+            return yield (0, utils_1.waitWithTimeout)(check, 5000, () => {
+                this.logEvent({ message: "checking device failed", port: this.getPort(), reason: 'Timeout' });
+                return false;
+            });
         });
     }
     performStart(props = {}, isRelaunch = false) {
         this.stopUpdatePull();
         this.setBikeProps(props);
-        const user = this.user;
+        const user = this.getUser();
         const { gear = DEFAULT_GEAR } = props;
         this.initData();
         let startState = {};
@@ -218,9 +137,7 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
             try {
                 this.logEvent({ message: 'start attempt', isRelaunch, isConnected: this.bike.isConnected() });
                 if (!isRelaunch && !this.bike.isConnected()) {
-                    const connected = yield this.connect();
-                    if (!connected)
-                        throw new Error('Could not connect');
+                    yield this.verifyConnection();
                 }
                 yield this.getBike().resetDevice();
                 if (!startState.setProg) {
@@ -251,13 +168,13 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
                 if (startRequest.targetPower && startRequest.targetPower !== 25 && data.power === 25) {
                     throw new Error('invalid device response: runData');
                 }
-                this.stopped = false;
-                this.paused = false;
+                this.started = true;
                 this.startUpdatePull();
-                return data;
+                return true;
             }
             catch (err) {
                 this.logEvent({ message: 'start attempt failed', error: err.message });
+                this.started = false;
                 if (startState.checkRunData) {
                     startState = {};
                 }
@@ -269,9 +186,18 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.stopped)
                 return;
+            yield this.verifyConnection();
             return this.getBike().runData();
         });
     }
+    getDeviceInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.stopped)
+                return;
+            const version = yield this.bike.getVersion();
+            return version || {};
+        });
+    }
 }
 DaumClassicAdapter.NAME = PROTOCOL_NAME;
 exports.default = DaumClassicAdapter;

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

@@ -3,7 +3,11 @@ import { ClassicBikeResponse, DaumClassicCommsState, DaumClassicRequest, DaumCla
 import SerialPortComms from '../../comms';
 import { DeviceType } from '../../../types/device';
 import { IncyclistBikeData } from '../../..';
-export default class Daum8008 extends SerialPortComms<DaumClassicCommsState, DaumClassicRequest, DaumClassicResponse> {
+import DaumSerialComms from '../types';
+import { SerialCommProps } from '../../comm';
+export default class Daum8008 extends SerialPortComms<DaumClassicCommsState, DaumClassicRequest, DaumClassicResponse> implements DaumSerialComms {
+    protected bikeNo: number;
+    constructor(props: SerialCommProps);
     validatePath(path: string): string;
     getDefaultLoggerName(): string;
     onConnected(): void;
@@ -13,23 +17,25 @@ export default class Daum8008 extends SerialPortComms<DaumClassicCommsState, Dau
     doSend(expected: number, payload: Uint8Array): Promise<DaumClassicResponse>;
     send(request: DaumClassicRequest): Promise<DaumClassicResponse>;
     sendCommand(logString: string, command: number[], expected: any): Promise<Uint8Array>;
-    checkCockpit(bikeNo?: number): Promise<checkCockpitReponse>;
+    checkCockpit(bike?: number): Promise<checkCockpitReponse>;
     getAddress(): Promise<ClassicBikeResponse>;
-    getVersion(bikeNo?: number): Promise<GetVersionReponse>;
-    resetDevice(bikeNo?: number): Promise<ClassicBikeResponse>;
-    startProg(bikeNo?: number): Promise<ProgResponse>;
-    stopProg(bikeNo?: number): Promise<ProgResponse>;
-    setProg(progNo?: number, bikeNo?: number): Promise<SetProgResponse>;
-    setBikeType(bikeType: DeviceType, bikeNo?: number): Promise<ClassicBikeResponse>;
-    setPerson(user?: User, bikeNo?: number): Promise<{
+    getVersion(bike?: number): Promise<GetVersionReponse>;
+    resetDevice(bike?: number): Promise<ClassicBikeResponse>;
+    startProg(bike?: number): Promise<ProgResponse>;
+    stopProg(bike?: number): Promise<ProgResponse>;
+    setProg(progNo?: number, bike?: number): Promise<SetProgResponse>;
+    setBikeType(bikeType: DeviceType, bike?: number): Promise<ClassicBikeResponse>;
+    setPerson(user?: User, bike?: number): Promise<{
         bike: number;
         age: number;
         gender: number;
         length: number;
         weight: number;
     }>;
-    runData(bikeNo?: number): Promise<IncyclistBikeData>;
-    setGear(gear: number, bikeNo?: number): Promise<SetGearRepsonse>;
-    setPower(power: number, bikeNo?: number): Promise<SetPowerRepsonse>;
-    setSlope(slope: number, bikeNo?: number): Promise<SetSlopeRepsonse>;
+    runData(bike?: number): Promise<IncyclistBikeData>;
+    setGear(gear: number, bike?: number): Promise<SetGearRepsonse>;
+    setPower(power: number, bike?: number): Promise<SetPowerRepsonse>;
+    setSlope(slope: number, bike?: number): Promise<SetSlopeRepsonse>;
+    setTargetSlope(slope: number): Promise<void>;
+    setTargetPower(power: number): Promise<void>;
 }

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

@@ -19,6 +19,10 @@ const utils_2 = require("./utils");
 const ByteLength = require('@serialport/parser-byte-length');
 const TIMEOUT_SEND = 2000;
 class Daum8008 extends comms_1.default {
+    constructor(props) {
+        super(props);
+        this.bikeNo = 0;
+    }
     validatePath(path) {
         return path;
     }
@@ -104,8 +108,9 @@ class Daum8008 extends comms_1.default {
             return response.data;
         });
     }
-    checkCockpit(bikeNo = 0) {
+    checkCockpit(bike) {
         return __awaiter(this, void 0, void 0, function* () {
+            const bikeNo = bike === undefined ? this.bikeNo : bike;
             try {
                 const data = yield this.sendCommand(`checkCockpit(${bikeNo})`, [0x10, bikeNo], 3);
                 return { bike: data[1], version: data[2] };
@@ -120,48 +125,56 @@ class Daum8008 extends comms_1.default {
     getAddress() {
         return __awaiter(this, void 0, void 0, function* () {
             const data = yield this.sendCommand(`getAddress()`, [0x11], 2);
+            this.bikeNo = data[1];
             return { bike: data[1] };
         });
     }
-    getVersion(bikeNo = 0) {
+    getVersion(bike) {
         return __awaiter(this, void 0, void 0, function* () {
+            const bikeNo = bike === undefined ? this.bikeNo : bike;
             const data = yield this.sendCommand(`getVersion(${bikeNo})`, [0x73, bikeNo], 11);
             return { bike: data[1], serialNo: (0, utils_2.getSerialNo)(data, 2, 8), cockpit: (0, utils_2.getCockpit)(data[10]) };
         });
     }
-    resetDevice(bikeNo = 0) {
+    resetDevice(bike) {
         return __awaiter(this, void 0, void 0, function* () {
+            const bikeNo = bike === undefined ? this.bikeNo : bike;
             const data = yield this.sendCommand(`resetDevice(${bikeNo})`, [0x12, bikeNo], 2);
             return { bike: data[1] };
         });
     }
-    startProg(bikeNo = 0) {
+    startProg(bike) {
         return __awaiter(this, void 0, void 0, function* () {
+            const bikeNo = bike === undefined ? this.bikeNo : bike;
             const data = yield this.sendCommand(`startProg(${bikeNo})`, [0x21, bikeNo], 3);
             return { bike: data[1], pedalling: data[2] > 0 };
         });
     }
-    stopProg(bikeNo = 0) {
+    stopProg(bike) {
         return __awaiter(this, void 0, void 0, function* () {
+            const bikeNo = bike === undefined ? this.bikeNo : bike;
             const data = yield this.sendCommand(`stopProg(${bikeNo})`, [0x22, bikeNo], 3);
             return { bike: data[1], pedalling: data[2] > 0 };
         });
     }
-    setProg(progNo = 0, bikeNo = 0) {
+    setProg(progNo = 0, bike) {
         return __awaiter(this, void 0, void 0, function* () {
+            const bikeNo = bike === undefined ? this.bikeNo : bike;
             const data = yield this.sendCommand(`setProg(${bikeNo},${progNo})`, [0x23, bikeNo, progNo], 4);
             return { bike: data[1], progNo: data[2], pedalling: data[3] !== 0 };
         });
     }
-    setBikeType(bikeType, bikeNo = 0) {
+    setBikeType(bikeType, bike) {
         return __awaiter(this, void 0, void 0, function* () {
+            const bikeNo = bike === undefined ? this.bikeNo : bike;
             const bikeVal = (0, utils_2.getBikeType)(bikeType);
             const data = yield this.sendCommand(`setBikeType(${bikeNo},${bikeType})`, [0x69, bikeNo, 0, 0, bikeVal], 3);
             return { bike: data[1] };
         });
     }
-    setPerson(user = {}, bikeNo = 0) {
+    setPerson(user = {}, bike) {
         return __awaiter(this, void 0, void 0, function* () {
+            const bikeNo = bike === undefined ? this.bikeNo : bike;
             const age = user.age !== undefined ? user.age : utils_2.DEFAULT_AGE;
             const gender = (0, utils_2.getGender)(user.sex);
             const length = (0, utils_2.getLength)(user.length);
@@ -194,32 +207,46 @@ class Daum8008 extends comms_1.default {
             return ({ bike: data[1], age, gender, length, weight });
         });
     }
-    runData(bikeNo = 0) {
+    runData(bike) {
         return __awaiter(this, void 0, void 0, function* () {
+            const bikeNo = bike === undefined ? this.bikeNo : bike;
             const data = yield this.sendCommand(`runData(${bikeNo})`, [0x40, bikeNo], 19);
             return (0, utils_2.parseRunData)(data);
         });
     }
-    setGear(gear, bikeNo = 0) {
+    setGear(gear, bike) {
         return __awaiter(this, void 0, void 0, function* () {
+            const bikeNo = bike === undefined ? this.bikeNo : bike;
             const gearVal = (0, utils_2.between)(gear, 1, 28);
             const data = yield this.sendCommand(`setGear(${bikeNo},${gearVal})`, [0x53, bikeNo, gearVal], 3);
             return ({ bike: data[1], gear: data[2] });
         });
     }
-    setPower(power, bikeNo = 0) {
+    setPower(power, bike) {
         return __awaiter(this, void 0, void 0, function* () {
+            const bikeNo = bike === undefined ? this.bikeNo : bike;
             const powerVal = Math.round((0, utils_2.between)(power, 25, 800) / 5);
             const data = yield this.sendCommand(`setPower(${bikeNo},${power})`, [0x51, bikeNo, powerVal], 3);
             return ({ bike: data[1], power: data[2] * 5 });
         });
     }
-    setSlope(slope, bikeNo = 0) {
+    setSlope(slope, bike) {
         return __awaiter(this, void 0, void 0, function* () {
+            const bikeNo = bike === undefined ? this.bikeNo : bike;
             const cmd = (0, utils_2.buildSetSlopeCommand)(bikeNo, slope);
             const data = yield this.sendCommand(`setSlope(${bikeNo},${slope})`, cmd, 6);
             return ({ bike: data[1], slope });
         });
     }
+    setTargetSlope(slope) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.setSlope(slope);
+        });
+    }
+    setTargetPower(power) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.setPower(power);
+        });
+    }
 }
 exports.default = Daum8008;

package/lib/serial/daum/classic/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';
 export type MockProps = {
@@ -65,11 +66,14 @@ export declare class DaumClassicSimulator {
     _timeoutResponse: number;
     _simulateNoReponseCnt: number;
     _simulateIllegalResponseCnt: number;
+    openHandles: Array<NodeJS.Timeout>;
     constructor();
     reset(): void;
     simulateTimeout(ms: number): void;
     simulateNoResponse(cnt?: number): void;
     simulateIllegalResponse(cnt?: number): void;
+    addHandle(handle: NodeJS.Timeout): void;
+    cleanup(): void;
     isPedalling(): 0 | 1;
 }
 export declare class DaumClassicMockBinding extends MockPortBinding {

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

@@ -90,6 +90,7 @@ class DaumClassicSimulator {
         this._timeoutResponse = 0;
         this._simulateNoReponseCnt = 0;
         this._simulateIllegalResponseCnt = 0;
+        this.openHandles = [];
         for (let i = 0; i < 10; i++)
             this.bikes.push(Object.assign({}, DEFAULT_BIKE_DATA));
         this.reset();
@@ -117,6 +118,12 @@ class DaumClassicSimulator {
     simulateIllegalResponse(cnt = 1) {
         this._simulateIllegalResponseCnt += cnt;
     }
+    addHandle(handle) {
+        this.openHandles.push(handle);
+    }
+    cleanup() {
+        this.openHandles.forEach(to => { clearTimeout(to); });
+    }
     isPedalling() {
         if (this.cadence && this.cadence > 0)
             return 1;
@@ -180,9 +187,11 @@ class DaumClassicMockBinding extends binding_mock_1.MockPortBinding {
                         this.simulator._simulateNoReponseCnt--;
                         return;
                     }
-                    const to = this.simulator._timeoutResponse || 5;
-                    if (handler)
-                        setTimeout(() => { handler(payload); }, to);
+                    const toVal = this.simulator._timeoutResponse || 5;
+                    if (handler) {
+                        const to = setTimeout(() => { handler(payload); }, toVal);
+                        this.simulator.addHandle(to);
+                    }
                 }
                 catch (err) {
                 }
@@ -346,7 +355,8 @@ class DaumClassicMockBinding extends binding_mock_1.MockPortBinding {
         if (bikeNo >= 0 && bikeNo < 10) {
             this.simulator.targetPower = power;
             this.simulator.isPowerMode = true;
-            setTimeout(() => { this.simulator.currentPower = power; }, 1000);
+            const to = setTimeout(() => { this.simulator.currentPower = power; }, 1000);
+            this.simulator.addHandle(to);
             const response = Buffer.from([0x51, bikeNo, power]);
             this.emitData(response);
         }

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

@@ -1,25 +1,30 @@
-import { SerialInterface } from '../..';
 import { SerialDeviceSettings } from '../../adapter';
 import { SerialCommProps } from '../../comm';
-import DaumAdapter from '../DaumAdapter';
+import DaumAdapter, { DaumControl } from '../DaumAdapter';
+import Daum8i from './comms';
 import { Daum8iDeviceProperties } from './types';
 import { IncyclistBikeData } from '../../..';
-export default class DaumPremiumAdapter extends DaumAdapter<SerialDeviceSettings, Daum8iDeviceProperties> {
+export declare class DaumPremiumControl extends DaumControl<Daum8iDeviceProperties> {
+    getSupportedCyclingModes(): Array<any>;
+}
+export default class DaumPremiumAdapter extends DaumAdapter<DaumPremiumControl, SerialDeviceSettings, Daum8iDeviceProperties, Daum8i> {
     static NAME: string;
     commProps: SerialCommProps;
-    _startRetryTimeout: number;
     constructor(settings: SerialDeviceSettings, props?: Daum8iDeviceProperties);
+    getBikeProps(props: SerialDeviceSettings): {
+        serial: any;
+        path: string;
+    };
     getName(): string;
     getUniqueName(): string;
-    getPort(): any;
     getInterface(): string;
     getProtocolName(): string;
-    getSerialInterface(): SerialInterface;
     isEqual(settings: SerialDeviceSettings): boolean;
-    getSupportedCyclingModes(): Array<any>;
-    check(): Promise<boolean>;
-    startRide(props?: Daum8iDeviceProperties): Promise<boolean>;
-    start(props?: Daum8iDeviceProperties): Promise<boolean>;
-    launch(props?: Daum8iDeviceProperties, isRelaunch?: boolean): Promise<boolean>;
+    performCheck(): Promise<boolean>;
+    getStartRetries(): number;
+    getStartRetryTimeout(): number;
+    performStart(props?: Daum8iDeviceProperties, _isRelaunch?: boolean): Promise<boolean>;
+    requiresProgramUpload(): boolean;
     getCurrentBikeData(): Promise<IncyclistBikeData>;
+    getDeviceInfo(): Promise<any>;
 }