incyclist-devices 2.1.15 → 2.1.18

package/lib/antv2/base/ant-interface.js

@@ -0,0 +1,285 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        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 });
+const events_1 = __importDefault(require("events"));
+const gd_eventlog_1 = require("gd-eventlog");
+const sensor_factory_1 = __importDefault(require("../factories/sensor-factory"));
+class AntInterface extends events_1.default {
+    static getInstance(props = {}) {
+        if (AntInterface._instance === undefined)
+            AntInterface._instance = new AntInterface(props);
+        return AntInterface._instance;
+    }
+    static hasInstance() {
+        return AntInterface._instance !== undefined;
+    }
+    constructor(props) {
+        super();
+        this.props = props;
+        this.device = undefined;
+        this.connectState = {
+            connected: false,
+            connecting: false
+        };
+        const { binding, logger } = props;
+        if (logger)
+            this.logger = logger;
+        else {
+            this.logger = new gd_eventlog_1.EventLogger('Ant+');
+        }
+        if (binding) {
+            this.Binding = binding;
+        }
+    }
+    getName() {
+        return AntInterface.INTERFACE_NAME;
+    }
+    getBinding() {
+        return this.Binding;
+    }
+    setBinding(binding) {
+        this.Binding = binding;
+    }
+    setLogger(logger) {
+        this.logger = logger;
+    }
+    logEvent(event) {
+        if (this.logger)
+            this.logger.logEvent(event);
+        const w = global.window;
+        if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.ANT_DEBUG) {
+            console.log('~~~ ANT', event);
+        }
+    }
+    isConnected() {
+        return this.connectState.connected;
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isConnected())
+                return true;
+            if (!this.connectState.connecting) {
+                this.connectState.connecting = true;
+                this.logEvent({ message: 'ANT+ connecting ...' });
+                try {
+                    const device = new this.Binding(Object.assign(Object.assign({}, this.props), { logger: this.logger }));
+                    const opened = yield device.open();
+                    if (!opened) {
+                        this.logEvent({ message: 'ANT+ not connected' });
+                        this.connectState.connecting = false;
+                        return false;
+                    }
+                    this.device = device;
+                    this.connectState.connected = true;
+                    this.connectState.connecting = false;
+                    this.logEvent({ message: 'ANT+ connected' });
+                    return true;
+                }
+                catch (err) {
+                    this.logEvent({ message: 'error', fn: 'connect', error: err.message, stack: err.stack });
+                    this.connectState.connected = false;
+                    this.connectState.connecting = false;
+                    return false;
+                }
+            }
+            else {
+                return new Promise(resolve => {
+                    setInterval(() => {
+                        if (!this.connectState.connecting)
+                            resolve(this.connectState.connected);
+                    }, 500);
+                });
+            }
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.device)
+                return true;
+            this.logEvent({ message: 'ANT+ disconnecting ...' });
+            const closed = yield this.device.close();
+            this.connectState.connected = !closed;
+            this.logEvent({ message: 'ANT+ disconnected' });
+            return closed;
+        });
+    }
+    onError(profile, error) {
+        this.logEvent({ message: 'ANT+ERROR:', profile, error });
+    }
+    onData(profile, id, data, tag) {
+        this.emit('data', profile, id, data, tag);
+    }
+    scan(props = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'starting scan ..' });
+            const detected = [];
+            const onDetected = (profile, deviceID) => {
+                if (deviceID && detected.find(s => s.deviceID === deviceID && s.profile === profile) === undefined) {
+                    try {
+                        detected.push({ interface: this.getName(), profile, deviceID });
+                        this.emit('device', { interface: 'ant', profile, deviceID });
+                    }
+                    catch (err) {
+                        this.logEvent({ message: 'error', fn: 'onDerected', error: err.message, stack: err.stack });
+                    }
+                }
+            };
+            let channel;
+            if (!this.activeScan) {
+                while (!this.isConnected()) {
+                    const connected = yield this.connect();
+                    if (!connected)
+                        return [];
+                }
+                channel = this.device.getChannel();
+                channel.setProps({ logger: this.logger });
+                if (!channel)
+                    return [];
+                const sensors = sensor_factory_1.default.createAll();
+                sensors.forEach((sensor) => {
+                    channel.attach(sensor);
+                });
+                channel.on('detected', onDetected);
+                channel.on('data', this.onData.bind(this));
+                try {
+                    const success = yield channel.startScanner();
+                    this.logEvent({ message: 'scan started', success });
+                }
+                catch (err) {
+                    this.logEvent({ message: 'scan could not be started', error: err.message, stack: err.stack });
+                    channel.off('detected', onDetected);
+                    channel.off('data', this.onData.bind(this));
+                    return [];
+                }
+                let iv;
+                return new Promise(resolve => {
+                    this.activeScan = channel;
+                    const start = Date.now();
+                    const timeout = props.timeout ? start + props.timeout : undefined;
+                    iv = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+                        if (this.activeScan && (!timeout || Date.now() < timeout))
+                            return;
+                        clearInterval(iv);
+                        if (this.activeScan)
+                            yield this.stopScan();
+                        this.emit('stop-scan');
+                        channel.off('detected', onDetected);
+                        channel.off('data', this.onData.bind(this));
+                        resolve(detected);
+                    }), 100);
+                });
+            }
+            else {
+                return new Promise(resolve => {
+                    channel = this.activeScan;
+                    channel.on('data', this.onData.bind(this));
+                    channel.on('detected', onDetected);
+                    this.once('stop-scan', () => {
+                        channel.off('detected', onDetected);
+                        channel.off('data', this.onData.bind(this));
+                        resolve(detected);
+                    });
+                });
+            }
+        });
+    }
+    stopScan() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'stopping scan ..' });
+            if (!this.activeScan)
+                return false;
+            const channel = this.activeScan;
+            try {
+                const stopped = yield channel.stopScanner();
+                this.activeScan = undefined;
+                this.logEvent({ message: 'scan stopped' });
+                return stopped;
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', fn: 'stopScan()', error: err.message, stack: err.stack });
+                return false;
+            }
+        });
+    }
+    startSensor(sensor, onDeviceData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isConnected()) {
+                const connected = yield this.connect();
+                if (!connected)
+                    return false;
+            }
+            let channel;
+            channel = this.device.getChannel();
+            channel.setProps({ logger: this.logger });
+            if (!channel)
+                return false;
+            channel.on('data', this.onData.bind(this));
+            sensor.setChannel(channel);
+            this.on('data', (profile, deviceID, data) => {
+                if (profile === sensor.getProfile() && deviceID === sensor.getDeviceID())
+                    onDeviceData(data);
+            });
+            try {
+                return yield channel.startSensor(sensor);
+            }
+            catch (err) {
+                this.logEvent({ message: 'could not start sensor', error: err.message || err, stack: err.stack });
+                try {
+                    yield channel.stopSensor(sensor);
+                }
+                catch (_a) { }
+                return false;
+            }
+        });
+    }
+    stopSensor(sensor) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isConnected() || !this.device) {
+                return true;
+            }
+            const channel = sensor.getChannel();
+            if (channel) {
+                try {
+                    if (!channel.flush) {
+                        this.logEvent({ message: 'old version of ant-channel detected' });
+                        channel.flush = () => {
+                            const c = channel;
+                            c.messageQueue.forEach(msg => { msg.resolve(false); });
+                            c.messageQueue = [];
+                            c.isWriting = false;
+                        };
+                    }
+                    channel.flush();
+                    channel.removeAllListeners('data');
+                    const stopped = yield channel.stopSensor(sensor);
+                    return stopped;
+                }
+                catch (err) {
+                    this.logEvent({ message: 'could not stop sensor', error: err.message || err, deviceID: sensor.getDeviceID(), stack: err.stack });
+                    return false;
+                }
+            }
+            else {
+                this.logEvent({ message: 'could not stop sensor', deviceID: sensor.getDeviceID(), error: 'no channel attached' });
+                return false;
+            }
+        });
+    }
+    isScanning() {
+        return (this.activeScan === undefined || this.activeScan === null);
+    }
+}
+AntInterface._instance = undefined;
+AntInterface.INTERFACE_NAME = 'ant';
+exports.default = AntInterface;

