incyclist-devices 2.1.31 → 2.1.33

package/lib/antv2/pwr/adapter.js

@@ -34,6 +34,7 @@ class AntPwrAdapter extends adapter_1.default {
         const data = {
             power: bikeData.power,
             cadence: bikeData.pedalRpm,
+            speed: bikeData.speed,
             timestamp: Date.now()
         };
         if (bikeData.time)

package/lib/ble/cp/adapter.js

@@ -66,20 +66,15 @@ class PwrAdapter extends adapter_1.default {
     transformData(bikeData) {
         if (bikeData === undefined)
             return;
-        let distance = 0;
-        if (this.distanceInternal !== undefined && bikeData.distanceInternal !== undefined) {
-            distance = Math.round(bikeData.distanceInternal - this.distanceInternal);
-        }
-        if (bikeData.distanceInternal !== undefined)
-            this.distanceInternal = bikeData.distanceInternal;
         let data = {
             speed: bikeData.speed,
-            slope: bikeData.slope,
-            power: bikeData.power !== undefined ? Math.round(bikeData.power) : undefined,
-            cadence: bikeData.pedalRpm !== undefined ? Math.round(bikeData.pedalRpm) : undefined,
-            distance,
+            power: bikeData.power,
+            cadence: bikeData.pedalRpm,
             timestamp: Date.now()
         };
+        if (bikeData.time)
+            data.deviceTime = bikeData.time;
+        this.data = data;
         return data;
     }
     stop() {

package/lib/serial/daum/DaumAdapter.d.ts

@@ -24,6 +24,7 @@ export default class DaumAdapter<S extends SerialDeviceSettings, P extends Devic
     updateBusy: boolean;
     startPromise: Promise<boolean>;
     checkPromise: Promise<boolean>;
+    internalEmitter: EventEmitter;
     constructor(settings: S, props?: P);
     getPort(): string;
     getSerialInterface(): SerialInterface;

package/lib/serial/daum/DaumAdapter.js

@@ -26,6 +26,7 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
         this.adapterTime = 0;
         this.requestBusy = false;
         this.updateBusy = false;
+        this.internalEmitter = new events_1.default();
         this.iv = undefined;
         this.deviceData = {
             isPedalling: false,
@@ -216,7 +217,9 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
                     this.started = true;
                     return true;
                 }));
+                this.internalEmitter.emit('start');
                 const started = yield this.startPromise;
+                this.internalEmitter.emit('started', started);
                 this.startPromise = undefined;
                 return started;
             }
@@ -340,8 +343,11 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
     }
     stop() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.stopped)
+            console.log('~~~ STOP', this.stopped);
+            if (this.stopped) {
                 return true;
+            }
+            this.internalEmitter.emit('stop');
             this.logEvent({ message: 'stop request', port: this.getPort() });
             if (this.paused)
                 this.resume();
@@ -355,6 +361,7 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
                 this.logEvent({ message: 'stop request failed', port: this.getPort(), reason: err.message });
                 throw (err);
             }
+            this.internalEmitter.emit('stopped', this.stopped);
             return this.stopped;
         });
     }

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

@@ -99,9 +99,14 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
         const user = this.getUser();
         const { gear = consts_1.DEFAULT_GEAR } = props;
         this.initData();
+        let stopped = false;
         let startState = {};
