incyclist-devices 2.0.38 → 2.1.1

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

@@ -15,249 +15,132 @@ Object.defineProperty(exports, "__esModule", { value: true });
 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 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 });
-    }
-    else {
-        serial = props.interface;
-    }
-    if (!serial || !serial.binding)
-        throw new Error(`unknonwn interface: ${ifaceName}`);
-    const path = `${port}`;
-    return { serial, path };
-};
+const serial_interface_1 = __importDefault(require("../../base/serial-interface"));
+const daum_erg_1 = __importDefault(require("../../../modes/daum-erg"));
+const daum_smarttrainer_1 = __importDefault(require("../../../modes/daum-smarttrainer"));
+const daum_power_1 = __importDefault(require("../../../modes/daum-power"));
+const consts_1 = require("./consts");
 class DaumClassicAdapter extends DaumAdapter_1.default {
     constructor(settings, props) {
         super(settings, props);
         const logger = new gd_eventlog_1.EventLogger('DaumClassic');
-        const commProps = Object.assign(Object.assign({}, getBikeProps(settings)), { logger });
-        this.bike = new comms_1.default(commProps);
+        const commProps = Object.assign(Object.assign({}, this.getBikeProps(settings)), { logger });
+        this.comms = 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.name = consts_1.PROTOCOL_NAME;
         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;
-            }
-        });
+        return consts_1.PROTOCOL_NAME;
     }
     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.getComms().getAddress();
+                    info.bikeNo = address === null || address === void 0 ? void 0 : address.bike;
+                    const version = yield this.getComms().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 { gear = DEFAULT_GEAR } = props;
+        const user = this.getUser();
+        const { gear = consts_1.DEFAULT_GEAR } = props;
         this.initData();
         let startState = {};
         return (0, utils_1.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () {
             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');
+                this.logEvent({ message: 'start attempt', isRelaunch, isConnected: this.getComms().isConnected() });
+                if (!isRelaunch && !this.getComms().isConnected()) {
+                    yield this.verifyConnection();
                 }
-                yield this.getBike().resetDevice();
+                yield this.getComms().resetDevice();
                 if (!startState.setProg) {
-                    yield this.getBike().setProg(0);
+                    yield this.getComms().setProg(0);
                     startState.setProg = true;
                 }
                 if (!startState.setPerson) {
-                    yield this.getBike().setPerson(user);
+                    yield this.getComms().setPerson(user);
                     startState.setPerson = true;
                 }
                 if (!startState.setBikeType) {
                     const bikeType = this.getCyclingMode().getSetting('bikeType') || 'race';
-                    yield this.getBike().setBikeType(bikeType.toLowerCase());
+                    yield this.getComms().setBikeType(bikeType.toLowerCase());
                     startState.setBikeType = true;
                 }
                 if (!startState.startProg) {
-                    yield this.getBike().startProg();
+                    yield this.getComms().startProg();
                     startState.startProg = true;
                 }
                 if (!startState.setGear) {
-                    yield this.bike.setGear(this.cyclingData.gear || gear);
+                    yield this.getComms().setGear(this.deviceData.gear || gear);
                     startState.setGear = true;
                 }
                 const startRequest = this.getCyclingMode().getBikeInitRequest();
                 yield this.sendRequest(startRequest);
                 startState.checkRunData = true;
-                const data = yield this.bike.runData();
+                const data = yield this.getComms().runData();
                 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 +152,22 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.stopped)
                 return;
-            return this.getBike().runData();
+            yield this.verifyConnection();
+            return this.getComms().runData();
+        });
+    }
+    getDeviceInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.stopped)
+                return;
+            const version = yield this.getComms().getVersion();
+            return version || {};
         });
     }
 }
-DaumClassicAdapter.NAME = PROTOCOL_NAME;
+DaumClassicAdapter.NAME = consts_1.PROTOCOL_NAME;
+DaumClassicAdapter.controllers = {
+    modes: [daum_erg_1.default, daum_smarttrainer_1.default, daum_power_1.default, daum_classic_standard_1.default],
+    default: daum_classic_standard_1.default
+};
 exports.default = DaumClassicAdapter;

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

