incyclist-devices 2.1.4 → 2.1.6

package/lib/antv2/base/adapter.js

@@ -333,9 +333,12 @@ class AntAdapter extends adpater_1.default {
             try {
                 this.sensorConnected = yield this.startSensor();
                 if (this.sensorConnected) {
-                    this.logEvent({ message: 'sensor started', props });
+                    this.logEvent({ message: 'sensor started', device: this.getName(), props });
                     this.startStatus.sensorStarted = true;
                 }
+                else {
+                    this.logEvent({ message: 'start sensor failed', device: this.getName(), reason: 'unknown', props });
+                }
             }
             catch (err) {
                 this.logEvent({ message: 'start sensor failed', device: this.getName(), reason: err.message, props });

package/lib/antv2/fe/adapter.d.ts

@@ -15,6 +15,7 @@ export default class AntFEAdapter extends AntAdapter<FitnessEquipmentSensorState
     protected distanceInternal?: number;
     protected startProps: AntDeviceProperties;
     protected promiseReconnect: Promise<boolean>;
+    protected promiseSendUpdate: Promise<boolean>;
     constructor(settings: AntDeviceSettings, props?: AntDeviceProperties);
     getDisplayName(): string;
     isReconnecting(): boolean;

package/lib/antv2/fe/adapter.js

@@ -40,19 +40,26 @@ class AntFEAdapter extends adapter_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             if ((this.paused || this.isReconnecting()) && !forced)
                 return;
+            if (this.promiseSendUpdate) {
+                this.logEvent({ message: 'send bike update skipped', device: this.getName(), request, reason: 'busy' });
+                return;
+            }
             let isReset = request.reset && Object.keys(request).length === 1;
             const update = isReset ? this.getCyclingMode().getBikeInitRequest() : this.getCyclingMode().sendBikeUpdate(request);
             this.logEvent({ message: 'send bike update requested', device: this.getName(), update, request });
             try {
                 const fe = this.sensor;
                 if (update.slope !== undefined) {
-                    yield fe.sendTrackResistance(update.slope);
+                    this.promiseSendUpdate = fe.sendTrackResistance(update.slope);
                 }
                 if (update.targetPower !== undefined) {
-                    yield fe.sendTargetPower(update.targetPower);
+                    this.promiseSendUpdate = fe.sendTargetPower(update.targetPower);
                 }
+                yield this.promiseSendUpdate;
+                delete this.promiseSendUpdate;
             }
             catch (err) {
+                delete this.promiseSendUpdate;
                 if (err.message && err.message.toLowerCase() === 'timeout') {
                     this.emit('timeout');
                     if (this.startProps.automaticReconnect) {

package/lib/ble/base/adapter.js

@@ -141,10 +141,8 @@ class BleAdapter extends adpater_1.default {
     }
     start(props = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            const wasPaused = this.paused;
             const wasStopped = this.stopped;
-            if (wasPaused)
-                this.resume();
+            this.resume();
             if (this.started && !wasStopped)
                 return true;
             this.stopped = false;

package/lib/ble/base/comms.js

@@ -61,10 +61,12 @@ class BleComms extends events_1.default {
         return this.connectState.isConnected;
     }
     pause() {
+        this.ble.pauseLogging();
         this.paused = true;
     }
     resume() {
         this.paused = false;
+        this.ble.resumeLogging();
     }
     getServiceUUids() {
         throw new Error("Method not implemented.");
@@ -174,9 +176,9 @@ class BleComms extends events_1.default {
     }
     initDevice() {
         this.logEvent({ message: 'get device info' });
-        return this.getDeviceInfo().then(() => {
-            this.emit('deviceInfo', this.deviceInfo);
-            this.logEvent(Object.assign({ message: 'device init done' }, this.deviceInfo));
+        return this.getDeviceInfo().then((info) => {
+            this.emit('deviceInfo', info);
+            this.logEvent(Object.assign({ message: 'device init done' }, info));
             this.isInitialized = true;
             return true;
         });
@@ -282,6 +284,7 @@ class BleComms extends events_1.default {
     }
     connect(props) {
         return __awaiter(this, void 0, void 0, function* () {
+            this.ble.resumeLogging();
             if (!this.ble.isConnected()) {
                 try {
                     yield this.ble.connect();
@@ -382,6 +385,7 @@ class BleComms extends events_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             const { id, name, address } = this;
             this.logEvent({ message: 'disconnect requested', device: { id, name, address } });
+            this.ble.pauseLogging();
             this.connectState.isDisconnecting = true;
             if (this.workerIv) {
                 this.stopWorker();

package/lib/ble/bindings/linux.d.ts

@@ -9,6 +9,8 @@ export declare class BleLinuxBinding extends EventEmitter implements BleBinding
     static getInstance(): any;
     startScanning(serviceUUIDs?: string[] | undefined, allowDuplicates?: boolean | undefined, callback?: ((error?: Error | undefined) => void) | undefined): void;
     stopScanning(callback?: (() => void) | undefined): void;
+    pauseLogging(): void;
+    resumeLogging(): void;
     on(eventName: string | symbol, listener: (...args: any[]) => void): this;
 }
 declare const Binding: any;

package/lib/ble/bindings/linux.js

@@ -23,6 +23,10 @@ class BleLinuxBinding extends events_1.default {
     stopScanning(callback) {
         throw new Error('Method not implemented.');
     }
+    pauseLogging() {
+    }
+    resumeLogging() {
+    }
     on(eventName, listener) {
         super.addListener(eventName, listener);
         if (eventName === 'stateChange') {

package/lib/ble/bindings/mock.js

@@ -29,6 +29,10 @@ class Binding extends events_1.default {
         return Binding._instance;
     }
     init() { }
+    pauseLogging() {
+    }
+    resumeLogging() {
+    }
     addMock(peripheral) {
         this.peripherals.push(peripheral);
     }

package/lib/ble/ble-interface.d.ts

@@ -43,6 +43,7 @@ export default class BleInterface extends EventEmitter implements IncyclistInter
         comms: BleComms;
         cb: (data: any) => void;
     }[];
+    loggingPaused: boolean;
     static _instance: BleInterface;
     static getInstance(props?: {
         binding?: BleBinding;
@@ -57,6 +58,9 @@ export default class BleInterface extends EventEmitter implements IncyclistInter
     stopConnectSensor(): void;
     waitForSensorConnectionFinish(): Promise<void>;
     getAdapterFactory(): BleAdapterFactory;
+    pauseLogging(): void;
+    resumeLogging(): void;
+    isDebugEnabled(): boolean;
     logEvent(event: any): void;
     onStateChange(state: BleInterfaceState): void;
     onError(err: any): void;

package/lib/ble/ble-interface.js

@@ -51,6 +51,7 @@ class BleInterface extends events_1.default {
             this.logger = props.logger;
         else
             this.logger = new gd_eventlog_1.EventLogger('BLE');
+        this.loggingPaused = false;
     }
     getBinding() { return this.binding; }
     setBinding(binding) { if (binding)
@@ -75,12 +76,38 @@ class BleInterface extends events_1.default {
     getAdapterFactory() {
         return adapter_factory_1.default.getInstance();
     }
-    logEvent(event) {
-        if (this.logger) {
-            this.logger.logEvent(event);
+    pauseLogging() {
+        this.logEvent({ message: 'pause logging on BLE Interface' });
+        this.loggingPaused = true;
+        try {
+            this.getBinding().pauseLogging();
         }
+        catch (_a) { }
+    }
+    resumeLogging() {
+        const event = { message: 'resume logging on BLE Interface' };
+        this.logger.logEvent(event);
+        if (this.isDebugEnabled()) {
+            console.log('~~~ BLE', event);
+        }
+        this.loggingPaused = false;
+        try {
+            this.getBinding().resumeLogging();
+        }
+        catch (_a) { }
+    }
+    isDebugEnabled() {
         const w = global.window;
         if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.BLE_DEBUG) {
+            return true;
+        }
+        return false;
+    }
+    logEvent(event) {
+        if (this.logger && !this.loggingPaused) {
+            this.logger.logEvent(event);
+        }
+        if (this.isDebugEnabled()) {
             console.log('~~~ BLE', event);
         }
     }
@@ -98,6 +125,7 @@ class BleInterface extends events_1.default {
         this.logEvent({ message: 'error', error: err.message, stack: err.stack });
     }
     connect(to) {
+        this.resumeLogging();
         const timeout = this.props.timeout || to || 2000;
         return new Promise((resolve, reject) => {
             if (this.connectState.isConnected) {
@@ -186,6 +214,7 @@ class BleInterface extends events_1.default {
                 this.connectState.timeout = null;
             }
             this.logEvent({ message: 'disconnect result: success' });
+            this.pauseLogging();
             return true;
         });
     }

package/lib/ble/fm/comms.d.ts

@@ -35,7 +35,7 @@ export default class BleFitnessMachineDevice extends BleComms {
     getWindSpeed(): number;
     parseIndoorBikeData(_data: Uint8Array): IndoorBikeData;
     parseFitnessMachineStatus(_data: Uint8Array): IndoorBikeData;
-    getFitnessMachineFeatures(): Promise<IndoorBikeFeatures>;
+    getFitnessMachineFeatures(): Promise<IndoorBikeFeatures | undefined>;
     onData(characteristic: string, data: Buffer): boolean;
     writeFtmsMessage(requestedOpCode: any, data: any, props?: BleWriteProps): Promise<number>;
     requestControl(): Promise<boolean>;

package/lib/ble/fm/comms.js

@@ -76,7 +76,7 @@ class BleFitnessMachineDevice extends comms_1.BleComms {
         this.cw = 0.6;
         this.windSpeed = 0;
         this.wheelSize = 2100;
-        this.data = {};
+        this.reset();
         this.services = BleFitnessMachineDevice.services;
     }
     static isMatching(characteristics) {
@@ -310,6 +310,7 @@ class BleFitnessMachineDevice extends comms_1.BleComms {
             }
             catch (err) {
                 this.logEvent({ message: 'could not read FitnessMachineFeatures', error: err.message, stack: err.stack });
+                return undefined;
             }
         });
     }

package/lib/ble/tacx/comms.js

@@ -12,7 +12,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const _1 = require(".");
 const consts_1 = require("../consts");
 const comms_1 = __importDefault(require("../fm/comms"));
 const utils_1 = require("../utils");
@@ -88,7 +87,7 @@ class TacxAdvancedFitnessMachineDevice extends comms_1.default {
         return 'Smart Trainer';
     }
     getProtocol() {
-        return _1.BleTacxComms.protocol;
+        return TacxAdvancedFitnessMachineDevice.protocol;
     }
     getServiceUUids() {
         return TacxAdvancedFitnessMachineDevice.services;

package/lib/ble/types.d.ts

@@ -8,6 +8,8 @@ export type BleInterfaceState = 'unknown' | 'resetting' | 'unsupported' | 'unaut
 export interface BleBinding extends EventEmitter {
     startScanning(serviceUUIDs?: string[], allowDuplicates?: boolean, callback?: (error?: Error) => void): void;
     stopScanning(callback?: () => void): void;
+    pauseLogging(): any;
+    resumeLogging(): any;
     _bindings: any;
     state: BleInterfaceState;
     on(eventName: string | symbol, listener: (...args: any[]) => void): this;

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

@@ -5,6 +5,7 @@ import { SerialCommProps } from '../../types';
 import { DeviceType, IncyclistBikeData, User } from '../../../types';
 export default class Daum8008 extends SerialPortComms<DaumClassicCommsState, DaumClassicRequest, DaumClassicResponse> implements DaumSerialComms {
     protected bikeNo: number;
+    protected prevFailedPayload: any;
     constructor(props: SerialCommProps);
     validatePath(path: string): string;
     getDefaultLoggerName(): string;

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

@@ -17,7 +17,7 @@ const comms_1 = __importDefault(require("../../base/comms"));
 const utils_2 = require("./utils");
 const types_1 = require("../types");
 const ByteLength = require('@serialport/parser-byte-length');
-const TIMEOUT_SEND = 2000;
+const TIMEOUT_SEND = 5000;
 class Daum8008 extends comms_1.default {
     constructor(props) {
         super(props);
@@ -65,11 +65,12 @@ class Daum8008 extends comms_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             this.initForResponse(expected);
             yield this.write(Buffer.from(payload));
-            const response = yield this.waitForResponse();
+            let response = yield this.waitForResponse();
             if (response.type === 'Error')
                 throw response.error;
             if (response.data[0] !== payload[0]) {
                 this.portFlush();
+                this.logEvent({ message: "sendCommand:received:", port: this.path, hex: Buffer.from(response.data).toString('hex') });
                 throw new Error('illegal response');
             }
             return response;
@@ -91,11 +92,13 @@ class Daum8008 extends comms_1.default {
                     const res = yield this.doSend(expected, payload);
                     this.logEvent(Object.assign(Object.assign({ message: "sendCommand:received:" }, logPayload), { hex: Buffer.from(res.data).toString('hex') }));
                     this.sendCmdPromise = null;
+                    this.prevFailedPayload = null;
                     resolve(res);
                 }
                 catch (err) {
                     this.logEvent(Object.assign(Object.assign({ message: "sendCommand:error:" }, logPayload), { error: err.message }));
                     this.sendCmdPromise = null;
+                    this.prevFailedPayload = payload;
                     reject(err);
                 }
             }));

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

@@ -569,7 +569,7 @@ class Daum8i extends comms_1.default {
                 }
             }
             catch (err) {
-                this.logEvent({ message: 'error', fn: 'programUpload', error: err.message, stack: err.stack });
+                this.logEvent({ message: 'programUpload failed', reason: err.message });
                 return false;
             }
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-devices",
-  "version": "2.1.4",
+  "version": "2.1.6",
   "dependencies": {
     "@serialport/bindings-interface": "^1.2.2",
     "@serialport/parser-byte-length": "^9.0.1",