incyclist-devices 1.5.38 → 2.0.0

package/lib/{kettler → serial/kettler}/comms.d.ts

@@ -1,11 +1,12 @@
 /// <reference types="node" />
-import { DeviceProtocol } from "../protocol";
+/// <reference types="node" />
 import { EventLogger } from "gd-eventlog";
-import { Command } from "../types/command";
+import { Command } from "../../types/command";
 import EventEmitter from "events";
-export declare type SerialCommsProps = {
+import { SerialInterface } from "..";
+export type SerialCommsProps = {
     logger?: EventLogger;
-    protocol: DeviceProtocol;
+    interface: string | SerialInterface;
     port: string;
     settings?: any;
 };
@@ -33,7 +34,8 @@ export default class KettlerSerialComms<T extends Command> extends EventEmitter
     private sendState;
     private currentCmd;
     private currentTimeout;
-    private protocol;
+    private serial;
+    private openPromise;
     constructor(opts: SerialCommsProps);
     getPort(): string;
     setPort(port: any): void;
@@ -47,7 +49,7 @@ export default class KettlerSerialComms<T extends Command> extends EventEmitter
     onPortOpen(): void;
     onPortClose(): Promise<void>;
     onPortError(err: any): void;
-    open(): void;
+    open(): Promise<boolean>;
     close(): void;
     startWorker(): void;
     stopWorker(): void;

package/lib/{kettler → serial/kettler}/comms.js

@@ -14,8 +14,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SendState = exports.SerialCommsState = void 0;
 const gd_eventlog_1 = require("gd-eventlog");
-const utils_1 = require("../utils");
+const utils_1 = require("../../utils/utils");
 const events_1 = __importDefault(require("events"));
+const __1 = require("..");
+const parser_readline_1 = require("@serialport/parser-readline");
 const DEFAULT_RCV_TIMEOUT = 1500;
 const DEFAULT_OPEN_TIMEOUT = 3000;
 const DEBUG_LOGGER = {
@@ -37,6 +39,23 @@ var SendState;
     SendState[SendState["Sending"] = 1] = "Sending";
     SendState[SendState["Receiving"] = 2] = "Receiving";
 })(SendState = exports.SendState || (exports.SendState = {}));
