incyclist-devices 2.1.0 → 2.1.1

package/lib/modes/ant-fe-adv-st-mode.d.ts

@@ -1,4 +1,4 @@
-import { IncyclistDeviceAdapter } from "..";
+import { IncyclistDeviceAdapter } from "../base/adpater";
 import SmartTrainerCyclingMode from "./antble-smarttrainer";
 import { UpdateRequest } from "./types";
 export default class AntAdvSimCyclingMode extends SmartTrainerCyclingMode {

package/lib/modes/antble-erg.d.ts

@@ -1,6 +1,6 @@
-import { IncyclistDeviceAdapter } from "..";
 import ICyclingMode, { CyclingModeProperyType, UpdateRequest } from "./types";
 import PowerBasedCyclingModeBase from "./power-base";
+import { IncyclistDeviceAdapter } from "../base/adpater";
 export default class ERGCyclingMode extends PowerBasedCyclingModeBase implements ICyclingMode {
     protected static config: {
         isERG: boolean;

package/lib/modes/antble-smarttrainer.d.ts

@@ -1,6 +1,6 @@
 import ICyclingMode, { CyclingModeProperyType, UpdateRequest } from "./types";
 import PowerBasedCyclingModeBase from "./power-base";
-import { IncyclistDeviceAdapter } from "../types/adapter";
+import { IAdapter } from "../types";
 export default class SmartTrainerCyclingMode extends PowerBasedCyclingModeBase implements ICyclingMode {
     protected static config: {
         name: string;
@@ -14,7 +14,7 @@ export default class SmartTrainerCyclingMode extends PowerBasedCyclingModeBase i
             default: string;
         }[];
     };
-    constructor(adapter: IncyclistDeviceAdapter, props?: any);
+    constructor(adapter: IAdapter, props?: any);
     getBikeInitRequest(): UpdateRequest;
     checkForResetOrEmpty(request: UpdateRequest): UpdateRequest | undefined;
     protected checkSlope(request: UpdateRequest, newRequest?: UpdateRequest): void;

package/lib/modes/base.d.ts

@@ -1,15 +1,15 @@
-import { IncyclistDeviceAdapter } from "../types/adapter";
-import ICyclingMode, { CyclingMode, CyclingModeConfig, CyclingModeProperty, IncyclistBikeData, Settings, UpdateRequest } from "./types";
+import { IncyclistBikeData, IAdapter } from "../types";
+import ICyclingMode, { CyclingMode, CyclingModeConfig, CyclingModeProperty, Settings, UpdateRequest } from "./types";
 export declare abstract class CyclingModeBase extends CyclingMode implements ICyclingMode {
-    adapter: IncyclistDeviceAdapter;
+    adapter: IAdapter;
     settings: Settings;
     properties: Settings;
     localConfig: CyclingModeConfig;
     protected static config: CyclingModeConfig;
     protected static isERG: boolean;
     static supportsERGMode(): boolean;
-    constructor(adapter: IncyclistDeviceAdapter, props?: any);
-    setAdapter(adapter: IncyclistDeviceAdapter): void;
+    constructor(adapter: IAdapter, props?: any);
+    setAdapter(adapter: IAdapter): void;
     setConfig(config: CyclingModeConfig): void;
     getConfig(): CyclingModeConfig;
     getName(): string;

package/lib/modes/daum-classic-standard.d.ts

@@ -1,6 +1,7 @@
-import ICyclingMode, { IncyclistBikeData, Settings, UpdateRequest } from "./types";
-import { IncyclistDeviceAdapter } from "../types/adapter";
+import ICyclingMode, { Settings, UpdateRequest } from "./types";
+import { IncyclistBikeData } from "../types";
 import SmartTrainerCyclingMode from "./antble-smarttrainer";
+import { IncyclistDeviceAdapter } from "../base/adpater";
 type DaumClassicEvent = {
     noData?: boolean;
     slopeUpdate?: boolean;

package/lib/modes/daum-erg.d.ts

@@ -1,6 +1,6 @@
-import ICyclingMode, { CyclingModeProperyType, IncyclistBikeData, UpdateRequest } from "./types";
+import ICyclingMode, { CyclingModeProperyType, UpdateRequest } from "./types";
+import { IncyclistBikeData, IAdapter } from "../types";
 import PowerBasedCyclingModeBase from "./power-base";
-import { IncyclistDeviceAdapter } from "../types/adapter";
 export type ERGEvent = {
     rpmUpdated?: boolean;
     gearUpdated?: boolean;
@@ -37,7 +37,7 @@ export default class ERGCyclingMode extends PowerBasedCyclingModeBase implements
             options?: undefined;
         })[];
     };
-    constructor(adapter: IncyclistDeviceAdapter, props?: any);
+    constructor(adapter: IAdapter, props?: any);
     getBikeInitRequest(): UpdateRequest;
     sendBikeUpdate(request: UpdateRequest): UpdateRequest;
     copyBikeData(data: IncyclistBikeData, bikeData: IncyclistBikeData): IncyclistBikeData;

package/lib/modes/daum-premium-standard.d.ts

@@ -1,6 +1,7 @@
-import ICyclingMode, { CyclingModeProperyType, IncyclistBikeData, Settings, UpdateRequest } from "./types";
-import { IncyclistDeviceAdapter } from "../types/adapter";
+import ICyclingMode, { CyclingModeProperyType, Settings, UpdateRequest } from "./types";
+import { IncyclistBikeData } from "../types";
 import PowerMeterCyclingMode from "./power-meter";
+import { IncyclistDeviceAdapter } from "../base/adpater";
 export default class DaumClassicCyclingMode extends PowerMeterCyclingMode implements ICyclingMode {
     prevInternalDistance: number;
     distanceOffset: number;

package/lib/modes/daum-smarttrainer.d.ts

@@ -1,7 +1,8 @@
 import { EventLogger } from "gd-eventlog";
-import ICyclingMode, { CyclingModeProperyType, IncyclistBikeData, Settings, UpdateRequest } from "./types";
-import { IncyclistDeviceAdapter } from "..";
+import ICyclingMode, { CyclingModeProperyType, Settings, UpdateRequest } from "./types";
+import { IncyclistBikeData } from "../types";
 import { CyclingModeBase } from "./base";
+import { IncyclistDeviceAdapter } from "../base/adpater";
 interface STUpdateRequest extends UpdateRequest {
     calculatedPower?: number;
     delta?: number;

package/lib/modes/kettler-erg.d.ts

@@ -1,6 +1,6 @@
-import ICyclingMode, { CyclingModeProperyType, IncyclistBikeData, UpdateRequest } from './types';
+import ICyclingMode, { CyclingModeProperyType, UpdateRequest } from './types';
+import { IncyclistBikeData, IAdapter } from "../types";
 import PowerBasedCyclingModeBase from './power-base';
-import { IncyclistDeviceAdapter } from '../types/adapter';
 export type ERGEvent = {
     rpmUpdated?: boolean;
     gearUpdated?: boolean;
@@ -37,7 +37,7 @@ export default class ERGCyclingMode extends PowerBasedCyclingModeBase implements
     chain: number[];
     cassette: number[];
     event: ERGEvent;
-    constructor(adapter: IncyclistDeviceAdapter, props?: any);
+    constructor(adapter: IAdapter, props?: any);
     getBikeInitRequest(): UpdateRequest;
     sendBikeUpdate(request: UpdateRequest): UpdateRequest;
     updateData(bikeData: IncyclistBikeData): any;

package/lib/modes/power-base.d.ts

@@ -1,6 +1,6 @@
-import { CyclingModeConfig, IncyclistBikeData, Settings, UpdateRequest } from './types';
+import { CyclingModeConfig, Settings, UpdateRequest } from './types';
+import { IncyclistBikeData, IAdapter } from "../types";
 import { EventLogger } from 'gd-eventlog';
-import { IncyclistDeviceAdapter } from '..';
 import { CyclingModeBase } from './base';
 export default class PowerBasedCyclingModeBase extends CyclingModeBase {
     data: IncyclistBikeData;
@@ -8,7 +8,7 @@ export default class PowerBasedCyclingModeBase extends CyclingModeBase {
     logger: EventLogger;
     prevRequest: UpdateRequest | undefined;
     protected static config: CyclingModeConfig;
-    constructor(adapter: IncyclistDeviceAdapter, props?: Settings);
+    constructor(adapter: IAdapter, props?: Settings);
     getData(): IncyclistBikeData;
     getSlope(): number;
     initLogger(defaultLogName: any): void;

package/lib/modes/power-base.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 });
-const adpater_1 = require("../base/adpater");
+const consts_1 = require("../base/consts");
 const calculations_1 = __importDefault(require("../utils/calculations"));
 const gd_eventlog_1 = require("gd-eventlog");
 const base_1 = require("./base");
@@ -29,7 +29,7 @@ class PowerBasedCyclingModeBase extends base_1.CyclingModeBase {
     }
     getWeight() {
         const a = this.adapter;
-        const defaultWeight = adpater_1.DEFAULT_BIKE_WEIGHT + adpater_1.DEFAULT_USER_WEIGHT;
+        const defaultWeight = consts_1.DEFAULT_BIKE_WEIGHT + consts_1.DEFAULT_USER_WEIGHT;
         const m = (a) ? a.getWeight() || defaultWeight : defaultWeight;
         return m;
     }

package/lib/modes/power-meter.d.ts

@@ -1,6 +1,7 @@
-import ICyclingMode, { IncyclistBikeData, Settings, UpdateRequest } from './types';
+import ICyclingMode, { Settings, UpdateRequest } from './types';
+import { IncyclistBikeData } from "../types";
 import PowerBasedCyclingModeBase from './power-base';
-import { IncyclistDeviceAdapter } from '..';
+import { IncyclistDeviceAdapter } from '../base/adpater';
 export default class PowerMeterCyclingMode extends PowerBasedCyclingModeBase implements ICyclingMode {
     protected static config: {
         name: string;

package/lib/modes/simulator.d.ts

@@ -1,5 +1,6 @@
 import { EventLogger } from "gd-eventlog";
-import { CyclingModeProperyType, IncyclistBikeData, UpdateRequest } from "./types";
+import { CyclingModeProperyType, UpdateRequest } from "./types";
+import { IncyclistBikeData } from "../types";
 import { Simulator } from "../simulator/Simulator";
 import PowerBasedCyclingModeBase from "./power-base";
 export type ERGEvent = {

package/lib/modes/types.d.ts

@@ -1,4 +1,4 @@
-import { IBike } from "../types/adapter";
+import { IAdapter, IncyclistBikeData } from "../types";
 export type UpdateRequest = {
     slope?: number;
     minPower?: number;
@@ -27,17 +27,6 @@ export type CyclingModeProperty = {
     default?: any;
     options?: any[];
 };
-export type IncyclistBikeData = {
-    isPedalling?: boolean;
-    power: number;
-    pedalRpm: number;
-    speed: number;
-    heartrate?: number;
-    distanceInternal?: number;
-    time?: number;
-    gear?: number;
-    slope?: number;
-};
 export type Settings = {
     [key: string]: any;
 };
@@ -63,7 +52,7 @@ export type CyclingModeConfig = {
     properties: CyclingModeProperty[];
 };
 export declare class CyclingMode implements ICyclingMode {
-    constructor(_adapter: IBike, _props?: any);
+    constructor(_adapter: IAdapter, _props?: any);
     static supportsERGMode(): boolean;
     getName(): string;
     getDescription(): string;

package/lib/serial/SinglePathScanner.d.ts

@@ -0,0 +1,17 @@
+import { SerialDeviceSettings } from './adapter';
+import { EventLogger } from "gd-eventlog";
+import { SerialScannerProps } from "./types";
+import SerialInterface from "./serial-interface";
+export declare class SinglePathScanner {
+    path: string;
+    serial: SerialInterface;
+    result: SerialDeviceSettings;
+    isScanning: boolean;
+    props: SerialScannerProps;
+    logger: EventLogger;
+    isFound: boolean;
+    constructor(path: string, serial: SerialInterface, props: SerialScannerProps);
+    logEvent(event: any): void;
+    onStopRequest(resolve: any): Promise<void>;
+    scan(): Promise<SerialDeviceSettings | undefined>;
+}

package/lib/serial/SinglePathScanner.js

@@ -0,0 +1,87 @@
+"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 });
+exports.SinglePathScanner = void 0;
+const gd_eventlog_1 = require("gd-eventlog");
+const utils_1 = require("../utils/utils");
+const adapter_factory_1 = __importDefault(require("./adapter-factory"));
+const types_1 = require("./types");
+class SinglePathScanner {
+    constructor(path, serial, props) {
+        this.path = path;
+        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');
+    }
+    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.BLE_DEBUG) {
+            console.log('~~~ SerialScanner', event);
+        }
+    }
+    onStopRequest(resolve) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'stopping scan', path: this.path });
+            if (!this.isFound)
+                yield this.serial.closePort(this.path);
+            this.isScanning = false;
+            resolve(this.result);
+        });
+    }
+    scan() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isScanning)
+                return;
+            this.isScanning = true;
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                this.logEvent({ message: 'starting scan', path: this.path, interface: this.serial.getName() });
+                this.serial.scanEvents.on('timeout', () => this.onStopRequest(resolve));
+                this.serial.scanEvents.on('stop', () => this.onStopRequest(resolve));
+                let found = false;
+                while (!found && this.isScanning) {
+                    try {
+                        const { protocol } = this.props;
+                        let host, port;
+                        if (this.serial.getName() === types_1.SerialInterfaceType.TCPIP) {
+                            [host, port] = this.path.split(':');
+                        }
+                        else {
+                            port = this.path;
+                        }
+                        const adapterSettings = { interface: this.serial.getName(), host, port, protocol };
+                        const adapter = adapter_factory_1.default.getInstance().createInstance(adapterSettings);
+                        found = yield adapter.check();
+                        if (found) {
+                            this.isFound = true;
+                            const name = adapter.getName();
+                            resolve(Object.assign(Object.assign({}, adapterSettings), { name }));
+                        }
+                        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);
+                    }
+                }
+            }));
+        });
+    }
+}
+exports.SinglePathScanner = SinglePathScanner;

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

