incyclist-devices 1.3.0 → 1.4.1

package/lib/daum/premium/bike.js

@@ -8,46 +8,50 @@ 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.Daum8iSerial = exports.Daum8iTcp = void 0;
-const indoorbike_js_1 = require("../indoorbike.js");
-const constants_js_1 = require("../constants.js");
-const tcpserial_1 = require("./tcpserial");
+const constants_1 = require("../constants");
+const tcpserial_1 = __importDefault(require("./tcpserial"));
 const utils_1 = require("./utils");
-const utils_2 = require("../../utils");
 const gd_eventlog_1 = require("gd-eventlog");
 const nop = () => { };
 const MAX_RETRIES = 5;
 const DEFAULT_TIMEOUT = 10000;
 const DEFAULT_SEND_DELAY = 1000;
-const OPEN_RETRY_DELAY = 3000;
-const CLOSE_RETRY_TIMEOUT = 5000;
 const TIMEOUT_START = 15000;
+const OPEN_TIMEOUT = 1000;
 const DAUM_PREMIUM_DEFAULT_PORT = 51955;
 const DAUM_PREMIUM_DEFAULT_HOST = '127.0.0.1';
 var __SerialPort = undefined;
 var net = undefined;
+const DEBUG_LOGGER = {
+    log: (e, ...args) => console.log(e, ...args),
+    logEvent: (event) => console.log(JSON.stringify(event))
+};
 class Daum8i {
     constructor(props) {
-        const opts = props || {};
-        this.LOG = new gd_eventlog_1.EventLogger('DaumPremium');
-        this.LOG.logEvent({ message: 'new DaumPremium object', opts });
-        if (opts.interface === 'tcpip') {
-            const port = opts.port || DAUM_PREMIUM_DEFAULT_PORT;
-            const host = opts.host || DAUM_PREMIUM_DEFAULT_HOST;
-            this.portName = `${host}:${port}`;
+        this.props = props || {};
+        this.logger = process.env.DEBUG ? DEBUG_LOGGER : new gd_eventlog_1.EventLogger('DaumPremium');
+        this.logger.logEvent({ message: 'new DaumPremium object', props: this.props });
+        if (this.props.interface === 'tcpip') {
+            const port = this.props.port || DAUM_PREMIUM_DEFAULT_PORT;
+            const host = this.props.host || DAUM_PREMIUM_DEFAULT_HOST;
+            this.portName = `${host}:51955`;
             this.tcpip = true;
             this.serial = false;
             this.tcpipConnection = { host, port };
         }
         else {
-            this.portName = opts.port || process.env.COM_PORT;
+            this.portName = this.props.port || process.env.COM_PORT;
             this.tcpip = false;
             this.serial = true;
             this.port = this.portName;
         }
-        this.settings = opts.settings || {};
-        this.settings.logger = this.LOG;
+        this.settings = this.props.settings || {};
+        this.settings.logger = this.logger;
         this.sendRetryDelay = DEFAULT_SEND_DELAY;
         this.sp = undefined;
         this.connected = false;
@@ -61,7 +65,6 @@ class Daum8i {
             bikeWeight: 10,
             maxPower: 800
         };
-        this.processor = new indoorbike_js_1.default(this);
     }
     static getClassName() {
         return "Daum8i";
@@ -76,7 +79,7 @@ class Daum8i {
         net = netClass;
     }
     static getSupportedInterfaces() {
-        return [constants_js_1.BIKE_INTERFACE.SERIAL, constants_js_1.BIKE_INTERFACE.TCPIP];
+        return [constants_1.BIKE_INTERFACE.SERIAL, constants_1.BIKE_INTERFACE.TCPIP];
     }
     getPort() {
         return this.portName;
@@ -85,7 +88,7 @@ class Daum8i {
         return this.connected;
     }
     setUser(user, callback) {
-        this.LOG.logEvent({ message: "setUser()", user, port: this.portName });
+        this.logger.logEvent({ message: "setUser()", user, port: this.portName });
         this.settings.user = user || {};
         var cb = callback || nop;
         cb(200, user);
@@ -101,43 +104,49 @@ class Daum8i {
     unblock() {
         this.blocked = false;
     }
-    connect(retry) {
-        this.LOG.logEvent({ message: "connect()", sp: (this.sp !== undefined), port: this.portName, retry, settings: this.settings, scanMode: this.scanMode });
+    connect() {
+        this.logger.logEvent({ message: "connect()", sp: (this.sp !== undefined), connected: this.connected, blocked: this.blocked, port: this.portName, settings: this.settings });
         if (this.connected || this.blocked) {
             return;
         }
         this.state.busy = true;
         this.state.commandsInQueue = {};
         try {
+            if (this.sp !== undefined) {
+                try {
+                    this.sp.removeAllListeners();
+                    this.sp.close();
+                }
+                catch (err) {
+                }
+                this.sp = undefined;
+            }
             if (this.sp === undefined) {
                 if (this.tcpip) {
                     const { host, port } = this.tcpipConnection;
-                    this.sp = new tcpserial_1.default({ host, port, net });
+                    const { logger } = this.props;
+                    this.logger.logEvent({ message: "creating TCPSocketPort", host, port });
+                    this.sp = new tcpserial_1.default({ host, port, net, timeout: OPEN_TIMEOUT, logger });
                 }
                 else {
                     const settings = this.settings.port || {};
                     settings.autoOpen = false;
+                    this.logger.logEvent({ message: "creating SerialPort", port: this.port, settings });
                     this.sp = new __SerialPort(this.port, settings);
                 }
                 this.sp.on('open', this.onPortOpen.bind(this));
                 this.sp.on('close', this.onPortClose.bind(this));
                 this.sp.on('error', (error) => { this.onPortError(error); });
                 this.sp.on('data', (data) => { this.onData(data); });
-                this.firstOpen = true;
             }
             const start = Date.now();
             this.state.connecting = true;
-            if (!this.state.opening)
-                this.state.opening = { start, timeout: start + this.getTimeoutValue(), retry: 0, maxRetries: MAX_RETRIES };
-            else {
-                this.state.opening.start = start;
-                this.state.opening.timeout = start + this.getTimeoutValue();
-                this.state.opening.retry = this.state.opening.retry + 1;
-            }
+            this.state.opening = { start, timeout: start + this.getTimeoutValue() };
+            this.logger.logEvent({ message: "opening port ..." });
             this.sp.open();
         }
         catch (err) {
-            this.LOG.logEvent({ message: "scan:error:", error: err.message, stack: err.stack });
+            this.logger.logEvent({ message: "scan:error:", error: err.message, stack: err.stack });
             this.state.busy = false;
         }
     }
@@ -156,7 +165,13 @@ class Daum8i {
             this.connect();
             const tTimeout = Date.now() + TIMEOUT_START;
             const iv = setInterval(() => {
-                if (this.isConnected()) {
+                if (this.state.error !== undefined) {
+                    clearInterval(iv);
+                    this.forceClose();
+                    reject(this.state.error);
+                    this.state = { opened: false, closed: true, busy: false };
+                }
+                else if (this.isConnected()) {
                     this.state.connecting = false;
                     resolve(true);
                     clearInterval(iv);
@@ -164,8 +179,9 @@ class Daum8i {
                 else {
                     if (Date.now() > tTimeout) {
                         this.state.connecting = false;
-                        reject(new Error('timeout'));
+                        this.forceClose();
                         clearInterval(iv);
+                        reject(new Error('timeout'));
                     }
                 }
             }, 100);
@@ -177,10 +193,10 @@ class Daum8i {
         this.state.opening = undefined;
         this.state.opened = true;
         this.state.busy = false;
-        this.LOG.logEvent({ message: "port opened", port: this.portName });
+        this.logger.logEvent({ message: "port opened", port: this.portName });
     }
     onPortClose() {
-        this.LOG.logEvent({ message: "port closed", port: this.portName });
+        this.logger.logEvent({ message: "port closed", port: this.portName });
         this.error = undefined;
         this.connected = false;
         if (this.state.opening) {
@@ -190,81 +206,56 @@ class Daum8i {
         else {
             this.state = { opened: false, closed: true, busy: false };
         }
+        this.sp.removeAllListeners();
         this.sp = undefined;
         if (this.queue !== undefined)
             this.queue.clear();
     }
+    getLogState() {
+        let s = undefined;
+        const { sending, busy, opening, connecting, writeBusy, waitingForStart, waitingForAck, waitingForEnd, retry } = this.state;
+        if (sending) {
+            s = {};
+            s.command = sending.command;
+            s.payload = sending.payload;
+        }
+        return { sending: s, busy, writeBusy, opening, connecting, waitingForStart, waitingForEnd, waitingForAck, retry };
+    }
     onPortError(error) {
-        this.LOG.logEvent({ message: "port error:", port: this.portName, error: error.message, connected: this.connected, state: this.state });
+        this.logger.logEvent({ message: "port error:", port: this.portName, error: error.message, connected: this.connected, state: this.getLogState() });
         this.error = error;
         if (this.blocked) {
             if (!this.state.closed) {
-                if (this.sp)
+                if (this.sp) {
+                    this.sp.removeAllListeners();
                     this.sp.close();
+                    this.sp = undefined;
+                }
                 this.state = { opened: false, closed: true, busy: false };
             }
             return;
         }
-        const reconnect = () => {
-            if (this.state.opening && !this.state.closing) {
-                this.LOG.logEvent({ message: "retry connection:", portName: this.port, connected: this.connected, scanMode: this.scanMode });
-                this.connect(true);
-            }
-        };
         if (this.state.closing) {
             if (error.message === 'Port is not open') {
                 this.state = { opened: false, closed: true, busy: false };
                 return;
             }
             else {
-                const { retry, maxRetries } = this.state.closing;
-                if ((retry + 1 < maxRetries)) {
-                    this.state.closing.retry = retry + 1;
-                    return setTimeout(() => { this.close(); }, CLOSE_RETRY_TIMEOUT);
-                }
-                else {
-                    this.LOG.logEvent({ message: "close request failed - giving up", port: this.portName });
-                    this.state.closing = undefined;
-                }
+                this.forceClose();
             }
         }
         else if (this.state.opening) {
-            if (!this.state.connect) {
-                const { retry, maxRetries } = this.state.opening;
-                try {
-                    if (this.sp)
-                        this.sp.close();
-                }
-                catch (err) {
-                    console.log(err);
-                }
-                if ((retry + 1) < maxRetries) {
-                    this.state.opening.retry = retry + 1;
-                    setTimeout(() => {
-                        if (!this.state.busy)
-                            reconnect();
-                        else {
-                            const iv = setInterval(() => {
-                                if (!this.state.busy) {
-                                    clearInterval(iv);
-                                    reconnect();
-                                }
-                            }, 50);
-                        }
-                    }, OPEN_RETRY_DELAY);
-                }
-                else {
-                    this.state.opening = undefined;
-                }
+            if (this.state.connecting) {
+                this.state.error = error;
             }
             else {
                 this.onPortOpen();
             }
         }
         else if (this.state.sending) {
-            this.LOG.logEvent({ message: "closing port", port: this.portName });
-            this.sp.close();
-            this.state = { opened: true, closed: false, busy: true };
+            this.state.error = error;
+            this.forceClose(false);
+            return;
         }
         this.state.busy = false;
     }
@@ -286,36 +277,46 @@ class Daum8i {
             }, 50);
         });
     }
-    close() {
-        this.LOG.logEvent({ message: 'close request', port: this.portName });
-        var port = this.sp;
-        if (this.bikeCmdWorker !== undefined) {
-            this.LOG.logEvent({ message: "stopping worker", port: this.portName });
-            clearInterval(this.bikeCmdWorker);
-            this.bikeCmdWorker = undefined;
+    forceClose(updateState = false) {
+        const sp = this.sp;
+        if (!this.sp)
+            return;
+        this.sp.removeAllListeners();
+        try {
+            sp.unpipe();
+            sp.flush();
         }
+        catch (_a) { }
+        sp.close();
+        this.connected = false;
+        if (updateState)
+            this.state = { opened: false, closed: true, busy: false };
+    }
+    close() {
+        this.logger.logEvent({ message: 'close request', port: this.portName });
+        var sp = this.sp;
         let connected = this.connected;
         try {
             if (connected) {
-                if (port) {
-                    port.unpipe();
-                    port.flush();
-                    port.close();
+                if (sp) {
+                    sp.unpipe();
+                    sp.flush();
+                    sp.close();
                 }
-                this.connected = false;
                 if (this.queue !== undefined) {
                     this.queue.clear();
                     this.queue = undefined;
                 }
             }
             else {
-                if (port)
-                    port.close();
+                if (sp)
+                    sp.close();
             }
         }
         catch (err) {
-            this.LOG.logEvent({ message: 'close: Exception', port: this.portName, error: err.message });
+            this.logger.logEvent({ message: 'close: Exception', port: this.portName, error: err.message });
         }
+        this.connected = false;
         const start = Date.now();
         if (this.state.closing === undefined)
             this.state.closing = { start, timeout: start + this.getTimeoutValue(), retry: 0, maxRetries: MAX_RETRIES };
@@ -327,7 +328,7 @@ class Daum8i {
         this.state.busy = false;
     }
     sendTimeout(message) {
-        this.LOG.logEvent({ message: `sendCommand:${message || 'timeout'}`, port: this.portName, cmd: this.cmdCurrent });
+        this.logger.logEvent({ message: `sendCommand:${message || 'timeout'}`, port: this.portName, cmd: this.cmdCurrent });
         delete this.state.commandsInQueue[this.cmdCurrent.command];
         if (this.cmdCurrent.callbackErr !== undefined) {
             let cb = this.cmdCurrent.callbackErr;
@@ -337,29 +338,39 @@ class Daum8i {
             cb(408, { message: message || "timeout" });
         }
     }
-    checkForTimeout(reject) {
+    checkForResponse() {
         const d = Date.now();
         const s = this.state.sending;
         if (s === undefined)
-            return;
+            return false;
+        const rejectFn = s.reject;
+        const reject = (err) => {
+            if (rejectFn && typeof rejectFn === 'function') {
+                rejectFn(err);
+            }
+        };
+        const error = this.state.error;
+        if (error !== undefined) {
+            reject(error);
+            return false;
+        }
         try {
-            if (!this.state.sending)
-                return;
             if (this.state.waitingForACK) {
                 const timeoutACK = this.state.ack ? this.state.ack.timeout : this.state.sending.timeout;
                 if (d < timeoutACK)
-                    return;
+                    return true;
                 reject(new Error('ACK timeout'));
-                return;
+                return false;
             }
             if (d < this.state.sending.timeout)
-                return;
-            reject(new Error('timeout'));
-            return;
+                return true;
+            reject(new Error('RESP timeout'));
+            return false;
         }
         catch (err) {
-            this.LOG.logEvent({ message: 'checkForTimeout: Exception', port: this.portName, error: err.message, stack: err.stack });
+            this.logger.logEvent({ message: 'checkForResponse: Exception', port: this.portName, error: err.message, stack: err.stack });
         }
+        return true;
     }
     getTimeoutValue(cmd) {
         let timeout = DEFAULT_TIMEOUT;
@@ -374,103 +385,153 @@ class Daum8i {
     }
     onData(data) {
         let cmd = '';
-        if (!Buffer.isBuffer(data)) {
-            data = Buffer.from(data, 'latin1');
+        if (this.state.waitingForEnd) {
+            cmd = this.state.partialCmd;
         }
+        const bufferData = Buffer.isBuffer(data) ? data : Buffer.from(data, 'latin1');
         const s = this.state.sending;
         if (s === undefined) {
             if (this.state.input === undefined)
-                this.state.input = Buffer.from(data);
+                this.state.input = bufferData;
             return;
         }
         const { portName, resolve } = this.state.sending;
         let incoming;
         if (this.state.input !== undefined) {
-            const arr = [this.state.input, data];
+            const arr = [this.state.input, bufferData];
             incoming = Buffer.concat(arr);
         }
         else {
-            incoming = data;
+            incoming = bufferData;
         }
+        const response = [...incoming];
+        this.logger.logEvent({ message: 'sendCommand:RECV', data: (0, utils_1.hexstr)(response) });
         for (let i = 0; i < incoming.length; i++) {
+            const getRemaining = () => {
+                let remaining = '';
+                const done = i === (incoming.length - 1);
+                if (!done) {
+                    for (let j = i + 1; j < incoming.length; j++)
+                        remaining += String.fromCharCode(incoming.readUInt8(j));
+                }
+                return remaining;
+            };
             const c = incoming.readUInt8(i);
             if (c === 0x06) {
-                this.LOG.logEvent({ message: "sendCommand:ACK received:", port: portName });
+                this.logger.logEvent({ message: "sendCommand:ACK received:", port: portName });
                 this.state.waitingForStart = true;
                 this.state.waitingForACK = false;
+                const remaining = getRemaining();
+                if (remaining && remaining !== '')
+                    return this.onData(remaining);
             }
             else if (c === 0x15) {
                 this.state.waitingForStart = true;
                 this.state.waitingForACK = false;
-                this.LOG.logEvent({ message: "sendCommand:NAK received:", port: portName });
+                this.logger.logEvent({ message: "sendCommand:NAK received:", port: portName });
+                const remaining = getRemaining();
+                if (remaining && remaining !== '')
+                    return this.onData(remaining);
             }
             else if (c === 0x01) {
                 this.state.waitingForEnd = true;
             }
             else if (c === 0x17) {
-                this.LOG.logEvent({ message: "sendCommand:received:", port: portName, cmd: `${cmd} [${utils_1.hexstr(cmd)}]` });
-                if (this.state.sending.timeoutCheckIv)
-                    clearInterval(this.state.sending.timeoutCheckIv);
-                this.state = {
-                    sending: undefined,
-                    busy: false,
-                    writeBusy: false,
-                    waitingForStart: false,
-                    waitingForEnd: false,
-                    waitingForACK: false,
-                };
-                this.sendACK();
-                const payload = cmd.substring(3, cmd.length - 2);
-                resolve(payload);
+                const remaining = getRemaining();
+                this.logger.logEvent({ message: "sendCommand:received:", duration: Date.now() - this.state.sending.tsRequest, port: portName, cmd: `${cmd} [${(0, utils_1.hexstr)(cmd)}]`, remaining: (0, utils_1.hexstr)(remaining) });
+                this.state.waitingForEnd = false;
+                const cmdStr = cmd.substring(0, cmd.length - 2);
+                const checksumExtracted = cmd.slice(-2);
+                const checksumCalculated = (0, utils_1.checkSum)((0, utils_1.getAsciiArrayFromStr)(cmdStr), []);
+                if (checksumExtracted === checksumCalculated) {
+                    this.sendACK();
+                    if (this.state.sending && this.state.sending.responseCheckIv) {
+                        clearInterval(this.state.sending.responseCheckIv);
+                    }
+                    this.state = {
+                        sending: undefined,
+                        busy: false,
+                        writeBusy: false,
+                        waitingForStart: false,
+                        waitingForEnd: false,
+                        waitingForACK: false,
+                    };
+                    const payload = cmd.substring(3, cmd.length - 2);
+                    resolve(payload);
+                }
+                else {
+                    this.sendNAK();
+                }
                 cmd = '';
+                if (remaining)
+                    return this.onData(remaining);
             }
             else {
                 if (this.state.waitingForEnd)
                     cmd += String.fromCharCode(c);
             }
         }
+        if (this.state.waitingForEnd) {
+            this.state.partialCmd = cmd;
+        }
     }
-    sendDaum8iCommand(command, queryType, payload, cb) {
+    sendDaum8iCommand(command, queryType, payload) {
+        const tsRequest = Date.now();
         return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
             if (this.blocked)
-                reject(new Error('blocked'));
+                return reject(new Error('blocked'));
             if (!this.state.busy) {
                 this.state.busy = true;
-                if (!this.connected) {
-                    reject(new Error('not connected'));
-                    if (!this.state.connecting) {
-                        this.saveConnect(true)
-                            .then(() => { this.state.busy = false; })
-                            .catch((reason) => { this.state.busy = reason === 'busy'; });
-                    }
-                    return;
-                }
             }
             else {
-                let start = Date.now();
-                while (this.state.busy && Date.now() - start < 5000) {
-                    yield utils_2.sleep(500);
-                }
-                if (this.state.busy) {
-                    reject(new Error('timeout'));
-                    return;
+                const message = (0, utils_1.buildMessage)(command, payload);
+                this.logger.logEvent({ message: 'sendCommand:waiting', port: this.portName, cmd: command, hex: (0, utils_1.hexstr)(message) });
+                const busyWait = () => {
+                    return new Promise((done) => {
+                        let start = Date.now();
+                        let timeout = start + 5000;
+                        const iv = setInterval(() => {
+                            if (this.state.busy) {
+                                if (Date.now() > timeout) {
+                                    clearInterval(iv);
+                                    done(false);
+                                }
+                            }
+                            else {
+                                clearInterval(iv);
+                                done(true);
+                            }
+                        }, 10);
+                    });
+                };
+                const res = yield busyWait();
+                if (!res) {
+                    this.logger.logEvent({ message: 'sendCommand:busy timeout', port: this.portName, cmd: command, hex: (0, utils_1.hexstr)(message), duration: Date.now() - tsRequest });
+                    return reject(new Error('BUSY timeout'));
                 }
                 this.state.busy = true;
             }
+            const writeDone = () => {
+                this.state.sending = undefined;
+                this.state.writeBusy = false;
+                this.state.busy = false;
+                this.state.sending = undefined;
+                this.state.waitingForStart = false;
+                this.state.waitingForEnd = false;
+                this.state.waitingForACK = false;
+            };
             const port = this.sp;
             const portName = this.portName;
             this.state.received = [];
             try {
-                const message = utils_1.buildMessage(command, payload);
+                const message = (0, utils_1.buildMessage)(command, payload);
                 const start = Date.now();
                 const timeout = start + this.getTimeoutValue();
-                this.LOG.logEvent({ message: "sendCommand:sending:", port: this.portName, cmd: command, hex: utils_1.hexstr(message) });
+                this.logger.logEvent({ message: "sendCommand:sending:", port: this.portName, cmd: command, hex: (0, utils_1.hexstr)(message) });
                 this.state.writeBusy = true;
-                if (!this.connected) {
-                    this.LOG.logEvent({ message: "sendCommand:error: not connected", port: this.portName });
-                    this.state.writeBusy = false;
-                    this.state.busy = false;
-                    this.state.sending = undefined;
+                if (!this.connected || port === undefined) {
+                    this.logger.logEvent({ message: "sendCommand:error: not connected", port: this.portName });
+                    writeDone();
                     return reject(new Error('not connected'));
                 }
                 port.write(message);
@@ -478,34 +539,18 @@ class Daum8i {
                 this.state.writeBusy = false;
                 this.state.retry = 0;
                 this.state.ack = { start, timeout };
-                this.state.sending = { command, payload, start, timeout, port, portName, resolve, reject };
-                this.state.sending.timeoutCheckIv = setInterval(() => {
-                    this.checkForTimeout((err) => {
-                        console.log(err.message, this.state.retry, this.state.retryBusy);
-                        if (this.state.retry > 2) {
-                            clearInterval(this.state.sending.timeoutCheckIv);
-                            this.state.sending.timeoutCheckIv = undefined;
-                            return reject(err);
-                        }
-                        if (this.state.retryBusy)
-                            return;
-                        this.state.retryBusy = true;
-                        this.state.retry++;
-                        setTimeout(() => {
-                            const restart = Date.now();
-                            this.state.ack = { start: restart, timeout: restart + this.getTimeoutValue() };
-                            this.LOG.logEvent({ message: "sendCommand:retry:", port: this.portName, cmd: command, hex: utils_1.hexstr(message) });
-                            port.write(message);
-                            this.state.retryBusy = false;
-                        }, this.sendRetryDelay);
-                    });
-                });
+                this.state.sending = { command, payload, start, timeout, port, portName, tsRequest, resolve, reject };
+                const iv = this.state.sending.responseCheckIv = setInterval(() => {
+                    const stillWaiting = this.checkForResponse();
+                    if (!stillWaiting) {
+                        clearInterval(iv);
+                        writeDone();
+                    }
+                }, 10);
             }
             catch (err) {
-                this.LOG.logEvent({ message: "sendCommand:error:", port: portName, error: err.message, stack: err.stack });
-                this.state.writeBusy = false;
-                this.state.busy = false;
-                this.state.sending = undefined;
+                this.logger.logEvent({ message: "sendCommand:error:", port: portName, error: err.message, stack: err.stack });
+                writeDone();
                 reject(err);
             }
         }));
@@ -518,7 +563,7 @@ class Daum8i {
         }
         catch (err) { }
         this.state.writeBusy = false;
-        this.LOG.logEvent({ message: "sendCommand:sending ACK", port, queue: this.state.commandsInQueue });
+        this.logger.logEvent({ message: "sendCommand:sending ACK", port, queue: this.state.commandsInQueue });
     }
     sendNAK() {
         const port = this.portName;
@@ -526,22 +571,22 @@ class Daum8i {
             this.sp.write([0x15]);
         }
         catch (err) { }
-        this.LOG.logEvent({ message: "sendCommand:sending NAK", port });
+        this.logger.logEvent({ message: "sendCommand:sending NAK", port });
     }
-    sendReservedDaum8iCommand(command, cmdType, data, onData, onError) {
+    sendReservedDaum8iCommand(command, cmdType, data) {
         let cmdData = [];
-        const key = utils_1.getReservedCommandKey(command);
-        utils_1.append(cmdData, utils_1.Int16ToIntArray(key));
+        const key = (0, utils_1.getReservedCommandKey)(command);
+        (0, utils_1.append)(cmdData, (0, utils_1.Int16ToIntArray)(key));
         if (data !== undefined && data.length > 0) {
-            utils_1.append(cmdData, utils_1.Int16ToIntArray(data.length));
-            utils_1.append(cmdData, data);
+            (0, utils_1.append)(cmdData, (0, utils_1.Int16ToIntArray)(data.length));
+            (0, utils_1.append)(cmdData, data);
         }
         else {
-            utils_1.append(cmdData, utils_1.Int16ToIntArray(0));
+            (0, utils_1.append)(cmdData, (0, utils_1.Int16ToIntArray)(0));
         }
-        return this.sendDaum8iCommand('M70', cmdType, utils_1.bin2esc(cmdData))
+        return this.sendDaum8iCommand('M70', cmdType, (0, utils_1.bin2esc)(cmdData))
             .then((resData) => {
-            const cmd = utils_1.esc2bin(resData);
+            const cmd = (0, utils_1.esc2bin)(resData);
             cmd.splice(0, 4);
             return cmd;
         });
@@ -567,7 +612,7 @@ class Daum8i {
             else if (str === '7')
                 deviceType = 'lyps';
             else
-                throw (new Error(`unknown device type ${typeof str === 'string' ? utils_1.ascii(str.charAt(0)) : str}`));
+                throw (new Error(`unknown device type ${typeof str === 'string' ? (0, utils_1.ascii)(str.charAt(0)) : str}`));
             return deviceType;
         });
     }
@@ -576,13 +621,13 @@ class Daum8i {
             .then((str) => {
             let deviceType;
             if (str === '0')
-                deviceType = constants_js_1.ACTUAL_BIKE_TYPE.ALLROUND;
+                deviceType = constants_1.ACTUAL_BIKE_TYPE.ALLROUND;
             else if (str === '1')
-                deviceType = constants_js_1.ACTUAL_BIKE_TYPE.RACE;
+                deviceType = constants_1.ACTUAL_BIKE_TYPE.RACE;
             else if (str === '2')
-                deviceType = constants_js_1.ACTUAL_BIKE_TYPE.MOUNTAIN;
+                deviceType = constants_1.ACTUAL_BIKE_TYPE.MOUNTAIN;
             else {
-                throw (new Error(`unknown actual device type ${typeof str === 'string' ? utils_1.ascii(str.charAt(0)) : str}`));
+                throw (new Error(`unknown actual device type ${typeof str === 'string' ? (0, utils_1.ascii)(str.charAt(0)) : str}`));
             }
             this.state.actualBikeType = deviceType;
             return deviceType;
@@ -591,16 +636,16 @@ class Daum8i {
     setActualBikeType(actualBikeType) {
         let bikeType;
         switch (actualBikeType) {
-            case constants_js_1.ACTUAL_BIKE_TYPE.ALLROUND:
+            case constants_1.ACTUAL_BIKE_TYPE.ALLROUND:
                 bikeType = '0';
                 break;
-            case constants_js_1.ACTUAL_BIKE_TYPE.RACE:
+            case constants_1.ACTUAL_BIKE_TYPE.RACE:
                 bikeType = '1';
                 break;
-            case constants_js_1.ACTUAL_BIKE_TYPE.TRIATHLON:
+            case constants_1.ACTUAL_BIKE_TYPE.TRIATHLON:
                 bikeType = '1';
                 break;
-            case constants_js_1.ACTUAL_BIKE_TYPE.MOUNTAIN:
+            case constants_1.ACTUAL_BIKE_TYPE.MOUNTAIN:
                 bikeType = '2';
                 break;
             default:
@@ -610,11 +655,11 @@ class Daum8i {
             .then((str) => {
             let deviceType;
             if (str === '0')
-                deviceType = constants_js_1.ACTUAL_BIKE_TYPE.ALLROUND;
+                deviceType = constants_1.ACTUAL_BIKE_TYPE.ALLROUND;
             else if (str === '1')
-                deviceType = constants_js_1.ACTUAL_BIKE_TYPE.RACE;
+                deviceType = constants_1.ACTUAL_BIKE_TYPE.RACE;
             else if (str === '2')
-                deviceType = constants_js_1.ACTUAL_BIKE_TYPE.MOUNTAIN;
+                deviceType = constants_1.ACTUAL_BIKE_TYPE.MOUNTAIN;
             else
                 throw (new Error('unknown actual device type'));
             this.state.actualBikeType = deviceType;
@@ -624,12 +669,12 @@ class Daum8i {
     getTrainingData() {
         return this.sendDaum8iCommand('X70', 'AF', [])
             .then((data) => {
-            const td = utils_1.parseTrainingData(data);
+            const td = (0, utils_1.parseTrainingData)(data);
             return td;
         });
     }
     setLoadControl(enabled) {
-        const val = enabled ? utils_1.ascii('1') : utils_1.ascii('0');
+        const val = enabled ? (0, utils_1.ascii)('1') : (0, utils_1.ascii)('0');
         return this.sendDaum8iCommand('S20', 'BF', [val])
             .then((data) => {
             const res = data === '1';
@@ -644,7 +689,7 @@ class Daum8i {
         });
     }
     setSlope(slope) {
-        this.LOG.logEvent({ message: 'setSlope not implemted' });
+        this.logger.logEvent({ message: 'setSlope not implemted' });
         return;
     }
     setPower(power) {
@@ -681,23 +726,25 @@ class Daum8iTcp extends Daum8i {
     static getClassName() { return "Daum8i"; }
     getType() { return "Daum8iTcp"; }
     static setSerialPort(spClass) { }
+    getInterface() { return constants_1.BIKE_INTERFACE.TCPIP; }
     static setNetImpl(netClass) {
         net = netClass;
     }
     static getSupportedInterfaces() {
-        return [constants_js_1.BIKE_INTERFACE.TCPIP];
+        return [constants_1.BIKE_INTERFACE.TCPIP];
     }
 }
 exports.Daum8iTcp = Daum8iTcp;
 class Daum8iSerial extends Daum8i {
     static getClassName() { return "Daum8i"; }
     getType() { return "Daum8iSerial"; }
+    getInterface() { return constants_1.BIKE_INTERFACE.SERIAL; }
     static setSerialPort(spClass) {
         __SerialPort = spClass;
     }
     static setNetImpl(netClass) { }
     static getSupportedInterfaces() {
-        return [constants_js_1.BIKE_INTERFACE.SERIAL];
+        return [constants_1.BIKE_INTERFACE.SERIAL];
     }
 }
 exports.Daum8iSerial = Daum8iSerial;