incyclist-devices 1.5.37 → 2.0.0-beta.1

package/lib/index.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KettlerRacerAdapter = exports.DaumPremiumAdapter = exports.DaumClassicAdapter = exports.TCPBinding = exports.SerialInterface = exports.useSerialPortProvider = exports.SerialPortProvider = exports.BleTacxAdapter = exports.BleWahooAdapter = exports.BleFmAdapter = exports.BlePwrAdapter = exports.BleHrmAdapter = exports.BleInterface = exports.BleAdapterFactory = exports.CyclingModeProperyType = exports.AntInterface = exports.AntPwrAdapter = exports.AntHrAdapter = exports.AntFEAdapter = exports.AntAdapterFactory = exports.IncyclistCapability = exports.AdapterFactory = exports.InterfaceFactory = exports.INTERFACE = void 0;
+const device_1 = require("./types/device");
+Object.defineProperty(exports, "INTERFACE", { enumerable: true, get: function () { return device_1.INTERFACE; } });
+const interfaces_1 = __importDefault(require("./interfaces"));
+exports.InterfaceFactory = interfaces_1.default;
+const adapters_1 = __importDefault(require("./adapters"));
+exports.AdapterFactory = adapters_1.default;
+const capabilities_1 = require("./types/capabilities");
+Object.defineProperty(exports, "IncyclistCapability", { enumerable: true, get: function () { return capabilities_1.IncyclistCapability; } });
+const serial_1 = require("./serial");
+Object.defineProperty(exports, "SerialPortProvider", { enumerable: true, get: function () { return serial_1.SerialPortProvider; } });
+Object.defineProperty(exports, "useSerialPortProvider", { enumerable: true, get: function () { return serial_1.useSerialPortProvider; } });
+Object.defineProperty(exports, "SerialInterface", { enumerable: true, get: function () { return serial_1.SerialInterface; } });
+Object.defineProperty(exports, "TCPBinding", { enumerable: true, get: function () { return serial_1.TCPBinding; } });
+Object.defineProperty(exports, "DaumPremiumAdapter", { enumerable: true, get: function () { return serial_1.DaumPremiumAdapter; } });
+Object.defineProperty(exports, "DaumClassicAdapter", { enumerable: true, get: function () { return serial_1.DaumClassicAdapter; } });
+Object.defineProperty(exports, "KettlerRacerAdapter", { enumerable: true, get: function () { return serial_1.KettlerRacerAdapter; } });
+const antv2_1 = require("./antv2");
+Object.defineProperty(exports, "AntAdapterFactory", { enumerable: true, get: function () { return antv2_1.AntAdapterFactory; } });
+Object.defineProperty(exports, "AntFEAdapter", { enumerable: true, get: function () { return antv2_1.AntFEAdapter; } });
+Object.defineProperty(exports, "AntHrAdapter", { enumerable: true, get: function () { return antv2_1.AntHrAdapter; } });
+Object.defineProperty(exports, "AntPwrAdapter", { enumerable: true, get: function () { return antv2_1.AntPwrAdapter; } });
+Object.defineProperty(exports, "AntInterface", { enumerable: true, get: function () { return antv2_1.AntInterface; } });
+const ble_1 = require("./ble");
+Object.defineProperty(exports, "BleAdapterFactory", { enumerable: true, get: function () { return ble_1.BleAdapterFactory; } });
+Object.defineProperty(exports, "BleInterface", { enumerable: true, get: function () { return ble_1.BleInterface; } });
+Object.defineProperty(exports, "BleHrmAdapter", { enumerable: true, get: function () { return ble_1.BleHrmAdapter; } });
+Object.defineProperty(exports, "BlePwrAdapter", { enumerable: true, get: function () { return ble_1.BlePwrAdapter; } });
+Object.defineProperty(exports, "BleFmAdapter", { enumerable: true, get: function () { return ble_1.BleFmAdapter; } });
+Object.defineProperty(exports, "BleWahooAdapter", { enumerable: true, get: function () { return ble_1.BleWahooAdapter; } });
+Object.defineProperty(exports, "BleTacxAdapter", { enumerable: true, get: function () { return ble_1.BleTacxAdapter; } });
+const cycling_mode_1 = require("./modes/cycling-mode");
+Object.defineProperty(exports, "CyclingModeProperyType", { enumerable: true, get: function () { return cycling_mode_1.CyclingModeProperyType; } });

package/lib/interfaces.d.ts

