incyclist-devices 2.1.0 → 2.1.2

package/lib/serial/base/serial-scanner.js

@@ -0,0 +1,87 @@
+"use strict";
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        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.SinglePathScanner = void 0;
+const gd_eventlog_1 = require("gd-eventlog");
+const types_1 = require("../types");
+const adapter_factory_1 = __importDefault(require("../factories/adapter-factory"));
+const utils_1 = require("../../utils/utils");
+class SinglePathScanner {
+    constructor(path, serial, props) {
+        this.path = path;
+        this.serial = serial;
+        this.result = undefined;
+        this.isScanning = false;
+        this.isFound = false;
+        this.props = props;
+        this.logger = props.logger || new gd_eventlog_1.EventLogger('SerialScanner');
+    }
+    logEvent(event) {
+        if (this.logger) {
+            this.logger.logEvent(event);
+        }
+        const w = global.window;
+        if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.BLE_DEBUG || process.env.ANT_DEBUG || process.env.SERIAL_DEBUG) {
+            console.log('~~~ SerialScanner', event);
+        }
+    }
+    onStopRequest(resolve) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'stopping scan', path: this.path });
+            if (!this.isFound)
+                yield this.serial.closePort(this.path);
+            this.isScanning = false;
+            resolve(this.result);
+        });
+    }
+    scan() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isScanning)
+                return;
+            this.isScanning = true;
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                this.logEvent({ message: 'starting scan', path: this.path, interface: this.serial.getName() });
+                this.serial.scanEvents.on('timeout', () => this.onStopRequest(resolve));
+                this.serial.scanEvents.on('stop', () => this.onStopRequest(resolve));
+                let found = false;
+                while (!found && this.isScanning) {
+                    try {
+                        const { protocol } = this.props;
+                        let host, port;
+                        if (this.serial.getName() === types_1.SerialInterfaceType.TCPIP) {
+                            [host, port] = this.path.split(':');
+                        }
+                        else {
+                            port = this.path;
+                        }
+                        const adapterSettings = { interface: this.serial.getName(), host, port, protocol };
+                        const adapter = adapter_factory_1.default.getInstance().createInstance(adapterSettings);
+                        found = yield (adapter === null || adapter === void 0 ? void 0 : adapter.check());
+                        if (found) {
+                            this.isFound = true;
+                            const name = adapter.getName();
+                            resolve(Object.assign(Object.assign({}, adapterSettings), { name }));
+                        }
+                        yield (0, utils_1.sleep)(100);
+                    }
+                    catch (err) {
+                        this.logEvent({ message: 'error', fn: 'scan()', error: err.message || err, stack: err.stack });
+                        yield (0, utils_1.sleep)(100);
+                    }
+                }
+            }));
+        });
+    }
+}
+exports.SinglePathScanner = SinglePathScanner;

package/lib/serial/base/serialport.d.ts

@@ -0,0 +1,17 @@
+import { BindingInterface } from '@serialport/bindings-interface';
+import { InterfaceBinding, InterfaceImplementation } from '../types';
+export default class SerialPortProvider {
+    static _instance: SerialPortProvider;
+    interfaces: InterfaceBinding[];
+    implemenations: InterfaceImplementation[];
+    static getInstance(): SerialPortProvider;
+    constructor();
+    setBinding(ifaceName: string, binding: BindingInterface): void;
+    getBinding(ifaceName: string): BindingInterface;
+    getSerialPort(ifaceName: string, props: any): any;
+    list(ifaceName: string): Promise<any>;
+    setLegacyClass(ifaceName: string, Serialport: any): void;
+    getLegacyInfo(ifaceName: string): InterfaceImplementation;
+    getLegacyClass(ifaceName: string): any;
+}
+export declare const useSerialPortProvider: () => SerialPortProvider;

package/lib/serial/base/serialport.js