package/lib/antv2/binding.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { IAntDevice, IChannel } from 'incyclist-ant-plus';
+import { AntInterfaceProps } from './ant-interface';
+export default class AntDeviceBinding implements IAntDevice {
+    constructor(_props: AntInterfaceProps);
+    open(): Promise<boolean>;
+    close(): Promise<boolean>;
+    getMaxChannels(): number;
+    getChannel(): IChannel;
+    freeChannel(channel: IChannel): void;
+    getDeviceNumber(): number;
+    write(data: Buffer): void;
+}

package/lib/antv2/binding.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class AntDeviceBinding {
+    constructor(_props) { }
+    open() {
+        throw new Error('Method not implemented.');
+    }
+    close() {
+        throw new Error('Method not implemented.');
+    }
+    getMaxChannels() {
+        throw new Error('Method not implemented.');
+    }
+    getChannel() {
+        throw new Error('Method not implemented.');
+    }
+    freeChannel(channel) {
+        throw new Error('Method not implemented.');
+    }
+    getDeviceNumber() {
+        throw new Error('Method not implemented.');
+    }
+    write(data) {
+        throw new Error('Method not implemented.');
+    }
+}
+exports.default = AntDeviceBinding;

package/lib/antv2/hr copy/adapter.d.ts

@@ -0,0 +1,11 @@
+import { HeartRateSensorState, Profile } from "incyclist-ant-plus";
+import AntAdapter from "../base/adapter";
+import { AntDeviceProperties, AntDeviceSettings, LegacyProfile } from "../types";
+export default class AntHrAdapter extends AntAdapter<HeartRateSensorState> {
+    protected static INCYCLIST_PROFILE_NAME: LegacyProfile;
+    protected static ANT_PROFILE_NAME: Profile;
+    constructor(settings: AntDeviceSettings, props?: AntDeviceProperties);
+    getDisplayName(): string;
+    mapToAdapterData(deviceData: HeartRateSensorState): void;
+    hasData(): boolean;
+}