+const getBikeProps = (props) => {
+    const { port, interface: ifaceName } = props;
+    let serial;
+    if (ifaceName && typeof ifaceName === 'string') {
+        serial = __1.SerialInterface.getInstance({ ifaceName });
+    }
+    else if (!ifaceName) {
+        serial = __1.SerialInterface.getInstance({ ifaceName: 'serial' });
+    }
+    else {
+        serial = props.interface;
+    }
+    if (!serial)
+        throw new Error(`unknonwn interface: ${ifaceName}`);
+    const path = `${port}`;
+    return { serial, path };
+};
 const CRLF = '\r\n';
 class KettlerSerialComms extends events_1.default {
     constructor(opts) {
@@ -44,8 +63,10 @@ class KettlerSerialComms extends events_1.default {
         this.stateIn = (allowedStates) => {
             return allowedStates.indexOf(this.state) >= 0;
         };
-        this.logger = process.env.DEBUG ? DEBUG_LOGGER : (opts.logger || new gd_eventlog_1.EventLogger(opts.protocol.getName()));
-        this.port = opts.port || process.env.COM_PORT;
+        const { serial, path } = getBikeProps(opts);
+        this.logger = process.env.DEBUG ? DEBUG_LOGGER : (opts.logger || new gd_eventlog_1.EventLogger('Kettler'));
+        this.serial = serial;
+        this.port = path;
         this.sp = undefined;
         this.queue = new utils_1.Queue();
         this.state = SerialCommsState.Idle;
@@ -53,7 +74,6 @@ class KettlerSerialComms extends events_1.default {
         this.settings = opts.settings || {};
         this.currentCmd = undefined;
         this.currentTimeout = undefined;
-        this.protocol = opts.protocol;
     }
     getPort() {
         return this.port;
@@ -101,7 +121,8 @@ class KettlerSerialComms extends events_1.default {
             this.stopCurrentTimeoutCheck();
             this.queue.clear();
             this.emit('closed');
-            this.sp.removeAllListeners();
+            if (this.sp)
+                this.sp.removeAllListeners();
             this.sp = undefined;
         });
     }
@@ -115,42 +136,60 @@ class KettlerSerialComms extends events_1.default {
             ignore = true;
         if (!ignore) {
             this.logger.logEvent({ message: "port error:", port: this.getPort(), error: err.message, stack: err.stack, state: this.state });
-            this.emit('error', err);
             this.stopCurrentTimeoutCheck();
             if (this.state === SerialCommsState.Connecting || this.state === SerialCommsState.Disconnecting) {
                 this.state = SerialCommsState.Error;
-                this.sp.removeAllListeners();
+                if (this.sp)
+                    this.sp.removeAllListeners();
                 this.sp = undefined;
             }
         }
     }
     open() {
-        this.logger.logEvent({ message: "open()", port: this.getPort() });
-        if (this.stateIn([SerialCommsState.Connected, SerialCommsState.Connecting, SerialCommsState.Disconnecting])) {
-            return;
-        }
-        try {
-            const SerialPort = this.protocol.getSerialPort();
-            if (this.sp === undefined) {
-                this.sp = new SerialPort(this.getPort(), this.settings);
-                this.sp.on('open', () => { this.onPortOpen(); });
-                this.sp.on('close', () => { this.onPortClose(); });
-                this.sp.on('error', (error) => { this.onPortError(error); });
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: "open()", port: this.getPort() });
+            if (this.state === SerialCommsState.Connected)
+                return true;
+            if (this.stateIn([SerialCommsState.Connecting, SerialCommsState.Disconnecting])) {
+                return this.openPromise;
             }
-            this.state = SerialCommsState.Connecting;
-            const parser = this.sp.pipe(new SerialPort.parsers.Readline({ delimiter: CRLF }));
-            parser.on('data', (data) => { this.onData(data); });
-            this.sp.open();
-            const timeout = this.settings.openTimeout || DEFAULT_OPEN_TIMEOUT;
-            this.currentTimeout = setTimeout(() => {
-                this.logger.logEvent({ message: "open() timeout", port: this.getPort() });
-                this.onPortError(new Error("open() timeout"));
-            }, timeout);
-        }
-        catch (err) {
-            this.logger.logEvent({ message: "error", fn: 'open()', error: err.message });
-            this.state = SerialCommsState.Disconnected;
-        }
+            this.openPromise = new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+                const done = (result) => {
+                    if (this.openPromise) {
+                        this.openPromise = undefined;
+                        resolve(result);
+                    }
+                };
+                try {
+                    const timeout = this.settings.openTimeout || DEFAULT_OPEN_TIMEOUT;
+                    this.currentTimeout = setTimeout(() => {
+                        this.logger.logEvent({ message: "open() timeout", port: this.getPort() });
+                        this.onPortError(new Error("open() timeout"));
+                        return done(false);
+                    }, timeout);
+                    const port = yield this.serial.openPort(this.port);
+                    if (port) {
+                        this.onPortOpen();
+                        this.sp = port;
+                        this.sp.on('close', () => { this.onPortClose(); });
+                        this.sp.on('error', (error) => { this.onPortError(error); });
+                        const parser = this.sp.pipe(new parser_readline_1.ReadlineParser({ delimiter: CRLF }));
+                        parser.on('data', (data) => { this.onData(data); });
+                        return done(true);
+                    }
+                    else {
+                        this.onPortError(new Error('could not open port'));
+                        return done(false);
+                    }
+                }
+                catch (err) {
+                    this.logger.logEvent({ message: "error", fn: 'open()', error: err.message });
+                    this.state = SerialCommsState.Disconnected;
+                    return done(false);
+                }
+            }));
+            return this.openPromise;
+        });
     }
     close() {
         this.logger.logEvent({ message: 'close()', port: this.getPort() });

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

@@ -1,11 +1,10 @@
-import { DeviceSettings } from "../../protocol";
-import DeviceAdapterBase, { DeviceAdapter, DeviceData, Bike } from "../../device";
-import { DeviceProtocol } from "../../protocol";
+import { DeviceProperties } from "../../../types/device";
 import { EventLogger } from "gd-eventlog";
 import SerialComms from "../comms";
-import { Command } from "../../types/command";
-import CyclingMode, { IncyclistBikeData } from "../../cycling-mode";
-import { User } from "../../types/user";
+import { Command } from "../../../types/command";
+import CyclingMode, { IncyclistBikeData } from "../../../modes/cycling-mode";
+import { SerialDeviceSettings, SerialIncyclistDevice } from "../../adapter";
+import { DeviceData } from "../../../types/data";
 export interface KettlerRacerCommand extends Command {
 }
 export interface KettlerExtendedBikeData {
@@ -21,18 +20,11 @@ export interface KettlerBikeData {
     time: number;
     power: number;
 }
-export interface KettlerDeviceSettings extends DeviceSettings {
-    userSettings?: User;
-    bikeSettings?: any;
-    cyclingMode?: CyclingMode;
-}
-export default class KettlerRacerAdapter extends DeviceAdapterBase implements DeviceAdapter, Bike {
+export default class KettlerRacerAdapter extends SerialIncyclistDevice {
     private id;
     private ignoreHrm;
     private ignoreBike;
     private ignorePower;
-    private logger;
-    private paused;
     private iv;
     private requests;
     private data;
@@ -42,28 +34,24 @@ export default class KettlerRacerAdapter extends DeviceAdapterBase implements De
     private requestBusy;
     private comms;
     private prevDistance;
-    constructor(protocol: DeviceProtocol, settings: KettlerDeviceSettings);
+    constructor(settings: SerialDeviceSettings, props?: DeviceProperties);
     isBike(): boolean;
     isPower(): boolean;
     isHrm(): boolean;
-    isSame(device: DeviceAdapter): boolean;
+    getProtocolName(): string;
+    isSame(device: SerialIncyclistDevice): boolean;
     setID(id: any): void;
     getID(): string;
     getName(): string;
     getPort(): string;
-    setIgnoreHrm(ignore: boolean): void;
-    setIgnorePower(ignore: boolean): void;
-    setIgnoreBike(ignore: boolean): void;
     _getComms(): SerialComms<KettlerRacerCommand>;
     _setComms(comms: SerialComms<KettlerRacerCommand>): void;
     getLogger(): EventLogger;
-    getUserSettings(): User;
-    getWeight(): number;
     setComputerMode(): Promise<boolean>;
     setClientMode(): Promise<boolean>;
     reset(): Promise<boolean>;
     getIdentifier(): Promise<string>;
-    getInterface(): Promise<string>;
+    getKettlerInterface(): Promise<string>;
     getVersion(): Promise<string>;
     getCalibration(): Promise<string>;
     startTraining(): Promise<string>;
@@ -77,11 +65,10 @@ export default class KettlerRacerAdapter extends DeviceAdapterBase implements De
     parseExtendedStatus(data: string): KettlerExtendedBikeData;
     parseStatus(data: string): KettlerBikeData;
     check(): Promise<boolean>;
-    start(props?: any): Promise<IncyclistBikeData>;
+    start(props?: any): Promise<boolean>;
     startUpdatePull(): void;
+    canSendUpdate(): boolean;
     stop(): Promise<boolean>;
-    pause(): Promise<boolean>;
-    resume(): Promise<boolean>;
     mapData(bikeData: KettlerBikeData): IncyclistBikeData;
     transformData(internalData: IncyclistBikeData, bikeData: KettlerBikeData): DeviceData;
     update(): Promise<void>;
@@ -89,13 +76,12 @@ export default class KettlerRacerAdapter extends DeviceAdapterBase implements De
     sendRequests(): Promise<void>;
     bikeSync(): Promise<void>;
     sendUpdate(request: any): Promise<unknown>;
-    sendData(): void;
     refreshRequests(): void;
     processClientRequest(request: any): Promise<unknown>;
+    connect(): Promise<boolean>;
+    close(): Promise<boolean>;
     waitForOpened(retries?: boolean): Promise<boolean>;
     waitForClosed(): Promise<boolean>;
     getSupportedCyclingModes(): any[];
     getDefaultCyclingMode(): CyclingMode;
-    setUserSettings(userSettings: any): void;
-    setBikeSettings(bikeSettings: any): void;
 }