incyclist-devices 1.5.38 → 2.0.0

package/lib/index.d.ts

@@ -0,0 +1,15 @@
+import { INTERFACE } from './types/device';
+import InterfaceFactory from './interfaces';
+import AdapterFactory from './adapters';
+import { IncyclistInterface, InterfaceProps } from './types/interface';
+import { IncyclistDeviceAdapter, Bike as Controllable } from './types/adapter';
+import { ControllableDevice as ControllableDeviceAdapter } from './base/adpater';
+import { IncyclistCapability } from './types/capabilities';
+import { DeviceData } from './types/data';
+import { DeviceSettings } from './types/device';
+import CyclingMode from './modes/cycling-mode';
+export * from './modes/cycling-mode';
+export * from './serial';
+export * from './ble';
+export * from './antv2';
+export { IncyclistInterface, INTERFACE, InterfaceFactory, InterfaceProps, DeviceSettings, CyclingMode, AdapterFactory, IncyclistDeviceAdapter, Controllable, ControllableDeviceAdapter, DeviceData, IncyclistCapability, };

package/lib/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IncyclistCapability = exports.ControllableDeviceAdapter = 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 adpater_1 = require("./base/adpater");
+Object.defineProperty(exports, "ControllableDeviceAdapter", { enumerable: true, get: function () { return adpater_1.ControllableDevice; } });
+const capabilities_1 = require("./types/capabilities");
+Object.defineProperty(exports, "IncyclistCapability", { enumerable: true, get: function () { return capabilities_1.IncyclistCapability; } });
+__exportStar(require("./modes/cycling-mode"), exports);
+__exportStar(require("./serial"), exports);
+__exportStar(require("./ble"), exports);
+__exportStar(require("./antv2"), exports);

package/lib/interfaces.d.ts

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

package/lib/interfaces.js

@@ -0,0 +1,27 @@
+"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");
+const ble_1 = require("./ble");
+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);
+            case device_1.INTERFACE.BLE:
+                const bleProps = props;
+                return ble_1.BleInterface.getInstance(bleProps);
+        }
+    }
+}
+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() {
@@ -35,6 +35,10 @@ class PowerBasedCyclingModeBase extends cycling_mode_1.CyclingModeBase {
         const vPrev = (prevData.speed || 0) / 3.6;
         const EkinPrev = 1 / 2 * m * vPrev * vPrev;
         let powerToMaintainSpeed = calculations_1.default.calculatePower(m, vPrev, slope, props);
+        if (t >= 30) {
+            const speed = calculations_1.default.calculateSpeed(m, power, slope, props);
+            return { speed, distance: 0 };
+        }
         const powerDelta = powerToMaintainSpeed - power;
         const Ekin = EkinPrev - powerDelta * t;
         if (Ekin > 0) {

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,21 @@
+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 {
+    pullFrequency: number;
+    check(): Promise<boolean>;
+    constructor(settings: SerialDeviceSettings, props?: DeviceProperties);
+    isEqual(settings: SerialDeviceSettings): boolean;
+    getPort(): string;
+    getUniqueName(): string;
+    getInterface(): string;
+    setMaxUpdateFrequency(ms: number): void;
+    setPullFrequency(ms: number): void;
+    getPullFrequency(): number;
+}

package/lib/serial/adapter.js

@@ -0,0 +1,61 @@
+"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");
+const DEFAULT_PULL_FREQUENCY = 1000;
+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);
+        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()})`;
+    }
+    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/bindings/tcp.d.ts

@@ -0,0 +1,45 @@
+/// <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<any>;
+    data: Buffer;
+    private pendingRead;
+    constructor(socket: net.Socket, options: Required<OpenOptions>);
+    get isOpen(): boolean;
+    onData(data: Buffer): void;
+    onError(err: Error): 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>;
+}