@@ -0,0 +1,87 @@
+"use strict";
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSerialPortProvider = void 0;
+const { SerialPortStream } = require('@serialport/stream');
+const DEFAULT_BAUD_RATE = 9600;
+class SerialPortProvider {
+    static getInstance() {
+        if (!SerialPortProvider._instance)
+            SerialPortProvider._instance = new SerialPortProvider();
+        return SerialPortProvider._instance;
+    }
+    constructor() {
+        this.interfaces = [];
+        this.implemenations = [];
+    }
+    setBinding(ifaceName, binding) {
+        const existing = this.interfaces.find(ib => ib.name === ifaceName);
+        if (existing)
+            existing.binding = binding;
+        else
+            this.interfaces.push({ name: ifaceName, binding });
+    }
+    getBinding(ifaceName) {
+        const existing = this.interfaces.find(ib => ib.name === ifaceName);
+        if (existing)
+            return existing.binding;
+    }
+    getSerialPort(ifaceName, props) {
+        const binding = this.getBinding(ifaceName);
+        if (binding) {
+            props.binding = binding;
+            if (props.autoOpen === undefined)
+                props.autoOpen = false;
+            if (!props.baudRate)
+                props.baudRate = DEFAULT_BAUD_RATE;
+            return new SerialPortStream(props);
+        }
+        const legacy = this.getLegacyInfo(ifaceName);
+        if (legacy && legacy.Serialport) {
+            const portName = props.path;
+            if (props.autoOpen === undefined)
+                props.autoOpen = false;
+            const settings = Object.assign({}, props);
+            delete settings.path;
+            return new legacy.Serialport(portName, settings);
+        }
+    }
+    list(ifaceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const Binding = this.getBinding(ifaceName);
+            if (Binding)
+                return yield Binding.list();
+            const legacy = this.getLegacyInfo(ifaceName);
+            if (legacy && legacy.Serialport && legacy.Serialport.list) {
+                return yield legacy.Serialport.list();
+            }
+            return [];
+        });
+    }
+    setLegacyClass(ifaceName, Serialport) {
+        const existing = this.getLegacyInfo(ifaceName);
+        if (existing)
+            existing.Serialport = Serialport;
+        else
+            this.implemenations.push({ name: ifaceName, Serialport });
+    }
+    getLegacyInfo(ifaceName) {
+        return this.implemenations.find(ib => ib.name === ifaceName);
+    }
+    getLegacyClass(ifaceName) {
+        const existing = this.implemenations.find(ib => ib.name === ifaceName);
+        if (existing)
+            return existing.Serialport;
+    }
+}
+exports.default = SerialPortProvider;
+const useSerialPortProvider = () => SerialPortProvider.getInstance();
+exports.useSerialPortProvider = useSerialPortProvider;

package/lib/serial/comms.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { EventLogger } from "gd-eventlog";
-import SerialInterface from "./serial-interface";
-import { SerialCommProps } from "./comm";
+import SerialInterface from "./base/serial-interface";
+import { SerialCommProps } from "./types";
 import { SerialPortStream } from "@serialport/stream";
 import { Queue } from "../utils/utils";
 export type ConnectionState = 'Connecting' | 'Connected' | 'Disconnected' | 'Disconnecting';

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