@@ -1,14 +1,14 @@
-import { ControllableDevice } from '../base/adpater';
-import { DeviceProperties } from '../types/device';
-import { SerialIncyclistDevice, SerialDeviceSettings } from './adapter';
+import { DeviceProperties } from '../types';
+import { SerialIncyclistDevice } from './adapter';
+import { SerialDeviceSettings } from "./types";
 export default class SerialAdapterFactory {
     static _instance: SerialAdapterFactory;
     adapters: Array<{
         protocol: string;
-        AdapterClass: typeof SerialIncyclistDevice<ControllableDevice<DeviceProperties>, DeviceProperties>;
+        AdapterClass: typeof SerialIncyclistDevice<DeviceProperties>;
     }>;
     static getInstance(): SerialAdapterFactory;
     constructor();
-    registerAdapter(protocol: string, AdapterClass: typeof SerialIncyclistDevice<ControllableDevice<DeviceProperties>, DeviceProperties>): void;
-    createInstance(props: SerialDeviceSettings, settings?: any): SerialIncyclistDevice<ControllableDevice<DeviceProperties>, DeviceProperties>;
+    registerAdapter(protocol: string, AdapterClass: typeof SerialIncyclistDevice<DeviceProperties>): void;
+    createInstance(props: SerialDeviceSettings, settings?: any): SerialIncyclistDevice<DeviceProperties>;
 }

