incyclist-devices 2.0.30 → 2.0.32

package/lib/ble/wahoo/adapter.js

@@ -83,9 +83,6 @@ class BleWahooAdapter extends fm_1.BleFmAdapter {
                     comms.on('data', (data) => {
                         this.onDeviceData(data);
                     });
-                    if (comms.features.heartrate && !this.hasCapability(capabilities_1.IncyclistCapability.HeartRate)) {
-                        this.capabilities.push(capabilities_1.IncyclistCapability.HeartRate);
-                    }
                     this.resetData();
                     this.stopped = false;
                     this.started = true;

package/lib/serial/adapter.d.ts

@@ -14,6 +14,7 @@ export declare class SerialIncyclistDevice extends ControllableDevice {
     isEqual(settings: SerialDeviceSettings): boolean;
     getPort(): string;
     getUniqueName(): string;
+    getSerialInterface(): SerialInterface;
     getInterface(): string;
     setMaxUpdateFrequency(ms: number): void;
     setPullFrequency(ms: number): void;

package/lib/serial/adapter.js

@@ -40,6 +40,9 @@ class SerialIncyclistDevice extends adpater_1.ControllableDevice {
     getUniqueName() {
         return `${this.getName()} (${this.getPort()})`;
     }
+    getSerialInterface() {
+        throw new Error('not implemented');
+    }
     getInterface() {
         return 'serial';
     }

package/lib/serial/bindings/tcp.d.ts

@@ -7,14 +7,14 @@ export interface TCPOpenOptions extends OpenOptions {
     timeout?: number;
 }
 export declare interface TCPBindingInterface<T extends BindingPortInterface = BindingPortInterface, R extends OpenOptions = OpenOptions, P extends PortInfo = PortInfo> extends BindingInterface<TCPPortBinding, TCPOpenOptions> {
-    list(port?: number): Promise<P[]>;
+    list(port?: number, excludeList?: string[]): Promise<P[]>;
 }
 export declare class CanceledError extends Error {
     canceled: true;
     constructor(message: string);
 }
 export declare function scanPort(host: string, port: number): Promise<boolean>;
-export declare function scanSubNet(sn: string, port: number): Promise<string[]>;
+export declare function scanSubNet(sn: string, port: number, excludeHosts?: string[]): Promise<string[]>;
 export declare function getSubnets(): string[];
 export declare const TCPBinding: TCPBindingInterface;
 export declare class TCPPortBinding implements BindingPortInterface {

package/lib/serial/bindings/tcp.js

@@ -50,10 +50,11 @@ function scanPort(host, port) {
     });
 }
 exports.scanPort = scanPort;
-function scanSubNet(sn, port) {
+function scanSubNet(sn, port, excludeHosts) {
     const range = [];
     for (let i = 1; i < 255; i++)
-        range.push(i);
+        if (!excludeHosts || !excludeHosts.includes(`${sn}.${i}`))
+            range.push(i);
     return Promise.all(range.map(j => scanPort(`${sn}.${j}`, port).then(success => success ? `${sn}.${j}` : null).catch()))
         .then(hosts => hosts.filter(h => h !== null))
         .catch();
@@ -86,13 +87,14 @@ function getSubnets() {
 }
 exports.getSubnets = getSubnets;
 exports.TCPBinding = {
-    list(port) {
+    list(port, excludeList) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!port)
                 return [];
             const subnets = getSubnets();
-            const hosts = [];
-            yield Promise.all(subnets.map(sn => scanSubNet(sn, port).then(found => { hosts.push(...found); })));
+            let hosts = [];
+            const excludeHosts = excludeList.map(e => e && e.includes(':') ? e.split(':')[0] : e);
+            yield Promise.all(subnets.map(sn => scanSubNet(sn, port, excludeHosts).then(found => { hosts.push(...found); })));
             return hosts.map(host => ({
                 path: `${host}:${port}`,
                 manufacturer: undefined,

package/lib/serial/daum/DaumAdapter.js

@@ -199,8 +199,10 @@ class DaumAdapterBase extends adapter_1.SerialIncyclistDevice {
         if (this.stopped)
             return Promise.resolve(true);
         this.logEvent({ message: 'stop request' });
+        if (this.paused)
+            this.resume();
         this.stopped = true;
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
             try {
                 if (this.iv) {
                     if (this.iv.sync)
@@ -211,15 +213,15 @@ class DaumAdapterBase extends adapter_1.SerialIncyclistDevice {
                 }
                 if (this.bike.stopWorker && typeof this.bike.stopWorker === 'function')
                     this.bike.stopWorker();
+                yield this.bike.close();
                 this.logEvent({ message: 'stop request completed' });
-                this.paused = undefined;
                 resolve(true);
             }
             catch (err) {
                 this.logEvent({ message: 'stop error', error: err.message });
                 reject(err);
             }
-        });
+        }));
     }
     canSendUpdate() {
         if (this.paused || this.stopped)

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

@@ -2,6 +2,7 @@ import CyclingMode from '../../../modes/cycling-mode';
 import DaumAdapter from '../DaumAdapter';
 import { DeviceProperties } from '../../../types/device';
 import { SerialDeviceSettings } from '../../adapter';
+import SerialInterface from '../../serial-interface';
 export interface DaumClassicDeviceProperties extends DeviceProperties {
     gear?: number;
 }
@@ -21,6 +22,7 @@ export default class DaumClassicAdapter extends DaumAdapter {
     getProtocolName(): string;
     getSupportedCyclingModes(): Array<any>;
     getDefaultCyclingMode(): CyclingMode;
+    getSerialInterface(): SerialInterface;
     check(): Promise<boolean>;
     performCheck(): Promise<boolean>;
     pause(): Promise<boolean>;

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

@@ -80,6 +80,10 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
     getDefaultCyclingMode() {
         return new daum_classic_1.default(this);
     }
+    getSerialInterface() {
+        var _a;
+        return (_a = this.bike) === null || _a === void 0 ? void 0 : _a.serial;
+    }
     check() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.isStopped())

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

@@ -1,4 +1,5 @@
 import { DeviceProperties } from '../../../types/device';
+import { SerialInterface } from '../..';
 import { SerialDeviceSettings } from '../../adapter';
 import { SerialCommProps } from '../../comm';
 import DaumAdapter from '../DaumAdapter';
@@ -14,6 +15,7 @@ export default class DaumPremiumAdapter extends DaumAdapter {
     getPort(): any;
     getInterface(): string;
     getProtocolName(): string;
+    getSerialInterface(): SerialInterface;
     isEqual(settings: SerialDeviceSettings): boolean;
     getSupportedCyclingModes(): Array<any>;
     check(): Promise<boolean>;

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

@@ -90,12 +90,19 @@ class DaumPremiumAdapter extends DaumAdapter_1.default {
     getProtocolName() {
         return PROTOCOL_NAME;
     }
+    getSerialInterface() {
+        var _a;
+        return (_a = this.bike) === null || _a === void 0 ? void 0 : _a.serial;
+    }
     isEqual(settings) {
         if (this.getInterface() === device_1.INTERFACE.TCPIP) {
-            const equal = super.isEqual(settings);
-            if (!equal)
-                return false;
             const as = this.settings;
+            if (settings.interface !== this.getInterface())
+                return false;
+            if (settings.protocol !== as.protocol)
+                return false;
+            if ((settings.port || DAUM_PREMIUM_DEFAULT_PORT) !== (as.port || DAUM_PREMIUM_DEFAULT_PORT))
+                return false;
             return (settings.host === as.host);
         }
         else {

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

@@ -34,7 +34,6 @@ const validatePath = (path) => {
     const port = parts[1];
     return `${host}:${port}`;
 };
-const drain = (sp) => new Promise(resolve => { sp.drain(resolve); });
 class Daum8i {
     constructor(props) {
         this.props = props || {};

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

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { MockBindingInterface, MockPortBinding, CreatePortOptions } from '@serialport/binding-mock';
-import { BindingInterface, PortInfo } from '@serialport/bindings-interface';
+import { BindingInterface } from '@serialport/bindings-interface';
 import { User } from '../../../types/user';
 export type MockProps = {
     interface: string;
@@ -25,7 +25,7 @@ export declare class Daum8iMockImpl {
     getSimulator(path: any): Daum8MockSimulator;
     reset(): void;
     createPort(path: string, options?: CreatePortOptions): void;
-    list(): Promise<PortInfo[]>;
+    list(): Promise<import("@serialport/bindings-interface").PortInfo[]>;
     open(options: any): Promise<Daum8iMockBinding>;
 }
 export declare class Daum8MockSimulator {

package/lib/serial/kettler/comms.d.ts

@@ -46,6 +46,7 @@ export default class KettlerSerialComms<T extends Command> extends EventEmitter
     _setSendState(state: SendState): void;
     _setCurrentCmd(cmd: T): void;
     stopCurrentTimeoutCheck(): void;
+    getSerialInterface(): SerialInterface;
     onPortOpen(): void;
     onPortClose(): Promise<void>;
     onPortError(err: any): void;

package/lib/serial/kettler/comms.js

@@ -102,6 +102,9 @@ class KettlerSerialComms extends events_1.default {
             this.currentTimeout = undefined;
         }
     }
+    getSerialInterface() {
+        return this.serial;
+    }
     onPortOpen() {
         this.logger.logEvent({ message: 'port opened', port: this.getPort() });
         this.state = SerialCommsState.Connected;

package/lib/serial/kettler/ergo-racer/adapter.d.ts

@@ -5,6 +5,7 @@ import { Command } from "../../../types/command";
 import CyclingMode, { IncyclistBikeData } from "../../../modes/cycling-mode";
 import { SerialDeviceSettings, SerialIncyclistDevice } from "../../adapter";
 import { DeviceData } from "../../../types/data";
+import SerialInterface from "../../serial-interface";
 export interface KettlerRacerCommand extends Command {
 }
 export interface KettlerExtendedBikeData {
@@ -44,6 +45,7 @@ export default class KettlerRacerAdapter extends SerialIncyclistDevice {
     getID(): string;
     getName(): string;
     getPort(): string;
+    getSerialInterface(): SerialInterface;
     _getComms(): SerialComms<KettlerRacerCommand>;
     _setComms(comms: SerialComms<KettlerRacerCommand>): void;
     getLogger(): EventLogger;

package/lib/serial/kettler/ergo-racer/adapter.js

@@ -58,6 +58,10 @@ class KettlerRacerAdapter extends adapter_1.SerialIncyclistDevice {
         const settings = this.settings;
         return settings.port;
     }
+    getSerialInterface() {
+        if (this.comms)
+            return this.comms.getSerialInterface();
+    }
     _getComms() {
         return this.comms;
     }

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

@@ -30,6 +30,7 @@ export declare class SinglePathScanner {
     isScanning: boolean;
     props: SerialScannerProps;
     logger: EventLogger;
+    isFound: boolean;
     constructor(path: string, serial: SerialInterface, props: SerialScannerProps);
     logEvent(event: any): void;
     onStopRequest(resolve: any): Promise<void>;
@@ -45,6 +46,7 @@ export default class SerialInterface extends EventEmitter implements IncyclistIn
     logger: EventLogger;
     toScan: NodeJS.Timeout;
     connected: boolean;
+    inUse: string[];
     static _instances: SerialInterface[];
     static getInstance(props: SerialInterfaceProps): SerialInterface;
     static _add(instance: SerialInterface): void;
@@ -53,6 +55,8 @@ export default class SerialInterface extends EventEmitter implements IncyclistIn
     setBinding(binding: BindingInterface): void;
     getName(): string;
     isConnected(): boolean;
+    setInUse(path: string): void;
+    releaseInUse(path: string): void;
     connect(): Promise<boolean>;
     disconnect(): Promise<boolean>;
     openPort(path: string): Promise<SerialPortStream | null>;

package/lib/serial/serial-interface.js

@@ -18,6 +18,7 @@ const serialport_1 = __importDefault(require("./serialport"));
 const gd_eventlog_1 = require("gd-eventlog");
 const utils_1 = require("../utils/utils");
 const adapters_1 = __importDefault(require("../adapters"));
+const adapter_factory_1 = __importDefault(require("./adapter-factory"));
 const DEFAULT_SCAN_TIMEOUT = 10000;
 exports.SerialInterfaceType = {
     SERIAL: 'serial',
@@ -29,6 +30,7 @@ class SinglePathScanner {
         this.serial = serial;
         this.result = undefined;
         this.isScanning = false;
+        this.isFound = false;
         this.props = props;
         this.logger = props.logger || new gd_eventlog_1.EventLogger('SerialScanner');
     }
@@ -44,7 +46,8 @@ class SinglePathScanner {
     onStopRequest(resolve) {
         return __awaiter(this, void 0, void 0, function* () {
             this.logEvent({ message: 'stopping scan', path: this.path });
-            yield this.serial.closePort(this.path);
+            if (!this.isFound)
+                yield this.serial.closePort(this.path);
             this.isScanning = false;
             resolve(this.result);
         });
@@ -73,8 +76,8 @@ class SinglePathScanner {
                         const adapter = adapters_1.default.create(adapterSettings);
                         found = yield adapter.check();
                         if (found) {
+                            this.isFound = true;
                             const name = adapter.getName();
-                            yield this.serial.closePort(this.path).catch();
                             resolve(Object.assign(Object.assign({}, adapterSettings), { name }));
                         }
                         yield (0, utils_1.sleep)(100);
@@ -117,6 +120,7 @@ class SerialInterface extends events_1.default {
         this.ifaceName = ifaceName;
         this.binding = undefined;
         this.ports = [];
+        this.inUse = [];
         this.isScanning = false;
         this.isStopScanRequested = false;
         this.scanEvents = new events_1.default();
@@ -148,6 +152,18 @@ class SerialInterface extends events_1.default {
     isConnected() {
         return this.connected;
     }
+    setInUse(path) {
+        this.logEvent({ message: 'block port for further scans', port: path });
+        if (!this.inUse.includes(path))
+            this.inUse.push(path);
+    }
+    releaseInUse(path) {
+        if (this.inUse.includes(path)) {
+            this.logEvent({ message: 're-enable port for further scans', port: path });
+            const idx = this.inUse.findIndex(r => r === path);
+            this.inUse.splice(idx, 1);
+        }
+    }
     connect() {
         return __awaiter(this, void 0, void 0, function* () {
             const binding = serialport_1.default.getInstance().getBinding(this.ifaceName);
@@ -255,13 +271,18 @@ class SerialInterface extends events_1.default {
                     this.scanEvents.emit('timeout');
                 }, timeout);
             }
-            this.logEvent({ message: 'checking for ports' });
             this.isScanning = true;
+            let attemptNo = 0;
             do {
+                if (attemptNo === 0)
+                    this.logEvent({ message: 'checking for ports', port, excludes: this.inUse });
+                else
+                    this.logEvent({ message: 'checking for ports retry', retry: attemptNo });
+                attemptNo++;
                 try {
                     if (this.getName() === 'tcpip') {
                         const _binding = binding;
-                        paths = (yield _binding.list(port)) || [];
+                        paths = (yield _binding.list(port, this.inUse)) || [];
                     }
                     else {
                         paths = (yield binding.list()) || [];
@@ -277,6 +298,7 @@ class SerialInterface extends events_1.default {
                 if (Date.now() > toExpiresAt)
                     timeOutExpired = true;
             } while (this.isScanning && !timeOutExpired && paths.length === 0);
+            paths = paths.filter(p => !this.inUse.includes(p.path));
             if (paths.length === 0) {
                 this.logEvent({ message: 'nothing to scan ' });
                 if (this.toScan) {
@@ -291,6 +313,9 @@ class SerialInterface extends events_1.default {
                 yield Promise.all(scanners.map(s => s.scan()
                     .then(device => {
                     if (device) {
+                        const adapter = adapter_factory_1.default.getInstance().createInstance(device);
+                        const path = adapter.getPort();
+                        this.inUse.push(path);
                         detected.push(device);
                         this.emit('device', device);
                     }

package/package.json

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