incyclist-devices 2.0.35 → 2.0.36

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

@@ -8,401 +8,217 @@ 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 });
-const gd_eventlog_1 = require("gd-eventlog");
-const utils_1 = require("./utils");
-const utils_2 = require("../../../utils/utils");
-const __1 = require("../..");
+const utils_1 = require("../../../utils/utils");
+const comms_1 = __importDefault(require("../../comms"));
+const types_1 = require("../premium/types");
+const utils_2 = require("./utils");
 const ByteLength = require('@serialport/parser-byte-length');
-const nop = () => { };
 const TIMEOUT_SEND = 2000;
-class Daum8008 {
-    constructor(props) {
-        this._timeoutSend = TIMEOUT_SEND;
-        const { logger, serial, path } = props;
-        this.logger = logger || new gd_eventlog_1.EventLogger('DaumClassic');
-        this.portName = path;
-        this.serial = serial;
-        this.spp = (0, __1.useSerialPortProvider)();
-        this.sp = undefined;
-        this.error = undefined;
-        this.opening = false;
-        this.connected = false;
-        this.closing = false;
-        this.closed = undefined;
-        this.cmdBusy = false;
-        this.queue = new utils_2.Queue();
-        this.isLoggingPaused = false;
-    }
-    static setSerialPort(spClass) {
-        __1.SerialPortProvider.getInstance().setLegacyClass('serial', spClass);
-    }
-    static getClassName() {
-        return "Daum8008";
-    }
-    getType() {
-        return "DaumClassic";
-    }
-    getPort() {
-        return this.portName;
+class Daum8008 extends comms_1.default {
+    validatePath(path) {
+        return path;
     }
-    isConnected() {
-        return this.connected;
+    getDefaultLoggerName() {
+        return 'DaumClassic';
     }
-    pauseLogging() {
-        this.isLoggingPaused = true;
+    onConnected() {
     }
-    resumeLogging() {
-        this.isLoggingPaused = false;
+    getTimeoutValue() {
+        return TIMEOUT_SEND;
     }
-    logEvent(e) {
-        if (!this.isLoggingPaused)
-            this.logger.logEvent(e);
-        const w = global.window;
-        if (w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) {
-            console.log('~~~ DaumClassic', e);
-        }
+    initForResponse(expected) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const parser = this.portPipe(new ByteLength({ length: expected }));
+            if (!parser)
+                return;
+            parser.on('data', (data) => {
+                this.portUnpipe();
+                this.recvState.data.enqueue({ type: 'Response', data });
+            });
+        });
     }
-    connect() {
+    waitForResponse() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.isConnected() && this.sp) {
-                return true;
-            }
-            try {
-                this.logEvent({ message: 'connect attempt', port: this.portName });
-                const port = yield this.serial.openPort(this.portName);
-                if (port !== null) {
-                    this.logEvent({ message: 'connect success', port: this.portName });
-                    this.connected = true;
-                    this.sp = port;
-                    this.sp.on('close', this.onPortClose.bind(this));
-                    this.sp.on('error', this.onPortError.bind(this));
-                    return true;
-                }
-                else {
-                    this.logEvent({ message: 'connect failure' });
-                    return false;
+            const timeout = this.getTimeoutValue();
+            let waitingForResponse = true;
+            let start = Date.now();
+            let tsTimeout = start + timeout;
+            while (waitingForResponse && Date.now() < tsTimeout) {
+                const response = this.recvState.data.dequeue();
+                if (response) {
+                    return response;
                 }
+                yield (0, utils_1.sleep)(5);
             }
-            catch (err) {
-                this.logEvent({ message: 'connect failure', reason: err.message });
-                return false;
+            throw new types_1.ResponseTimeout();
+        });
+    }
+    doSend(expected, payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.initForResponse(expected);
+            yield this.write(Buffer.from(payload));
+            const response = yield this.waitForResponse();
+            if (response.type === 'Error')
+                throw response.error;
+            if (response.data[0] !== payload[0]) {
+                this.portFlush();
+                throw new Error('illegal response');
             }
+            return response;
         });
     }
-    close() {
+    send(request) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.serial)
-                return;
-            this.closing = true;
-            this.stopWorker();
-            if (this.isConnected()) {
+            const { expected, command, logString } = request;
+            const payload = Array.isArray(command) ? new Uint8Array(command) : command;
+            let logPayload = {
+                port: this.path,
+                cmd: logString || 'BinaryCommand',
+            };
+            yield this.ensurePrevCmdFinish(logPayload);
+            this.sendCmdPromise = new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
                 try {
-                    yield this.flush();
+                    this.logEvent(Object.assign(Object.assign({ message: "sendCommand:sending:" }, logPayload), { hex: Buffer.from(payload).toString('hex') }));
+                    yield this.ensureConnection();
+                    const res = yield this.doSend(expected, payload);
+                    this.logEvent(Object.assign(Object.assign({ message: "sendCommand:received:" }, logPayload), { hex: Buffer.from(res.data).toString('hex') }));
+                    this.sendCmdPromise = null;
+                    resolve(res);
                 }
-                catch (_a) { }
-                try {
-                    yield this.serial.closePort(this.portName);
+                catch (err) {
+                    this.logEvent(Object.assign(Object.assign({ message: "sendCommand:error:" }, logPayload), { error: err.message }));
+                    this.sendCmdPromise = null;
+                    reject(err);
                 }
-                catch (_b) { }
-            }
-            this.connected = false;
-            this.cmdBusy = false;
-            if (this.sp) {
-                this.sp.removeAllListeners();
-                this.sp = null;
-            }
-            this.error = undefined;
-            this.closing = false;
-            this.closed = true;
-            return;
+            }));
+            return this.sendCmdPromise;
         });
     }
