incyclist-devices 2.0.35 → 2.0.37

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

@@ -8,252 +8,55 @@ 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.ResponseTimeout = exports.BusyTimeout = exports.ACKTimeout = exports.CheckSumError = void 0;
 const constants_1 = require("../constants");
 const utils_1 = require("./utils");
-const gd_eventlog_1 = require("gd-eventlog");
+const types_1 = require("./types");
 const utils_2 = require("../../../utils/utils");
-const DEFAULT_TIMEOUT = 10000;
-const MAX_DATA_BLOCK_SIZE = 512;
-const DS_BITS_OFF = 0;
-const DS_BITS_ENDLESS_RACE = 2;
-const DEBUG_LOGGER = {
-    log: (e, ...args) => console.log(e, ...args),
-    logEvent: (event) => console.log(JSON.stringify(event))
-};
-const validateHost = (host) => {
-    const ipParts = host.split('.');
-    if (ipParts.length > 1)
-        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}`;
-};
-class CheckSumError extends Error {
-    constructor() {
-        super();
-        this.message = 'checksum incorrect';
+const comms_1 = __importDefault(require("../../comms"));
+const consts_1 = require("./consts");
+class Daum8i extends comms_1.default {
+    validatePath(path) {
+        return (0, utils_1.validatePath)(path);
     }
-}
-exports.CheckSumError = CheckSumError;
-class ACKTimeout extends Error {
-    constructor() {
-        super();
-        this.message = 'ACK timeout';
+    getDefaultLoggerName() {
+        return 'DaumPremium';
     }
-}
-exports.ACKTimeout = ACKTimeout;
-class BusyTimeout extends Error {
-    constructor() {
-        super();
-        this.message = 'BUSY timeout';
+    getAckTimeoutValue() {
+        return consts_1.DEFAULT_ACK_TIMEOUT;
     }
-}
-exports.BusyTimeout = BusyTimeout;
-class ResponseTimeout extends Error {
-    constructor() {
-        super();
-        this.message = 'RESP timeout';
-    }
-}
-exports.ResponseTimeout = ResponseTimeout;
-class Daum8i {
-    constructor(props) {
-        this.onNAK = () => {
-        };
-        this.props = props || {};
-        const { logger, serial, path } = props;
-        this.serial = serial;
-        this.path = validatePath(path);
-        const w = global.window;
-        this.logger = logger || ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.DEBUG ? DEBUG_LOGGER : new gd_eventlog_1.EventLogger('DaumPremium'));
-        this.isLoggingPaused = false;
-        this.connectState = 'Disconnected';
-        this.connectPromise = null;
-        this.recvState = { data: new utils_2.Queue() };
-        this.settings = {};
-        this.bikeData = {
-            userWeight: 75,
-            bikeWeight: 10,
-            maxPower: 800
-        };
-    }
-    getInterface() {
-        var _a;
-        return (_a = this.serial) === null || _a === void 0 ? void 0 : _a.ifaceName;
-    }
-    getPort() {
-        return this.path;
-    }
-    isConnected() {
-        return this.connectState === 'Connected' || this.connectState === 'Disconnecting';
-    }
-    pauseLogging() {
-        this.isLoggingPaused = true;
-    }
-    resumeLogging() {
-        this.isLoggingPaused = false;
-    }
-    logEvent(e) {
-        if (this.isLoggingPaused)
-            return;
-        this.logger.logEvent(e);
-        const w = global.window;
-        if (w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) {
-            console.log('~~~ DaumPremium', e);
-        }
-    }
-    connect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.isConnected() && this.sp) {
-                return true;
-            }
-            if (this.connectState === 'Connecting') {
-                if (this.connectPromise) {
-                    try {
-                        yield this.connectPromise;
-                    }
-                    catch (_a) {
-                    }
-                }
-                return this.isConnected();
-            }
-            try {
-                this.connectState = 'Connecting';
-                this.connectPromise = this.serial.openPort(this.path);
-                const port = yield this.connectPromise;
-                this.connectPromise = null;
-                if (port !== null) {
-                    this.connectState = 'Connected';
-                    this.sp = port;
-                    this.sp.on('close', this.onPortClose.bind(this));
-                    this.sp.on('error', this.onPortError.bind(this));
-                    this.sp.on('data', this.onData.bind(this));
-                    return true;
-                }
-                else {
-                    this.connectState = 'Disconnected';
-                    return false;
-                }
-            }
-            catch (_b) {
-                this.connectState = 'Disconnected';
-                return false;
-            }
-        });
+    getTimeoutValue() {
+        return consts_1.DEFAULT_TIMEOUT;
     }
-    closePort() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.sp)
-                return true;
-            try {
-                yield this.flush();
-                yield this.serial.closePort(this.path);
-                return true;
-            }
-            catch (err) {
-                this.logEvent({ message: 'could not close ', reason: err.message });
-                return false;
-            }
-        });
+    onConnected() {
+        this.sp.on('data', this.onData.bind(this));
     }
-    cleanupPort() {
-        if (this.sp) {
-            this.sp.removeAllListeners();
-        }
-        this.sp = null;
-        this.recvState.data.clear();
+    getInitialCommsState() {
+        const state = super.getInitialCommsState();
+        state.waitingForACK = false;
+        state.waitingForStart = false;
+        state.waitingForEnd = false;
+        return state;
     }
-    close() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let isDisconnected = false;
-            if (this.disconnectPromise) {
-                try {
-                    isDisconnected = yield this.disconnectPromise;
-                }
-                catch (_a) {
-                }
-                return isDisconnected;
-            }
-            if (this.connectState === 'Disconnected') {
-                this.cleanupPort();
-                return true;
-            }
-            else if (this.connectState === 'Disconnecting' || this.connectState === 'Connected' || this.connectState === 'Connecting') {
-                this.connectState = 'Disconnecting';
-                this.disconnectPromise = this.closePort();
-                isDisconnected = yield this.disconnectPromise;
-                this.connectPromise = null;
-                this.disconnectPromise = null;
-                if (isDisconnected)
-                    this.connectState = 'Disconnected';
-                this.cleanupPort();
-            }
-            return isDisconnected;
-        });
-    }
-    flush() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.writePromise) {
-                yield this.waitWithTimeout(this.writePromise, 1000);
-                this.writePromise = null;
-            }
-        });
-    }
-    onPortClose() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.connectState !== 'Disconnected' && this.connectState !== 'Disconnecting')
-                this.logEvent({ message: "port closed:", port: this.path });
-            this.connectState = 'Disconnected';
-            this.cleanupPort();
-        });
-    }
-    onPortError(error) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.connectState === 'Disconnecting' || this.connectState === 'Disconnected') {
-                return;
-            }
-            this.logEvent({ message: "port error:", port: this.path, error: error.message, connected: this.isConnected(), state: this.connectState });
-            if (this.isSending()) {
-                this.rejectCurrent(error);
-            }
-            if (this.connectState === 'Connected')
-                this.close();
-        });
-    }
-    isSending() {
-        return (this.writePromise !== undefined && this.writePromise !== null) || (this.sendCmdPromise !== null && this.sendCmdPromise !== undefined);
-    }
-    rejectCurrent(error) {
-        this.recvState.data.enqueue({ type: 'Error', error });
-    }
-    getTimeoutValue(cmd) {
-        let timeout = DEFAULT_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;
+    setState(ack, start, end) {
+        this.recvState.waitingForACK = ack;
+        this.recvState.waitingForStart = start;
+        this.recvState.waitingForEnd = end;
     }
     onData(data, depth = 0) {
         return __awaiter(this, void 0, void 0, function* () {
             let cmd = '';
             const MAX_DEPTH = 5;
-            if (this.recvState.waitingForEnd) {
+            if (this.recvState.waitingForEnd && this.recvState.partialCmd) {
                 cmd = this.recvState.partialCmd;
             }
             const bufferData = Buffer.isBuffer(data) ? data : Buffer.from(data, 'latin1');
             let incoming = bufferData;
             if (depth === 0)
-                this.logEvent({ message: 'sendCommand:RECV', data: (0, utils_1.hexstr)(incoming), state: this.recvState });
+                this.logEvent({ message: 'sendCommand:RECV', data: Buffer.from(incoming).toString('hex') });
             for (let i = 0; i < incoming.length; i++) {
                 const getRemaining = () => {
                     let remaining = '';
@@ -265,7 +68,7 @@ class Daum8i {
                     return remaining;
                 };
                 const c = incoming.readUInt8(i);
-                if (c === 0x06) {
+                if (c === 0x06 && this.recvState.waitingForACK) {
                     this.recvState.waitingForStart = true;
                     this.recvState.waitingForACK = false;
                     const remaining = getRemaining();
@@ -273,7 +76,7 @@ class Daum8i {
                     if (remaining && remaining !== '' && depth < MAX_DEPTH)
                         return this.onData(remaining, depth + 1);
                 }
-                else if (c === 0x15) {
+                else if (c === 0x15 && this.recvState.waitingForACK) {
                     this.recvState.waitingForStart = true;
                     this.recvState.waitingForACK = false;
                     const remaining = getRemaining();
@@ -281,33 +84,38 @@ class Daum8i {
                     if (remaining && remaining !== '' && depth < MAX_DEPTH)
                         return this.onData(remaining, depth + 1);
                 }
-                else if (c === 0x01) {
+                else if (c === 0x01 && this.recvState.waitingForStart) {
                     this.recvState.waitingForStart = false;
                     this.recvState.waitingForEnd = true;
                 }
-                else if (c === 0x17) {
+                else if (c === 0x17 && this.recvState.waitingForEnd) {
                     const remaining = getRemaining();
                     this.recvState.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) {
-                        const payload = cmd.substring(3, cmd.length - 2);
-                        this.recvState.data.enqueue({ type: 'Response', data: payload });
+                    if (cmd.length < 5) {
+                        this.recvState.data.enqueue({ type: 'Error', error: new Error('illegal data'), data: cmd });
                     }
                     else {
-                        const error = new CheckSumError();
-                        this.recvState.data.enqueue({ type: 'Error', error, data: cmd });
-                        this.recvState.waitingForACK = false;
-                        this.recvState.waitingForStart = true;
-                        this.recvState.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) {
+                            const payload = cmd.substring(3, cmd.length - 2);
+                            this.recvState.data.enqueue({ type: 'Response', cmd: cmd.substring(0, 3), data: payload });
+                        }
+                        else {
+                            const error = new types_1.CheckSumError();
+                            this.recvState.data.enqueue({ type: 'Error', error, data: cmd });
+                            this.recvState.waitingForACK = false;
+                            this.recvState.waitingForStart = true;
+                            this.recvState.waitingForEnd = false;
+                        }
+                        cmd = '';
+                        if (remaining && depth < 5)
+                            return this.onData(remaining, depth + 1);
                     }
-                    cmd = '';
-                    if (remaining && depth < 5)
-                        return this.onData(remaining, depth + 1);
                 }
                 else {
-                    if (this.recvState.waitingForEnd)
+                    if (this.recvState.waitingForEnd && c !== 0x01 && c !== 0x06 && c !== 0x15)
                         cmd += String.fromCharCode(c);
                 }
             }
@@ -316,62 +124,74 @@ class Daum8i {
             }
         });
     }
-    waitWithTimeout(promise, timeout, onTimeout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let to;
-            const toPromise = (ms) => {
-                return new Promise(resolve => { to = setTimeout(resolve, ms); });
-            };
-            let res;
-            try {
-                res = yield Promise.race([promise, toPromise(timeout).then(() => { if (onTimeout)
-                        onTimeout(); })]);
-            }
-            catch (_a) {
-            }
-            clearTimeout(to);
-            return res;
-        });
-    }
-    sendDaum8iCommand(command, payload = '') {
+    send(request) {
         return __awaiter(this, void 0, void 0, function* () {
+            const { command, payload = '' } = request;
             const message = (0, utils_1.buildMessage)(command, payload);
-            const tsRequest = Date.now();
-            if (this.sendCmdPromise) {
-                this.logEvent({ message: 'sendCommand:waiting', port: this.path, cmd: command, hex: (0, utils_1.hexstr)(message) });
-                const onTimeout = () => {
-                    this.logEvent({ message: 'sendCommand:busy timeout', port: this.path, cmd: command, hex: (0, utils_1.hexstr)(message), duration: Date.now() - tsRequest });
-                    throw new Error('BUSY timeout');
+            let logPayload;
+            if (request.isBinary) {
+                logPayload = {
+                    port: this.path,
+                    cmd: request.logString || 'BinaryCommand',
                 };
-                this.waitWithTimeout(this.sendCmdPromise, 5000, onTimeout);
-                this.sendCmdPromise = null;
             }
+            else {
+                logPayload = {
+                    port: this.path,
+                    cmd: `${request.logString} (${command})` || command
+                };
+            }
+            yield this.ensurePrevCmdFinish(logPayload);
             this.sendCmdPromise = new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
                 try {
-                    this.logEvent({ message: "sendCommand:sending:", port: this.path, cmd: command, hex: (0, utils_1.hexstr)(message) });
-                    if (!this.isConnected()) {
-                        const connected = yield this.connect();
-                        if (!connected) {
-                            reject(new Error('not connected'));
-                            return;
-                        }
-                    }
+                    this.logEvent(Object.assign(Object.assign({ message: "sendCommand:sending:" }, logPayload), { hex: Buffer.from(message).toString('hex') }));
+                    yield this.ensureConnection();
                     let retryCnt = 0;
                     let ok = false;
                     do {
+                        if (retryCnt > 0)
+                            this.logEvent(Object.assign(Object.assign({ message: "sendCommand:resending:" }, logPayload), { hex: Buffer.from(message).toString('hex') }));
                         yield this.write(Buffer.from(message));
                         ok = yield this.waitForACK();
+                        this.logEvent(Object.assign({ message: `sendCommand:${ok ? 'ACK' : 'NAK'} received:` }, logPayload));
                         if (!ok) {
-                            yield (0, utils_2.sleep)(1000);
+                            yield (0, utils_2.sleep)(100);
                             retryCnt++;
                         }
                     } while (!ok && retryCnt < 5);
-                    const res = yield this.waitForResponse();
+                    if (!ok) {
+                        this.sendCmdPromise = null;
+                        throw new Error('ACK Error');
+                    }
+                    let checksumFailure = false;
+                    let retry = 0;
+                    let response;
+                    do {
+                        response = yield this.waitForResponse();
+                        if (response.type === 'Response') {
+                            this.logEvent(Object.assign(Object.assign({ message: `sendCommand:received:` }, logPayload), { response: request.isBinary ? Buffer.from(response.data).toString('hex') : (0, utils_1.responseLog)(response.data) }));
+                            yield this.sendACK(logPayload);
+                            this.sendCmdPromise = null;
+                            return resolve(response);
+                        }
+                        if (response.type === 'Error') {
+                            this.logEvent(Object.assign(Object.assign({ message: `sendCommand:received:ERROR` }, logPayload), { error: response.error.message }));
+                            if (response.error instanceof types_1.CheckSumError && retry < 5) {
+                                checksumFailure = true;
+                                yield this.sendNAK(logPayload);
+                                retry++;
+                            }
+                            else {
+                                this.sendCmdPromise = null;
+                                throw response.error;
+                            }
+                        }
+                    } while (checksumFailure && retry < 5);
                     this.sendCmdPromise = null;
-                    resolve(res);
+                    return response;
                 }
                 catch (err) {
-                    this.logEvent({ message: "sendCommand:error:", port: this.path, error: err.message, stack: err.stack });
+                    this.logEvent(Object.assign(Object.assign({ message: "sendCommand:error:" }, logPayload), { error: err.message, stack: err.stack }));
                     this.sendCmdPromise = null;
                     reject(err);
                 }
@@ -379,15 +199,22 @@ class Daum8i {
             return this.sendCmdPromise;
         });
     }
-    onIgnored(payload) {
-        this.logEvent({ message: 'onData:IGNORED', port: this.path, data: payload });
+    sendStrCommand(logString, command, payload = '') {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.send({ logString, command, payload, isBinary: false });
+            return response.data;
+        });
     }
-    onACK() {
+    sendBinaryCommand(logString, command, payload = '') {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.send({ logString, command, payload, isBinary: true });
+            return response.data;
+        });
     }
     waitForACK() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.recvState.waitingForACK = true;
-            const timeout = this.getTimeoutValue();
+            this.setState(true, false, false);
+            const timeout = this.getAckTimeoutValue();
             let waitingForACK = true;
             let start = Date.now();
             let tsTimeout = start + timeout;
@@ -398,13 +225,12 @@ class Daum8i {
                 }
                 else {
                     if (response.type === 'ACK' || response.type === 'NAK') {
-                        this.logEvent({ message: `sendCommand:${response.type} received:`, port: this.path });
                         waitingForACK = false;
                         return (response.type === 'ACK');
                     }
                 }
             }
-            throw new ACKTimeout();
+            throw new types_1.ACKTimeout();
         });
     }
     waitForResponse() {
@@ -413,46 +239,16 @@ class Daum8i {
             let waitingForResponse = true;
             let start = Date.now();
             let tsTimeout = start + timeout;
-            let retry = 0;
-            while (waitingForResponse && Date.now() < tsTimeout && retry < 5) {
+            while (waitingForResponse && Date.now() < tsTimeout) {
                 const response = this.recvState.data.dequeue();
                 if (!response) {
                     yield (0, utils_2.sleep)(5);
                 }
                 else {
-                    if (response.type === 'Response') {
-                        this.logEvent({ message: `sendCommand:received:`, port: this.path, cmd: response.data });
-                        yield this.sendACK();
-                        waitingForResponse = false;
-                        return response.data;
-                    }
-                    if (response.type === 'Error') {
-                        this.logEvent({ message: `sendCommand:received:ERROR`, port: this.path, error: response.error.message });
-                        if (response.error instanceof CheckSumError && retry < 5) {
-                            yield this.sendNAK();
-                            retry++;
-                        }
-                        else {
-                            throw response.error;
-                        }
-                    }
+                    return response;
                 }
             }
-            throw new ResponseTimeout();
-        });
-    }
-    portWrite(buffer) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.sp) {
-                this.logEvent({ message: 'write failed', error: 'port is not opened' });
-                return;
-            }
-            try {
-                yield this.sp.write(buffer);
-            }
-            catch (err) {
-                this.logEvent({ message: 'write failed', error: err.message });
-            }
+            throw new types_1.ResponseTimeout();
         });
     }
     write(buffer, ackExpected = true) {
@@ -472,52 +268,33 @@ class Daum8i {
             this.writePromise = null;
         });
     }
-    sendACK() {
+    sendACK(logPayload) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: "sendCommand:sending ACK", port: this.path });
+            this.logEvent(Object.assign({ message: "sendCommand:sending ACK" }, logPayload));
             yield this.write(Buffer.from([0x06]), false);
         });
     }
-    sendNAK() {
+    sendNAK(logPayload) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: "sendCommand:sending NAK", port: this.path });
+            this.logEvent(Object.assign({ message: "sendCommand:sending NAK" }, logPayload));
             yield this.write(Buffer.from([0x15]), false);
         });
     }
-    sendReservedDaum8iCommand(command, data) {
-        let buffer;
-        if (data !== undefined && data.length > 0) {
-            buffer = Buffer.alloc(data.length + 4);
-            buffer.writeInt16LE(command, 0);
-            buffer.writeUInt16LE(data.length, 2);
-            data.copy(buffer, 4);
-        }
-        else {
-            buffer = Buffer.alloc(4);
-            buffer.writeInt16LE(command, 0);
-            buffer.writeUInt16LE(0, 2);
-        }
-        const cmdData = Uint8Array.from(buffer);
-        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;
-        });
-    }
     getProtocolVersion() {
-        return this.sendDaum8iCommand('V00')
-            .then((data) => {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.sendStrCommand('getProtocolVersion', 'V00');
             const version = data.substring(0, 1) + '.' + data.substring(1);
             return (version);
         });
     }
     getDashboardVersion() {
-        return this.sendDaum8iCommand('V70');
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.sendStrCommand('getDashboardVersion', 'V70');
+        });
     }
     getDeviceType() {
-        return this.sendDaum8iCommand('Y00')
-            .then((str) => {
+        return __awaiter(this, void 0, void 0, function* () {
+            const str = yield this.sendStrCommand('getDeviceType', 'Y00');
             let deviceType;
             if (str === '0')
                 deviceType = 'run';
@@ -531,8 +308,8 @@ class Daum8i {
         });
     }
     getActualBikeType() {
-        return this.sendDaum8iCommand('M72')
-            .then((str) => {
+        return __awaiter(this, void 0, void 0, function* () {
+            const str = yield this.sendStrCommand('getActualBikeType', 'M72');
             let deviceType;
             if (str === '0')
                 deviceType = constants_1.ACTUAL_BIKE_TYPE.ALLROUND;
@@ -548,25 +325,25 @@ class Daum8i {
         });
     }
     setActualBikeType(actualBikeType) {
-        let bikeType;
-        switch (actualBikeType) {
-            case constants_1.ACTUAL_BIKE_TYPE.ALLROUND:
-                bikeType = '0';
-                break;
-            case constants_1.ACTUAL_BIKE_TYPE.RACE:
-                bikeType = '1';
-                break;
-            case constants_1.ACTUAL_BIKE_TYPE.TRIATHLON:
-                bikeType = '1';
-                break;
-            case constants_1.ACTUAL_BIKE_TYPE.MOUNTAIN:
-                bikeType = '2';
-                break;
-            default:
-                bikeType = undefined;
-        }
-        return this.sendDaum8iCommand(`M72${bikeType}`)
-            .then((str) => {
+        return __awaiter(this, void 0, void 0, function* () {
+            let bikeType;
+            switch (actualBikeType) {
+                case constants_1.ACTUAL_BIKE_TYPE.ALLROUND:
+                    bikeType = '0';
+                    break;
+                case constants_1.ACTUAL_BIKE_TYPE.RACE:
+                    bikeType = '1';
+                    break;
+                case constants_1.ACTUAL_BIKE_TYPE.TRIATHLON:
+                    bikeType = '1';
+                    break;
+                case constants_1.ACTUAL_BIKE_TYPE.MOUNTAIN:
+                    bikeType = '2';
+                    break;
+                default:
+                    bikeType = undefined;
+            }
+            const str = yield this.sendStrCommand('setActualBikeType', `M72${bikeType}`);
             let deviceType;
             if (str === '0')
                 deviceType = constants_1.ACTUAL_BIKE_TYPE.ALLROUND;
@@ -581,88 +358,118 @@ class Daum8i {
         });
     }
     getTrainingData() {
-        return this.sendDaum8iCommand('X70')
-            .then((data) => {
-            const td = (0, utils_1.parseTrainingData)(data);
-            return td;
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.sendStrCommand('getTrainingData', 'X70');
+            return (0, utils_1.parseTrainingData)(data);
         });
     }
     setLoadControl(enabled) {
-        const val = enabled ? (0, utils_1.ascii)('1') : (0, utils_1.ascii)('0');
-        return this.sendDaum8iCommand('S20', [val])
-            .then((data) => {
+        return __awaiter(this, void 0, void 0, function* () {
+            const val = enabled ? (0, utils_1.ascii)('1') : (0, utils_1.ascii)('0');
+            const data = yield this.sendStrCommand('setLoadControl', 'S20', new Uint8Array([val]));
             const res = data === '1';
             return res;
         });
     }
     getLoadControl() {
-        return this.sendDaum8iCommand('S20')
-            .then((data) => {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.sendStrCommand('getLoadControl', 'S20');
             const res = data === '1';
             return res;
         });
     }
     setPower(power) {
-        const powerStr = Number.parseFloat(power).toFixed(2);
-        return this.sendDaum8iCommand(`S23${powerStr}`)
-            .then((str) => {
+        return __awaiter(this, void 0, void 0, function* () {
+            const powerStr = typeof power === 'string' ? Number.parseFloat(power).toFixed(2) : power.toFixed(2);
+            const str = yield this.sendStrCommand('setPower', `S23${powerStr}`);
+            return parseInt(str);
+        });
+    }
+    getPower() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const str = yield this.sendStrCommand('getPower', 'S23');
+            return parseInt(str);
+        });
+    }
+    setGear(gear) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const str = yield this.sendStrCommand('setGear', `M71${gear}`);
             return parseInt(str);
         });
     }
-    getPower(power) {
-        return this.sendDaum8iCommand('S23')
-            .then((str) => {
+    getGear() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const str = yield this.sendStrCommand('getGear', 'M71');
             return parseInt(str);
         });
     }
+    sendReservedDaum8iCommand(logString, command, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let buffer;
+            if (data !== undefined && data.length > 0) {
+                buffer = Buffer.alloc(data.length + 4);
+                buffer.writeInt16LE(command, 0);
+                buffer.writeUInt16LE(data.length, 2);
+                data.copy(buffer, 4);
+            }
+            else {
+                buffer = Buffer.alloc(4);
+                buffer.writeInt16LE(command, 0);
+                buffer.writeUInt16LE(0, 2);
+            }
+            const cmdData = Uint8Array.from(buffer);
+            const res = yield this.sendBinaryCommand(logString || 'ReservedCommand', 'M70', (0, utils_1.bin2esc)(cmdData));
+            const resData = Uint8Array.from(res, x => x.charCodeAt(0));
+            const cmd = (0, utils_1.esc2bin)(resData);
+            return cmd;
+        });
+    }
     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, (0, utils_1.getPersonData)(person))
-            .then((res) => {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { sex, age, length, weight } = person;
+            const logStr = `setPerson(${sex === undefined ? '' : sex},${age === undefined ? '' : age},${length === undefined ? '' : length},${weight === undefined ? '' : length})`;
+            const res = yield this.sendReservedDaum8iCommand(logStr, utils_1.ReservedCommands.PERSON_SET, (0, utils_1.getPersonData)(person));
             const buffer = Buffer.from(res);
             const success = buffer.readInt16LE(0) === utils_1.ReservedCommands.PERSON_SET;
-            this.logEvent({ message: 'setPerson() response', success, buffer });
+            this.logEvent({ message: `${logStr} response`, success });
             if (!success)
                 throw new Error('Illegal Response');
             return true;
         });
     }
     programUploadInit() {
-        this.logEvent({ message: 'programUploadInit() request' });
-        return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PROGRAM_LIST_BEGIN)
-            .then((res) => {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.sendReservedDaum8iCommand('programUploadInit()', utils_1.ReservedCommands.PROGRAM_LIST_BEGIN);
             const buffer = Buffer.from(res);
             const success = buffer.readInt16LE(0) === utils_1.ReservedCommands.PROGRAM_LIST_BEGIN;
-            this.logEvent({ message: 'programUploadInit() response', success, buffer });
+            this.logEvent({ message: 'programUploadInit() response', success });
             if (!success)
                 throw new Error('Illegal Response');
             return true;
         });
     }
     programUploadStart(bikeType, route) {
-        const payload = Buffer.alloc(40);
-        const epp = route ? (0, utils_1.routeToEpp)(route) : undefined;
-        const eppLength = epp ? epp.length : 0;
-        const bikeTypeVal = (0, utils_1.getBikeType)(bikeType);
-        const wBits = route.lapMode ? DS_BITS_ENDLESS_RACE : DS_BITS_OFF;
-        payload.writeInt32LE(0, 0);
-        payload.writeInt8(bikeTypeVal, 4);
-        payload.writeInt8(0, 5);
-        payload.writeInt16LE(0, 6);
-        payload.writeInt32LE(0, 8);
-        payload.writeInt32LE(0, 12);
-        payload.writeFloatLE(0, 16);
-        payload.writeFloatLE(0, 20);
-        payload.writeInt16LE(0, 24);
-        payload.writeInt16LE(0, 26);
-        payload.writeInt16LE(0, 28);
-        payload.writeInt16LE(wBits, 30);
-        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, payload)
-            .then((res) => {
+        return __awaiter(this, void 0, void 0, function* () {
+            const payload = Buffer.alloc(40);
+            const epp = route ? (0, utils_1.routeToEpp)(route) : undefined;
+            const eppLength = epp ? epp.length : 0;
+            const bikeTypeVal = (0, utils_1.getBikeType)(bikeType);
+            const wBits = route.lapMode ? consts_1.DS_BITS_ENDLESS_RACE : consts_1.DS_BITS_OFF;
+            payload.writeInt32LE(0, 0);
+            payload.writeInt8(bikeTypeVal, 4);
+            payload.writeInt8(0, 5);
+            payload.writeInt16LE(0, 6);
+            payload.writeInt32LE(0, 8);
+            payload.writeInt32LE(0, 12);
+            payload.writeFloatLE(0, 16);
+            payload.writeFloatLE(0, 20);
+            payload.writeInt16LE(0, 24);
+            payload.writeInt16LE(0, 26);
+            payload.writeInt16LE(0, 28);
+            payload.writeInt16LE(wBits, 30);
+            payload.writeInt32LE(7, 32);
+            payload.writeInt32LE(eppLength, 36);
+            const res = yield this.sendReservedDaum8iCommand('programUploadStart()', utils_1.ReservedCommands.PROGRAM_LIST_NEW_PROGRAM, payload);
             const buffer = Buffer.from(res);
             if (buffer.readInt16LE(0) === utils_1.ReservedCommands.PROGRAM_LIST_NEW_PROGRAM) {
                 this.logEvent({ message: 'programUploadStart() response', success: true });
@@ -673,23 +480,23 @@ class Daum8i {
         });
     }
     programUploadSendBlock(epp, offset) {
-        const remaining = epp.length - offset;
-        if (remaining <= 0)
-            return Promise.resolve(true);
-        const size = remaining > MAX_DATA_BLOCK_SIZE ? MAX_DATA_BLOCK_SIZE : remaining;
-        const payload = Buffer.alloc(size + 8);
-        payload.writeInt32LE(size, 0);
-        payload.writeInt32LE(offset, 4);
-        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, payload)
-            .then((res) => {
+        return __awaiter(this, void 0, void 0, function* () {
+            const remaining = epp.length - offset;
+            if (remaining <= 0)
+                return Promise.resolve(true);
+            const size = remaining > consts_1.MAX_DATA_BLOCK_SIZE ? consts_1.MAX_DATA_BLOCK_SIZE : remaining;
+            const payload = Buffer.alloc(size + 8);
+            payload.writeInt32LE(size, 0);
+            payload.writeInt32LE(offset, 4);
+            const chunk = Buffer.from(epp.slice(offset, offset + size));
+            chunk.copy(payload, 8);
+            const logStr = `programUploadSendBlock(${offset},${size})`;
+            const res = yield this.sendReservedDaum8iCommand(logStr, utils_1.ReservedCommands.PROGRAM_LIST_CONTINUE_PROGRAM, payload);
             const buffer = Buffer.from(res);
             let success = buffer.readInt16LE(0) === utils_1.ReservedCommands.PROGRAM_LIST_CONTINUE_PROGRAM;
             success = success && (buffer.readInt16LE(2) === 1);
             success = success && (buffer.readInt8(4) === 1);
-            this.logEvent({ message: 'programUploadSendBlock() response' });
+            this.logEvent({ message: `${logStr} response`, data: buffer.toString('hex') });
             if (!success)
                 throw new Error('Illegal Response');
             return true;
@@ -697,9 +504,8 @@ class Daum8i {
         });
     }
     programUploadDone() {
-        this.logEvent({ message: 'programUploadDone() request' });
-        return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PROGRAM_LIST_END)
-            .then((res) => {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.sendReservedDaum8iCommand('programUploadDone()', utils_1.ReservedCommands.PROGRAM_LIST_END);
             const buffer = Buffer.from(res);
             const success = buffer.readInt16LE(0) === utils_1.ReservedCommands.PROGRAM_LIST_END;
             this.logEvent({ message: 'programUploadDone() response', success });
@@ -709,6 +515,21 @@ class Daum8i {
             ;
         });
     }
+    startProgram(programId = 1) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const payload = Buffer.alloc(2);
+            payload.writeInt16LE(programId, 0);
+            const logStr = `startProgram(${programId})`;
+            const res = yield this.sendReservedDaum8iCommand(logStr, utils_1.ReservedCommands.PROGRAM_LIST_START, payload);
+            const buffer = Buffer.from(res);
+            const success = buffer.readInt16LE(0) === utils_1.ReservedCommands.PROGRAM_LIST_START;
+            this.logEvent({ message: 'startProgram() request', programId, success });
+            if (!success)
+                throw new Error('Illegal Response');
+            return true;
+            ;
+        });
+    }
     programUpload(bikeType, route, onStatusUpdate) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
@@ -720,9 +541,11 @@ class Daum8i {
                     let offset = 0;
                     if (onStatusUpdate)
                         onStatusUpdate(0, epp.length);
+                    if (epp.length === 0)
+                        done = true;
                     while (success && !done) {
                         success = yield this.programUploadSendBlock(epp, offset);
-                        offset += MAX_DATA_BLOCK_SIZE;
+                        offset += consts_1.MAX_DATA_BLOCK_SIZE;
                         done = offset >= epp.length;
                         if (onStatusUpdate)
                             onStatusUpdate(done ? epp.length : offset, epp.length);
@@ -732,41 +555,14 @@ class Daum8i {
                     }
                 }
                 else {
+                    onStatusUpdate(0, 0);
                     return yield this.programUploadDone();
                 }
             }
             catch (err) {
-                console.log('~~~ err', err);
+                this.logEvent({ message: 'error', fn: 'programUpload', error: err.message, stack: err.stack });
                 return false;
             }
-            return false;
-        });
-    }
-    startProgram(programId = 1) {
-        const payload = Buffer.alloc(2);
-        payload.writeInt16LE(programId, 0);
-        this.logEvent({ message: 'startProgram() request', programId });
-        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;
-            this.logEvent({ message: 'startProgram() request', programId, success });
-            if (!success)
-                throw new Error('Illegal Response');
-            return true;
-            ;
-        });
-    }
-    setGear(gear) {
-        return this.sendDaum8iCommand(`M71${gear}`)
-            .then((str) => {
-            return parseInt(str);
-        });
-    }
-    getGear() {
-        return this.sendDaum8iCommand('M71')
-            .then((str) => {
-            return parseInt(str);
         });
     }
 }