package/lib/antv2/hr copy/adapter.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const adapter_1 = __importDefault(require("../base/adapter"));
+const types_1 = require("../../types");
+class AntHrAdapter extends adapter_1.default {
+    constructor(settings, props) {
+        super(settings, props);
+        this.capabilities = [types_1.IncyclistCapability.HeartRate];
+    }
+    getDisplayName() {
+        const { ComputedHeartRate } = this.deviceData;
+        const hrmStr = ComputedHeartRate ? ` (${ComputedHeartRate})` : '';
+        return `${this.getUniqueName()}${hrmStr}`;
+    }
+    mapToAdapterData(deviceData) {
+        if (deviceData.ComputedHeartRate) {
+            this.data.heartrate = deviceData.ComputedHeartRate;
+            this.data.timestamp = Date.now();
+        }
+    }
+    hasData() {
+        return this.deviceData.ComputedHeartRate !== undefined && this.deviceData.ComputedHeartRate !== null;
+    }
+}
+AntHrAdapter.INCYCLIST_PROFILE_NAME = 'Heartrate Monitor';
+AntHrAdapter.ANT_PROFILE_NAME = 'HR';
+exports.default = AntHrAdapter;

package/lib/antv2/hr copy/index.d.ts

@@ -0,0 +1,2 @@
+import AntHrAdapter from './adapter';
+export default AntHrAdapter;

package/lib/antv2/hr copy/index.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const adapter_1 = __importDefault(require("./adapter"));
+exports.default = adapter_1.default;

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

@@ -0,0 +1,5 @@
+import { ISensor, Profile } from "incyclist-ant-plus";
+export default class SensorFactory {
+    static create(profile: Profile, deviceID?: number): ISensor;
+    static createAll(): ISensor[];
+}

package/lib/antv2/sensor-factory.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const incyclist_ant_plus_1 = require("incyclist-ant-plus");
+const profiles = [
+    { profile: 'PWR', Class: incyclist_ant_plus_1.BicyclePowerSensor },
+    { profile: 'HR', Class: incyclist_ant_plus_1.HeartRateSensor },
+    { profile: 'FE', Class: incyclist_ant_plus_1.FitnessEquipmentSensor },
+];
+class SensorFactory {
+    static create(profile, deviceID) {
+        const info = profiles.find(i => i.profile === profile);
+        if (!info)
+            return;
+        return new info.Class(deviceID);
+    }
+    static createAll() {
+        return profiles.map(info => new info.Class());
+    }
+}
+exports.default = SensorFactory;

package/lib/ble/base/adapter.d.ts

@@ -38,4 +38,5 @@ export default class BleAdapter<TDeviceData extends BleDeviceData, TDevice exten
     stop(): Promise<boolean>;
     pause(): Promise<boolean>;
     resume(): Promise<boolean>;
+    update(): void;
 }

package/lib/ble/base/adapter.js

@@ -109,21 +109,26 @@ class BleAdapter extends adpater_1.default {
         return settings.name || settings.id || settings.address;
     }
     onDeviceData(deviceData) {
-        this.dataMsgCount++;
-        this.lastDataTS = Date.now();
-        this.deviceData = Object.assign({}, deviceData);
-        if (!this.started || !this.canEmitData())
-            return;
-        this.logEvent({ message: 'onDeviceData', data: deviceData, isControllable: this.isControllable() });
-        if (this.isControllable()) {
-            const mappedData = this.mapData(deviceData);
-            const incyclistData = this.getCyclingMode().updateData(mappedData);
-            this.data = this.transformData(incyclistData);
+        try {
+            this.dataMsgCount++;
+            this.lastDataTS = Date.now();
+            this.deviceData = Object.assign({}, deviceData);
+            if (!this.canEmitData())
+                return;
+            this.logEvent({ message: 'onDeviceData', data: deviceData, isControllable: this.isControllable() });
+            if (this.isControllable()) {
+                const mappedData = this.mapData(deviceData);
+                const incyclistData = this.getCyclingMode().updateData(mappedData);
+                this.data = this.transformData(incyclistData);
+            }
+            else {
+                this.data = this.mapData(this.deviceData);
+            }
+            this.emitData(this.data);
         }
-        else {
-            this.data = this.mapData(this.deviceData);
+        catch (err) {
+            this.logEvent({ message: 'Error', fn: 'onDeviceData', error: err.message });
         }
-        this.emitData(this.data);
     }
     mapData(deviceData) {
         throw new Error('message not implemented');
@@ -223,5 +228,7 @@ class BleAdapter extends adpater_1.default {
             return res;
         });
     }
+    update() {
+    }
 }
 exports.default = BleAdapter;

package/lib/ble/cp/adapter.d.ts

@@ -16,4 +16,5 @@ export default class PwrAdapter extends BleAdapter<PowerData, BleCyclingPowerDev
     mapData(deviceData: PowerData): IncyclistBikeData;
     transformData(bikeData: IncyclistBikeData): IncyclistAdapterData;
     stop(): Promise<boolean>;
+    sendUpdate(request: any): void;
 }

package/lib/ble/cp/adapter.js

@@ -93,6 +93,14 @@ class PwrAdapter extends adapter_1.default {
             return stopped;
         });
     }
+    sendUpdate(request) {
+        try {
+            super.sendUpdate(request);
+        }
+        catch (err) {
+            this.logEvent({ message: 'Error', fn: 'sendUpdate', error: err.message });
+        }
+    }
 }
 PwrAdapter.INCYCLIST_PROFILE_NAME = 'Power Meter';
 PwrAdapter.controllers = {