@@ -1,24 +1,13 @@
-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 class DaumControl<P extends DeviceProperties> extends ControllableDevice<P> {
-    getSupportedCyclingModes(): Array<typeof CyclingMode>;
-    getDefaultCyclingMode(): ICyclingMode;
-    sendInitCommands(): Promise<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;
+import { IncyclistAdapterData, ControllerConfig, IAdapter, DeviceProperties, IncyclistBikeData } from '../../types';
+import { SerialDeviceSettings } from "../types";
+import { DaumSerialComms } from './types';
+import { SerialIncyclistDevice } from '../base/adapter';
+import SerialInterface from '../base/serial-interface';
+export default class DaumAdapter<S extends SerialDeviceSettings, P extends DeviceProperties, C extends DaumSerialComms> extends SerialIncyclistDevice<P> {
+    protected static controllers: ControllerConfig;
+    comms: C;
     distanceInternal: number;
-    cyclingData: IncyclistBikeData;
-    deviceData: DeviceData;
+    deviceData: IncyclistBikeData;
     requests: Array<any>;
     iv: any;
     tsPrevData: number;
@@ -32,9 +21,9 @@ export default class DaumAdapter<DC extends DaumControl<P>, S extends SerialDevi
     getSerialInterface(): SerialInterface;
     sendInitCommands(): Promise<boolean>;
     getCurrentBikeData(): Promise<IncyclistBikeData>;
-    getBike(): C;
+    getComms(): C;
     isEqual(settings: SerialDeviceSettings): boolean;
-    isSame(device: IncyclistDeviceAdapter): boolean;
+    isSame(device: IAdapter): boolean;
     isStopped(): boolean;
     initData(): void;
     pause(): Promise<boolean>;
@@ -53,13 +42,12 @@ export default class DaumAdapter<DC extends DaumControl<P>, S extends SerialDevi
     reconnect(): Promise<boolean>;
     logEvent(event: any): void;
     stop(): Promise<boolean>;
-    canSendUpdate(): boolean;
     sendUpdate(request: any): Promise<unknown>;
     update(): Promise<void>;
     sendRequests(): Promise<void>;
     bikeSync(): Promise<void>;
     updateData(bikeData: IncyclistBikeData): IncyclistBikeData;
-    transformData(cyclingData: IncyclistBikeData): DeviceData;
+    transformData(cyclingData: IncyclistBikeData): IncyclistAdapterData;
     sendRequest(request: any): Promise<any>;
     refreshRequests(): void;
     processClientRequest(request: any): Promise<unknown>;

package/lib/serial/daum/DaumAdapter.js

@@ -12,28 +12,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DaumControl = void 0;
 const daum_erg_1 = __importDefault(require("../../modes/daum-erg"));
+const utils_1 = require("../../utils/utils");
+const types_1 = require("../../types");
+const adapter_1 = require("../base/adapter");
 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");
-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.DaumControl = DaumControl;
 class DaumAdapter extends adapter_1.SerialIncyclistDevice {
     constructor(settings, props) {
         super(settings, props);
@@ -42,7 +26,7 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
         this.requestBusy = false;
         this.updateBusy = false;
         this.iv = undefined;
-        this.cyclingData = {
+        this.deviceData = {
             isPedalling: false,
             time: 0,
             power: 0,
@@ -51,27 +35,25 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
             distanceInternal: 0,
             heartrate: 0
         };
-        this.deviceData = {};
         this.capabilities = [
-            capabilities_1.IncyclistCapability.Power, capabilities_1.IncyclistCapability.Speed, capabilities_1.IncyclistCapability.Cadence, capabilities_1.IncyclistCapability.Gear, capabilities_1.IncyclistCapability.HeartRate,
-            capabilities_1.IncyclistCapability.Control
+            types_1.IncyclistCapability.Power, types_1.IncyclistCapability.Speed, types_1.IncyclistCapability.Cadence, types_1.IncyclistCapability.Gear, types_1.IncyclistCapability.HeartRate,
+            types_1.IncyclistCapability.Control
         ];
-        this.setControl(new DaumControl(this, props));
     }
     getPort() {
         var _a;
-        return (_a = this.bike) === null || _a === void 0 ? void 0 : _a.getPort();
+        return (_a = this.comms) === null || _a === void 0 ? void 0 : _a.getPort();
     }
     getSerialInterface() {
         var _a;
-        return (_a = this.bike) === null || _a === void 0 ? void 0 : _a.serial;
+        return (_a = this.comms) === 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 daum_erg_1.default) {
-                        const power = this.deviceData.power;
+                        const power = this.data.power;
                         const request = power ? { targetPower: power } : this.getCyclingMode().getBikeInitRequest();
                         yield this.sendUpdate(request);
                         return true;
@@ -87,8 +69,8 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
     getCurrentBikeData() {
         throw new Error('Method not implemented.');
     }
-    getBike() {
-        return this.bike;
+    getComms() {
+        return this.comms;
     }
     isEqual(settings) {
         const as = this.settings;
@@ -111,7 +93,7 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
         this.distanceInternal = undefined;
         this.paused = false;
         this.stopped = false;
-        this.cyclingData = {
+        this.deviceData = {
             isPedalling: false,
             time: 0,
             power: 0,
@@ -120,7 +102,7 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
             distanceInternal: 0,
             heartrate: 0
         };
-        this.deviceData = {};
+        this.data = {};
         this.requests = [];
         const name = this.getCyclingMode().getName();
         const settings = this.getCyclingMode().getSettings();
@@ -132,7 +114,7 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
         });
         return __awaiter(this, void 0, void 0, function* () {
             const paused = yield _super.pause.call(this);
-            this.bike.pauseLogging();
+            this.comms.pauseLogging();
             return paused;
         });
     }
@@ -142,7 +124,7 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
         });
         return __awaiter(this, void 0, void 0, function* () {
             const resumed = yield _super.resume.call(this);
-            this.bike.resumeLogging();
+            this.comms.resumeLogging();
             return resumed;
         });
     }
@@ -249,7 +231,7 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
         }, this.pullFrequency);
         const ivUpdate = setInterval(() => {
             try {
-                this.emitData(this.deviceData);
+                this.emitData(this.data);
                 this.refreshRequests();
             }
             catch (_a) { }
@@ -269,33 +251,33 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
     }
     connect() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.bike)
