incyclist-devices 2.1.19 → 2.1.22

package/README.MD

@@ -8,6 +8,9 @@ __ANT__
 - Smart Trainers (ANT+ FE)
 - Power Meters (ANT+PWR)
 - Heartrate Monitors (ANT+HR)
+- Cadence Sensors (ANT+CAD)
+- Speed Sensors (ANT+SPD)
+- Speed + Cadence Sensors (ANT+SC)
 
 __BLE__
 - Smart Trainers (BLE FTMS)

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

@@ -3,7 +3,7 @@ import { IChannel, ISensor, Profile } from 'incyclist-ant-plus';
 import AntInterface from './interface';
 import IncyclistDevice from '../../base/adpater';
 import { AntDeviceProperties, AntDeviceSettings, LegacyProfile, BaseDeviceData, AdapterStartStatus } from '../types';
-import { IAdapter, IncyclistAdapterData, IncyclistBikeData } from '../../types';
+import { IAdapter, IncyclistAdapterData, IncyclistBikeData, IncyclistCapability } from '../../types';
 export default class AntAdapter<TDeviceData extends BaseDeviceData> extends IncyclistDevice<AntDeviceProperties> {
     sensor: ISensor;
     data: IncyclistAdapterData;
@@ -29,6 +29,7 @@ export default class AntAdapter<TDeviceData extends BaseDeviceData> extends Incy
     constructor(settings: AntDeviceSettings, props?: AntDeviceProperties);
     getProfileName(): Profile;
     getLegacyProfileName(): LegacyProfile;
+    protected getStaticCapabilities(): Array<IncyclistCapability>;
     createSensor(settings: AntDeviceSettings): ISensor;
     isEqual(settings: AntDeviceSettings): boolean;
     getDefaultReconnectDelay(): number;

package/lib/antv2/base/adapter.js

@@ -51,15 +51,22 @@ class AntAdapter extends adpater_1.default {
         if (this.isDebugEnabled()) {
             this.ant.setLogger(this);
         }
+        if (this.getStaticCapabilities())
+            this.capabilities = this.getStaticCapabilities();
     }
     getProfileName() {
+        var _a;
         const C = this.constructor;
-        return C['ANT_PROFILE_NAME'];
+        return ((_a = this.sensor) === null || _a === void 0 ? void 0 : _a.getProfile()) || C['ANT_PROFILE_NAME'];
     }
     getLegacyProfileName() {
         const C = this.constructor;
         return C['INCYCLIST_PROFILE_NAME'];
     }
+    getStaticCapabilities() {
+        const C = this.constructor;
+        return C['CAPABILITIES'];
+    }
     createSensor(settings) {
         return sensor_factory_1.default.create(this.getProfileName(), Number(settings.deviceID));
     }
@@ -190,11 +197,10 @@ class AntAdapter extends adpater_1.default {
         return id.toString();
     }
     getName() {
-        var _a;
         if (this.settings.name)
             return this.settings.name;
         const deviceID = this.getID();
-        const profile = (_a = this.sensor) === null || _a === void 0 ? void 0 : _a.getProfile();
+        const profile = this.getProfileName();
         return `Ant+${profile} ${deviceID}`;
     }
     getUniqueName() {

package/lib/antv2/base/interface.d.ts

@@ -1,10 +1,15 @@
 /// <reference types="node" />
 import EventEmitter from "events";
 import { EventLogger } from "gd-eventlog";
-import { IAntDevice, IChannel, ISensor } from "incyclist-ant-plus";
+import { Channel, IAntDevice, IChannel, ISensor } from "incyclist-ant-plus";
 import { AntDeviceSettings, AntScanProps, AntInterfaceProps } from "../types";
 import { IncyclistInterface } from "../../types";
 import AntDeviceBinding from "./binding";
+type ChannelUsage = 'scan' | 'sensor';
+interface ChannelInfo {
+    channel: Channel;
+    usage: ChannelUsage;
+}
 export default class AntInterface extends EventEmitter implements IncyclistInterface {
     static _instance: AntInterface;
     static INTERFACE_NAME: string;
@@ -22,6 +27,7 @@ export default class AntInterface extends EventEmitter implements IncyclistInter
     };
     protected props: AntInterfaceProps;
     protected logEnabled: boolean;
+    protected channelsInUse: Array<ChannelInfo>;
     constructor(props: AntInterfaceProps);
     getName(): string;
     getBinding(): typeof AntDeviceBinding;
@@ -42,5 +48,8 @@ export default class AntInterface extends EventEmitter implements IncyclistInter
     isScanning(): boolean;
     stopScan(): Promise<boolean>;
     startSensor(sensor: ISensor, onDeviceData: (data: any) => void): Promise<boolean>;
+    private blockChannel;
+    private unblockChannel;
     stopSensor(sensor: ISensor): Promise<boolean>;
 }
+export {};

package/lib/antv2/base/interface.js

@@ -31,6 +31,7 @@ class AntInterface extends events_1.default {
         this.device = undefined;
         this.connected = false;
         this.connectPromise = null;
+        this.channelsInUse = [];
         this.logEnabled = props.log || true;
         const { binding, logger } = props;
         this.setLogger(logger || new gd_eventlog_1.EventLogger('Ant+'));
@@ -106,16 +107,32 @@ class AntInterface extends events_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             this.logEvent({ message: 'ANT+ disconnecting ...' });
             let closed = false;
-            if (this.device) {
-                try {
-                    closed = yield this.device.close();
+            try {
+                let promises = [];
+                if (this.channelsInUse.length > 0) {
+                    this.channelsInUse.forEach(c => {
+                        if (c.usage === 'scan')
+                            promises.push(this.stopScan());
+                        else
+                            promises.push(c.channel.stopAllSensors());
+                    });
+                    yield Promise.allSettled(promises);
+                    yield (0, utils_1.sleep)(200);
+                }
+                if (this.device) {
+                    try {
+                        closed = yield this.device.close();
+                    }
+                    catch (_a) {
+                        closed = false;
+                    }
                 }
-                catch (_a) {
-                    closed = false;
+                else {
+                    closed = true;
                 }
             }
-            else {
-                closed = true;
+            catch (err) {
+                this.logEvent({ message: 'Error', fn: '', error: err.message, stack: err.stack });
             }
             this.logEvent({ message: 'ANT+ disconnected' });
             this.connectPromise = null;
@@ -205,10 +222,12 @@ class AntInterface extends events_1.default {
                 addListeners(channel);
                 try {
                     const success = yield channel.startScanner();
+                    this.blockChannel(channel, 'scan');
                     this.logEvent({ message: 'scan started', success });
                 }
                 catch (err) {
                     this.logEvent({ message: 'scan could not be started', error: err.message, stack: err.stack });
+                    this.unblockChannel(channel);
                     removeListeners(channel);
                     return done(detected);
                 }
@@ -261,10 +280,12 @@ class AntInterface extends events_1.default {
                 this.logEvent({ message: 'stopping scan done ..' });
                 return true;
             }
+            const channel = this.activeScan.channel;
             return new Promise(done => {
                 this.activeScan.emitter.emit('stop');
                 this.once('scan stopped', (res) => {
                     this.logEvent({ message: 'stopping scan done ..' });
+                    this.unblockChannel(channel);
                     done(res);
                 });
             });
@@ -281,6 +302,7 @@ class AntInterface extends events_1.default {
             channel = this.device.getChannel();
             if (!channel)
                 return false;
+            this.blockChannel(channel, 'sensor');
             channel.setProps({ logger: this.logger });
             const onData = (profile, deviceID, data, tag) => {
                 if (profile === sensor.getProfile() && deviceID === sensor.getDeviceID())
@@ -304,10 +326,19 @@ class AntInterface extends events_1.default {
                     yield channel.stopSensor(sensor);
                 }
                 catch (_a) { }
+                this.unblockChannel(channel);
                 return false;
             }
         });
     }
+    blockChannel(channel, usage) {
+        this.channelsInUse.push({ channel: channel, usage });
+    }
+    unblockChannel(channel) {
+        const idx = this.channelsInUse.findIndex(c => { var _a; return ((_a = c.channel) === null || _a === void 0 ? void 0 : _a.getChannelNo()) === channel.getChannelNo(); });
+        if (idx !== -1)
+            this.channelsInUse.splice(idx, 1);
+    }
     stopSensor(sensor) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.isConnected()) {
@@ -328,6 +359,7 @@ class AntInterface extends events_1.default {
                     channel.flush();
                     channel.removeAllListeners('data');
                     const stopped = yield channel.stopSensor(sensor);
+                    this.unblockChannel(channel);
                     return stopped;
                 }
                 catch (err) {

package/lib/antv2/factories/sensor-factory.js

@@ -7,6 +7,8 @@ const profiles = [
     { profile: 'HR', Class: incyclist_ant_plus_2.HeartRateSensor },
     { profile: 'FE', Class: incyclist_ant_plus_2.FitnessEquipmentSensor },
     { profile: 'CAD', Class: incyclist_ant_plus_1.CadenceSensor },
+    { profile: 'SPD', Class: incyclist_ant_plus_1.SpeedSensor },
+    { profile: 'SC', Class: incyclist_ant_plus_1.SpeedCadenceSensor },
 ];
 class SensorFactory {
     static create(profile, deviceID) {

package/lib/antv2/index.d.ts

@@ -1,8 +1,11 @@
 import AntPwrAdapter from "./pwr";
 import AntFEAdapter from "./fe";
 import AntHrAdapter from "./hr";
+import AntCadAdapter from "./cad";
 import AntAdapterFactory from "./factories/adapter-factory";
 import AntInterface from "./base/interface";
 import { AntInterfaceProps } from "./types";
+import AntSpdAdapter from "./spd";
+import AntScAdapter from "./sc";
 export { AntDeviceSettings, AntDeviceProperties, AntScanProps } from "./types";
-export { AntAdapterFactory, AntFEAdapter, AntHrAdapter, AntPwrAdapter, AntInterface, AntInterfaceProps };
+export { AntAdapterFactory, AntFEAdapter, AntHrAdapter, AntPwrAdapter, AntScAdapter, AntSpdAdapter, AntCadAdapter, AntInterface, AntInterfaceProps };

package/lib/antv2/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AntInterface = exports.AntPwrAdapter = exports.AntHrAdapter = exports.AntFEAdapter = exports.AntAdapterFactory = void 0;
+exports.AntInterface = exports.AntCadAdapter = exports.AntSpdAdapter = exports.AntScAdapter = exports.AntPwrAdapter = exports.AntHrAdapter = exports.AntFEAdapter = exports.AntAdapterFactory = void 0;
 const pwr_1 = __importDefault(require("./pwr"));
 exports.AntPwrAdapter = pwr_1.default;
 const fe_1 = __importDefault(require("./fe"));
@@ -11,12 +11,19 @@ exports.AntFEAdapter = fe_1.default;
 const hr_1 = __importDefault(require("./hr"));
 exports.AntHrAdapter = hr_1.default;
 const cad_1 = __importDefault(require("./cad"));
+exports.AntCadAdapter = cad_1.default;
 const adapter_factory_1 = __importDefault(require("./factories/adapter-factory"));
 exports.AntAdapterFactory = adapter_factory_1.default;
 const interface_1 = __importDefault(require("./base/interface"));
 exports.AntInterface = interface_1.default;
+const spd_1 = __importDefault(require("./spd"));
+exports.AntSpdAdapter = spd_1.default;
+const sc_1 = __importDefault(require("./sc"));
+exports.AntScAdapter = sc_1.default;
 const af = adapter_factory_1.default.getInstance();
 af.register('PWR', 'Power Meter', pwr_1.default);
 af.register('HR', 'Heartrate Monitor', hr_1.default);
 af.register('FE', 'Smart Trainer', fe_1.default);
 af.register('CAD', 'Cadence Sensor', cad_1.default);
+af.register('SPD', 'Speed Sensor', spd_1.default);
+af.register('SC', 'Speed + Cadence Sensor', sc_1.default);

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

@@ -0,0 +1,11 @@
+import { SpeedCadenceSensorState, Profile } from "incyclist-ant-plus";
+import AntAdapter from "../base/adapter";
+import { LegacyProfile } from "../types";
+import { IncyclistCapability } from "../../types";
+export default class AntSpdAdapter extends AntAdapter<SpeedCadenceSensorState> {
+    protected static INCYCLIST_PROFILE_NAME: LegacyProfile;
+    protected static ANT_PROFILE_NAME: Profile;
+    protected static CAPABILITIES: IncyclistCapability[];
+    mapToAdapterData(deviceData: SpeedCadenceSensorState): void;
+    hasData(): boolean;
+}

package/lib/antv2/sc/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 AntSpdAdapter extends adapter_1.default {
+    mapToAdapterData(deviceData) {
+        if (deviceData.CalculatedSpeed !== undefined) {
+            this.data.speed = deviceData.CalculatedSpeed;
+            this.data.timestamp = Date.now();
+        }
+        if (deviceData.CalculatedDistance !== undefined) {
+            this.data.deviceDistanceCounter = deviceData.CalculatedDistance;
+        }
+        if (deviceData.CalculatedCadence) {
+            this.data.cadence = deviceData.CalculatedCadence;
+            this.data.timestamp = Date.now();
+        }
+    }
+    hasData() {
+        return ((this.deviceData.CalculatedSpeed !== undefined && this.deviceData.CalculatedSpeed !== null) ||
+            (this.deviceData.CalculatedCadence !== undefined && this.deviceData.CalculatedCadence !== null));
+    }
+}
+AntSpdAdapter.INCYCLIST_PROFILE_NAME = 'Speed + Cadence Sensor';
+AntSpdAdapter.ANT_PROFILE_NAME = 'SC';
+AntSpdAdapter.CAPABILITIES = [types_1.IncyclistCapability.Speed, types_1.IncyclistCapability.Cadence];
+exports.default = AntSpdAdapter;

package/lib/antv2/sc/index.d.ts

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

package/lib/antv2/sc/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/spd/adapter.d.ts

@@ -0,0 +1,11 @@
+import { SpeedSensorState, Profile } from "incyclist-ant-plus";
+import AntAdapter from "../base/adapter";
+import { LegacyProfile } from "../types";
+import { IncyclistCapability } from "../../types";
+export default class AntSpdAdapter extends AntAdapter<SpeedSensorState> {
+    protected static INCYCLIST_PROFILE_NAME: LegacyProfile;
+    protected static ANT_PROFILE_NAME: Profile;
+    protected static CAPABILITIES: IncyclistCapability[];
+    mapToAdapterData(deviceData: SpeedSensorState): void;
+    hasData(): boolean;
+}

package/lib/antv2/spd/adapter.js

@@ -0,0 +1,25 @@
+"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 AntSpdAdapter extends adapter_1.default {
+    mapToAdapterData(deviceData) {
+        if (deviceData.CalculatedSpeed !== undefined) {
+            this.data.speed = deviceData.CalculatedSpeed;
+            this.data.timestamp = Date.now();
+        }
+        if (deviceData.CalculatedDistance !== undefined) {
+            this.data.deviceDistanceCounter = deviceData.CalculatedDistance;
+        }
+    }
+    hasData() {
+        return this.deviceData.CalculatedSpeed !== undefined && this.deviceData.CalculatedSpeed !== null;
+    }
+}
+AntSpdAdapter.INCYCLIST_PROFILE_NAME = 'Speed Sensor';
+AntSpdAdapter.ANT_PROFILE_NAME = 'SPD';
+AntSpdAdapter.CAPABILITIES = [types_1.IncyclistCapability.Speed];
+exports.default = AntSpdAdapter;

package/lib/antv2/spd/index.d.ts

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

package/lib/antv2/spd/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/serial/base/serial-interface.js

@@ -19,6 +19,7 @@ const utils_1 = require("../../utils/utils");
 const adapter_factory_1 = __importDefault(require("../factories/adapter-factory"));
 const serial_scanner_1 = require("./serial-scanner");
 const DEFAULT_SCAN_TIMEOUT = 10000;
+const MAX_PARALLEL_SCANS = 5;
 class SerialInterface extends events_1.default {
     static getInstance(props) {
         const { ifaceName, binding, logger } = props;
@@ -237,6 +238,10 @@ class SerialInterface extends events_1.default {
                 return [];
             }
             this.logEvent({ message: 'scanning on ', interface: this.ifaceName, paths: paths.map(p => p.path).join(','), timeout });
+            let listReduced = false;
+            if (paths.length > MAX_PARALLEL_SCANS) {
+                paths = paths.filter((p, idx) => idx < MAX_PARALLEL_SCANS);
+            }
             const scanners = paths.map(p => new serial_scanner_1.SinglePathScanner(p.path, this, Object.assign(Object.assign({}, props), { logger: this.logger })));
             try {
                 yield Promise.all(scanners.map(s => s.scan()
@@ -259,6 +264,9 @@ class SerialInterface extends events_1.default {
                 clearTimeout(this.toScan);
                 this.toScan = null;
             }
+            if (listReduced) {
+                paths.forEach(p => this.inUse.push(p.path));
+            }
             this.isScanning = false;
             this.logEvent({ message: 'scan finished on', interface: this.ifaceName, paths: paths.map(p => p.path), devices: detected.map(d => {
                     const res = Object.assign({}, d);

package/lib/serial/base/serial-scanner.js

@@ -67,17 +67,20 @@ class SinglePathScanner {
                         }
                         const adapterSettings = { interface: this.serial.getName(), host, port, protocol };
                         const adapter = adapter_factory_1.default.getInstance().createInstance(adapterSettings);
-                        found = yield (adapter === null || adapter === void 0 ? void 0 : adapter.check());
-                        if (found) {
-                            this.isFound = true;
-                            const name = adapter.getName();
-                            resolve(Object.assign(Object.assign({}, adapterSettings), { name }));
+                        if (this.isScanning) {
+                            found = yield (adapter === null || adapter === void 0 ? void 0 : adapter.check());
+                            if (found) {
+                                this.isFound = true;
+                                const name = adapter.getName();
+                                resolve(Object.assign(Object.assign({}, adapterSettings), { name }));
+                            }
+                            yield adapter.close();
+                            yield (0, utils_1.sleep)(1000);
                         }
-                        yield (0, utils_1.sleep)(100);
                     }
                     catch (err) {
                         this.logEvent({ message: 'error', fn: 'scan()', error: err.message || err, stack: err.stack });
-                        yield (0, utils_1.sleep)(100);
+                        yield (0, utils_1.sleep)(2000);
                     }
                 }
             }));

package/package.json

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