package/lib/serial/adapter.d.ts

@@ -1,16 +1,11 @@
-import { DeviceProperties, DeviceSettings } from "../types/device";
-import IncyclistDevice, { ControllableDevice } from "../base/adpater";
-import SerialInterface from "./serial-interface";
-export interface SerialDeviceSettings extends DeviceSettings {
-    protocol: string;
-    host?: string;
-    port?: string;
-    interface: string | SerialInterface;
-}
-export declare class SerialIncyclistDevice<C extends ControllableDevice<P>, P extends DeviceProperties> extends IncyclistDevice<C, P> {
+import IncyclistDevice from "../base/adpater";
+import { DeviceProperties } from "../types";
+import SerialInterface from "./base/serial-interface";
+import { SerialDeviceSettings } from "./types";
+export declare class SerialIncyclistDevice<P extends DeviceProperties> extends IncyclistDevice<P> {
     pullFrequency: number;
     check(): Promise<boolean>;
-    constructor(settings: SerialDeviceSettings, props?: DeviceProperties);
+    constructor(settings: SerialDeviceSettings, props?: P);
     isEqual(settings: SerialDeviceSettings): boolean;
     getPort(): string;
     getUniqueName(): string;

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

@@ -0,0 +1,17 @@
+import IncyclistDevice from "../../base/adpater";
+import { DeviceProperties } from "../../types";
+import SerialInterface from "./serial-interface";
+import { SerialDeviceSettings } from "../types";
+export declare class SerialIncyclistDevice<P extends DeviceProperties> extends IncyclistDevice<P> {
+    pullFrequency: number;
+    check(): Promise<boolean>;
+    constructor(settings: SerialDeviceSettings, props?: P);
+    isEqual(settings: SerialDeviceSettings): boolean;
+    getPort(): string;
+    getUniqueName(): string;
+    getSerialInterface(): SerialInterface;
+    getInterface(): string;
+    setMaxUpdateFrequency(ms: number): void;
+    setPullFrequency(ms: number): void;
+    getPullFrequency(): number;
+}

package/lib/serial/base/adapter.js

@@ -0,0 +1,67 @@
+"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 });
+exports.SerialIncyclistDevice = void 0;
+const adpater_1 = __importDefault(require("../../base/adpater"));
+const DEFAULT_PULL_FREQUENCY = 1000;
+class SerialIncyclistDevice extends adpater_1.default {
+    check() {
+        return __awaiter(this, void 0, void 0, function* () { throw new Error('not implemnted'); });
+    }
+    ;
+    constructor(settings, props) {
+        super(settings, props);
+        this.pullFrequency = DEFAULT_PULL_FREQUENCY;
+    }
+    isEqual(settings) {
+        if (settings.interface !== this.getInterface())
+            return false;
+        const s = this.settings;
+        if (settings.protocol !== s.protocol)
+            return false;
+        if (settings.port !== s.port)
+            return false;
+        if (settings.host && (!s.host || s.host !== settings.host))
+            return false;
+        return true;
+    }
+    getPort() {
+        const settings = this.settings;
+        return settings.port;
+    }
+    getUniqueName() {
+        return `${this.getName()} (${this.getPort()})`;
+    }
+    getSerialInterface() {
+        throw new Error('not implemented');
+    }
+    getInterface() {
+        return 'serial';
+    }
+    setMaxUpdateFrequency(ms) {
+        if (ms <= this.pullFrequency)
+            this.updateFrequency = -1;
+        else
+            this.updateFrequency = ms;
+    }
+    setPullFrequency(ms) {
+        this.pullFrequency = ms;
+        if (this.updateFrequency <= this.pullFrequency)
+            this.updateFrequency = -1;
+    }
+    getPullFrequency() {
+        return this.pullFrequency;
+    }
+}
+exports.SerialIncyclistDevice = SerialIncyclistDevice;

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

@@ -0,0 +1,62 @@
+/// <reference types="node" />
+import { EventLogger } from "gd-eventlog";
+import SerialInterface from "./serial-interface";
+import { SerialCommProps } from "../types";
+import { SerialPortStream } from "@serialport/stream";
+import { Queue } from "../../utils/utils";
+export type ConnectionState = 'Connecting' | 'Connected' | 'Disconnected' | 'Disconnecting';
+export type Request = {
+    logString?: string;
+    isBinary?: boolean;
+};
+export type Response = {};
+export interface CommsState {
+    data?: Queue<Response>;
+}
+export default class SerialPortComms<T extends CommsState, C extends Request, R extends Response> {
+    logger: EventLogger;
+    serial: SerialInterface;
+    protected path: string;
+    protected props: SerialCommProps;
+    protected sp: SerialPortStream;
+    protected connectState: ConnectionState;
+    protected connectPromise: Promise<SerialPortStream>;
+    protected disconnectPromise: Promise<boolean>;
+    protected writePromise: Promise<void>;
+    protected sendCmdPromise: Promise<R>;
+    protected actualBikeType?: string;
+    protected recvState: T;
+    protected isLoggingPaused: boolean;
+    constructor(props: SerialCommProps);
+    getBusyTimeout(): number;
+    getDefaultLoggerName(): string;
+    getInitialCommsState(): T;
+    validatePath(path: string): string;
+    getInterface(): string;
+    getPort(): string;
+    isConnected(): boolean;
+    pauseLogging(): void;
+    resumeLogging(): void;
+    logEvent(e: any): void;
+    connect(): Promise<boolean>;
+    onConnected(): void;
+    portFlush(): void;
+    portPipe(destination: any, options?: any): any;
+    portUnpipe(destination?: any): void;
+    closePort(): Promise<boolean>;
+    resetState(isDisconnected?: boolean): void;
+    cleanupPort(isDisconnected?: boolean): void;
+    close(): Promise<boolean>;
+    flush(): Promise<void>;
+    onPortClose(): Promise<void>;
+    onPortError(error: Error): Promise<void>;
+    isSending(): boolean;
+    rejectCurrent(error: Error): void;
+    getTimeoutValue(): number;
+    onData(data: any, depth?: number): Promise<void>;
+    send(command: C): Promise<R>;
+    portWrite(buffer: Buffer): Promise<void>;
+    write(buffer: Buffer): Promise<void>;
+    ensurePrevCmdFinish(logPayload: any): Promise<void>;
+    ensureConnection(): Promise<void>;
+}