@@ -1,9 +1,11 @@
-import { User } from '../../../types/user';
 import { ClassicBikeResponse, DaumClassicCommsState, DaumClassicRequest, DaumClassicResponse, GetVersionReponse, ProgResponse, SetGearRepsonse, SetPowerRepsonse, SetProgResponse, SetSlopeRepsonse, checkCockpitReponse } from './types';
-import SerialPortComms from '../../comms';
-import { DeviceType } from '../../../types/device';
-import { IncyclistBikeData } from '../../..';
-export default class Daum8008 extends SerialPortComms<DaumClassicCommsState, DaumClassicRequest, DaumClassicResponse> {
+import SerialPortComms from '../../base/comms';
+import { DaumSerialComms } from '../types';
+import { SerialCommProps } from '../../types';
+import { DeviceType, IncyclistBikeData, User } from '../../../types';
+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 +15,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

@@ -13,12 +13,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../../../utils/utils");
-const comms_1 = __importDefault(require("../../comms"));
-const types_1 = require("../premium/types");
+const comms_1 = __importDefault(require("../../base/comms"));
 const utils_2 = require("./utils");
+const types_1 = require("../types");
 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/consts.d.ts

@@ -0,0 +1,2 @@
+export declare const PROTOCOL_NAME = "Daum Classic";
+export declare const DEFAULT_GEAR = 10;

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_GEAR = exports.PROTOCOL_NAME = void 0;
+exports.PROTOCOL_NAME = "Daum Classic";
+exports.DEFAULT_GEAR = 10;

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

@@ -14,9 +14,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DaumClassicMockBinding = exports.DaumClassicSimulator = exports.DaumClassicMockImpl = exports.DaumClassicMock = void 0;
 const binding_mock_1 = require("@serialport/binding-mock");
-const __1 = require("../../");
 const utils_1 = require("../../../utils/utils");
 const calculations_1 = __importDefault(require("../../../utils/calculations"));
+const serialport_1 = __importDefault(require("../../base/serialport"));
+const serial_interface_1 = __importDefault(require("../../base/serial-interface"));
 exports.DaumClassicMock = {
     reset() {
         DaumClassicMockImpl.getInstance().reset();
@@ -43,8 +44,8 @@ class DaumClassicMockImpl {
     }
     static reset() {
         DaumClassicMockImpl._instance = undefined;
-        __1.SerialPortProvider._instance = undefined;
-        __1.SerialInterface._instances = [];
+        serialport_1.default._instance = undefined;
+        serial_interface_1.default._instances = [];
     }
     constructor() {
         this.simulators = new Map();
@@ -90,6 +91,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 +119,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 +188,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 +356,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/classic/types.d.ts

@@ -1,12 +1,7 @@
-import { IncyclistBikeData } from "../../..";
-import { DaumBikeData, DeviceProperties } from "../../../types/device";
+import { DeviceProperties, IncyclistBikeData } from "../../../types";
 import { Queue } from "../../../utils/utils";
-import { Request, Response } from "../../comms";
-export type DaumClassiAdapterProps = {
-    path: string;
-    ifaceName?: string;
-};
-export interface DaumClassicDeviceProperties extends DeviceProperties {
+import { Request, Response } from "../../base/comms";
+export interface DaumClassicProperties extends DeviceProperties {
     gear?: number;
 }
 export interface DaumClassicRequest extends Request {
@@ -18,8 +13,11 @@ export interface DaumClassicResponse extends Response {
     data?: Uint8Array;
     error?: Error;
 }
-export interface DaumClassicBikeData extends DaumBikeData {
-}
+export type DaumClassicStartInfo = {
+    bikeNo?: number;
+    serialNo?: string;
+    cockpit?: string;
+};
 export type ResponseType = 'Response' | 'Error';
 export type DaumClassicCommsState = {
     data: Queue<DaumClassicResponse>;