-    flush() {
+    sendCommand(logString, command, expected) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.cmdBusy)
-                return;
-            return new Promise(done => {
-                const tsStart = Date.now();
-                const iv = setInterval(() => {
-                    if (!this.cmdBusy || (Date.now() - tsStart > TIMEOUT_SEND + 500)) {
-                        clearInterval(iv);
-                        done();
-                    }
-                }, 100);
-            });
+            const response = yield this.send({ logString, command, expected });
+            return response.data;
         });
     }
-    onPortClose() {
+    checkCockpit(bikeNo = 0) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: "port closed", port: this.getPort() });
-            yield this.close();
-        });
-    }
-    onPortError(err) {
-        if (this.closed && !this.opening)
-            return;
-        if ((this.closing || this.closed) && (err.message === 'Port is not open' || err.message === 'Writing to COM port (GetOverlappedResult): Operation aborted'))
-            return;
-        const state = { opening: this.opening, connected: this.connected, closing: this.closing, closed: this.closed, busy: this.cmdBusy };
-        this.logEvent({ message: "port error:", port: this.getPort(), error: err.message, state });
-        this.error = err;
-        this.cmdBusy = false;
-    }
-    startWorker() {
-        this.bikeCmdWorker = setInterval(() => {
-            this.sendDaum8008CommandfromQueue();
-        }, 50);
-    }
-    stopWorker() {
-        this.logEvent({ message: "stop worker", port: this.getPort() });
-        if (this.queue !== undefined)
-            this.queue.clear();
-        if (this.bikeCmdWorker !== undefined) {
-            clearInterval(this.bikeCmdWorker);
-            this.bikeCmdWorker = undefined;
-        }
-    }
-    sendDaum8008CommandfromQueue() {
-        if (!this.connected || this.closing || !this.sp)
-            return;
-        if (this.cmdStart !== undefined && this.error !== undefined) {
-            if (this.cmdStart !== undefined) {
-                const cmdInfo = this.cmdCurrent;
-                var retry = 0;
-                if (cmdInfo.options !== undefined && cmdInfo.options.retries !== undefined) {
-                    retry = this.cmdCurrent.options.retries;
-                }
-                if (cmdInfo.callbackErr !== undefined && retry === 0) {
-                    let cb = cmdInfo.callbackErr;
-                    let error = this.error;
-                    this.cmdBusy = false;
-                    this.cmdCurrent = undefined;
-                    this.cmdStart = undefined;
-                    this.error = undefined;
-                    return cb(500, { message: error });
-                }
+            try {
+                const data = yield this.sendCommand(`checkCockpit(${bikeNo})`, [0x10, bikeNo], 3);
+                return { bike: data[1], version: data[2] };
             }
-        }
-        if (this.connected && this.cmdBusy && !this.closing) {
-            if (this.cmdCurrent !== undefined && this.cmdCurrent.start !== undefined) {
-                const cmdInfo = this.cmdCurrent;
-                const timeout = (cmdInfo.options && cmdInfo.options.timeout) ? cmdInfo.options.timeout : this._timeoutSend;
-                let d = Date.now() - cmdInfo.start;
-                if (d > timeout) {
-                    this.logEvent({ message: 'sendCommmand:timeout', port: this.getPort() });
-                    const port = this.sp;
-                    port.unpipe();
-                    port.flush();
-                    if (this.cmdCurrent.callbackErr !== undefined) {
-                        let cb = this.cmdCurrent.callbackErr;
-                        this.cmdBusy = false;
-                        this.cmdCurrent = undefined;
-                        this.cmdStart = undefined;
-                        return cb(408, { message: "timeout" });
-                    }
-                }
+            catch (err) {
+                if (err instanceof types_1.ResponseTimeout)
+                    return { bike: bikeNo, version: undefined };
+                throw err;
             }
-            return;
-        }
-        else {
-        }
-        if (this.cmdBusy)
-            return;
-        if (this.queue === undefined || this.queue.isEmpty()) {
-            return;
-        }
-        const cmd = this.queue.dequeue();
-        if (this.connected && !this.closing && !this.closed)
-            this.send(cmd);
-    }
-    sendDaum8008Command(logStr, payload, expected, callback, callbackErr, options) {
-        let cmdInfo = {
-            logStr,
-            payload,
-            expected,
-            callback: callback || nop,
-            callbackErr: callbackErr || nop,
-            options: options
-        };
-        this.queue.enqueue(cmdInfo);
-        if (this.queue.size() > 1)
-            this.logEvent({ message: "sendCommand:adding:", cmd: logStr, hex: (0, utils_1.hexstr)(payload), queueSize: this.queue.size() });
-        if (this.bikeCmdWorker === undefined) {
-            this.startWorker();
-        }
-    }
-    send(cmdInfo) {
-        this.cmdBusy = true;
-        this.cmdCurrent = cmdInfo;
-        const { logStr, payload, expected, callback, callbackErr } = cmdInfo;
-        const done = () => {
-            this.cmdBusy = false;
-            this.cmdCurrent = undefined;
-            this.cmdStart = undefined;
-        };
-        try {
-            const serialPort = this.sp;
-            const parser = serialPort.pipe(new ByteLength({ length: expected }));
-            parser.on('data', (data) => {
-                let duration = Date.now() - this.cmdStart;
-                this.logEvent({ message: "sendCommand:received:", duration, hex: (0, utils_1.hexstr)(data), port: this.getPort() });
-                serialPort.unpipe();
-                if (callbackErr !== undefined) {
-                    if (data[0] !== payload[0]) {
-                        serialPort.flush();
-                        this.logEvent({ message: "sendCommand:illegal response", port: this.getPort() });
-                        done();
-                        return callbackErr(512, { message: "illegal response" });
-                    }
-                }
-                callback(data);
-                done();
-            });
-            this.logEvent({ message: "sendCommand:sending:", cmd: logStr, hex: (0, utils_1.hexstr)(payload), port: this.getPort() });
-            this.cmdCurrent.start = this.cmdStart = Date.now();
-            serialPort.write(payload);
-        }
-        catch (err) {
-            this.logEvent({ message: "sendCommand:error:", error: err.message, port: this.getPort() });
-            done();
-            callbackErr(500, { message: `Exception: ${err.message}` });
-        }
-    }
-    checkCockpit(bikeNo = 0) {
-        return new Promise((resolve, reject) => {
-            this.sendDaum8008Command(`checkCockpit(${bikeNo})`, [0x10, bikeNo], 3, (data) => resolve({ bike: data[1], version: data[2] }), (status, err) => {
-                if (status === 408)
-                    return resolve({ bike: bikeNo, version: undefined });
-                reject((0, utils_1.buildError)(status, err));
-            });
         });
     }
     getAddress() {
-        return new Promise((resolve, reject) => {
-            this.sendDaum8008Command(`getAddress()`, [0x11], 2, (data) => resolve({ bike: data[1] }), (status, err) => reject((0, utils_1.buildError)(status, err)));
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.sendCommand(`getAddress()`, [0x11], 2);
+            return { bike: data[1] };
         });
     }
     getVersion(bikeNo = 0) {
-        return new Promise((resolve, reject) => {
-            this.sendDaum8008Command(`getVersion(${bikeNo})`, [0x73, bikeNo], 11, (data) => resolve({ bike: data[1], serialNo: (0, utils_1.hexstr)(data, 2, 8), cockpit: (0, utils_1.getCockpit)(data[10]) }), (status, err) => reject((0, utils_1.buildError)(status, err)));
+        return __awaiter(this, void 0, void 0, function* () {
+            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) {
-        return new Promise((resolve, reject) => {
-            this.sendDaum8008Command(`resetDevice(${bikeNo})`, [0x12, bikeNo], 2, (data) => resolve({}), (status, err) => reject((0, utils_1.buildError)(status, err)));
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.sendCommand(`resetDevice(${bikeNo})`, [0x12, bikeNo], 2);
+            return { bike: data[1] };
         });
     }
     startProg(bikeNo = 0) {
-        return new Promise((resolve, reject) => {
-            this.sendDaum8008Command(`startProg(${bikeNo})`, [0x21, bikeNo], 3, (data) => resolve({ bike: data[1], pedalling: data[2] > 0 }), (status, err) => reject((0, utils_1.buildError)(status, err)));
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.sendCommand(`startProg(${bikeNo})`, [0x21, bikeNo], 3);
+            return { bike: data[1], pedalling: data[2] > 0 };
         });
     }
     stopProg(bikeNo = 0) {
-        return new Promise((resolve, reject) => {
-            this.sendDaum8008Command(`stopProg(${bikeNo})`, [0x22, bikeNo], 3, (data) => resolve({ bike: data[1], pedalling: data[2] !== 0 }), (status, err) => reject((0, utils_1.buildError)(status, err)));
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.sendCommand(`stopProg(${bikeNo})`, [0x22, bikeNo], 3);
+            return { bike: data[1], pedalling: data[2] > 0 };
         });
     }
     setProg(progNo = 0, bikeNo = 0) {
-        return new Promise((resolve, reject) => {
-            this.sendDaum8008Command(`setProg(${bikeNo},${progNo})`, [0x23, bikeNo, progNo], 4, (data) => resolve({ bike: data[1], progNo: data[2], pedalling: data[3] !== 0 }), (status, err) => reject((0, utils_1.buildError)(status, err)));
+        return __awaiter(this, void 0, void 0, function* () {
+            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) {
-        const bikeVal = (0, utils_1.getBikeType)(bikeType);
-        return new Promise((resolve, reject) => {
-            this.sendDaum8008Command(`setBikeType(${bikeNo},${bikeType})`, [0x69, bikeNo, 0, 0, bikeVal], 3, (data) => resolve({}), (status, err) => reject((0, utils_1.buildError)(status, err)));
+        return __awaiter(this, void 0, void 0, function* () {
+            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) {
-        const age = user.age !== undefined ? user.age : utils_1.DEFAULT_AGE;
-        const gender = (0, utils_1.getGender)(user.sex);
-        const length = (0, utils_1.getLength)(user.length);
-        const maxPower = 800;
-        const mUser = user.weight;
-        const weight = (0, utils_1.getWeight)(mUser) + 10;
-        var cmd = [0x24, bikeNo, 0];
-        cmd.push(age);
-        cmd.push(gender);
-        cmd.push(length);
-        cmd.push(weight);
-        cmd.push(0);
-        cmd.push(0);
-        cmd.push(3);
-        cmd.push(Math.round(maxPower / 5));
-        cmd.push(0);
-        cmd.push(0);
-        cmd.push(0);
-        cmd.push(0);
-        return new Promise((resolve, reject) => {
-            this.sendDaum8008Command(`setPerson(${bikeNo},${age},${gender},${length},${weight})`, cmd, 16, (data) => {
-                let ok = true;
-                cmd.forEach((v, i) => {
-                    if (data[i] !== v) {
-                        if (i === 10 && v >= 160) {
-                            if (data[i] === 0 || data[i] === 80)
-                                return;
-                        }
-                        reject((0, utils_1.buildError)(512, 'illegal response'));
-                        ok = false;
+        return __awaiter(this, void 0, void 0, function* () {
+            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);
+            const maxPower = 800;
+            const mUser = user.weight;
+            const weight = (0, utils_2.getWeight)(mUser) + 10;
+            var cmd = [0x24, bikeNo, 0];
+            cmd.push(age);
+            cmd.push(gender);
+            cmd.push(length);
+            cmd.push(weight);
+            cmd.push(0);
+            cmd.push(0);
+            cmd.push(3);
+            cmd.push(Math.round(maxPower / 5));
+            cmd.push(0);
+            cmd.push(0);
+            cmd.push(0);
+            cmd.push(0);
+            const data = yield this.sendCommand(`setPerson(${bikeNo},${age},${gender},${length},${weight})`, cmd, 16);
+            cmd.forEach((v, i) => {
+                if (data[i] !== v) {
+                    if (i === 10 && v >= 160) {
+                        if (data[i] === 0 || data[i] === 80)
+                            return;
                     }
-                });
-                if (ok)
-                    resolve({ bike: data[1], age, gender, length, weight });
-            }, (status, err) => reject((0, utils_1.buildError)(status, err)));
+                    throw new Error('illegal response');
+                }
+            });
+            return ({ bike: data[1], age, gender, length, weight });
         });
     }
     runData(bikeNo = 0) {
-        return new Promise((resolve, reject) => {
-            this.sendDaum8008Command(`runData(${bikeNo})`, [0x40, bikeNo], 19, (data) => {
-                try {
-                    const parsed = (0, utils_1.parseRunData)(data);
-                    resolve(parsed);
-                }
-                catch (e) {
-                    reject((0, utils_1.buildError)(500, e));
-                }
-            }, (status, err) => reject((0, utils_1.buildError)(status, err)));
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.sendCommand(`runData(${bikeNo})`, [0x40, bikeNo], 19);
+            return (0, utils_2.parseRunData)(data);
         });
     }
     setGear(gear, bikeNo = 0) {
-        let gearVal = gear;
-        if (gear === undefined || gear < 1)
-            gearVal = 1;
-        if (gear > 28)
-            gearVal = 28;
-        return new Promise((resolve, reject) => {
-            this.sendDaum8008Command(`setGear(${bikeNo},${gearVal})`, [0x53, bikeNo, gearVal], 3, (data) => resolve({ bike: data[1], gear: data[2] }), (status, err) => reject((0, utils_1.buildError)(status, err)));
+        return __awaiter(this, void 0, void 0, function* () {
+            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) {
-        return new Promise((resolve, reject) => {
-            if (power === undefined) {
-                resolve({});
-                return;
-            }
-            let powerRequest = power;
-            if (power < 25)
-                powerRequest = 25;
-            if (power > 800)
-                powerRequest = 800;
-            const powerVal = Math.round(powerRequest / 5);
-            this.sendDaum8008Command(`setPower(${bikeNo},${power})`, [0x51, bikeNo, powerVal], 3, (data) => resolve({ bike: data[1], power: (data[2] * 5) }), (status, err) => reject((0, utils_1.buildError)(status, err)));
+        return __awaiter(this, void 0, void 0, function* () {
+            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) {
-        return new Promise((resolve, reject) => {
-            if (slope === undefined) {
-                resolve({});
-                return;
-            }
-            const cmd = [0x55, bikeNo];
-            const arr = (0, utils_1.Float32ToIntArray)(slope);
-            cmd.push(arr[3]);
-            cmd.push(arr[2]);
-            cmd.push(arr[1]);
-            cmd.push(arr[0]);
-            this.sendDaum8008Command(`setSlope(${bikeNo},${slope})`, cmd, 6, (data) => resolve({ bike: data[1], slope: slope }), (status, err) => reject((0, utils_1.buildError)(status, err)));
+        return __awaiter(this, void 0, void 0, function* () {
+            const cmd = (0, utils_2.buildSetSlopeCommand)(bikeNo, slope);
+            const data = yield this.sendCommand(`setSlope(${bikeNo},${slope})`, cmd, 6);
+            return ({ bike: data[1], slope });
         });
     }
 }

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

@@ -77,7 +77,7 @@ class DaumClassicMockImpl {
 exports.DaumClassicMockImpl = DaumClassicMockImpl;
 const DEFAULT_BIKE_DATA = {
     cockpitVersion: 3,
-    serialNo: '4464:<;8',
+    serialNo: '3434353d3b383c3b',
     cockpitType: 50,
     isPedalling: false,
     bikeType: 0,
@@ -212,8 +212,10 @@ class DaumClassicMockBinding extends binding_mock_1.MockPortBinding {
         if (bikeNo >= 0 && bikeNo < 10) {
             const { cockpitType, serialNo } = this.simulator.bikes[bikeNo] || {};
             const response = Buffer.from([0x73, bikeNo, 0, 0, 0, 0, 0, 0, 0, 0, cockpitType]);
-            for (let i = 0; i < serialNo.length && i < 8; i++)
-                response.writeUInt8(serialNo.charCodeAt(i), i + 2);
+            for (let i = 0; i < serialNo.length && i < 8; i++) {
+                const s = new Uint8Array(Buffer.from(serialNo, 'hex'));
+                response.writeUInt8(s[i], i + 2);
+            }
             this.emitData(response);
         }
     }

package/lib/serial/daum/classic/modes/daum-classic.d.ts

@@ -1,8 +1,8 @@
 import CyclingMode, { CyclingModeProperty, IncyclistBikeData, Settings, UpdateRequest } from "../../../../modes/cycling-mode";
 import SmartTrainerCyclingMode from "../../SmartTrainerCyclingMode";
-import DaumAdapter from "../../DaumAdapter";
+import { ControllableDevice } from "../../../../base/adpater";
 export default class DaumClassicCyclingMode extends SmartTrainerCyclingMode implements CyclingMode {
-    constructor(adapter: DaumAdapter, props?: Settings);
+    constructor(adapter: ControllableDevice, props?: Settings);
     getName(): string;
     getDescription(): string;
     getProperties(): CyclingModeProperty[];

package/lib/serial/daum/classic/modes/daum-classic.js

@@ -16,7 +16,7 @@ const config = {
 class DaumClassicCyclingMode extends SmartTrainerCyclingMode_1.default {
     constructor(adapter, props) {
         super(adapter, props);
-        this.logger = adapter ? adapter.logger : undefined;
+        this.logger = adapter ? adapter.getLogger() : undefined;
         if (!this.logger)
             this.logger = new gd_eventlog_1.EventLogger('DaumClassic');
     }

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

@@ -0,0 +1,59 @@
+import { IncyclistBikeData } from "../../..";
+import { DaumBikeData, DeviceProperties } from "../../../types/device";
+import { Queue } from "../../../utils/utils";
+import { Request, Response } from "../../comms";
+export type DaumClassiAdapterProps = {
+    path: string;
+    ifaceName?: string;
+};
+export interface DaumClassicDeviceProperties extends DeviceProperties {
+    gear?: number;
+}
+export interface DaumClassicRequest extends Request {
+    expected: number;
+    command: number[] | Uint8Array;
+}
+export interface DaumClassicResponse extends Response {
+    type: ResponseType;
+    data?: Uint8Array;
+    error?: Error;
+}
+export interface DaumClassicBikeData extends DaumBikeData {
+}
+export type ResponseType = 'Response' | 'Error';
+export type DaumClassicCommsState = {
+    data: Queue<DaumClassicResponse>;
+};
+export type ClassicBikeResponse = {
+    bike: number;
+};
+export interface checkCockpitReponse extends ClassicBikeResponse {
+    version?: number;
+}
+export interface GetVersionReponse extends ClassicBikeResponse {
+    serialNo: string;
+    cockpit: string;
+}
+export interface SetPersonResponse extends ClassicBikeResponse {
+    gender: number;
+    age: number;
+    weight: number;
+    length: number;
+}
+export interface ProgResponse extends ClassicBikeResponse {
+    pedalling: boolean;
+}
+export interface SetProgResponse extends ProgResponse {
+    progNo: number;
+}
+export interface SetPowerRepsonse extends ClassicBikeResponse {
+    power: number;
+}
+export interface SetGearRepsonse extends ClassicBikeResponse {
+    gear: number;
+}
+export interface SetSlopeRepsonse extends ClassicBikeResponse {
+    slope: number;
+}
+export interface GetRunDataRepsonse extends ClassicBikeResponse, IncyclistBikeData {
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });