incyclist-devices 1.5.38 → 2.0.0

package/lib/{daum/premium/bike.js → serial/daum/premium/comms.js}

@@ -8,28 +8,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Daum8iSerial = exports.Daum8iTcp = void 0;
 const constants_1 = require("../constants");
-const tcpserial_1 = __importDefault(require("./tcpserial"));
 const utils_1 = 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 TIMEOUT_START = 15000;
-const OPEN_TIMEOUT = 1000;
-const DAUM_PREMIUM_DEFAULT_PORT = 51955;
-const DAUM_PREMIUM_DEFAULT_HOST = '127.0.0.1';
 const MAX_DATA_BLOCK_SIZE = 512;
 const DS_BITS_OFF = 0;
 const DS_BITS_ENDLESS_RACE = 2;
-var __SerialPort = undefined;
-var net = undefined;
 const DEBUG_LOGGER = {
     log: (e, ...args) => console.log(e, ...args),
     logEvent: (event) => console.log(JSON.stringify(event))
@@ -40,58 +26,42 @@ const validateHost = (host) => {
         return ipParts.map(p => Number(p)).join('.');
     return host;
 };
+const validatePath = (path) => {
+    const parts = path.split(':');
+    if (parts.length < 2)
+        return path;
+    const host = validateHost(parts[0]);
+    const port = parts[1];
+    return `${host}:${port}`;
+};
+const drain = (sp) => new Promise(resolve => { sp.drain(resolve); });
 class Daum8i {
     constructor(props) {
         this.props = props || {};
-        this.logger = process.env.DEBUG ? DEBUG_LOGGER : new gd_eventlog_1.EventLogger('DaumPremium');
-        if (this.props.interface === 'tcpip') {
-            const port = this.props.port || DAUM_PREMIUM_DEFAULT_PORT;
-            const host = validateHost(this.props.host || DAUM_PREMIUM_DEFAULT_HOST);
-            this.portName = `${host}:51955`;
-            this.tcpip = true;
-            this.serial = false;
-            this.tcpipConnection = { host, port };
-        }
-        else {
-            this.portName = this.props.port || process.env.COM_PORT;
-            this.tcpip = false;
-            this.serial = true;
-            this.port = this.portName;
-        }
-        this.settings = this.props.settings || {};
-        this.settings.logger = this.logger;
+        const { logger, serial, path } = props;
+        this.serial = serial;
+        this.path = validatePath(path);
+        this.logger = logger || (process.env.DEBUG ? DEBUG_LOGGER : new gd_eventlog_1.EventLogger('DaumPremium'));
         this.isLoggingPaused = false;
-        this.sendRetryDelay = DEFAULT_SEND_DELAY;
-        this.sp = undefined;
         this.connected = false;
         this.blocked = false;
         this.state = {
             ack: { wait: false, startWait: undefined },
             commandsInQueue: {},
         };
+        this.settings = {};
         this.bikeData = {
             userWeight: 75,
             bikeWeight: 10,
             maxPower: 800
         };
     }
-    static getClassName() {
-        return "Daum8i";
-    }
-    getType() {
-        return "Daum8i";
-    }
-    static setSerialPort(spClass) {
-        __SerialPort = spClass;
-    }
-    static setNetImpl(netClass) {
-        net = netClass;
-    }
-    static getSupportedInterfaces() {
-        return [constants_1.BIKE_INTERFACE.SERIAL, constants_1.BIKE_INTERFACE.TCPIP];
+    getInterface() {
+        var _a;
+        return (_a = this.serial) === null || _a === void 0 ? void 0 : _a.ifaceName;
     }
     getPort() {
-        return this.portName;
+        return this.path;
     }
     isConnected() {
         return this.connected;
@@ -99,141 +69,71 @@ class Daum8i {
     pauseLogging() {
         this.isLoggingPaused = true;
     }
-    resumLogging() {
+    resumeLogging() {
         this.isLoggingPaused = false;
     }
     logEvent(e) {
         if (!this.isLoggingPaused)
             this.logger.logEvent(e);
     }
-    setUser(user, callback) {
-        this.logEvent({ message: "setUser()", user, port: this.portName });
-        this.settings.user = user || {};
-        var cb = callback || nop;
-        cb(200, user);
-    }
-    getUserWeight() {
-        if (!this.settings || !this.settings.user || !this.settings.user.weight)
-            return 75;
-        return this.settings.user.weight;
-    }
-    getBikeWeight() {
-        return 10;
-    }
-    unblock() {
-        this.blocked = false;
-    }
     connect() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.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;
+            if (this.isConnected() && this.sp) {
+                return true;
             }
-            this.state.busy = true;
-            this.state.commandsInQueue = {};
             try {
-                if (this.sp !== undefined) {
-                    yield this.forceClose();
-                    this.sp = undefined;
-                }
-                if (this.sp === undefined) {
-                    if (this.tcpip) {
-                        const { host, port } = this.tcpipConnection;
-                        const { logger } = this.props;
-                        this.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.logEvent({ message: "creating SerialPort", port: this.port, settings });
-                        this.sp = new __SerialPort(this.port, settings);
-                    }
-                    this.sp.on('open', this.onPortOpen.bind(this));
+                const port = yield this.serial.openPort(this.path);
+                if (port !== null) {
+                    this.connected = true;
+                    this.sp = port;
                     this.sp.on('close', this.onPortClose.bind(this));
                     this.sp.on('error', (error) => { this.onPortError(error); });
                     this.sp.on('data', (data) => { this.onData(data); });
+                    return true;
+                }
+                else {
+                    return false;
                 }
-                const start = Date.now();
-                this.state.connecting = true;
-                this.state.opening = { start, timeout: start + this.getTimeoutValue() };
-                this.logEvent({ message: "opening port ..." });
-                yield this.sp.open();
             }
-            catch (err) {
-                this.logEvent({ message: "connect:error:", error: err.message, stack: err.stack });
-                this.state.busy = false;
+            catch (_a) {
+                return false;
             }
         });
     }
-    reconnect() {
+    close() {
         return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield this.saveClose();
-                yield this.saveConnect();
+            if (this.isConnected() && this.serial && this.sp) {
+                try {
+                    yield this.flush();
+                    yield this.serial.closePort(this.path);
+                }
+                catch (err) {
+                    this.logEvent({ message: 'could not close ', reason: err.message });
+                    return false;
+                }
             }
-            catch (_a) { }
+            this.connected = false;
+            if (this.sp) {
+                this.sp.removeAllListeners();
+                this.sp = null;
+            }
+            return true;
         });
     }
-    saveConnect() {
-        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-            if (this.isConnected()) {
-                this.state.connecting = false;
-                return resolve(true);
-            }
-            try {
-                yield this.connect();
-            }
-            catch (_a) { }
-            const tTimeout = Date.now() + TIMEOUT_START;
-            const iv = setInterval(() => __awaiter(this, void 0, void 0, function* () {
-                try {
-                    if (this.state.error !== undefined) {
-                        clearInterval(iv);
-                        yield this.forceClose();
-                        reject(this.state.error);
-                    }
-                    else if (this.isConnected()) {
-                        this.state.connecting = false;
-                        resolve(true);
+    flush() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.state.writeBusy)
+                return;
+            return new Promise(done => {
+                const iv = setInterval(() => {
+                    if (!this.state.writeBusy) {
                         clearInterval(iv);
+                        this.writeDone();
+                        done();
                     }
-                    else {
-                        if (Date.now() > tTimeout) {
-                            this.state.connecting = false;
-                            yield this.forceClose();
-                            clearInterval(iv);
-                            reject(new Error('timeout'));
-                        }
-                    }
-                }
-                catch (_b) { }
-            }), 100);
-        }));
-    }
-    onPortOpen() {
-        this.error = undefined;
-        this.connected = true;
-        this.state.opening = undefined;
-        this.state.opened = true;
-        this.state.busy = false;
-        this.logEvent({ message: "port opened", port: this.portName });
-    }
-    onPortClose() {
-        this.logEvent({ message: "port closed", port: this.portName });
-        this.error = undefined;
-        this.connected = false;
-        if (this.state.opening) {
-            this.state.opened = false;
-            this.state.closed = true;
-        }
-        else {
-            this.state = { opened: false, closed: true, busy: false };
-        }
-        this.sp.removeAllListeners();
-        this.sp = undefined;
-        if (this.queue !== undefined)
-            this.queue.clear();
+                }, 100);
+            });
+        });
     }
     getLogState() {
         let s = undefined;
@@ -245,137 +145,53 @@ class Daum8i {
         }
         return { sending: s, busy, writeBusy, opening, connecting, waitingForStart, waitingForEnd, waitingForAck, retry };
     }
+    onPortClose() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.connected = false;
+            if (this.sp) {
+                this.sp.removeAllListeners();
+                this.sp = null;
+            }
+        });
+    }
     onPortError(error) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: "port error:", port: this.portName, error: error.message, connected: this.connected, state: this.getLogState() });
+            this.logEvent({ message: "port error:", port: this.path, error: error.message, connected: this.connected, state: this.getLogState() });
             this.error = error;
             if (this.blocked) {
                 if (!this.state.closed) {
-                    yield this.forceClose();
+                    yield this.close();
                 }
                 return;
             }
-            if (this.state.closing) {
-                if (error.message === 'Port is not open') {
-                    this.state = { opened: false, closed: true, busy: false };
-                    return;
-                }
-                else {
-                    yield this.forceClose();
-                }
-            }
-            else if (this.state.opening) {
-                if (this.state.connecting) {
-                    this.state.error = error;
-                }
-                else {
-                    this.onPortOpen();
-                }
-            }
-            else if (this.state.sending) {
+            if (this.state.sending) {
                 if (this.state.sending.reject)
                     this.state.sending.reject(error);
                 this.writeDone();
-                yield this.forceClose(false);
+                yield this.close();
                 return;
             }
             this.state.busy = false;
         });
     }
-    errorHandler() {
-        throw new Error("Error");
-    }
-    saveClose(force) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.close();
-        });
-    }
     forceClose(updateState = false) {
         return __awaiter(this, void 0, void 0, function* () {
-            const sp = this.sp;
             if (!this.sp)
                 return;
-            this.state.closing = true;
-            sp.removeAllListeners();
-            sp.on('error', () => { });
             try {
-                sp.unpipe();
-                sp.flush();
-            }
-            catch (_a) { }
-            try {
-                yield this.closePort(1000);
+                yield this.close();
                 this.writeDone();
                 if (this.queue !== undefined)
                     this.queue.clear();
             }
-            catch (_b) { }
+            catch (_a) { }
             this.connected = false;
             if (updateState)
                 this.state = { opened: false, closed: true, busy: false };
         });
     }
