incyclist-devices 2.0.37 → 2.1.0

package/lib/serial/adapter-factory.d.ts

@@ -1,12 +1,14 @@
+import { ControllableDevice } from '../base/adpater';
+import { DeviceProperties } from '../types/device';
 import { SerialIncyclistDevice, SerialDeviceSettings } from './adapter';
 export default class SerialAdapterFactory {
     static _instance: SerialAdapterFactory;
-    adapters: {
+    adapters: Array<{
         protocol: string;
-        AdapterClass: typeof SerialIncyclistDevice;
-    }[];
+        AdapterClass: typeof SerialIncyclistDevice<ControllableDevice<DeviceProperties>, DeviceProperties>;
+    }>;
     static getInstance(): SerialAdapterFactory;
     constructor();
-    registerAdapter(protocol: string, AdapterClass: typeof SerialIncyclistDevice): void;
-    createInstance(props: SerialDeviceSettings, settings?: any): SerialIncyclistDevice;
+    registerAdapter(protocol: string, AdapterClass: typeof SerialIncyclistDevice<ControllableDevice<DeviceProperties>, DeviceProperties>): void;
+    createInstance(props: SerialDeviceSettings, settings?: any): SerialIncyclistDevice<ControllableDevice<DeviceProperties>, DeviceProperties>;
 }

package/lib/serial/adapter.d.ts

@@ -1,5 +1,5 @@
 import { DeviceProperties, DeviceSettings } from "../types/device";
