incyclist-devices 2.0.38 → 2.1.0

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

@@ -1,20 +1,14 @@
-import CyclingMode, { CyclingModeProperty, IncyclistBikeData, Settings, UpdateRequest } from '../modes/cycling-mode';
+import ICyclingMode, { IncyclistBikeData, Settings, UpdateRequest } from './types';
 import PowerBasedCyclingModeBase from './power-base';
-import { ControllableDeviceAdapter } from '..';
-export declare const config: {
-    name: string;
-    description: string;
-    properties: any[];
-};
-export default class PowerMeterCyclingMode extends PowerBasedCyclingModeBase implements CyclingMode {
-    constructor(adapter: ControllableDeviceAdapter, props?: Settings);
-    getName(): string;
-    getDescription(): string;
-    getProperties(): CyclingModeProperty[];
-    getProperty(name: string): CyclingModeProperty;
+import { IncyclistDeviceAdapter } from '..';
+export default class PowerMeterCyclingMode extends PowerBasedCyclingModeBase implements ICyclingMode {
+    protected static config: {
+        name: string;
+        description: string;
+        properties: any[];
+    };
+    constructor(adapter: IncyclistDeviceAdapter, props?: Settings);
     getBikeInitRequest(): UpdateRequest;
     sendBikeUpdate(request?: UpdateRequest): UpdateRequest;
-    updateData(bikeData: IncyclistBikeData, props?: {
-        log: boolean;
-    }): IncyclistBikeData;
+    copyBikeData(data: IncyclistBikeData, bikeData: IncyclistBikeData): IncyclistBikeData;
 }

package/lib/modes/power-meter.js

@@ -3,76 +3,37 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.config = void 0;
 const power_base_1 = __importDefault(require("./power-base"));
-const MIN_SPEED = 10;
-exports.config = {
-    name: 'PowerMeter',
-    description: 'Power and cadence are taken from device. Speed is calculated from power and current slope\nThis mode will not respect maximum power and/or workout limits',
-    properties: []
-};
 class PowerMeterCyclingMode extends power_base_1.default {
     constructor(adapter, props) {
         super(adapter, props);
         this.initLogger('PowerMeterMode');
-        this.data = { speed: 0, slope: 0, power: 0, distanceInternal: 0, pedalRpm: 0, isPedalling: false, heartrate: 0 };
-    }
-    getName() {
-        return exports.config.name;
-    }
-    getDescription() {
-        return exports.config.description;
-    }
-    getProperties() {
-        return exports.config.properties;
-    }
-    getProperty(name) {
-        return exports.config.properties.find(p => p.name === name);
+        this.data.slope = 0;
     }
     getBikeInitRequest() {
         return {};
     }
     sendBikeUpdate(request = {}) {
-        const prevData = this.data || {};
-        const prevSlope = prevData.slope || 0;
+        this.logger.logEvent({ message: "processing update request", request });
+        const prevData = this.data;
+        const prevSlope = prevData.slope;
         if (request.slope && request.slope !== prevSlope) {
             this.data.slope = request.slope;
-            this.updateData(this.data, { log: false });
+            this.updateData(this.data, false);
         }
-        this.logger.logEvent({ message: "processing update request", request });
         return {};
     }
-    updateData(bikeData, props = { log: true }) {
-        try {
-            const prevData = this.data || {};
-            const data = JSON.parse(JSON.stringify(bikeData));
-            let power = bikeData.power || 0;
-            const slope = prevData.slope || 0;
-            const distanceInternal = prevData.distanceInternal || 0;
-            if (power > 0) {
-                data.isPedalling = true;
-            }
-            const m = this.getWeight();
-            const t = this.getTimeSinceLastUpdate();
-            const { speed, distance } = this.calculateSpeedAndDistance(power, slope, m, t);
-            data.power = Math.round(power);
-            data.slope = slope;
-            if (power === 0 && speed < MIN_SPEED) {
-                data.speed = Math.round(prevData.speed - 1) < 0 ? 0 : Math.round(prevData.speed - 1);
-                data.distanceInternal = distanceInternal + data.speed / 3.6 * t;
-            }
-            else {
-                data.speed = speed;
-                data.distanceInternal = distanceInternal + distance;
-            }
-            if (props.log)
-                this.logger.logEvent({ message: "updateData result", data, bikeData, prevSpeed: prevData.speed, stopped: speed < MIN_SPEED });
-            this.data = data;
+    copyBikeData(data, bikeData) {
+        const newData = super.copyBikeData(data, bikeData);
+        if (bikeData.power > 0) {
+            newData.isPedalling = true;
         }
-        catch (err) {
-            this.logger.logEvent({ message: 'error', fn: 'updateData()', error: err.message || err });
-        }
-        return this.data;
+        return newData;
     }
 }
+PowerMeterCyclingMode.config = {
+    name: 'PowerMeter',
+    description: 'Power and cadence are taken from device. Speed is calculated from power and current slope\nThis mode will not respect maximum power and/or workout limits',
+    properties: []
+};
 exports.default = PowerMeterCyclingMode;

package/lib/modes/simulator.d.ts

@@ -1,5 +1,5 @@
 import { EventLogger } from "gd-eventlog";
-import { CyclingModeProperty, IncyclistBikeData, UpdateRequest } from "../modes/cycling-mode";
+import { CyclingModeProperyType, IncyclistBikeData, UpdateRequest } from "./types";
 import { Simulator } from "../simulator/Simulator";
 import PowerBasedCyclingModeBase from "./power-base";
 export type ERGEvent = {
@@ -9,21 +9,48 @@ export type ERGEvent = {
     tsStart?: number;
 };
 export default class SimulatorCyclingMode extends PowerBasedCyclingModeBase {
-    static isERG: boolean;
+    protected static config: {
+        isERG: boolean;
+        name: string;
+        description: string;
+        properties: ({
+            key: string;
+            name: string;
+            description: string;
+            type: CyclingModeProperyType;
+            options: string[];
+            default: string;
+            min?: undefined;
+            max?: undefined;
+            condition?: undefined;
+        } | {
+            key: string;
+            name: string;
+            description: string;
+            type: CyclingModeProperyType;
+            default: number;
+            min: number;
+            max: number;
+            options?: undefined;
+            condition?: undefined;
+        } | {
+            key: string;
+            name: string;
+            description: string;
+            condition: (s: any) => boolean;
+            type: CyclingModeProperyType;
+            default: number;
+            min: number;
+            max: number;
+            options?: undefined;
+        })[];
+    };
     logger: EventLogger;
     data: IncyclistBikeData;
     prevRequest: UpdateRequest;
     prevUpdateTS: number;
-    hasBikeUpdate: boolean;
-    chain: number[];
-    cassette: number[];
     event: ERGEvent;
     constructor(adapter: Simulator, props?: any);
-    getName(): string;
-    getDescription(): string;
-    getProperties(): CyclingModeProperty[];
-    getProperty(name: string): CyclingModeProperty;
     getBikeInitRequest(): UpdateRequest;
-    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
     updateData(bikeData: IncyclistBikeData): IncyclistBikeData;
 }

package/lib/modes/simulator.js

@@ -3,62 +3,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const gd_eventlog_1 = require("gd-eventlog");
-const cycling_mode_1 = require("../modes/cycling-mode");
+const types_1 = require("./types");
 const power_base_1 = __importDefault(require("./power-base"));
 const MIN_SPEED = 10;
-const config = {
-    name: "Simulator",
-    description: "Simulates a ride with constant speed or power output",
-    properties: [
-        { key: 'mode', name: 'Simulation Type', description: '', type: cycling_mode_1.CyclingModeProperyType.SingleSelect, options: ['Speed', 'Power'], default: 'Power' },
-        { key: 'delay', name: 'Start Delay', description: 'Delay (in s) at start of training', type: cycling_mode_1.CyclingModeProperyType.Integer, default: 2, min: 0, max: 30 },
-        { key: 'power', name: 'Power', description: 'Power (in W) at start of training', condition: (s) => !s.mode || s.mode === 'Power', type: cycling_mode_1.CyclingModeProperyType.Integer, default: 150, min: 25, max: 800 },
-        { key: 'speed', name: 'Speed', description: 'Speed (in km/h) at start of training', condition: (s) => s.mode === 'Speed', type: cycling_mode_1.CyclingModeProperyType.Integer, default: 30, min: 5, max: 50 },
-        { key: 'bikeType', name: 'Bike Type', description: '', type: cycling_mode_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain', 'Triathlon'], default: 'Race' }
-    ]
-};
 class SimulatorCyclingMode extends power_base_1.default {
     constructor(adapter, props) {
         super(adapter, props);
         this.prevUpdateTS = 0;
-        this.hasBikeUpdate = false;
         this.event = {};
-        this.logger = adapter.logger || new gd_eventlog_1.EventLogger('SIMMode');
-        this.data = {};
-        this.logger.logEvent({ message: 'constructor', props });
-    }
-    getName() {
-        return config.name;
-    }
-    getDescription() {
-        return config.description;
-    }
-    getProperties() {
-        return config.properties;
-    }
-    getProperty(name) {
-        return config.properties.find(p => p.name === name);
+        this.initLogger('SIMMode');
     }
     getBikeInitRequest() {
         return {};
     }
-    sendBikeUpdate(request) {
-        this.logger.logEvent({ message: 'bike update request', request });
-        const r = request || { refresh: true };
-        if (r.refresh) {
-            if (Object.keys(r).length === 1)
-                return this.prevRequest || {};
-            delete r.refresh;
-        }
-        if (request.slope !== undefined) {
-            if (!this.data)
-                this.data = {};
-            this.data.slope = request.slope;
-        }
-        this.prevRequest = request ? JSON.parse(JSON.stringify(request)) : {};
-        return r;
-    }
     updateData(bikeData) {
         const prevData = JSON.parse(JSON.stringify(this.data || {}));
         const prevSpeed = prevData.speed;
@@ -136,5 +93,16 @@ class SimulatorCyclingMode extends power_base_1.default {
         return data;
     }
 }
-SimulatorCyclingMode.isERG = true;
+SimulatorCyclingMode.config = {
+    isERG: true,
+    name: "Simulator",
+    description: "Simulates a ride with constant speed or power output",
+    properties: [
+        { key: 'mode', name: 'Simulation Type', description: '', type: types_1.CyclingModeProperyType.SingleSelect, options: ['Speed', 'Power'], default: 'Power' },
+        { key: 'delay', name: 'Start Delay', description: 'Delay (in s) at start of training', type: types_1.CyclingModeProperyType.Integer, default: 2, min: 0, max: 30 },
+        { key: 'power', name: 'Power', description: 'Power (in W) at start of training', condition: (s) => !s.mode || s.mode === 'Power', type: types_1.CyclingModeProperyType.Integer, default: 150, min: 25, max: 800 },
+        { key: 'speed', name: 'Speed', description: 'Speed (in km/h) at start of training', condition: (s) => s.mode === 'Speed', type: types_1.CyclingModeProperyType.Integer, default: 30, min: 5, max: 50 },
+        { key: 'bikeType', name: 'Bike Type', description: '', type: types_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain', 'Triathlon'], default: 'Race' }
+    ]
+};
 exports.default = SimulatorCyclingMode;

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

@@ -1,4 +1,4 @@
-import { ControllableDeviceAdapter } from "..";
+import { IBike } from "../types/adapter";
 export type UpdateRequest = {
     slope?: number;
     minPower?: number;
@@ -41,14 +41,14 @@ export type IncyclistBikeData = {
 export type Settings = {
     [key: string]: any;
 };
-export default interface CyclingMode {
+export default interface ICyclingMode {
     getName(): string;
     getDescription(): string;
+    getProperties(): CyclingModeProperty[];
+    getProperty(name: string): CyclingModeProperty;
     getBikeInitRequest(): UpdateRequest;
     sendBikeUpdate(request: UpdateRequest): UpdateRequest;
     updateData(data: IncyclistBikeData): IncyclistBikeData;
-    getProperties(): CyclingModeProperty[];
-    getProperty(name: string): CyclingModeProperty;
     setSettings(settings: any): any;
     setSetting(name: string, value: any): void;
     getSetting(name: string): any;
@@ -56,23 +56,26 @@ export default interface CyclingMode {
     setModeProperty(name: string, value: any): void;
     getModeProperty(name: string): any;
 }
-export declare class CyclingModeBase implements CyclingMode {
-    adapter: ControllableDeviceAdapter;
-    settings: Settings;
-    properties: Settings;
-    constructor(adapter: ControllableDeviceAdapter, props?: any);
-    setAdapter(adapter: ControllableDeviceAdapter): void;
-    getBikeInitRequest(): UpdateRequest;
+export type CyclingModeConfig = {
+    isERG?: boolean;
+    name: string;
+    description: string;
+    properties: CyclingModeProperty[];
+};
+export declare class CyclingMode implements ICyclingMode {
+    constructor(_adapter: IBike, _props?: any);
+    static supportsERGMode(): boolean;
     getName(): string;
     getDescription(): string;
-    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
-    updateData(data: IncyclistBikeData): IncyclistBikeData;
     getProperties(): CyclingModeProperty[];
-    getProperty(name: string): CyclingModeProperty;
-    setSettings(settings?: any): void;
-    setSetting(name: string, value: any): void;
-    getSetting(name: string): any;
+    getProperty(_name: string): CyclingModeProperty;
+    getBikeInitRequest(): UpdateRequest;
+    sendBikeUpdate(_request: UpdateRequest): UpdateRequest;
+    updateData(_data: IncyclistBikeData): IncyclistBikeData;
+    setSettings(_settings: any): void;
+    setSetting(_name: string, _value: any): void;
+    getSetting(_name: string): void;
     getSettings(): Settings;
-    setModeProperty(name: string, value: any): void;
-    getModeProperty(name: string): any;
+    setModeProperty(_name: string, _value: any): void;
+    getModeProperty(_name: string): void;
 }

package/lib/modes/types.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CyclingMode = exports.CyclingModeProperyType = void 0;
+var CyclingModeProperyType;
+(function (CyclingModeProperyType) {
+    CyclingModeProperyType["Integer"] = "Integer";
+    CyclingModeProperyType["Boolean"] = "Boolean";
+    CyclingModeProperyType["Float"] = "Float";
+    CyclingModeProperyType["String"] = "String";
+    CyclingModeProperyType["SingleSelect"] = "SingleSelect";
+    CyclingModeProperyType["MultiSelect"] = "MultiSelect";
+})(CyclingModeProperyType || (exports.CyclingModeProperyType = CyclingModeProperyType = {}));
+class CyclingMode {
+    constructor(_adapter, _props) { }
+    static supportsERGMode() { return false; }
+    getName() {
+        throw new Error("Method not implemented.");
+    }
+    getDescription() {
+        throw new Error("Method not implemented.");
+    }
+    getProperties() {
+        throw new Error("Method not implemented.");
+    }
+    getProperty(_name) {
+        throw new Error("Method not implemented.");
+    }
+    getBikeInitRequest() {
+        throw new Error("Method not implemented.");
+    }
+    sendBikeUpdate(_request) {
+        throw new Error("Method not implemented.");
+    }
+    updateData(_data) {
+        throw new Error("Method not implemented.");
+    }
+    setSettings(_settings) {
+        throw new Error("Method not implemented.");
+    }
+    setSetting(_name, _value) {
+        throw new Error("Method not implemented.");
+    }
+    getSetting(_name) {
+        throw new Error("Method not implemented.");
+    }
+    getSettings() {
+        throw new Error("Method not implemented.");
+    }
+    setModeProperty(_name, _value) {
+        throw new Error("Method not implemented.");
+    }
+    getModeProperty(_name) {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.CyclingMode = CyclingMode;

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

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

package/lib/serial/adapter.d.ts

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

package/lib/serial/adapter.js

@@ -8,11 +8,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 = require("../base/adpater");
+const adpater_1 = __importDefault(require("../base/adpater"));
 const DEFAULT_PULL_FREQUENCY = 1000;
-class SerialIncyclistDevice extends adpater_1.ControllableDevice {
+class SerialIncyclistDevice extends adpater_1.default {
     check() {
         return __awaiter(this, void 0, void 0, function* () { throw new Error('not implemnted'); });
     }

package/lib/serial/daum/DaumAdapter.d.ts

@@ -1,54 +1,57 @@
-import { EventLogger } from 'gd-eventlog';
-import CyclingMode, { IncyclistBikeData } from '../../modes/cycling-mode';
-import { Bike } from '../../types/adapter';
+import ICyclingMode, { CyclingMode, IncyclistBikeData } from '../../modes/types';
 import { DeviceProperties } from '../../types/device';
 import { SerialDeviceSettings, SerialIncyclistDevice } from '../adapter';
 import { DeviceData } from '../../types/data';
+import SerialInterface from '../serial-interface';
+import DaumSerialComms from './types';
+import { ControllableDevice } from '../../base/adpater';
+import { IncyclistDeviceAdapter } from '../../types/adapter';
 export interface IDaumAdapter {
     getCurrentBikeData(): Promise<IncyclistBikeData>;
 }
-export declare abstract class AbstractDaumAdapter extends SerialIncyclistDevice implements IDaumAdapter {
-    abstract getCurrentBikeData(): Promise<any>;
+export declare class DaumControl<P extends DeviceProperties> extends ControllableDevice<P> {
+    getSupportedCyclingModes(): Array<typeof CyclingMode>;
+    getDefaultCyclingMode(): ICyclingMode;
+    sendInitCommands(): Promise<boolean>;
 }
-export default class DaumAdapter<S extends SerialDeviceSettings, P extends DeviceProperties> extends AbstractDaumAdapter implements Bike {
-    bike: any;
-    ignoreHrm: boolean;
-    ignoreBike: boolean;
-    ignorePower: boolean;
+export default class DaumAdapter<DC extends DaumControl<P>, S extends SerialDeviceSettings, P extends DeviceProperties, C extends DaumSerialComms> extends SerialIncyclistDevice<DC, P> implements IDaumAdapter {
+    bike: C;
     distanceInternal: number;
-    paused: boolean;
-    stopped: boolean;
     cyclingData: IncyclistBikeData;
     deviceData: DeviceData;
-    currentRequest: any;
     requests: Array<any>;
     iv: any;
-    logger: EventLogger;
     tsPrevData: number;
     adapterTime: number;
     requestBusy: boolean;
     updateBusy: boolean;
+    startPromise: Promise<boolean>;
+    checkPromise: Promise<boolean>;
     constructor(settings: S, props?: P);
-    setCyclingMode(mode: CyclingMode | string, settings?: any): void;
+    getPort(): string;
+    getSerialInterface(): SerialInterface;
     sendInitCommands(): Promise<boolean>;
-    getSupportedCyclingModes(): Array<any>;
-    getCyclingMode(): CyclingMode;
-    getDefaultCyclingMode(): CyclingMode;
     getCurrentBikeData(): Promise<IncyclistBikeData>;
-    getBike(): any;
+    getBike(): C;
     isEqual(settings: SerialDeviceSettings): boolean;
-    isSame(device: SerialIncyclistDevice): boolean;
+    isSame(device: IncyclistDeviceAdapter): boolean;
     isStopped(): boolean;
     initData(): void;
     pause(): Promise<boolean>;
     resume(): Promise<boolean>;
-    start(props?: P): Promise<any>;
-    stopUpdatePull(): void;
+    waitForPrevCheckFinished(): Promise<void>;
+    check(): Promise<boolean>;
+    performCheck(): Promise<boolean>;
+    waitForPrevStartFinished(): Promise<void>;
+    start(props?: P): Promise<boolean>;
+    performStart(props?: P, isRelaunch?: boolean): Promise<boolean>;
     startUpdatePull(): void;
+    stopUpdatePull(): void;
     connect(): Promise<boolean>;
     close(): Promise<boolean>;
-    logEvent(event: any): void;
+    verifyConnection(): Promise<void>;
     reconnect(): Promise<boolean>;
+    logEvent(event: any): void;
     stop(): Promise<boolean>;
     canSendUpdate(): boolean;
     sendUpdate(request: any): Promise<unknown>;
@@ -60,5 +63,5 @@ export default class DaumAdapter<S extends SerialDeviceSettings, P extends Devic
     sendRequest(request: any): Promise<any>;
     refreshRequests(): void;
     processClientRequest(request: any): Promise<unknown>;
-    check(): Promise<boolean>;
+    getDeviceInfo(): Promise<any>;
 }