incyclist-devices 1.5.9 → 1.5.11

package/lib/daum/classic/DaumClassicAdapter.d.ts

@@ -12,7 +12,11 @@ export default class DaumClassicAdapter extends DaumAdapter {
     getPort(): any;
     getSupportedCyclingModes(): Array<any>;
     getDefaultCyclingMode(): CyclingMode;
+    pause(): Promise<boolean>;
+    resume(): Promise<boolean>;
     check(): Promise<unknown>;
+    relaunch(props: any): Promise<unknown>;
     start(props: any): Promise<unknown>;
+    launch(props: any, isRelaunch?: boolean): Promise<unknown>;
     getCurrentBikeData(): any;
 }

package/lib/daum/classic/DaumClassicAdapter.js

@@ -53,6 +53,27 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
     getDefaultCyclingMode() {
         return new DaumClassicCyclingMode_1.default(this);
     }
+    pause() {
+        const _super = Object.create(null, {
+            pause: { get: () => super.pause }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('~~~~~~~~~~ PAUSE');
+            const paused = yield _super.pause.call(this);
+            this.bike.pauseLogging();
+            return paused;
+        });
+    }
+    resume() {
+        const _super = Object.create(null, {
+            resume: { get: () => super.resume }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const resumed = yield _super.resume.call(this);
+            this.bike.resumeLogging();
+            return resumed;
+        });
+    }
     check() {
         var info = {};
         return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
@@ -79,9 +100,20 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
             }
         }));
     }
+    relaunch(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'relaunch()' });
+            return yield this.launch(props, true);
+        });
+    }
     start(props) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'start()', props });
