incyclist-devices 2.0.37 → 2.1.0

package/lib/ble/fm/adapter.js

@@ -1,4 +1,27 @@
 "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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 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) {
@@ -14,17 +37,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const gd_eventlog_1 = require("gd-eventlog");
 const power_meter_1 = __importDefault(require("../../modes/power-meter"));
-const ble_st_mode_1 = __importDefault(require("../../modes/ble-st-mode"));
-const ble_erg_mode_1 = __importDefault(require("../../modes/ble-erg-mode"));
+const antble_smarttrainer_1 = __importDefault(require("../../modes/antble-smarttrainer"));
+const antble_erg_1 = __importDefault(require("../../modes/antble-erg"));
 const comms_1 = __importDefault(require("./comms"));
-const adapter_1 = require("../base/adapter");
+const adapter_1 = __importStar(require("../base/adapter"));
 const consts_1 = require("./consts");
 const utils_1 = require("../../utils/utils");
 const capabilities_1 = require("../../types/capabilities");
-class BleFmAdapter extends adapter_1.BleControllableAdapter {
+class BleFmAdapter extends adapter_1.default {
     constructor(settings, props) {
         super(settings, props);
         this.distanceInternal = 0;
+        this.setControl(new adapter_1.BlePowerControl(this, props));
         this.logger = new gd_eventlog_1.EventLogger('BLE-FM');
         const { id, address, name } = settings;
         const logger = this.logger;
@@ -54,22 +78,22 @@ class BleFmAdapter extends adapter_1.BleControllableAdapter {
         const modes = [power_meter_1.default];
         const features = (_a = this.getComms()) === null || _a === void 0 ? void 0 : _a.features;
         if (!features)
-            return [power_meter_1.default, ble_st_mode_1.default, ble_erg_mode_1.default];
+            return [power_meter_1.default, antble_smarttrainer_1.default, antble_erg_1.default];
         if (features.setPower === undefined || features.setPower)
-            modes.push(ble_erg_mode_1.default);
+            modes.push(antble_erg_1.default);
         if (features.setSlope === undefined || features.setSlope)
-            modes.push(ble_st_mode_1.default);
+            modes.push(antble_smarttrainer_1.default);
         return modes;
     }
     getDefaultCyclingMode() {
         var _a;
         const features = (_a = this.getComms()) === null || _a === void 0 ? void 0 : _a.features;
         if (!features)
-            return new ble_st_mode_1.default(this);
+            return new antble_smarttrainer_1.default(this);
         if (features.setSlope === undefined || features.setSlope)
-            return new ble_st_mode_1.default(this);
+            return new antble_smarttrainer_1.default(this);
         if (features.setPower === undefined || features.setPower)
-            return new ble_erg_mode_1.default(this);
+            return new antble_erg_1.default(this);
         return new power_meter_1.default(this);
     }
     mapData(deviceData) {
@@ -227,6 +251,9 @@ class BleFmAdapter extends adapter_1.BleControllableAdapter {
                 }
             }
             catch (err) {
+                if (err.message === 'not connected') {
+                    this.logEvent({ message: 'send bike update failed', reason: 'not connected' });
+                }
                 this.logEvent({ message: 'error', fn: 'sendUpdate()', request, error: err.message, stack: err.stack });
             }
         });
@@ -235,7 +262,7 @@ class BleFmAdapter extends adapter_1.BleControllableAdapter {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.started && !this.stopped) {
                 try {
-                    if (this.getCyclingMode() instanceof ble_erg_mode_1.default) {
+                    if (this.getCyclingMode() instanceof antble_erg_1.default) {
                         const power = this.data.power;
                         const request = power ? { targetPower: power } : this.getCyclingMode().getBikeInitRequest();
                         yield this.sendUpdate(request, true);

package/lib/ble/hr/adapter.d.ts

@@ -1,12 +1,14 @@
 import BleAdapter from '../base/adapter';
 import { DeviceProperties } from '../../types/device';
-import { BleDeviceSettings } from '../types';
+import { BleDeviceProperties, BleDeviceSettings } from '../types';
 import { HrmData } from './types';
 import { DeviceData } from '../../types/data';
-export default class HrmAdapter extends BleAdapter {
+import { NonControllableDevice } from '../../base/adpater';
+import { IncyclistDeviceAdapter } from '../../types/adapter';
+export default class HrmAdapter extends BleAdapter<NonControllableDevice<BleDeviceProperties>> {
     ignore: boolean;
     constructor(settings: BleDeviceSettings, props?: DeviceProperties);
-    isSame(device: BleAdapter): boolean;
+    isSame(device: IncyclistDeviceAdapter): boolean;
     getProfile(): string;
     getName(): string;
     getDisplayName(): string;

package/lib/ble/peripheral-cache.d.ts

@@ -1,6 +1,7 @@
+import { Controllable } from "../types/adapter";
 import BleAdapter from "./base/adapter";
 import BlePeripheralConnector from "./ble-peripheral";
-import { BleCharacteristic, BlePeripheral } from "./types";
+import { BleCharacteristic, BleDeviceProperties, BlePeripheral } from "./types";
 export interface PeripheralState {
     isLoading: boolean;
     isConfigured: boolean;
@@ -18,7 +19,7 @@ export interface PeripheralCacheItem {
 }
 export default class BlePeripheralCache {
     peripherals: PeripheralCacheItem[];
-    findAdapter(adapter: BleAdapter): PeripheralCacheItem;
+    findAdapter(adapter: BleAdapter<Controllable<BleDeviceProperties>>): PeripheralCacheItem;
     getConnector(peripheral: BlePeripheral): BlePeripheralConnector;
     getPeripheral(query: {
         id?: string;

package/lib/ble/tacx/adapter.d.ts

@@ -1,10 +1,10 @@
 import { BleFmAdapter } from '../fm';
-import BleAdapter from '../base/adapter';
 import { DeviceProperties } from '../../types/device';
 import { BleDeviceSettings, BleStartProperties } from '../types';
+import { IncyclistDeviceAdapter } from '../../types/adapter';
 export default class BleTacxFEAdapter extends BleFmAdapter {
     constructor(settings: BleDeviceSettings, props?: DeviceProperties);
-    isSame(device: BleAdapter): boolean;
+    isSame(device: IncyclistDeviceAdapter): boolean;
     getProfile(): string;
     start(props?: BleStartProperties): Promise<any>;
 }

package/lib/ble/wahoo/adapter.d.ts

@@ -1,9 +1,9 @@
 import { BleFmAdapter } from '../fm';
-import BleAdapter from '../base/adapter';
 import { BleDeviceProperties, BleDeviceSettings, BleStartProperties } from '../types';
+import { IncyclistDeviceAdapter } from '../../types/adapter';
 export default class BleWahooAdapter extends BleFmAdapter {
     constructor(settings: BleDeviceSettings, props?: BleDeviceProperties);
-    isSame(device: BleAdapter): boolean;
+    isSame(device: IncyclistDeviceAdapter): boolean;
     getProfile(): string;
     start(props?: BleStartProperties): Promise<any>;
 }

package/lib/index.d.ts

@@ -2,15 +2,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 { IncyclistDeviceAdapter, 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';
+import { DeviceSettings, DeviceProperties } from './types/device';
+import ICyclingMode from './modes/types';
 import calc from './utils/calculations';
-export * from './modes/cycling-mode';
+export * from './modes/types';
 export * from './serial';
 export * from './ble';
 export * from './antv2';
-export { IncyclistInterface, INTERFACE, InterfaceFactory, InterfaceProps, DeviceSettings, CyclingMode, AdapterFactory, IncyclistDeviceAdapter, Controllable, ControllableDeviceAdapter, DeviceData, IncyclistCapability, calc, };
+export { IncyclistInterface, INTERFACE, InterfaceFactory, InterfaceProps, DeviceSettings, DeviceProperties, ICyclingMode, AdapterFactory, IncyclistDeviceAdapter, Controllable, ControllableDeviceAdapter, DeviceData, IncyclistCapability, calc, };

package/lib/index.js

@@ -17,20 +17,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calc = exports.IncyclistCapability = exports.ControllableDeviceAdapter = exports.AdapterFactory = exports.InterfaceFactory = exports.INTERFACE = void 0;
+exports.calc = exports.IncyclistCapability = exports.ControllableDeviceAdapter = exports.Controllable = 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 adapter_1 = require("./types/adapter");
+Object.defineProperty(exports, "Controllable", { enumerable: true, get: function () { return adapter_1.Controllable; } });
 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; } });
 const calculations_1 = __importDefault(require("./utils/calculations"));
 exports.calc = calculations_1.default;
-__exportStar(require("./modes/cycling-mode"), exports);
+__exportStar(require("./modes/types"), exports);
 __exportStar(require("./serial"), exports);
 __exportStar(require("./ble"), exports);
 __exportStar(require("./antv2"), exports);

package/lib/interfaces.d.ts

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

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

@@ -0,0 +1,12 @@
+import { IncyclistDeviceAdapter } from "..";
+import SmartTrainerCyclingMode from "./antble-smarttrainer";
+import { UpdateRequest } from "./types";
+export default class AntAdvSimCyclingMode extends SmartTrainerCyclingMode {
+    constructor(adapter: IncyclistDeviceAdapter, props?: any);
+    getName(): string;
+    getDescription(): string;
+    checkForResetOrEmpty(request: UpdateRequest): UpdateRequest | undefined;
+    protected checkForTempPowerAdjustments(request: UpdateRequest, newRequest?: UpdateRequest): void;
+    protected checkEmptyRequest(newRequest: UpdateRequest): void;
+    sendBikeUpdate(incoming: UpdateRequest): UpdateRequest;
+}

package/lib/modes/ant-fe-adv-st-mode.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const antble_smarttrainer_1 = __importDefault(require("./antble-smarttrainer"));
+const MAX_DEVIATION = 10;
+class AntAdvSimCyclingMode extends antble_smarttrainer_1.default {
+    constructor(adapter, props) {
+        super(adapter, props);
+        this.initLogger('AdvmartTrainerMode');
+    }
+    getName() {
+        return 'Advanced Smart Trainer';
+    }
+    getDescription() {
+        return 'Sends Slope to device. Respects Limits (from workout or settings). Calculates speed based on power and slope. ';
+    }
+    checkForResetOrEmpty(request) {
+        if (!request || request.reset) {
+            this.prevRequest = {};
+            return { reset: true };
+        }
+        if (request.slope === undefined && request.targetPowerDelta === undefined && request.targetPower === undefined && request.refresh && this.prevRequest) {
+            return this.prevRequest;
+        }
+    }
+    checkForTempPowerAdjustments(request, newRequest = {}) {
+        if (request.targetPowerDelta && this.prevRequest && this.prevRequest.targetPower) {
+            newRequest.targetPower = this.prevRequest.targetPower + request.targetPowerDelta;
+            if (newRequest.targetPower < 10)
+                newRequest.targetPower = this.prevRequest.targetPower;
+            delete request.targetPowerDelta;
+        }
+    }
+    checkEmptyRequest(newRequest) {
+        if (Object.keys(newRequest).length === 0) {
+            if (this.prevRequest) {
+                newRequest.slope = this.prevRequest.slope;
+                newRequest.targetPower = this.prevRequest.targetPower;
+                newRequest.refresh = true;
+            }
+        }
+    }
+    sendBikeUpdate(incoming) {
+        var _a;
+        this.logger.logEvent({ message: "processing update request", request: incoming, prev: this.prevRequest, data: this.getData() });
+        let newRequest = {};
+        const request = Object.assign({}, incoming);
+        try {
+            const req = this.checkForResetOrEmpty(request);
+            if (req)
+                return req;
+            this.checkSlope(request, newRequest);
+            let data = this.getData();
+            if (data.power) {
+                const { minPower, maxPower } = request;
+                let targetPower = request.targetPower;
+                if (minPower !== undefined && maxPower !== undefined && minPower === maxPower)
+                    targetPower = maxPower;
+                if (targetPower !== undefined && Math.abs(data.power - targetPower) > MAX_DEVIATION)
+                    newRequest.targetPower = targetPower;
+                else if (minPower !== undefined && data.power < minPower)
+                    newRequest.targetPower = minPower;
+                else if (request.maxPower !== undefined && data.power > request.maxPower)
+                    newRequest.targetPower = maxPower;
+                else if ((_a = this.prevRequest) === null || _a === void 0 ? void 0 : _a.targetPower) {
+                    newRequest.targetPower = this.prevRequest.targetPower;
+                }
+                if (newRequest.targetPower) {
+                    this.checkForTempPowerAdjustments(request, newRequest);
+                }
+            }
+            this.checkEmptyRequest(newRequest);
+            this.prevRequest = JSON.parse(JSON.stringify(newRequest));
+        }
+        catch (err) {
+            this.logger.logEvent({ message: "error", fn: 'sendBikeUpdate()', error: err.message, stack: err.stack });
+        }
+        return newRequest;
+    }
+}
+exports.default = AntAdvSimCyclingMode;

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

@@ -0,0 +1,31 @@
+import { IncyclistDeviceAdapter } from "..";
+import ICyclingMode, { CyclingModeProperyType, UpdateRequest } from "./types";
+import PowerBasedCyclingModeBase from "./power-base";
+export default class ERGCyclingMode extends PowerBasedCyclingModeBase implements ICyclingMode {
+    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;
+        } | {
+            key: string;
+            name: string;
+            description: string;
+            type: CyclingModeProperyType;
+            default: number;
+            min: number;
+            max: number;
+            options?: undefined;
+        })[];
+    };
+    constructor(adapter: IncyclistDeviceAdapter, props?: any);
+    getBikeInitRequest(): UpdateRequest;
+}

package/lib/modes/antble-erg.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const power_base_1 = __importDefault(require("./power-base"));
+class ERGCyclingMode extends power_base_1.default {
+    constructor(adapter, props) {
+        super(adapter, props);
+        this.initLogger('ERGMode');
+    }
+    getBikeInitRequest() {
+        const startPower = Number(this.getSetting('startPower'));
+        this.prevRequest = { targetPower: startPower };
+        return { targetPower: startPower };
+    }
+}
+ERGCyclingMode.config = {
+    isERG: true,
+    name: "ERG",
+    description: "Calculates speed based on power and slope. Power targets are set by workout or remain stable throughout the workout",
+    properties: [
+        { key: 'bikeType', name: 'Bike Type', description: '', type: types_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain', 'Triathlon'], default: 'Race' },
+        { key: 'startPower', name: 'Starting Power', description: 'Initial power in Watts at start of training', type: types_1.CyclingModeProperyType.Integer, default: 50, min: 25, max: 800 },
+    ]
+};
+exports.default = ERGCyclingMode;

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

@@ -0,0 +1,23 @@
+import ICyclingMode, { CyclingModeProperyType, UpdateRequest } from "./types";
+import PowerBasedCyclingModeBase from "./power-base";
+import { IncyclistDeviceAdapter } from "../types/adapter";
+export default class SmartTrainerCyclingMode extends PowerBasedCyclingModeBase implements ICyclingMode {
+    protected static config: {
+        name: string;
+        description: string;
+        properties: {
+            key: string;
+            name: string;
+            description: string;
+            type: CyclingModeProperyType;
+            options: string[];
+            default: string;
+        }[];
+    };
+    constructor(adapter: IncyclistDeviceAdapter, props?: any);
+    getBikeInitRequest(): UpdateRequest;
+    checkForResetOrEmpty(request: UpdateRequest): UpdateRequest | undefined;
+    protected checkSlope(request: UpdateRequest, newRequest?: UpdateRequest): void;
+    protected checkEmptyRequest(newRequest: UpdateRequest): void;
+    sendBikeUpdate(incoming: UpdateRequest): UpdateRequest;
+}

package/lib/modes/antble-smarttrainer.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const power_base_1 = __importDefault(require("./power-base"));
+class SmartTrainerCyclingMode extends power_base_1.default {
+    constructor(adapter, props) {
+        super(adapter, props);
+        this.initLogger('SmartTrainerMode');
+    }
+    getBikeInitRequest() {
+        this.prevRequest = { slope: 0 };
+        return { slope: 0 };
+    }
+    checkForResetOrEmpty(request) {
+        if (!request || request.reset) {
+            this.prevRequest = {};
+            return { reset: true };
+        }
+        if (request.slope === undefined && request.refresh && this.prevRequest) {
+            return this.prevRequest;
+        }
+    }
+    checkSlope(request, newRequest = {}) {
+        if (request.slope !== undefined) {
+            newRequest.slope = parseFloat(request.slope.toFixed(1));
+            this.data.slope = newRequest.slope;
+        }
+    }
+    checkEmptyRequest(newRequest) {
+        if (Object.keys(newRequest).length === 0) {
+            if (this.prevRequest) {
+                newRequest.slope = this.prevRequest.slope;
+                newRequest.refresh = true;
+            }
+        }
+    }
+    sendBikeUpdate(incoming) {
+        this.logger.logEvent({ message: "processing update request", request: incoming, prev: this.prevRequest, data: this.getData() });
+        let newRequest = {};
+        const request = Object.assign({}, incoming);
+        try {
+            const req = this.checkForResetOrEmpty(request);
+            if (req)
+                return req;
+            this.checkSlope(request, newRequest);
+            this.checkEmptyRequest(newRequest);
+            this.prevRequest = JSON.parse(JSON.stringify(newRequest));
+        }
+        catch (err) {
+            this.logger.logEvent({ message: "error", fn: 'sendBikeUpdate()', error: err.message, stack: err.stack });
+        }
+        return newRequest;
+    }
+}
+SmartTrainerCyclingMode.config = {
+    name: "Smart Trainer",
+    description: "Calculates speed based on power and slope. Slope is set to the device",
+    properties: [
+        { key: 'bikeType', name: 'Bike Type', description: '', type: types_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain', 'Triathlon'], default: 'Race' }
+    ]
+};
+exports.default = SmartTrainerCyclingMode;

package/lib/modes/base.d.ts

@@ -0,0 +1,29 @@
+import { IncyclistDeviceAdapter } from "../types/adapter";
+import ICyclingMode, { CyclingMode, CyclingModeConfig, CyclingModeProperty, IncyclistBikeData, Settings, UpdateRequest } from "./types";
+export declare abstract class CyclingModeBase extends CyclingMode implements ICyclingMode {
+    adapter: IncyclistDeviceAdapter;
+    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;
+    setConfig(config: CyclingModeConfig): void;
+    getConfig(): CyclingModeConfig;
+    getName(): string;
+    getDescription(): string;
+    getProperties(): CyclingModeProperty[];
+    getProperty(name: string): CyclingModeProperty;
+    setSettings(settings?: any): void;
+    setSetting(name: string, value: any): void;
+    getSetting(name: string): any;
+    getSettingDefault(name: string): any;
+    getSettings(): Settings;
+    setModeProperty(name: string, value: any): void;
+    getModeProperty(name: string): any;
+    abstract getBikeInitRequest(): UpdateRequest;
+    abstract sendBikeUpdate(request: UpdateRequest): UpdateRequest;
+    abstract updateData(data: IncyclistBikeData): IncyclistBikeData;
+}

package/lib/modes/{cycling-mode.js → base.js}

@@ -1,47 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CyclingModeBase = 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 CyclingModeBase {
+exports.CyclingModeBase = void 0;
+const types_1 = require("./types");
+class CyclingModeBase extends types_1.CyclingMode {
+    static supportsERGMode() {
+        return this.config.isERG === true;
+    }
     constructor(adapter, props) {
+        super(adapter, props);
         this.settings = {};
         this.properties = {};
-        if (!adapter)
-            throw new Error('IllegalArgument: adapter is null');
         this.setAdapter(adapter);
         this.setSettings(props);
     }
     setAdapter(adapter) {
         this.adapter = adapter;
     }
-    getBikeInitRequest() {
-        return {};
+    setConfig(config) {
+        this.localConfig = config;
+    }
+    getConfig() {
+        if (this.localConfig)
+            return this.localConfig;
+        let cm = this.constructor;
+        return cm.config;
     }
     getName() {
-        throw new Error("Method not implemented.");
+        return this.getConfig().name;
     }
     getDescription() {
-        throw new Error("Method not implemented.");
-    }
-    sendBikeUpdate(request) {
-        throw new Error("Method not implemented.");
-    }
-    updateData(data) {
-        throw new Error("Method not implemented.");
+        return this.getConfig().description;
     }
     getProperties() {
-        throw new Error("Method not implemented.");
+        return this.getConfig().properties;
     }
     getProperty(name) {
-        throw new Error("Method not implemented.");
+        return this.getConfig().properties.find(p => p.name === name);
     }
     setSettings(settings) {
         if (settings) {
@@ -55,10 +49,12 @@ class CyclingModeBase {
         const res = this.settings[name];
         if (res !== undefined)
             return res;
+        return this.getSettingDefault(name);
+    }
+    getSettingDefault(name) {
         const prop = this.getProperties().find(p => p.key === name);
         if (prop && prop.default !== undefined)
             return prop.default;
-        return undefined;
     }
     getSettings() {
         return this.settings;
@@ -77,3 +73,4 @@ class CyclingModeBase {
     }
 }
 exports.CyclingModeBase = CyclingModeBase;
+CyclingModeBase.config = { name: '', description: '', properties: [] };

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

@@ -0,0 +1,16 @@
+import ICyclingMode, { IncyclistBikeData, Settings, UpdateRequest } from "./types";
+import { IncyclistDeviceAdapter } from "../types/adapter";
+import SmartTrainerCyclingMode from "./antble-smarttrainer";
+type DaumClassicEvent = {
+    noData?: boolean;
+    slopeUpdate?: boolean;
+    initialCall?: boolean;
+};
+export default class DaumClassicCyclingMode extends SmartTrainerCyclingMode implements ICyclingMode {
+    event: DaumClassicEvent;
+    constructor(adapter: IncyclistDeviceAdapter, props?: Settings);
+    getBikeInitRequest(): UpdateRequest;
+    checkForResetOrEmpty(request: UpdateRequest): UpdateRequest | undefined;
+    protected updateSpeedAndDistance(_power: number, _slope: any, _bikeType: any, data: IncyclistBikeData, prevData: any): number;
+}
+export {};

package/lib/modes/daum-classic-standard.js

@@ -0,0 +1,54 @@
+"use strict";
+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 types_1 = require("./types");
+const antble_smarttrainer_1 = __importDefault(require("./antble-smarttrainer"));
+const config = {
+    name: "Daum Classic",
+    description: "The device calculates speed and power based on slope. Incyclist will not modify any values recived from the device\nThis mode will not respect maximum power and/or workout limits",
+    properties: [
+        { key: 'bikeType', name: 'Bike Type', description: '', type: types_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain'], default: 'Race' },
+    ]
+};
+class DaumClassicCyclingMode extends antble_smarttrainer_1.default {
+    constructor(adapter, props) {
+        super(adapter, props);
+        this.logger = adapter ? adapter.getLogger() : undefined;
+        if (!this.logger)
+            this.logger = new gd_eventlog_1.EventLogger('DaumClassic');
+        this.setConfig(config);
+        this.event = { noData: true, initialCall: true, slopeUpdate: false };
+    }
+    getBikeInitRequest() {
+        return { slope: 0 };
+    }
+    checkForResetOrEmpty(request) {
+        if (!request || request.reset) {
+            this.prevRequest = {};
+            return {};
+        }
+        if (Object.keys(request).length === 0 && this.prevRequest) {
+            return { slope: this.prevRequest.slope, refresh: true };
+        }
+        if (request.slope === undefined && request.refresh && this.prevRequest) {
+            return this.prevRequest;
+        }
+    }
+    updateSpeedAndDistance(_power, _slope, _bikeType, data, prevData) {
+        const distanceInternal = prevData.distanceInternal || 0;
+        const t = this.getTimeSinceLastUpdate();
+        if (data.pedalRpm === 0 || data.isPedalling === false) {
+            data.speed = 0;
+            data.power = 0;
+        }
+        else {
+            let v = data.speed / 3.6;
+            data.distanceInternal = distanceInternal + v * t;
+        }
+        return t;
+    }
+}
+exports.default = DaumClassicCyclingMode;