@@ -0,0 +1,6 @@
+import { InterfaceProps } from "./types/interface";
+import { SerialInterface } from "./serial";
+import AntInterface from "./antv2/ant-interface";
+export default class InterfaceFactory {
+    static create(ifaceName: string, props?: InterfaceProps): AntInterface | SerialInterface;
+}

package/lib/interfaces.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const serial_1 = require("./serial");
+const ant_interface_1 = __importDefault(require("./antv2/ant-interface"));
+const device_1 = require("./types/device");
+class InterfaceFactory {
+    static create(ifaceName, props) {
+        switch (ifaceName) {
+            case device_1.INTERFACE.SERIAL:
+            case device_1.INTERFACE.TCPIP:
+                const serialProps = props;
+                serialProps.ifaceName = ifaceName;
+                return serial_1.SerialInterface.getInstance(serialProps);
+            case device_1.INTERFACE.ANT:
+                const antProps = props;
+                return ant_interface_1.default.getInstance(antProps);
+        }
+    }
+}
+exports.default = InterfaceFactory;

package/lib/{ble → modes}/ble-erg-mode.d.ts

@@ -1,13 +1,13 @@
-import CyclingMode, { CyclingModeProperty, IncyclistBikeData, UpdateRequest } from "../cycling-mode";
-import { DeviceAdapter } from "../device";
-import PowerBasedCyclingModeBase from "../modes/power-base";
+import { IncyclistDeviceAdapter } from "../types/adapter";
+import CyclingMode, { CyclingModeProperty, IncyclistBikeData, UpdateRequest } from "./cycling-mode";
+import PowerBasedCyclingModeBase from "./power-base";
 export default class BleERGCyclingMode extends PowerBasedCyclingModeBase implements CyclingMode {
     static isERG: boolean;
     prevRequest: UpdateRequest;
     hasBikeUpdate: boolean;
     chain: number[];
     cassette: number[];
-    constructor(adapter: DeviceAdapter, props?: any);
+    constructor(adapter: IncyclistDeviceAdapter, props?: any);
     getName(): string;
     getDescription(): string;
     getProperties(): CyclingModeProperty[];

package/lib/{ble → modes}/ble-erg-mode.js

@@ -3,8 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const cycling_mode_1 = require("../cycling-mode");
-const power_base_1 = __importDefault(require("../modes/power-base"));
+const cycling_mode_1 = require("./cycling-mode");
+const power_base_1 = __importDefault(require("./power-base"));
 const config = {
     name: "ERG",
     description: "Calculates speed based on power and slope. Power targets are set by workout or remain stable throughout the workout",

package/lib/{ble → modes}/ble-st-mode.d.ts

@@ -1,10 +1,10 @@
-import CyclingMode, { CyclingModeProperty, IncyclistBikeData, UpdateRequest } from "../cycling-mode";
-import { DeviceAdapter } from "../device";
+import CyclingMode, { CyclingModeProperty, IncyclistBikeData, UpdateRequest } from "../modes/cycling-mode";
 import PowerBasedCyclingModeBase from "../modes/power-base";
+import { IncyclistDeviceAdapter } from "../types/adapter";
 export default class FtmsCyclingMode extends PowerBasedCyclingModeBase implements CyclingMode {
     prevRequest: UpdateRequest;
     hasBikeUpdate: boolean;
-    constructor(adapter: DeviceAdapter, props?: any);
+    constructor(adapter: IncyclistDeviceAdapter, props?: any);
     getName(): string;
     getDescription(): string;
     getProperties(): CyclingModeProperty[];

package/lib/{ble → modes}/ble-st-mode.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 cycling_mode_1 = require("../cycling-mode");
+const cycling_mode_1 = require("../modes/cycling-mode");
 const power_base_1 = __importDefault(require("../modes/power-base"));
 const config = {
     name: "Smart Trainer",

package/lib/{cycling-mode.d.ts → modes/cycling-mode.d.ts}

@@ -1,5 +1,5 @@
-import { Device } from "./protocol";
-export declare type UpdateRequest = {
+import { IncyclistDeviceAdapter } from "../types/adapter";
+export type UpdateRequest = {
     slope?: number;
     minPower?: number;
     maxPower?: number;
@@ -17,7 +17,7 @@ export declare enum CyclingModeProperyType {
     SingleSelect = "SingleSelect",
     MultiSelect = "MultiSelect"
 }
-export declare type CyclingModeProperty = {
+export type CyclingModeProperty = {
     key: string;
     name: string;
     description: string;
@@ -27,7 +27,7 @@ export declare type CyclingModeProperty = {
     default?: any;
     options?: any[];
 };
-export declare type IncyclistBikeData = {
+export type IncyclistBikeData = {
     isPedalling: boolean;
     power: number;
     pedalRpm: number;
@@ -38,7 +38,7 @@ export declare type IncyclistBikeData = {
     gear?: number;
     slope?: number;
 };
-export declare type Settings = {
+export type Settings = {
     [key: string]: any;
 };
 export default interface CyclingMode {
@@ -57,11 +57,11 @@ export default interface CyclingMode {
     getModeProperty(name: string): any;
 }
 export declare class CyclingModeBase implements CyclingMode {
-    adapter: Device;
+    adapter: IncyclistDeviceAdapter;
     settings: Settings;
     properties: Settings;
-    constructor(adapter: Device, props?: any);
-    setAdapter(adapter: Device): void;
+    constructor(adapter: IncyclistDeviceAdapter, props?: any);
+    setAdapter(adapter: IncyclistDeviceAdapter): void;
     getBikeInitRequest(): UpdateRequest;
     getName(): string;
     getDescription(): string;

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

@@ -1,11 +1,11 @@
-import { IncyclistBikeData, Settings, CyclingModeBase } from '../cycling-mode';
-import { DeviceAdapter } from '../device';
+import { IncyclistBikeData, Settings, CyclingModeBase } from './cycling-mode';
 import { EventLogger } from 'gd-eventlog';
+import { IncyclistDeviceAdapter } from '../types/adapter';
 export default class PowerBasedCyclingModeBase extends CyclingModeBase {
     data: IncyclistBikeData;
     prevUpdateTS: number;
     logger: EventLogger;
-    constructor(adapter: DeviceAdapter, props?: Settings);
+    constructor(adapter: IncyclistDeviceAdapter, props?: Settings);
     initLogger(defaultLogName: any): void;
     getWeight(): any;
     getTimeSinceLastUpdate(): number;

package/lib/modes/power-base.js

@@ -3,9 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const cycling_mode_1 = require("../cycling-mode");
-const device_1 = require("../device");
-const calculations_1 = __importDefault(require("../calculations"));
+const cycling_mode_1 = require("./cycling-mode");
+const adpater_1 = require("../base/adpater");
+const calculations_1 = __importDefault(require("../utils/calculations"));
 const gd_eventlog_1 = require("gd-eventlog");
 class PowerBasedCyclingModeBase extends cycling_mode_1.CyclingModeBase {
     constructor(adapter, props) {
@@ -21,7 +21,7 @@ class PowerBasedCyclingModeBase extends cycling_mode_1.CyclingModeBase {
     }
     getWeight() {
         const a = this.adapter;
-        const m = (a && a.getWeight && a.getWeight()) ? a.getWeight() : device_1.DEFAULT_BIKE_WEIGHT + device_1.DEFAULT_USER_WEIGHT;
+        const m = (a && a.getWeight && a.getWeight()) ? a.getWeight() : adpater_1.DEFAULT_BIKE_WEIGHT + adpater_1.DEFAULT_USER_WEIGHT;
         return m;
     }
     getTimeSinceLastUpdate() {

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

@@ -1,13 +1,13 @@
-import CyclingMode, { CyclingModeProperty, IncyclistBikeData, Settings, UpdateRequest } from '../cycling-mode';
+import CyclingMode, { CyclingModeProperty, IncyclistBikeData, Settings, UpdateRequest } from '../modes/cycling-mode';
 import PowerBasedCyclingModeBase from './power-base';
-import { DeviceAdapter } from '../device';
+import { IncyclistDeviceAdapter } from '../types/adapter';
 export declare const config: {
     name: string;
     description: string;
     properties: any[];
 };
 export default class PowerMeterCyclingMode extends PowerBasedCyclingModeBase implements CyclingMode {
-    constructor(adapter: DeviceAdapter, props?: Settings);
+    constructor(adapter: IncyclistDeviceAdapter, props?: Settings);
     getName(): string;
     getDescription(): string;
     getProperties(): CyclingModeProperty[];

package/lib/modes/simulator.d.ts

@@ -1,8 +1,8 @@
 import { EventLogger } from "gd-eventlog";
-import { CyclingModeProperty, IncyclistBikeData, UpdateRequest } from "../cycling-mode";
+import { CyclingModeProperty, IncyclistBikeData, UpdateRequest } from "../modes/cycling-mode";
 import { Simulator } from "../simulator/Simulator";
 import PowerBasedCyclingModeBase from "./power-base";
-export declare type ERGEvent = {
+export type ERGEvent = {
     rpmUpdated?: boolean;
     gearUpdated?: boolean;
     starting?: boolean;

package/lib/modes/simulator.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const gd_eventlog_1 = require("gd-eventlog");
-const cycling_mode_1 = require("../cycling-mode");
+const cycling_mode_1 = require("../modes/cycling-mode");
 const power_base_1 = __importDefault(require("./power-base"));
 const MIN_SPEED = 10;
 const config = {

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

@@ -0,0 +1,12 @@
+import { SerialIncyclistDevice, SerialDeviceSettings } from './adapter';
+export default class SerialAdapterFactory {
+    static _instance: SerialAdapterFactory;
+    adapters: {
+        protocol: string;
+        AdapterClass: typeof SerialIncyclistDevice;
+    }[];
+    static getInstance(): SerialAdapterFactory;
+    constructor();
+    registerAdapter(protocol: string, AdapterClass: typeof SerialIncyclistDevice): void;
+    createInstance(props: SerialDeviceSettings, settings?: any): SerialIncyclistDevice;
+}

package/lib/serial/adapter-factory.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class SerialAdapterFactory {
+    static getInstance() {
+        if (!SerialAdapterFactory._instance)
+            SerialAdapterFactory._instance = new SerialAdapterFactory();
+        return SerialAdapterFactory._instance;
+    }
+    constructor() {
+        this.adapters = [];
+    }
+    registerAdapter(protocol, AdapterClass) {
+        const existing = this.adapters.findIndex(a => a.protocol === protocol);
+        if (existing !== -1)
+            this.adapters[existing].AdapterClass = AdapterClass;
+        else
+            this.adapters.push({ protocol, AdapterClass });
+    }
+    createInstance(props, settings) {
+        const { protocol } = props;
+        if (!protocol)
+            return null;
+        const adapter = this.adapters.find(a => a.protocol === protocol);
+        if (!adapter)
+            return null;
+        const { AdapterClass } = adapter;
+        return new AdapterClass(props, settings);
+    }
+}
+exports.default = SerialAdapterFactory;

package/lib/serial/adapter.d.ts

@@ -0,0 +1,16 @@
+import { DeviceProperties, DeviceSettings } from "../types/device";
+import { 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 extends ControllableDevice {
+    check(): Promise<boolean>;
+    constructor(settings: SerialDeviceSettings, props?: DeviceProperties);
+    isEqual(settings: SerialDeviceSettings): boolean;
+    getPort(): string;
+    getInterface(): string;
+}

package/lib/serial/adapter.js

@@ -0,0 +1,42 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerialIncyclistDevice = void 0;
+const adpater_1 = require("../base/adpater");
+class SerialIncyclistDevice extends adpater_1.ControllableDevice {
+    check() {
+        return __awaiter(this, void 0, void 0, function* () { throw new Error('not implemnted'); });
+    }
+    ;
+    constructor(settings, props) {
+        super(settings, props);
+    }
+    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;
+    }
+    getInterface() {
+        return 'serial';
+    }
+}
+exports.SerialIncyclistDevice = SerialIncyclistDevice;

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

@@ -0,0 +1,44 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { BindingPortInterface, OpenOptions, PortStatus, PortInfo, SetOptions, UpdateOptions, BindingInterface } from "@serialport/bindings-interface";
+import { EventLogger } from 'gd-eventlog';
+import net from 'net';
+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[]>;
+}
+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 getSubnets(): string[];
+export declare const TCPBinding: TCPBindingInterface;
+export declare class TCPPortBinding implements BindingPortInterface {
+    openOptions: Required<OpenOptions>;
+    socket: any;
+    logger: EventLogger;
+    writeOperation: null | Promise<void>;
+    data: Buffer;
+    private pendingRead;
+    constructor(socket: net.Socket, options: Required<OpenOptions>);
+    get isOpen(): boolean;
+    onData(data: Buffer): void;
+    close(): Promise<void>;
+    read(buffer: Buffer, offset: number, length: number): Promise<{
+        buffer: Buffer;
+        bytesRead: number;
+    }>;
+    write(buffer: Buffer): Promise<void>;
+    update(options: UpdateOptions): Promise<void>;
+    set(options: SetOptions): Promise<void>;
+    get(): Promise<PortStatus>;
+    getBaudRate(): Promise<{
+        baudRate: number;
+    }>;
+    flush(): Promise<void>;
+    drain(): Promise<void>;
+}