+            this.logger.logEvent({ message: 'start(-)' });
+            return yield this.launch(props, false);
+        });
+    }
+    launch(props, isRelaunch = false) {
+        return __awaiter(this, void 0, void 0, function* () {
             const opts = props || {};
             const { user, bikeSettings } = opts;
             if (user && user.weight)
@@ -89,6 +121,9 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
             if (bikeSettings && bikeSettings.weight)
                 this.bikeSettings.weight = bikeSettings.weight;
             this.initData();
+            if (isRelaunch) {
+                yield this.stop();
+            }
             let startState = {};
             return (0, utils_1.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () {
                 try {
@@ -133,6 +168,8 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
                 }
             }), 5, 1000)
                 .then(data => {
+                this.stopped = false;
+                this.paused = false;
                 this.startUpdatePull();
                 return data;
             });

package/lib/daum/classic/bike.d.ts

@@ -27,12 +27,16 @@ export default class Daum8008 {
     bikeCmdWorker: any;
     cmdStart: number;
     cmdCurrent: any;
+    isLoggingPaused: boolean;
     constructor(opts?: any);
     static setSerialPort(spClass: any): void;
     static getClassName(): string;
     getType(): string;
     getPort(): string;
     isConnected(): boolean;
+    pauseLogging(): void;
+    resumLogging(): void;
+    logEvent(e: any): void;
     setUser(user: User, callback: any): void;
     getUserWeight(): number;
     getBikeWeight(): any;

package/lib/daum/classic/bike.js

@@ -27,6 +27,7 @@ class Daum8008 {
         this.closed = undefined;
         this.cmdBusy = false;
         this.queue = new utils_2.Queue();
+        this.isLoggingPaused = false;
     }
     static setSerialPort(spClass) {
         __SerialPort = spClass;
@@ -43,8 +44,18 @@ class Daum8008 {
     isConnected() {
         return this.connected;
     }
+    pauseLogging() {
+        this.isLoggingPaused = true;
+    }
+    resumLogging() {
+        this.isLoggingPaused = false;
+    }
+    logEvent(e) {
+        if (!this.isLoggingPaused)
+            this.logger.logEvent(e);
+    }
     setUser(user, callback) {
-        this.logger.logEvent({ message: "setUser()", user });
+        this.logEvent({ message: "setUser()", user });
         if (user)
             this.settings.user = user;
         var cb = callback || nop;
@@ -65,7 +76,7 @@ class Daum8008 {
         return 10;
     }
     connect() {
-        this.logger.logEvent({ message: "connect()", port: this.getPort(), sp: (this.sp !== undefined), });
+        this.logEvent({ message: "connect()", port: this.getPort(), sp: (this.sp !== undefined), });
         if (this.closing || this.opening) {
             return;
         }
@@ -84,7 +95,7 @@ class Daum8008 {
             this.sp.open();
         }
         catch (err) {
-            this.logger.logEvent({ message: "startTraining:error:", error: err.message });
+            this.logEvent({ message: "startTraining:error:", error: err.message });
         }
     }
     saveConnect() {
@@ -120,7 +131,7 @@ class Daum8008 {
         });
     }
     close() {
-        this.logger.logEvent({ message: 'close()', port: this.getPort() });
+        this.logEvent({ message: 'close()', port: this.getPort() });
         if (this.closing) {
             return;
         }
@@ -174,7 +185,7 @@ class Daum8008 {
         });
     }
     onPortOpen() {
-        this.logger.logEvent({ message: "port opened", port: this.getPort() });
+        this.logEvent({ message: "port opened", port: this.getPort() });
         this.error = undefined;
         this.connected = true;
         this.opening = false;
@@ -185,7 +196,7 @@ class Daum8008 {
         this.cmdBusy = false;
     }
     onPortClose() {
-        this.logger.logEvent({ message: "port closed", port: this.getPort() });
+        this.logEvent({ message: "port closed", port: this.getPort() });
         this.error = undefined;
         this.connected = false;
         this.closing = false;
@@ -202,7 +213,7 @@ class Daum8008 {
         if (this.opening && (err.message === 'Port is already open' || err.message === 'Port is opening'))
             return;
         const state = { opening: this.opening, connected: this.connected, closing: this.closing, closed: this.closed, busy: this.cmdBusy };
-        this.logger.logEvent({ message: "port error:", port: this.getPort(), error: err.message, stack: err.stack, state });
+        this.logEvent({ message: "port error:", port: this.getPort(), error: err.message, stack: err.stack, state });
         this.error = err;
         this.cmdBusy = false;
     }
@@ -238,7 +249,7 @@ class Daum8008 {
                 const timeout = (cmdInfo.options && cmdInfo.options.timeout) ? cmdInfo.options.timeout : (this.settings.timeoutMessage || TIMEOUT_SEND);
                 let d = Date.now() - cmdInfo.start;
                 if (d > timeout) {
-                    this.logger.logEvent({ message: 'sendCommmand:timeout', port: this.getPort() });
+                    this.logEvent({ message: 'sendCommmand:timeout', port: this.getPort() });
                     const port = this.sp;
                     port.unpipe();
                     port.flush();
@@ -274,7 +285,7 @@ class Daum8008 {
         };
         this.queue.enqueue(cmdInfo);
         if (this.queue.size() > 1)
-            this.logger.logEvent({ message: "sendCommand:adding:", cmd: logStr, hex: (0, utils_1.hexstr)(payload), queueSize: this.queue.size() });
+            this.logEvent({ message: "sendCommand:adding:", cmd: logStr, hex: (0, utils_1.hexstr)(payload), queueSize: this.queue.size() });
         if (this.bikeCmdWorker === undefined) {
             this.startWorker();
         }
@@ -293,12 +304,12 @@ class Daum8008 {
             const parser = serialPort.pipe(new ByteLength({ length: expected }));
             parser.on('data', (data) => {
                 let duration = Date.now() - this.cmdStart;
-                this.logger.logEvent({ message: "sendCommand:received:", duration, hex: (0, utils_1.hexstr)(data), port: this.getPort() });
+                this.logEvent({ message: "sendCommand:received:", duration, hex: (0, utils_1.hexstr)(data), port: this.getPort() });
                 serialPort.unpipe();
                 if (callbackErr !== undefined) {
                     if (data[0] !== payload[0]) {
                         serialPort.flush();
-                        this.logger.logEvent({ message: "sendCommand:illegal response", port: this.getPort() });
+                        this.logEvent({ message: "sendCommand:illegal response", port: this.getPort() });
                         done();
                         return callbackErr(512, { message: "illegal response" });
                     }
@@ -306,12 +317,12 @@ class Daum8008 {
                 callback(data);
                 done();
             });
-            this.logger.logEvent({ message: "sendCommand:sending:", cmd: logStr, hex: (0, utils_1.hexstr)(payload), port: this.getPort() });
+            this.logEvent({ message: "sendCommand:sending:", cmd: logStr, hex: (0, utils_1.hexstr)(payload), port: this.getPort() });
             this.cmdCurrent.start = this.cmdStart = Date.now();
             serialPort.write(payload);
         }
         catch (err) {
-            this.logger.logEvent({ message: "sendCommand:error:", error: err.message, port: this.getPort() });
+            this.logEvent({ message: "sendCommand:error:", error: err.message, port: this.getPort() });
             done();
             callbackErr(500, { message: `Exception: ${err.message}` });
         }

package/lib/daum/premium/DaumPremiumAdapter.d.ts

@@ -7,6 +7,10 @@ export default class DaumPremiumDevice extends DaumAdapter {
     getInterface(): any;
     getSupportedCyclingModes(): Array<any>;
     check(): Promise<unknown>;
+    pause(): Promise<boolean>;
+    resume(): Promise<boolean>;
+    relaunch(props: any): Promise<unknown>;
     start(props: any): Promise<unknown>;
+    launch(props: any, isRelaunch?: boolean): Promise<unknown>;
     getCurrentBikeData(): Promise<any>;
 }

package/lib/daum/premium/DaumPremiumAdapter.js

@@ -62,11 +62,40 @@ class DaumPremiumDevice extends DaumAdapter_1.default {
             }
         }));
     }
+    pause() {
+        const _super = Object.create(null, {
+            pause: { get: () => super.pause }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const paused = yield _super.pause.call(this);
+            this.bike.pauseLogging();
+            return paused;
+        });
+    }
+    resume() {
+        const _super = Object.create(null, {
+            resume: { get: () => super.resume }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const resumed = yield _super.resume.call(this);
+            this.bike.resumeLogging();
+            return resumed;
+        });
+    }
+    relaunch(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'relaunch()' });
+            return yield this.launch(props, true);
+        });
+    }
     start(props) {
         return __awaiter(this, void 0, void 0, function* () {
             this.logger.logEvent({ message: 'start()' });
-            console.log('~~~setPersonSupport:', this.getCyclingMode().getModeProperty('setPersonSupport'));
-            console.log('~~~eppSupport:', this.getCyclingMode().getModeProperty('eppSupport'));
+            return yield this.launch(props, false);
+        });
+    }
+    launch(props, isRelaunch = false) {
+        return __awaiter(this, void 0, void 0, function* () {
             const opts = props || {};
             if (opts.user && opts.user.weight)
                 this.userSettings.weight = opts.user.weight;
@@ -76,11 +105,12 @@ class DaumPremiumDevice extends DaumAdapter_1.default {
             const route = opts.route;
             var info = {};
             this.initData();
+            if (isRelaunch) {
+                yield this.stop();
+            }
             return (0, utils_1.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () {
-                if (this.isStopped())
-                    return;
                 try {
-                    if (!this.bike.isConnected()) {
+                    if (!isRelaunch && !this.bike.isConnected()) {
                         yield this.bike.saveConnect();
                     }
                     if (!info.deviceType) {
@@ -113,6 +143,8 @@ class DaumPremiumDevice extends DaumAdapter_1.default {
                 }
             }), 5, 1500)
                 .then(data => {
+                this.stopped = false;
+                this.paused = false;
                 this.startUpdatePull();
                 return data;
             });

package/lib/daum/premium/bike.d.ts

@@ -28,6 +28,7 @@ declare class Daum8i {
     queue: Queue<any>;
     cmdCurrent: any;
     cmdStart: number;
+    isLoggingPaused: boolean;
     constructor(props: any);
     static getClassName(): string;
     getType(): string;
@@ -36,6 +37,9 @@ declare class Daum8i {
     static getSupportedInterfaces(): string[];
     getPort(): string;
     isConnected(): boolean;
+    pauseLogging(): void;
+    resumLogging(): void;
+    logEvent(e: any): void;
     setUser(user: any, callback: any): void;
     getUserWeight(): any;
     getBikeWeight(): number;

package/lib/daum/premium/bike.js

@@ -38,7 +38,6 @@ class Daum8i {
     constructor(props) {
         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;
@@ -55,6 +54,7 @@ class Daum8i {
         }
         this.settings = this.props.settings || {};
         this.settings.logger = this.logger;
+        this.isLoggingPaused = false;
         this.sendRetryDelay = DEFAULT_SEND_DELAY;
         this.sp = undefined;
         this.connected = false;
@@ -90,8 +90,18 @@ class Daum8i {
     isConnected() {
         return this.connected;
     }
+    pauseLogging() {
+        this.isLoggingPaused = true;
+    }
+    resumLogging() {
+        this.isLoggingPaused = false;
+    }
+    logEvent(e) {
+        if (!this.isLoggingPaused)
+            this.logger.logEvent(e);
+    }
     setUser(user, callback) {
-        this.logger.logEvent({ message: "setUser()", user, port: this.portName });
+        this.logEvent({ message: "setUser()", user, port: this.portName });
         this.settings.user = user || {};
         var cb = callback || nop;
         cb(200, user);
@@ -108,7 +118,7 @@ class Daum8i {
         this.blocked = false;
     }
     connect() {
-        this.logger.logEvent({ message: "connect()", sp: (this.sp !== undefined), connected: this.connected, blocked: this.blocked, port: this.portName, settings: this.settings });
+        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;
         }
@@ -128,13 +138,13 @@ class Daum8i {
                 if (this.tcpip) {
                     const { host, port } = this.tcpipConnection;
                     const { logger } = this.props;
-                    this.logger.logEvent({ message: "creating TCPSocketPort", host, port });
+                    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.logger.logEvent({ message: "creating SerialPort", port: this.port, settings });
+                    this.logEvent({ message: "creating SerialPort", port: this.port, settings });
                     this.sp = new __SerialPort(this.port, settings);
                 }
                 this.sp.on('open', this.onPortOpen.bind(this));
@@ -145,11 +155,11 @@ class Daum8i {
             const start = Date.now();
             this.state.connecting = true;
             this.state.opening = { start, timeout: start + this.getTimeoutValue() };
-            this.logger.logEvent({ message: "opening port ..." });
+            this.logEvent({ message: "opening port ..." });
             this.sp.open();
         }
         catch (err) {
-            this.logger.logEvent({ message: "scan:error:", error: err.message, stack: err.stack });
+            this.logEvent({ message: "scan:error:", error: err.message, stack: err.stack });
             this.state.busy = false;
         }
     }
@@ -196,10 +206,10 @@ class Daum8i {
         this.state.opening = undefined;
         this.state.opened = true;
         this.state.busy = false;
-        this.logger.logEvent({ message: "port opened", port: this.portName });
+        this.logEvent({ message: "port opened", port: this.portName });
     }
     onPortClose() {
-        this.logger.logEvent({ message: "port closed", port: this.portName });
+        this.logEvent({ message: "port closed", port: this.portName });
         this.error = undefined;
         this.connected = false;
         if (this.state.opening) {
@@ -225,7 +235,7 @@ class Daum8i {
         return { sending: s, busy, writeBusy, opening, connecting, waitingForStart, waitingForEnd, waitingForAck, retry };
     }
     onPortError(error) {
-        this.logger.logEvent({ message: "port error:", port: this.portName, error: error.message, connected: this.connected, state: this.getLogState() });
+        this.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) {
@@ -296,7 +306,7 @@ class Daum8i {
             this.state = { opened: false, closed: true, busy: false };
     }
     close() {
-        this.logger.logEvent({ message: 'close request', port: this.portName });
+        this.logEvent({ message: 'close request', port: this.portName });
         var sp = this.sp;
         let connected = this.connected;
         try {
@@ -317,7 +327,7 @@ class Daum8i {
             }
         }
         catch (err) {
-            this.logger.logEvent({ message: 'close: Exception', port: this.portName, error: err.message });
+            this.logEvent({ message: 'close: Exception', port: this.portName, error: err.message });
         }
         this.connected = false;
         const start = Date.now();
@@ -331,7 +341,7 @@ class Daum8i {
         this.state.busy = false;
     }
     sendTimeout(message) {
-        this.logger.logEvent({ message: `sendCommand:${message || 'timeout'}`, port: this.portName, cmd: this.cmdCurrent });
+        this.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;
@@ -371,7 +381,7 @@ class Daum8i {
             return false;
         }
         catch (err) {
-            this.logger.logEvent({ message: 'checkForResponse: Exception', port: this.portName, error: err.message, stack: err.stack });
+            this.logEvent({ message: 'checkForResponse: Exception', port: this.portName, error: err.message, stack: err.stack });
         }
         return true;
     }
@@ -408,7 +418,7 @@ class Daum8i {
             incoming = bufferData;
         }
         const response = [...incoming];
-        this.logger.logEvent({ message: 'sendCommand:RECV', data: (0, utils_1.hexstr)(response) });
+        this.logEvent({ message: 'sendCommand:RECV', data: (0, utils_1.hexstr)(response) });
         for (let i = 0; i < incoming.length; i++) {
             const getRemaining = () => {
                 let remaining = '';
@@ -421,7 +431,7 @@ class Daum8i {
             };
             const c = incoming.readUInt8(i);
             if (c === 0x06) {
-                this.logger.logEvent({ message: "sendCommand:ACK received:", port: portName });
+                this.logEvent({ message: "sendCommand:ACK received:", port: portName });
                 this.state.waitingForStart = true;
                 this.state.waitingForACK = false;
                 const remaining = getRemaining();
@@ -431,7 +441,7 @@ class Daum8i {
             else if (c === 0x15) {
                 this.state.waitingForStart = true;
                 this.state.waitingForACK = false;
-                this.logger.logEvent({ message: "sendCommand:NAK received:", port: portName });
+                this.logEvent({ message: "sendCommand:NAK received:", port: portName });
                 const remaining = getRemaining();
                 if (remaining && remaining !== '')
                     return this.onData(remaining);
@@ -441,7 +451,7 @@ class Daum8i {
             }
             else if (c === 0x17) {
                 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.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);
@@ -488,7 +498,7 @@ class Daum8i {
             }
             else {
                 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) });
+                this.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();
@@ -509,7 +519,7 @@ class Daum8i {
                 };
                 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 });
+                    this.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;
@@ -530,10 +540,10 @@ class Daum8i {
                 const message = (0, utils_1.buildMessage)(command, payload);
                 const start = Date.now();
                 const timeout = start + this.getTimeoutValue();
-                this.logger.logEvent({ message: "sendCommand:sending:", port: this.portName, cmd: command, hex: (0, utils_1.hexstr)(message) });
+                this.logEvent({ message: "sendCommand:sending:", port: this.portName, cmd: command, hex: (0, utils_1.hexstr)(message) });
                 this.state.writeBusy = true;
                 if (!this.connected || port === undefined) {
-                    this.logger.logEvent({ message: "sendCommand:error: not connected", port: this.portName });
+                    this.logEvent({ message: "sendCommand:error: not connected", port: this.portName });
                     writeDone();
                     return reject(new Error('not connected'));
                 }
@@ -552,7 +562,7 @@ class Daum8i {
                 }, 10);
             }
             catch (err) {
-                this.logger.logEvent({ message: "sendCommand:error:", port: portName, error: err.message, stack: err.stack });
+                this.logEvent({ message: "sendCommand:error:", port: portName, error: err.message, stack: err.stack });
                 writeDone();
                 reject(err);
             }
@@ -566,7 +576,7 @@ class Daum8i {
         }
         catch (err) { }
         this.state.writeBusy = false;
-        this.logger.logEvent({ message: "sendCommand:sending ACK", port, queue: this.state.commandsInQueue });
+        this.logEvent({ message: "sendCommand:sending ACK", port, queue: this.state.commandsInQueue });
     }
     sendNAK() {
         const port = this.portName;
@@ -574,7 +584,7 @@ class Daum8i {
             this.sp.write([0x15]);
         }
         catch (err) { }
-        this.logger.logEvent({ message: "sendCommand:sending NAK", port });
+        this.logEvent({ message: "sendCommand:sending NAK", port });
     }
     sendReservedDaum8iCommand(command, cmdType, data) {
         let buffer;
@@ -695,7 +705,7 @@ class Daum8i {
         });
     }
     setSlope(slope) {
-        this.logger.logEvent({ message: 'setSlope not implemted' });
+        this.logEvent({ message: 'setSlope not implemted' });
         return;
     }
     setPower(power) {
@@ -713,24 +723,24 @@ class Daum8i {
     }
     setPerson(person) {
         const { sex, age, length, weight } = person;
-        this.logger.logEvent({ message: 'setPerson() request', sex, age, length, weight });
+        this.logEvent({ message: 'setPerson() request', sex, age, length, weight });
         return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PERSON_SET, 'BF', (0, utils_1.getPersonData)(person))
             .then((res) => {
             const buffer = Buffer.from(res);
             const success = buffer.readInt16LE(0) === utils_1.ReservedCommands.PERSON_SET;
-            this.logger.logEvent({ message: 'setPerson() response', success, buffer });
+            this.logEvent({ message: 'setPerson() response', success, buffer });
             if (!success)
                 throw new Error('Illegal Response');
             return true;
         });
     }
     programUploadInit() {
-        this.logger.logEvent({ message: 'programUploadInit() request' });
+        this.logEvent({ message: 'programUploadInit() request' });
         return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PROGRAM_LIST_BEGIN, 'BF')
             .then((res) => {
             const buffer = Buffer.from(res);
             const success = buffer.readInt16LE(0) === utils_1.ReservedCommands.PROGRAM_LIST_BEGIN;
-            this.logger.logEvent({ message: 'programUploadInit() response', success, buffer });
+            this.logEvent({ message: 'programUploadInit() response', success, buffer });
             if (!success)
                 throw new Error('Illegal Response');
             return true;
@@ -756,15 +766,15 @@ class Daum8i {
         payload.writeInt16LE(wBits, 30);
         payload.writeInt32LE(7, 32);
         payload.writeInt32LE(eppLength, 36);
-        this.logger.logEvent({ message: 'programUploadStart() request', bikeType, length: eppLength });
+        this.logEvent({ message: 'programUploadStart() request', bikeType, length: eppLength });
         return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PROGRAM_LIST_NEW_PROGRAM, 'BF', payload)
             .then((res) => {
             const buffer = Buffer.from(res);
             if (buffer.readInt16LE(0) === utils_1.ReservedCommands.PROGRAM_LIST_NEW_PROGRAM) {
-                this.logger.logEvent({ message: 'programUploadStart() response', success: true });
+                this.logEvent({ message: 'programUploadStart() response', success: true });
                 return epp;
             }
-            this.logger.logEvent({ message: 'programUploadStart() response', success: false });
+            this.logEvent({ message: 'programUploadStart() response', success: false });
             throw new Error('Illegal Response');
         });
     }
@@ -778,14 +788,14 @@ class Daum8i {
         payload.writeInt32LE(offset, 4);
         const chunk = Buffer.from(epp.slice(offset, offset + size));
         chunk.copy(payload, 8);
-        this.logger.logEvent({ message: 'programUploadSendBlock() request', offset, size });
+        this.logEvent({ message: 'programUploadSendBlock() request', offset, size });
         return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PROGRAM_LIST_CONTINUE_PROGRAM, 'BF', payload)
             .then((res) => {
             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.logger.logEvent({ message: 'programUploadSendBlock() response' });
+            this.logEvent({ message: 'programUploadSendBlock() response' });
             if (!success)
                 throw new Error('Illegal Response');
             return true;
@@ -793,12 +803,12 @@ class Daum8i {
         });
     }
     programUploadDone() {
-        this.logger.logEvent({ message: 'programUploadDone() request' });
+        this.logEvent({ message: 'programUploadDone() request' });
         return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PROGRAM_LIST_END, 'BF')
             .then((res) => {
             const buffer = Buffer.from(res);
             const success = buffer.readInt16LE(0) === utils_1.ReservedCommands.PROGRAM_LIST_END;
-            this.logger.logEvent({ message: 'programUploadDone() response', success });
+            this.logEvent({ message: 'programUploadDone() response', success });
             if (!success)
                 throw new Error('Illegal Response');
             return true;
@@ -840,12 +850,12 @@ class Daum8i {
     startProgram(programId = 1) {
         const payload = Buffer.alloc(2);
         payload.writeInt16LE(programId, 0);
-        this.logger.logEvent({ message: 'startProgram() request', programId });
+        this.logEvent({ message: 'startProgram() request', programId });
         return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PROGRAM_LIST_START, 'BF', payload)
             .then((res) => {
             const buffer = Buffer.from(res);
             const success = buffer.readInt16LE(0) === utils_1.ReservedCommands.PROGRAM_LIST_START;
-            this.logger.logEvent({ message: 'startProgram() request', programId, success });
+            this.logEvent({ message: 'startProgram() request', programId, success });
             if (!success)
                 throw new Error('Illegal Response');
             return true;

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "incyclist-devices",
-  "version": "1.5.9",
+  "version": "1.5.11",
   "dependencies": {
     "@serialport/parser-byte-length": "^9.0.1",
     "@serialport/parser-delimiter": "^9.0.1",
     "@types/serialport": "^8.0.1",
     "gd-ant-plus": "^0.0.33",
-    "incyclist-ant-plus": "^0.1.6",
+    "incyclist-ant-plus": "^0.1.7",
     "win32filetime": "^1.0.2"
   },
   "peerDependencies": {