-import { ControllableDevice } from "../base/adpater";
+import IncyclistDevice, { ControllableDevice } from "../base/adpater";
 import SerialInterface from "./serial-interface";
 export interface SerialDeviceSettings extends DeviceSettings {
     protocol: string;
@@ -7,7 +7,7 @@ export interface SerialDeviceSettings extends DeviceSettings {
     port?: string;
     interface: string | SerialInterface;
 }
-export declare class SerialIncyclistDevice extends ControllableDevice {
+export declare class SerialIncyclistDevice<C extends ControllableDevice<P>, P extends DeviceProperties> extends IncyclistDevice<C, P> {
     pullFrequency: number;
     check(): Promise<boolean>;
     constructor(settings: SerialDeviceSettings, props?: DeviceProperties);

package/lib/serial/adapter.js

@@ -8,11 +8,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SerialIncyclistDevice = void 0;
-const adpater_1 = require("../base/adpater");
+const adpater_1 = __importDefault(require("../base/adpater"));
 const DEFAULT_PULL_FREQUENCY = 1000;
-class SerialIncyclistDevice extends adpater_1.ControllableDevice {
+class SerialIncyclistDevice extends adpater_1.default {
     check() {
         return __awaiter(this, void 0, void 0, function* () { throw new Error('not implemnted'); });
     }

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

@@ -1,54 +1,57 @@
-import { EventLogger } from 'gd-eventlog';
-import CyclingMode, { IncyclistBikeData } from '../../modes/cycling-mode';
-import { Bike } from '../../types/adapter';
+import ICyclingMode, { CyclingMode, IncyclistBikeData } from '../../modes/types';
 import { DeviceProperties } from '../../types/device';
 import { SerialDeviceSettings, SerialIncyclistDevice } from '../adapter';
 import { DeviceData } from '../../types/data';
+import SerialInterface from '../serial-interface';
+import DaumSerialComms from './types';
+import { ControllableDevice } from '../../base/adpater';
+import { IncyclistDeviceAdapter } from '../../types/adapter';
 export interface IDaumAdapter {
     getCurrentBikeData(): Promise<IncyclistBikeData>;
 }
-export declare abstract class AbstractDaumAdapter extends SerialIncyclistDevice implements IDaumAdapter {
-    abstract getCurrentBikeData(): Promise<any>;
+export declare class DaumControl<P extends DeviceProperties> extends ControllableDevice<P> {
+    getSupportedCyclingModes(): Array<typeof CyclingMode>;
+    getDefaultCyclingMode(): ICyclingMode;
+    sendInitCommands(): Promise<boolean>;
 }
-export default class DaumAdapter<S extends SerialDeviceSettings, P extends DeviceProperties> extends AbstractDaumAdapter implements Bike {
-    bike: any;
-    ignoreHrm: boolean;
-    ignoreBike: boolean;
-    ignorePower: boolean;
+export default class DaumAdapter<DC extends DaumControl<P>, S extends SerialDeviceSettings, P extends DeviceProperties, C extends DaumSerialComms> extends SerialIncyclistDevice<DC, P> implements IDaumAdapter {
+    bike: C;
     distanceInternal: number;
-    paused: boolean;
-    stopped: boolean;
     cyclingData: IncyclistBikeData;
     deviceData: DeviceData;
-    currentRequest: any;
     requests: Array<any>;
     iv: any;
-    logger: EventLogger;
     tsPrevData: number;
     adapterTime: number;
     requestBusy: boolean;
     updateBusy: boolean;
+    startPromise: Promise<boolean>;
+    checkPromise: Promise<boolean>;
     constructor(settings: S, props?: P);
-    setCyclingMode(mode: CyclingMode | string, settings?: any): void;
+    getPort(): string;
+    getSerialInterface(): SerialInterface;
     sendInitCommands(): Promise<boolean>;
-    getSupportedCyclingModes(): Array<any>;
-    getCyclingMode(): CyclingMode;
-    getDefaultCyclingMode(): CyclingMode;
     getCurrentBikeData(): Promise<IncyclistBikeData>;
-    getBike(): any;
+    getBike(): C;
     isEqual(settings: SerialDeviceSettings): boolean;
-    isSame(device: SerialIncyclistDevice): boolean;
+    isSame(device: IncyclistDeviceAdapter): boolean;
     isStopped(): boolean;
     initData(): void;
     pause(): Promise<boolean>;
     resume(): Promise<boolean>;
-    start(props?: P): Promise<any>;
-    stopUpdatePull(): void;
+    waitForPrevCheckFinished(): Promise<void>;
+    check(): Promise<boolean>;
+    performCheck(): Promise<boolean>;
+    waitForPrevStartFinished(): Promise<void>;
+    start(props?: P): Promise<boolean>;
+    performStart(props?: P, isRelaunch?: boolean): Promise<boolean>;
     startUpdatePull(): void;
+    stopUpdatePull(): void;
     connect(): Promise<boolean>;
     close(): Promise<boolean>;
-    logEvent(event: any): void;
+    verifyConnection(): Promise<void>;
     reconnect(): Promise<boolean>;
+    logEvent(event: any): void;
     stop(): Promise<boolean>;
     canSendUpdate(): boolean;
     sendUpdate(request: any): Promise<unknown>;
@@ -60,5 +63,5 @@ export default class DaumAdapter<S extends SerialDeviceSettings, P extends Devic
     sendRequest(request: any): Promise<any>;
     refreshRequests(): void;
     processClientRequest(request: any): Promise<unknown>;
-    check(): Promise<boolean>;
+    getDeviceInfo(): Promise<any>;
 }

package/lib/serial/daum/DaumAdapter.js

@@ -12,25 +12,36 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractDaumAdapter = void 0;
-const ERGCyclingMode_1 = __importDefault(require("./ERGCyclingMode"));
-const SmartTrainerCyclingMode_1 = __importDefault(require("./SmartTrainerCyclingMode"));
-const DaumPowerMeterCyclingMode_1 = __importDefault(require("./DaumPowerMeterCyclingMode"));
+exports.DaumControl = void 0;
+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 utils_1 = require("../../utils/utils");
 const adapter_1 = require("../adapter");
 const capabilities_1 = require("../../types/capabilities");
-class AbstractDaumAdapter extends adapter_1.SerialIncyclistDevice {
+const adpater_1 = require("../../base/adpater");
+class DaumControl extends adpater_1.ControllableDevice {
+    getSupportedCyclingModes() {
+        return [daum_erg_1.default, daum_smarttrainer_1.default, daum_power_1.default];
+    }
+    getDefaultCyclingMode() {
+        return new daum_erg_1.default(this.adapter);
+    }
+    sendInitCommands() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return true;
+        });
+    }
 }
-exports.AbstractDaumAdapter = AbstractDaumAdapter;
-class DaumAdapter extends AbstractDaumAdapter {
+exports.DaumControl = DaumControl;
+class DaumAdapter extends adapter_1.SerialIncyclistDevice {
     constructor(settings, props) {
         super(settings, props);
         this.requests = [];
         this.adapterTime = 0;
         this.requestBusy = false;
         this.updateBusy = false;
-        this.stopped = false;
-        this.paused = false;
+        this.iv = undefined;
         this.cyclingData = {
             isPedalling: false,
             time: 0,
@@ -45,31 +56,21 @@ class DaumAdapter extends AbstractDaumAdapter {
             capabilities_1.IncyclistCapability.Power, capabilities_1.IncyclistCapability.Speed, capabilities_1.IncyclistCapability.Cadence, capabilities_1.IncyclistCapability.Gear, capabilities_1.IncyclistCapability.HeartRate,
             capabilities_1.IncyclistCapability.Control
         ];
+        this.setControl(new DaumControl(this, props));
     }
-    setCyclingMode(mode, settings) {
-        let selectedMode = this.cyclingMode;
-        if (typeof mode === 'string') {
-            if (!this.cyclingMode || this.cyclingMode.getName() !== mode) {
-                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);
+    getPort() {
+        var _a;
+        return (_a = this.bike) === null || _a === void 0 ? void 0 : _a.getPort();
+    }
+    getSerialInterface() {
+        var _a;
+        return (_a = this.bike) === null || _a === void 0 ? void 0 : _a.serial;
     }
     sendInitCommands() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.started && !this.stopped) {
                 try {
-                    if (this.getCyclingMode() instanceof ERGCyclingMode_1.default) {
+                    if (this.getCyclingMode() instanceof daum_erg_1.default) {
                         const power = this.deviceData.power;
                         const request = power ? { targetPower: power } : this.getCyclingMode().getBikeInitRequest();
                         yield this.sendUpdate(request);
@@ -80,22 +81,9 @@ class DaumAdapter extends AbstractDaumAdapter {
                     return false;
                 }
             }
-            else {
-                return false;
-            }
+            return false;
         });
     }
-    getSupportedCyclingModes() {
-        return [ERGCyclingMode_1.default, SmartTrainerCyclingMode_1.default, DaumPowerMeterCyclingMode_1.default];
-    }
-    getCyclingMode() {
-        if (!this.cyclingMode)
-            this.setCyclingMode(this.getDefaultCyclingMode());
-        return this.cyclingMode;
-    }
-    getDefaultCyclingMode() {
-        return new ERGCyclingMode_1.default(this);
-    }
     getCurrentBikeData() {
         throw new Error('Method not implemented.');
     }
@@ -133,7 +121,6 @@ class DaumAdapter extends AbstractDaumAdapter {
             heartrate: 0
         };
         this.deviceData = {};
-        this.currentRequest = {};
         this.requests = [];
         const name = this.getCyclingMode().getName();
         const settings = this.getCyclingMode().getSettings();
@@ -159,38 +146,131 @@ class DaumAdapter extends AbstractDaumAdapter {
             return resumed;
         });
     }
+    waitForPrevCheckFinished() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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;
+            }
+        });
+    }
+    check() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.waitForPrevCheckFinished();
+            yield this.waitForPrevStartFinished();
+            if (this.isStopped())
+                return false;
+            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* () {
+            throw new Error('Method not implemented.');
+        });
+    }
+    waitForPrevStartFinished() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.startPromise) {
+                this.logEvent({ message: "waiting for previous device launch", port: this.getPort() });
+                try {
+                    yield this.startPromise;
+                }
+                catch (_a) { }
+                this.logEvent({ message: "previous device launch attempt completed", port: this.getPort() });
+                this.startPromise = undefined;
+            }
+        });
+    }
     start(props) {
-        throw new Error('Method not implemented.');
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.waitForPrevCheckFinished();
+            yield this.waitForPrevStartFinished();
+            const isRelaunch = this.started;
+            const message = isRelaunch ? 'relaunch of device' : 'initial start of device';
+            this.logEvent({ message });
+            try {
+                if (isRelaunch && this.isPaused())
+                    this.resume();
+                this.startPromise = this.performStart(props, isRelaunch).then((started) => __awaiter(this, void 0, void 0, function* () {
+                    if (!started) {
+                        this.logEvent({ message: 'start result: not started' });
+                        this.started = false;
+                        return false;
+                    }
+                    if (!isRelaunch) {
+                        try {
+                            const deviceInfo = yield this.getDeviceInfo();
+                            this.logEvent({ message: 'device info', deviceInfo });
+                        }
+                        catch (_a) { }
+                    }
+                    this.logEvent({ message: 'start result: success' });
+                    this.started = true;
+                    return true;
+                }));
+                const started = yield this.startPromise;
+                this.startPromise = undefined;
+                return started;
+            }
+            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}`);
+            }
+        });
     }
-    stopUpdatePull() {
-        if (!this.iv)
-            return;
-        if (this.iv.sync)
-            clearInterval(this.iv.sync);
-        if (this.iv.update)
-            clearInterval(this.iv.update);
-        this.iv = undefined;
+    performStart(props, isRelaunch = false) {
+        throw new Error('Method not implemented.');
     }
     startUpdatePull() {
-        this.logEvent({ message: 'start update pull', iv: this.iv, ignoreBike: this.ignoreBike, ignoreHrm: this.ignoreHrm, ignorePower: this.ignorePower });
         if (this.iv)
             return;
-        if (this.ignoreBike && this.ignoreHrm && this.ignorePower)
-            return;
+        this.logEvent({ message: 'start update pull', port: this.getPort() });
         const ivSync = setInterval(() => {
-            this.bikeSync();
+            try {
+                this.bikeSync();
+            }
+            catch (_a) { }
         }, this.pullFrequency);
         const ivUpdate = setInterval(() => {
-            this.emitData(this.deviceData);
-            this.refreshRequests();
+            try {
+                this.emitData(this.deviceData);
+                this.refreshRequests();
+            }
+            catch (_a) { }
         }, this.pullFrequency);
         this.iv = {
             sync: ivSync,
             update: ivUpdate
         };
     }
+    stopUpdatePull() {
+        if (!this.iv)
+            return;
+        this.logEvent({ message: 'stop update pull', port: this.getPort() });
+        clearInterval(this.iv.sync);
+        clearInterval(this.iv.update);
+        this.iv = undefined;
+    }
     connect() {
         return __awaiter(this, void 0, void 0, function* () {
+            if (!this.bike)
+                return false;
             if (this.bike.isConnected())
                 return true;
             try {
@@ -205,19 +285,21 @@ class DaumAdapter extends AbstractDaumAdapter {
     }
     close() {
         return __awaiter(this, void 0, void 0, function* () {
+            if (!this.bike)
+                return true;
             if (!this.bike.isConnected())
                 return true;
             return yield this.bike.close();
         });
     }
-    logEvent(event) {
-        if (!this.logger)
-            return;
-        this.logger.logEvent(event);
-        const w = global.window;
-        if (w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) {
-            console.log(`~~~ ${this.logger.getName()}`, event);
-        }
+    verifyConnection() {
+        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');
+            }
+        });
     }
     reconnect() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -231,33 +313,34 @@ class DaumAdapter extends AbstractDaumAdapter {
             }
         });
     }
+    logEvent(event) {
+        if (!this.logger || this.paused)
+            return;
+        this.logger.logEvent(event);
+        const w = global.window;
+        if (w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) {
+            console.log(`~~~ ${this.logger.getName()}`, event);
+        }
+    }
     stop() {
-        if (this.stopped)
-            return Promise.resolve(true);
-        this.logEvent({ message: 'stop request' });
-        if (this.paused)
-            this.resume();
-        this.stopped = true;
-        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.stopped)
+                return true;
+            this.logEvent({ message: 'stop request' });
+            if (this.paused)
+                this.resume();
             try {
-                if (this.iv) {
-                    if (this.iv.sync)
-                        clearInterval(this.iv.sync);
-                    if (this.iv.update)
-                        clearInterval(this.iv.update);
-                    this.iv = undefined;
-                }
-                if (this.bike.stopWorker && typeof this.bike.stopWorker === 'function')
-                    this.bike.stopWorker();
+                this.stopUpdatePull();
                 yield this.bike.close();
                 this.logEvent({ message: 'stop request completed' });
-                resolve(true);
+                this.stopped = true;
             }
             catch (err) {
-                this.logEvent({ message: 'stop error', error: err.message });
-                reject(err);
+                this.logEvent({ message: 'stop request failed', reason: err.message });
+                throw (err);
             }
-        }));
+            return this.stopped;
+        });
     }
     canSendUpdate() {
         if (this.paused || this.stopped)
@@ -274,39 +357,44 @@ class DaumAdapter extends AbstractDaumAdapter {
     }
     update() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.stopped)
+            if (!this.canSendUpdate() || this.updateBusy)
                 return;
             this.updateBusy = true;
-            this.getCurrentBikeData()
-                .then(bikeData => {
+            try {
+                const bikeData = yield this.getCurrentBikeData();
                 const incyclistData = this.updateData(bikeData);
                 const data = this.transformData(incyclistData);
                 this.updateBusy = false;
                 this.emitData(data);
-            })
-                .catch(err => {
-                this.logEvent({ message: 'bike update error', error: err.message, stack: err.stack });
-                const incyclistData = this.updateData(this.cyclingData);
-                this.transformData(incyclistData);
+            }
+            catch (err) {
+                try {
+                    this.logEvent({ message: 'bike update error', error: err.message, stack: err.stack });
+                    const incyclistData = this.updateData(this.cyclingData);
+                    this.transformData(incyclistData);
+                }
+                catch (_a) { }
                 this.updateBusy = false;
-            });
+            }
         });
     }
     sendRequests() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.stopped || this.paused)
                 return;
+            if (this.requestBusy)
+                return;
             if (this.requests.length > 0) {
-                const processing = [...this.requests];
-                const cnt = processing.length;
-                processing.forEach((request, idx) => __awaiter(this, void 0, void 0, function* () {
-                    if (cnt > 1 && idx < cnt - 1) {
-                        this.logEvent({ message: 'ignoring bike update request', request });
-                        this.requests.shift();
-                        return;
-                    }
-                }));
-                const request = processing[0];
+                const cnt = this.requests.length;
+                if (cnt > 1) {
+                    this.requests.forEach((request, idx) => {
+                        if (idx !== cnt - 1) {
+                            this.logEvent({ message: 'ignoring bike update request', request });
+                        }
+                    });
+                    this.requests = [this.requests[cnt - 1]];
+                }
+                let request = this.requests[0];
                 try {
                     yield this.sendRequest(request);
                     this.requests.shift();
@@ -319,16 +407,7 @@ class DaumAdapter extends AbstractDaumAdapter {
     }
     bikeSync() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.paused || this.stopped) {
-                return;
-            }
-            if (this.updateBusy || this.requestBusy) {
-                return;
-            }
-            this.logEvent({ message: 'bikeSync', ignoreBike: this.ignoreBike });
-            if (!this.ignoreBike) {
-                yield this.sendRequests();
-            }
+            yield this.sendRequests();
             yield this.update();
         });
     }
@@ -367,15 +446,6 @@ class DaumAdapter extends AbstractDaumAdapter {
             deviceTime: cyclingData.time,
             deviceDistanceCounter: cyclingData.distanceInternal
         };
-        if (this.ignoreHrm)
-            delete data.heartrate;
-        if (this.ignorePower) {
-            delete data.power;
-            delete data.cadence;
-        }
-        if (this.ignoreBike) {
-            data = { heartrate: data.heartrate };
-        }
         this.deviceData = data;
         return data;
     }
@@ -391,10 +461,10 @@ class DaumAdapter extends AbstractDaumAdapter {
                     return {};
                 }
                 if (request.slope !== undefined) {
-                    yield bike.setSlope(request.slope);
+                    yield bike.setTargetSlope(request.slope);
                 }
                 if (request.targetPower !== undefined) {
-                    yield bike.setPower(request.targetPower);
+                    yield bike.setTargetPower(request.targetPower);
                 }
                 this.requestBusy = false;
                 return request;
@@ -429,8 +499,10 @@ class DaumAdapter extends AbstractDaumAdapter {
             resolve(bikeRequest);
         }));
     }
-    check() {
-        throw new Error('Method not implemented.');
+    getDeviceInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('Method not implemented.');
+        });
     }
 }
 exports.default = DaumAdapter;

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

@@ -1,33 +1,32 @@
-import CyclingMode, { IncyclistBikeData } from '../../../modes/cycling-mode';
-import DaumAdapter from '../DaumAdapter';
+import ICyclingMode, { CyclingMode, IncyclistBikeData } from '../../../modes/types';
+import DaumAdapter, { DaumControl } from '../DaumAdapter';
 import { DeviceProperties } from '../../../types/device';
 import { SerialDeviceSettings } from '../../adapter';
-import SerialInterface from '../../serial-interface';
+import { SerialCommProps } from '../../comm';
+import Daum8008 from './comms';
 export interface DaumClassicDeviceProperties extends DeviceProperties {
     gear?: number;
 }
-export default class DaumClassicAdapter extends DaumAdapter<SerialDeviceSettings, DaumClassicDeviceProperties> {
+export type DaumClassicStartInfo = {
+    bikeNo?: number;
+    serialNo?: string;
+    cockpit?: string;
+};
+export declare class DaumClassicControl extends DaumControl<DaumClassicDeviceProperties> {
+    getSupportedCyclingModes(): Array<typeof CyclingMode>;
+    getDefaultCyclingMode(): ICyclingMode;
+}
+export default class DaumClassicAdapter extends DaumAdapter<DaumClassicControl, SerialDeviceSettings, DaumClassicDeviceProperties, Daum8008> {
     static NAME: string;
-    name: string;
-    id: string;
-    started: boolean;
-    startPromise: Promise<unknown>;
-    checkPromise: Promise<boolean>;
+    protected name: string;
+    protected id: string;
     constructor(settings: SerialDeviceSettings, props?: DaumClassicDeviceProperties);
-    setID(id: any): void;
-    getID(): string;
+    getBikeProps(props: SerialDeviceSettings): SerialCommProps;
     getName(): string;
-    setName(name: any): void;
-    getPort(): any;
+    setName(name: string): void;
     getProtocolName(): string;
-    getSupportedCyclingModes(): Array<any>;
-    getDefaultCyclingMode(): CyclingMode;
-    getSerialInterface(): SerialInterface;
-    check(): Promise<boolean>;
     performCheck(): Promise<boolean>;
-    startRide(props?: DaumClassicDeviceProperties): Promise<boolean>;
-    start(props?: DaumClassicDeviceProperties): Promise<boolean>;
-    launch(props: DaumClassicDeviceProperties, isRelaunch?: boolean): Promise<boolean>;
-    performStart(props?: DaumClassicDeviceProperties, isRelaunch?: boolean): Promise<unknown>;
+    performStart(props?: DaumClassicDeviceProperties, isRelaunch?: boolean): Promise<boolean>;
     getCurrentBikeData(): Promise<IncyclistBikeData>;
+    getDeviceInfo(): Promise<any>;
 }