+            if (!this.comms)
                 return false;
-            if (this.bike.isConnected())
+            if (this.comms.isConnected())
                 return true;
             try {
-                const connected = yield this.bike.connect();
+                const connected = yield this.comms.connect();
                 return connected;
             }
             catch (err) {
-                yield this.bike.close();
+                yield this.comms.close();
                 return false;
             }
         });
     }
     close() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.bike)
+            if (!this.comms)
                 return true;
-            if (!this.bike.isConnected())
+            if (!this.comms.isConnected())
                 return true;
-            return yield this.bike.close();
+            return yield this.comms.close();
         });
     }
     verifyConnection() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.bike.isConnected()) {
-                const connected = yield this.bike.connect();
+            if (!this.comms.isConnected()) {
+                const connected = yield this.comms.connect();
                 if (!connected)
                     throw new Error('not connected');
             }
@@ -304,8 +286,8 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
     reconnect() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                yield this.bike.close();
-                const connected = yield this.bike.connect();
+                yield this.comms.close();
+                const connected = yield this.comms.connect();
                 return connected;
             }
             catch (err) {
@@ -331,7 +313,7 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
                 this.resume();
             try {
                 this.stopUpdatePull();
-                yield this.bike.close();
+                yield this.comms.close();
                 this.logEvent({ message: 'stop request completed' });
                 this.stopped = true;
             }
@@ -342,11 +324,6 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
             return this.stopped;
         });
     }
-    canSendUpdate() {
-        if (this.paused || this.stopped)
-            return false;
-        return super.canSendUpdate();
-    }
     sendUpdate(request) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.paused || this.stopped)
@@ -357,7 +334,7 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
     }
     update() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.canSendUpdate() || this.updateBusy)