-    closePort(timeout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                let isClosed = false;
-                const to = setTimeout(() => {
-                    if (!isClosed)
-                        resolve(false);
-                }, timeout);
-                try {
-                    this.sp.removeAllListeners('close');
-                    this.sp.removeAllListeners('error');
-                }
-                catch (err) {
-                    this.logger.logEvent({ message: 'error', fn: 'closePort()', error: err.message });
-                }
-                this.sp.on('error', () => { });
-                this.sp.on('close', () => {
-                    clearTimeout(to);
-                    isClosed = true;
-                    resolve(true);
-                });
-                this.sp.close();
-            });
-        });
-    }
-    close() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'close request', port: this.portName });
-            var sp = this.sp;
-            if (!sp) {
-                this.state = { opened: false, closed: true, busy: false };
-                this.connected = false;
-                return;
-            }
-            let connected = this.connected;
-            try {
-                if (connected) {
-                    try {
-                        sp.removeAllListeners();
-                        sp.on('error', () => { });
-                        sp.unpipe();
-                        sp.flush();
-                    }
-                    catch (_a) { }
-                }
-                yield this.closePort(this.getTimeoutValue());
-                this.writeDone();
-                if (this.queue !== undefined) {
-                    this.queue.clear();
-                    this.queue = undefined;
-                }
-            }
-            catch (err) {
-                this.logEvent({ message: 'close: Exception', port: this.portName, error: err.message });
-            }
-            this.state = { opened: false, closed: true, busy: false };
-            this.connected = false;
-        });
-    }
     sendTimeout(message) {
-        this.logEvent({ message: `sendCommand:${message || 'timeout'}`, port: this.portName, cmd: this.cmdCurrent });
+        this.logEvent({ message: `sendCommand:${message || 'timeout'}`, port: this.path, cmd: this.cmdCurrent });
         delete this.state.commandsInQueue[this.cmdCurrent.command];
         if (this.cmdCurrent.callbackErr !== undefined) {
             let cb = this.cmdCurrent.callbackErr;
@@ -415,112 +231,112 @@ class Daum8i {
             return false;
         }
         catch (err) {
-            this.logEvent({ message: 'checkForResponse: Exception', port: this.portName, error: err.message, stack: err.stack });
+            this.logEvent({ message: 'checkForResponse: Exception', port: this.path, error: err.message, stack: err.stack });
         }
         return true;
     }
     getTimeoutValue(cmd) {
         let timeout = DEFAULT_TIMEOUT;
-        if (this.settings && this.settings.tcpip && this.settings.tcpip.timeout)
-            timeout = this.settings.tcpip.timeout;
-        if (this.settings && this.settings.serial && this.settings.serial.timeout)
-            timeout = this.settings.serial.timeout;
+        if (this.settings && this.settings.timeout)
+            timeout = this.settings.timeout;
         if (cmd !== undefined && cmd.options !== undefined && cmd.options.timeout !== undefined) {
             timeout = cmd.options.timeout;
         }
         return timeout;
     }
     onData(data, depth = 0) {
-        let cmd = '';
-        const MAX_DEPTH = 5;
-        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) {
-            this.logEvent({ message: 'onData:IGNORED', data: bufferData.toString('hex') });
-            return;
-        }
-        const { portName, resolve } = this.state.sending;
-        let incoming = bufferData;
-        this.logEvent({ message: 'sendCommand:RECV', data: (0, utils_1.hexstr)(incoming) });
-        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.state.waitingForStart = true;
-                this.state.waitingForACK = false;
-                const remaining = getRemaining();
-                this.logEvent({ message: "sendCommand:ACK received:", port: portName, remaining: (0, utils_1.hexstr)(remaining) });
-                if (remaining && remaining !== '' && depth < MAX_DEPTH)
-                    return this.onData(remaining, depth + 1);
-            }
-            else if (c === 0x15) {
-                this.state.waitingForStart = true;
-                this.state.waitingForACK = false;
-                const remaining = getRemaining();
-                this.logEvent({ message: "sendCommand:NAK received:", port: portName, remaining: (0, utils_1.hexstr)(remaining) });
-                if (remaining && remaining !== '' && depth < MAX_DEPTH)
-                    return this.onData(remaining, depth + 1);
+        return __awaiter(this, void 0, void 0, function* () {
+            let cmd = '';
+            const MAX_DEPTH = 5;
+            if (this.state.waitingForEnd) {
+                cmd = this.state.partialCmd;
             }
-            else if (c === 0x01) {
-                this.state.waitingForEnd = true;
+            const bufferData = Buffer.isBuffer(data) ? data : Buffer.from(data, 'latin1');
+            const s = this.state.sending;
+            if (s === undefined) {
+                this.logEvent({ message: 'onData:IGNORED', data: bufferData.toString('hex') });
+                return;
             }
-            else if (c === 0x17) {
-                const remaining = getRemaining();
-                if (this.state.waitingForACK) {
-                    this.logEvent({ message: "sendCommand:ignored:", 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 { portName, resolve } = this.state.sending;
+            let incoming = bufferData;
+            this.logEvent({ message: 'sendCommand:RECV', data: (0, utils_1.hexstr)(incoming) });
+            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.state.waitingForStart = true;
+                    this.state.waitingForACK = false;
+                    const remaining = getRemaining();
+                    this.logEvent({ message: "sendCommand:ACK received:", port: portName, remaining: (0, utils_1.hexstr)(remaining) });
+                    if (remaining && remaining !== '' && depth < MAX_DEPTH)
+                        return this.onData(remaining, depth + 1);
                 }
-                else {
-                    this.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 if (c === 0x15) {
+                    this.state.waitingForStart = true;
+                    this.state.waitingForACK = false;
+                    const remaining = getRemaining();
+                    this.logEvent({ message: "sendCommand:NAK received:", port: portName, remaining: (0, utils_1.hexstr)(remaining) });
+                    if (remaining && remaining !== '' && depth < MAX_DEPTH)
+                        return this.onData(remaining, depth + 1);
+                }
+                else if (c === 0x01) {
+                    this.state.waitingForEnd = true;
+                }
+                else if (c === 0x17) {
+                    const remaining = getRemaining();
+                    if (this.state.waitingForACK) {
+                        this.logEvent({ message: "sendCommand:ignored:", 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;
                     }
                     else {
-                        this.sendNAK();
+                        this.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) {
+                            yield 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 {
+                            yield this.sendNAK();
+                        }
                     }
+                    cmd = '';
+                    if (remaining && depth < 5)
+                        return this.onData(remaining, depth + 1);
+                }
+                else {
+                    if (this.state.waitingForEnd)
+                        cmd += String.fromCharCode(c);
                 }
-                cmd = '';
-                if (remaining && depth < 5)
-                    return this.onData(remaining, depth + 1);
             }
-            else {
-                if (this.state.waitingForEnd)
-                    cmd += String.fromCharCode(c);
+            if (this.state.waitingForEnd) {
+                this.state.partialCmd = cmd;
             }
-        }
-        if (this.state.waitingForEnd) {
-            this.state.partialCmd = cmd;
-        }
+        });
     }
-    sendDaum8iCommand(command, queryType, payload) {
+    sendDaum8iCommand(command, payload = '') {
         const tsRequest = Date.now();
         return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
             if (this.blocked)
@@ -530,7 +346,7 @@ class Daum8i {
             }
             else {
                 const message = (0, utils_1.buildMessage)(command, payload);
-                this.logEvent({ message: 'sendCommand:waiting', port: this.portName, cmd: command, hex: (0, utils_1.hexstr)(message) });
+                this.logEvent({ message: 'sendCommand:waiting', port: this.path, cmd: command, hex: (0, utils_1.hexstr)(message) });
                 const busyWait = () => {
                     return new Promise((done) => {
                         let start = Date.now();
@@ -551,26 +367,26 @@ class Daum8i {
                 };
                 const res = yield busyWait();
                 if (!res) {
-                    this.logEvent({ message: 'sendCommand:busy timeout', port: this.portName, cmd: command, hex: (0, utils_1.hexstr)(message), duration: Date.now() - tsRequest });
+                    this.logEvent({ message: 'sendCommand:busy timeout', port: this.path, cmd: command, hex: (0, utils_1.hexstr)(message), duration: Date.now() - tsRequest });
                     return reject(new Error('BUSY timeout'));
                 }
                 this.state.busy = true;
             }
             const port = this.sp;
-            const portName = this.portName;
+            const portName = this.path;
             this.state.received = [];
             try {
                 const message = (0, utils_1.buildMessage)(command, payload);
                 const start = Date.now();
                 const timeout = start + this.getTimeoutValue();
-                this.logEvent({ message: "sendCommand:sending:", port: this.portName, cmd: command, hex: (0, utils_1.hexstr)(message) });
+                this.logEvent({ message: "sendCommand:sending:", port: this.path, cmd: command, hex: (0, utils_1.hexstr)(message) });
                 this.state.writeBusy = true;
                 if (!this.connected || port === undefined) {
-                    this.logEvent({ message: "sendCommand:error: not connected", port: this.portName });
+                    this.logEvent({ message: "sendCommand:error: not connected", port: this.path });
                     this.writeDone();
                     return reject(new Error('not connected'));
                 }
-                port.write(message);
+                yield this.write(Buffer.from(message));
                 this.state.waitingForACK = true;
                 this.state.writeBusy = false;
                 this.state.retry = 0;
@@ -603,25 +419,36 @@ class Daum8i {
         this.state.waitingForEnd = false;
         this.state.waitingForACK = false;
     }
+    write(buffer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise(done => {
+                this.state.writeBusy = true;
+                try {
+                    this.sp.write(buffer, () => {
+                        this.state.writeBusy = false;
+                        done();
+                    });
+                }
+                catch (err) {
+                    this.state.writeBusy = false;
+                    done();
+                }
+            });
+        });
+    }
     sendACK() {
-        const port = this.portName;
-        this.state.writeBusy = true;
-        try {
-            this.sp.write([0x06]);
-        }
-        catch (err) { }
-        this.state.writeBusy = false;
-        this.logEvent({ message: "sendCommand:sending ACK", port, queue: this.state.commandsInQueue });
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: "sendCommand:sending ACK", port: this.path, queue: this.state.commandsInQueue });
+            yield this.write(Buffer.from([0x06]));
+        });
     }
     sendNAK() {
-        const port = this.portName;
-        try {
-            this.sp.write([0x15]);
-        }
-        catch (err) { }
-        this.logEvent({ message: "sendCommand:sending NAK", port });
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: "sendCommand:sending NAK", port: this.path, queue: this.state.commandsInQueue });
+            yield this.write(Buffer.from([0x15]));
+        });
     }
-    sendReservedDaum8iCommand(command, cmdType, data) {
+    sendReservedDaum8iCommand(command, data) {
         let buffer;
         if (data !== undefined && data.length > 0) {
             buffer = Buffer.alloc(data.length + 4);
@@ -635,28 +462,25 @@ class Daum8i {
             buffer.writeUInt16LE(0, 2);
         }
         const cmdData = Uint8Array.from(buffer);
-        return this.sendDaum8iCommand('M70', cmdType, (0, utils_1.bin2esc)(cmdData))
+        return this.sendDaum8iCommand('M70', (0, utils_1.bin2esc)(cmdData))
             .then((res) => {
             const resData = Uint8Array.from(res, x => x.charCodeAt(0));
             const cmd = (0, utils_1.esc2bin)(resData);
             return cmd;
         });
     }
-    stopWorker() {
-        this.logEvent({ message: "stop worker", port: this.getPort() });
-    }
     getProtocolVersion() {
-        return this.sendDaum8iCommand('V00', 'AF', [])
+        return this.sendDaum8iCommand('V00')
             .then((data) => {
             const version = data.substring(0, 1) + '.' + data.substring(1);
             return (version);
         });
     }
     getDashboardVersion() {
-        return this.sendDaum8iCommand('V70', 'AF', []);
+        return this.sendDaum8iCommand('V70');
     }
     getDeviceType() {
-        return this.sendDaum8iCommand('Y00', 'AF', [])
+        return this.sendDaum8iCommand('Y00')
             .then((str) => {
             let deviceType;
             if (str === '0')
@@ -666,12 +490,12 @@ class Daum8i {
             else if (str === '7')
                 deviceType = 'lyps';
             else
-                throw (new Error(`unknown device type ${typeof str === 'string' ? (0, utils_1.ascii)(str.charAt(0)) : str}`));
+                throw (new Error(`unknown device type ${typeof str === 'string' ? str : (0, utils_1.ascii)(str)}`));
             return deviceType;
         });
     }
     getActualBikeType() {
-        return this.sendDaum8iCommand('M72', 'AF', [])
+        return this.sendDaum8iCommand('M72')
             .then((str) => {
             let deviceType;
             if (str === '0')
@@ -705,7 +529,7 @@ class Daum8i {
             default:
                 bikeType = undefined;
         }
-        return this.sendDaum8iCommand(`M72${bikeType}`, 'BF', [])
+        return this.sendDaum8iCommand(`M72${bikeType}`)
             .then((str) => {
             let deviceType;
             if (str === '0')
@@ -721,7 +545,7 @@ class Daum8i {
         });
     }
     getTrainingData() {
-        return this.sendDaum8iCommand('X70', 'AF', [])
+        return this.sendDaum8iCommand('X70')
             .then((data) => {
             const td = (0, utils_1.parseTrainingData)(data);
             return td;
@@ -729,32 +553,28 @@ class Daum8i {
     }
     setLoadControl(enabled) {
         const val = enabled ? (0, utils_1.ascii)('1') : (0, utils_1.ascii)('0');
-        return this.sendDaum8iCommand('S20', 'BF', [val])
+        return this.sendDaum8iCommand('S20', [val])
             .then((data) => {
             const res = data === '1';
             return res;
         });
     }
     getLoadControl() {
-        return this.sendDaum8iCommand('S20', 'AF', [])
+        return this.sendDaum8iCommand('S20')
             .then((data) => {
             const res = data === '1';
             return res;
         });
     }
-    setSlope(slope) {
-        this.logEvent({ message: 'setSlope not implemted' });
-        return;
-    }
     setPower(power) {
         const powerStr = Number.parseFloat(power).toFixed(2);
-        return this.sendDaum8iCommand(`S23${powerStr}`, 'BF', [])
+        return this.sendDaum8iCommand(`S23${powerStr}`)
             .then((str) => {
             return parseInt(str);
         });
     }
     getPower(power) {
-        return this.sendDaum8iCommand('S23', 'AF', [])
+        return this.sendDaum8iCommand('S23')
             .then((str) => {
             return parseInt(str);
         });
@@ -762,7 +582,7 @@ class Daum8i {
     setPerson(person) {
         const { sex, age, length, weight } = person;
         this.logEvent({ message: 'setPerson() request', sex, age, length, weight });
-        return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PERSON_SET, 'BF', (0, utils_1.getPersonData)(person))
+        return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PERSON_SET, (0, utils_1.getPersonData)(person))
             .then((res) => {
             const buffer = Buffer.from(res);
             const success = buffer.readInt16LE(0) === utils_1.ReservedCommands.PERSON_SET;
@@ -774,7 +594,7 @@ class Daum8i {
     }
     programUploadInit() {
         this.logEvent({ message: 'programUploadInit() request' });
-        return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PROGRAM_LIST_BEGIN, 'BF')
+        return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PROGRAM_LIST_BEGIN)
             .then((res) => {
             const buffer = Buffer.from(res);
             const success = buffer.readInt16LE(0) === utils_1.ReservedCommands.PROGRAM_LIST_BEGIN;
@@ -805,7 +625,7 @@ class Daum8i {
         payload.writeInt32LE(7, 32);
         payload.writeInt32LE(eppLength, 36);
         this.logEvent({ message: 'programUploadStart() request', bikeType, length: eppLength });
-        return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PROGRAM_LIST_NEW_PROGRAM, 'BF', payload)
+        return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PROGRAM_LIST_NEW_PROGRAM, payload)
             .then((res) => {
             const buffer = Buffer.from(res);
             if (buffer.readInt16LE(0) === utils_1.ReservedCommands.PROGRAM_LIST_NEW_PROGRAM) {
@@ -827,7 +647,7 @@ class Daum8i {
         const chunk = Buffer.from(epp.slice(offset, offset + size));
         chunk.copy(payload, 8);
         this.logEvent({ message: 'programUploadSendBlock() request', offset, size });
-        return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PROGRAM_LIST_CONTINUE_PROGRAM, 'BF', payload)
+        return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PROGRAM_LIST_CONTINUE_PROGRAM, payload)
             .then((res) => {
             const buffer = Buffer.from(res);
             let success = buffer.readInt16LE(0) === utils_1.ReservedCommands.PROGRAM_LIST_CONTINUE_PROGRAM;
@@ -842,7 +662,7 @@ class Daum8i {
     }
     programUploadDone() {
         this.logEvent({ message: 'programUploadDone() request' });
-        return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PROGRAM_LIST_END, 'BF')
+        return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PROGRAM_LIST_END)
             .then((res) => {
             const buffer = Buffer.from(res);
             const success = buffer.readInt16LE(0) === utils_1.ReservedCommands.PROGRAM_LIST_END;
@@ -881,6 +701,7 @@ class Daum8i {
             }
             catch (err) {
                 console.log('~~~ err', err);
+                return false;
             }
             return false;
         });
@@ -889,7 +710,7 @@ class Daum8i {
         const payload = Buffer.alloc(2);
         payload.writeInt16LE(programId, 0);
         this.logEvent({ message: 'startProgram() request', programId });
-        return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PROGRAM_LIST_START, 'BF', payload)
+        return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PROGRAM_LIST_START, payload)
             .then((res) => {
             const buffer = Buffer.from(res);
             const success = buffer.readInt16LE(0) === utils_1.ReservedCommands.PROGRAM_LIST_START;
@@ -901,42 +722,16 @@ class Daum8i {
         });
     }
     setGear(gear) {
-        return this.sendDaum8iCommand('M71', 'BF', `${gear}`)
+        return this.sendDaum8iCommand(`M71${gear}`)
             .then((str) => {
-            const gearVal = parseInt(str);
-            return gearVal > 0 ? gearVal - 1 : undefined;
+            return parseInt(str);
         });
     }
     getGear() {
-        return this.sendDaum8iCommand('M71', 'AF', '')
+        return this.sendDaum8iCommand('M71')
             .then((str) => {
             return parseInt(str);
         });
     }
 }
-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_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_1.BIKE_INTERFACE.SERIAL];
-    }
-}
-exports.Daum8iSerial = Daum8iSerial;
+exports.default = Daum8i;