-        return (0, utils_1.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () {
+        const start = () => __awaiter(this, void 0, void 0, function* () {
             try {
+                if (stopped) {
+                    this.started = false;
+                    return false;
+                }
                 this.logEvent({ message: 'start attempt', isRelaunch, isConnected: this.getComms().isConnected() });
                 if (!isRelaunch && !this.getComms().isConnected()) {
                     yield this.verifyConnection();
@@ -136,13 +141,15 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
                 startState.checkRunData = true;
                 const data = yield this.getComms().runData();
                 if (startRequest.targetPower && startRequest.targetPower !== 25 && data.power === 25) {
-                    throw new Error('invalid device response: runData');
+                    throw (new Error('invalid device response: runData'));
                 }
                 this.started = true;
                 this.startUpdatePull();
-                return true;
+                return (true);
             }
             catch (err) {
+                if (stopped)
+                    return false;
                 this.logEvent({ message: 'start attempt failed', error: err.message });
                 this.started = false;
                 if (startState.checkRunData) {
@@ -150,7 +157,15 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
                 }
                 throw (new Error(`could not start device, reason:${err.message}`));
             }
-        }), 5, 1000);
+        });
+        const checkInterrupt = () => new Promise(done => {
+            this.internalEmitter.on('stop', () => {
+                stopped = true;
+                this.started = false;
+                done(false);
+            });
+        });
+        return (0, utils_1.runWithRetries)(() => Promise.race([start(), checkInterrupt()]), 5, 1000);
     }
     getCurrentBikeData() {
         return __awaiter(this, void 0, void 0, function* () {

package/lib/serial/daum/premium/adapter.d.ts

@@ -21,7 +21,7 @@ export default class DaumPremiumAdapter extends DaumAdapter<SerialDeviceSettings
     getStartRetries(): number;
     getStartRetryTimeout(): number;
     restart(pause?: number): Promise<boolean>;
-    performStart(props?: DaumPremiumDeviceProperties, _isRelaunch?: boolean, wasPaused?: boolean): Promise<boolean>;
+    performStart(props?: DaumPremiumDeviceProperties, _isRelaunch?: boolean, wasPaused?: boolean): Promise<any>;
     requiresProgramUpload(): boolean;
     getCurrentBikeData(): Promise<IncyclistBikeData>;
     getDeviceInfo(): Promise<any>;

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

@@ -139,8 +139,12 @@ class DaumPremiumAdapter extends DaumAdapter_1.default {
             if (!wasPaused)
                 yield this.stop();
             var info = {};
-            yield (0, utils_1.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () {
+            let stopped = false;
+            this.stopped = false;
+            const start = () => __awaiter(this, void 0, void 0, function* () {
                 try {
+                    if (stopped)
+                        return false;
                     if (wasPaused) {
                         info.deviceType = 'Resumed';
                         info.version = "Resumed";
@@ -177,21 +181,33 @@ class DaumPremiumAdapter extends DaumAdapter_1.default {
                     if (!this.getCyclingMode().getModeProperty('eppSupport')) {
                         info.gear = yield this.getComms().setGear(this.deviceData.gear || gear || DEFAULT_GEAR);
                     }
-                    return;
+                    return true;
                 }
                 catch (err) {
+                    if (stopped)
+                        return false;
                     if (info.connected && !info.deviceType) {
                         yield (0, utils_1.sleep)(500);
                         yield this.reconnect();
                     }
                     throw (err);
                 }
-            }), this.getStartRetries(), this.getStartRetryTimeout());
-            this.stopped = false;
-            this.paused = false;
-            this.started = true;
-            this.startUpdatePull();
-            return true;
+            });
+            const checkInterrupt = () => new Promise(done => {
+                this.internalEmitter.on('stop', () => {
+                    stopped = true;
+                    this.started = false;
+                    done(false);
+                });
+            });
+            const started = yield (0, utils_1.runWithRetries)(() => Promise.race([start(), checkInterrupt()]), this.getStartRetries(), this.getStartRetryTimeout());
+            if (started) {
+                this.stopped = false;
+                this.paused = false;
+                this.started = true;
+                this.startUpdatePull();
+            }
+            return started;
         });
     }
     requiresProgramUpload() {

package/package.json

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

package/lib/adapters.d.ts

@@ -1,7 +0,0 @@
-import { IncyclistDeviceAdapter } from "./base/adpater";
-import { DeviceProperties, DeviceSettings } from "./types/device";
-export default class AdapterFactory {
-    static adapters: IncyclistDeviceAdapter[];
-    static reset(): void;
-    static create(settings: DeviceSettings, props?: DeviceProperties): any;
-}

package/lib/adapters.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const antv2_1 = require("./antv2");
-const ble_1 = require("./ble");
-const serial_1 = require("./serial");
-const Simulator_1 = require("./simulator/Simulator");
-const device_1 = require("./types/device");
-class AdapterFactory {
-    static reset() {
-        AdapterFactory.adapters = [];
-        ble_1.BleAdapterFactory.getInstance().instances = [];
-    }
-    static create(settings, props) {
-        const adapters = AdapterFactory.adapters;
-        if (!settings.interface && settings.protocol === 'Simulator') {
-            const adapter = new Simulator_1.Simulator(settings);
-            if (adapter) {
-                adapters.push(adapter);
-            }
-            return adapter;
-        }
-        const existing = adapters.find(a => a.isEqual(settings));
-        if (existing)
-            return existing;
-        const ifaceName = typeof settings.interface === 'string' ? settings.interface : settings.interface.getName();
-        let adapter;
-        switch (ifaceName) {
-            case device_1.INTERFACE.SERIAL:
-            case device_1.INTERFACE.TCPIP:
-                adapter = serial_1.SerialAdapterFactory.getInstance().createInstance(settings, props);
-                break;
-            case device_1.INTERFACE.ANT:
-                adapter = antv2_1.AntAdapterFactory.getInstance().createInstance(settings, props);
-                break;
-            case device_1.INTERFACE.BLE:
-                adapter = ble_1.BleAdapterFactory.getInstance().createInstance(settings, props);
-                break;
-            case device_1.INTERFACE.SIMULATOR:
-                adapter = new Simulator_1.Simulator(settings, props);
-                break;
-        }
-        if (adapter) {
-            adapters.push(adapter);
-        }
-        return adapter;
-    }
-}
-AdapterFactory.adapters = [];
-exports.default = AdapterFactory;

package/lib/antv2/adapter-factory.d.ts

@@ -1,14 +0,0 @@
-import { Profile } from "incyclist-ant-plus";
-import AntAdapter from "./base/adapter";
-import { AntDeviceProperties, AntDeviceSettings, LegacyProfile, BaseDeviceData } from "./types";
-import { AntAdapterInfo, AdapterQuery } from "./types";
-export default class AntAdapterFactory {
-    static _instance: AntAdapterFactory;
-    adapters: AntAdapterInfo[];
-    static getInstance(): AntAdapterFactory;
-    constructor();
-    register<TDeviceData extends BaseDeviceData>(antProfile: Profile, incyclistProfile: LegacyProfile, Adapter: typeof AntAdapter<TDeviceData>): void;
-    getAdapter(query?: AdapterQuery): any;
-    createInstance(settings: AntDeviceSettings, props?: AntDeviceProperties): any;
-    createFromDetected(profile: Profile, deviceID: number, props?: AntDeviceProperties): any;
-}

package/lib/antv2/adapter-factory.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class AntAdapterFactory {
-    static getInstance() {
-        if (!AntAdapterFactory._instance)
-            AntAdapterFactory._instance = new AntAdapterFactory();
-        return AntAdapterFactory._instance;
-    }
-    constructor() {
-        this.adapters = [];
-    }
-    register(antProfile, incyclistProfile, Adapter) {
-        const info = Object.assign({}, { antProfile, incyclistProfile, Adapter });
-        const existing = this.adapters.findIndex(a => a.antProfile === antProfile);
-        if (existing !== -1)
-            this.adapters[existing] = info;
-        else
-            this.adapters.push(info);
-    }
-    getAdapter(query) {
-        const { antProfile, incyclistProfile } = query;
-        if (!antProfile && !incyclistProfile)
-            throw new Error('Illegal arguments: either "antProfile" or "incyclistProfile" must be set');
-        let found;
-        if (antProfile)
-            found = this.adapters.find(a => a.antProfile === antProfile);
-        if (incyclistProfile)
-            found = this.adapters.find(a => a.incyclistProfile === incyclistProfile);
-        return found;
-    }
-    createInstance(settings, props) {
-        let info;
-        const { profile, protocol } = settings;
-        let isLegacy = false;
-        if (protocol) {
-            try {
-                const incyclistProfile = profile;
-                info = this.getAdapter({ incyclistProfile });
-                isLegacy = true;
-            }
-            catch (_a) {
-                isLegacy = false;
-            }
-        }
-        if (!isLegacy) {
-            const antProfile = profile;
-            info = this.getAdapter({ antProfile });
-        }
-        if (info && info.Adapter)
-            return new info.Adapter(settings, props);
-    }
-    createFromDetected(profile, deviceID, props) {
-        const info = this.getAdapter({ antProfile: profile });
-        if (!info || !info.Adapter)
-            return;
-        const settings = Object.assign({}, {
-            profile: info.incyclistProfile,
-            deviceID: deviceID.toString(),
-            interface: 'ant',
-            protocol: 'Ant'
-        });
-        return new info.Adapter(settings, props);
-    }
-}
-exports.default = AntAdapterFactory;

package/lib/antv2/adapter.d.ts

@@ -1,54 +0,0 @@
-/// <reference types="node" />
-import { IChannel, ISensor, Profile } from 'incyclist-ant-plus';
-import AntInterface from './ant-interface';
-import IncyclistDevice from '../base/adpater';
-import { AntDeviceProperties, AntDeviceSettings, BaseDeviceData } from './types';
-import { IAdapter, IncyclistAdapterData, IncyclistBikeData } from '../types';
-export default class AntAdapter<TDeviceData extends BaseDeviceData> extends IncyclistDevice<AntDeviceProperties> {
-    sensor: ISensor;
-    data: IncyclistAdapterData;
-    deviceData: TDeviceData;
-    updateFrequency: number;
-    channel: IChannel;
-    ant: AntInterface;
-    userSettings: {
-        weight?: number;
-    };
-    bikeSettings: {
-        weight?: number;
-    };
-    onDataFn: (data: IncyclistAdapterData) => void;
-    startupRetryPause: number;
-    protected ivDataTimeout: NodeJS.Timeout;
-    protected lastDataTS: number;
-    protected dataMsgCount: number;
-    protected ivWaitForData: NodeJS.Timeout;
-    constructor(settings: AntDeviceSettings, props?: AntDeviceProperties);
-    createSensor(settings: AntDeviceSettings): ISensor;
-    isEqual(settings: AntDeviceSettings): boolean;
-    connect(): Promise<boolean>;
-    close(): Promise<boolean>;
-    resetData(): void;
-    isSame(device: IAdapter): boolean;
-    hasData(): boolean;
-    mapData(deviceData: TDeviceData): IncyclistBikeData;
-    transformData(data: IncyclistBikeData): void;
-    mapToAdapterData(deviceData: any): void;
-    onDeviceData(deviceData: TDeviceData): void;
-    isWaitingForData(): boolean;
-    waitForData(timeout: number): Promise<boolean>;
-    getID(): string;
-    getName(): string;
-    getInterface(): string;
-    getProfile(): Profile;
-    getLogData(data: any, excludeList: any): any;
-    triggerTimeoutCheck(): void;
-    startDataTimeoutCheck(): void;
-    stopDataTimeoutCheck(): void;
-    check(): Promise<boolean>;
-    checkCapabilities(): Promise<void>;
-    initControl(): Promise<void>;
-    sendUpdate(request: any): void;
-    start(props?: AntDeviceProperties): Promise<boolean>;
-    stop(): Promise<boolean>;
-}