+            if (!this.canEmitData() || this.updateBusy)
                 return;
             this.updateBusy = true;
             try {
@@ -370,7 +347,7 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
             catch (err) {
                 try {
                     this.logEvent({ message: 'bike update error', error: err.message, stack: err.stack });
-                    const incyclistData = this.updateData(this.cyclingData);
+                    const incyclistData = this.updateData(this.deviceData);
                     this.transformData(incyclistData);
                 }
                 catch (_a) { }
@@ -425,8 +402,8 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
             data.time = bikeData.time;
         if (bikeData.slope)
             data.slope = bikeData.slope;
-        this.cyclingData = this.getCyclingMode().updateData(data);
-        return this.cyclingData;
+        this.deviceData = this.getCyclingMode().updateData(data);
+        return this.deviceData;
     }
     transformData(cyclingData) {
         let distance = 0;
@@ -446,7 +423,7 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
             deviceTime: cyclingData.time,
             deviceDistanceCounter: cyclingData.distanceInternal
         };
-        this.deviceData = data;
+        this.data = data;
         return data;
     }
     sendRequest(request) {
@@ -454,7 +431,7 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
             this.requestBusy = true;
             try {
                 this.logEvent({ message: 'sendRequest', request });
-                const bike = this.getBike();
+                const bike = this.getComms();
                 const isReset = (!request || request.reset || Object.keys(request).length === 0);
                 if (isReset) {
                     this.requestBusy = false;
@@ -479,7 +456,7 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
     refreshRequests() {
         if (this.isPaused() || this.isStopped())
             return;
-        if (!this.cyclingData.isPedalling || this.cyclingData.pedalRpm === 0)
+        if (!this.deviceData.isPedalling || this.deviceData.pedalRpm === 0)
             return;
         let bikeRequest = this.getCyclingMode().sendBikeUpdate({ refresh: true }) || {};
         const prev = this.requests[this.requests.length - 1] || {};
@@ -490,7 +467,7 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
     }
     processClientRequest(request) {
         if (request.slope !== undefined) {
-            this.cyclingData.slope = request.slope;
+            this.deviceData.slope = request.slope;
         }
         return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
             let bikeRequest = this.getCyclingMode().sendBikeUpdate(request);
@@ -505,4 +482,8 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
         });
     }
 }
+DaumAdapter.controllers = {
+    modes: [daum_erg_1.default, daum_smarttrainer_1.default, daum_power_1.default],
+    default: daum_erg_1.default
+};
 exports.default = DaumAdapter;

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

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

package/lib/serial/daum/classic/PROTOCOL_NAME.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/adapter.d.ts

@@ -1,32 +1,20 @@
-import ICyclingMode, { CyclingMode, IncyclistBikeData } from '../../../modes/types';
-import DaumAdapter, { DaumControl } from '../DaumAdapter';
-import { DeviceProperties } from '../../../types/device';
-import { SerialDeviceSettings } from '../../adapter';
-import { SerialCommProps } from '../../comm';
+import DaumAdapter from '../DaumAdapter';
+import { DaumClassicProperties } from './types';
+import { SerialDeviceSettings, SerialCommProps } from "../../types";
+import { IncyclistBikeData, ControllerConfig } from "../../../types";
 import Daum8008 from './comms';
-export interface DaumClassicDeviceProperties extends DeviceProperties {
-    gear?: number;
-}
-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> {
+export default class DaumClassicAdapter extends DaumAdapter<SerialDeviceSettings, DaumClassicProperties, Daum8008> {
     static NAME: string;
+    protected static controllers: ControllerConfig;
     protected name: string;
     protected id: string;
-    constructor(settings: SerialDeviceSettings, props?: DaumClassicDeviceProperties);
+    constructor(settings: SerialDeviceSettings, props?: DaumClassicProperties);
     getBikeProps(props: SerialDeviceSettings): SerialCommProps;
     getName(): string;
     setName(name: string): void;
     getProtocolName(): string;
     performCheck(): Promise<boolean>;
-    performStart(props?: DaumClassicDeviceProperties, isRelaunch?: boolean): Promise<boolean>;
+    performStart(props?: DaumClassicProperties, isRelaunch?: boolean): Promise<boolean>;
     getCurrentBikeData(): Promise<IncyclistBikeData>;
     getDeviceInfo(): Promise<any>;
 }