incyclist-devices 1.4.102 → 1.5.0

package/lib/daum/classic/DaumClassicAdapter.d.ts

@@ -1,18 +1,18 @@
-import CyclingMode from '../../CyclingMode';
-import DaumAdapter from '../DaumAdapter';
-export default class DaumClassicAdapter extends DaumAdapter {
-    static NAME: string;
-    name: string;
-    id: string;
-    constructor(protocol: any, bike: any);
-    setID(id: any): void;
-    getID(): string;
-    getName(): string;
-    setName(name: any): void;
-    getPort(): any;
-    getSupportedCyclingModes(): Array<any>;
-    getDefaultCyclingMode(): CyclingMode;
-    check(): Promise<unknown>;
-    start(props: any): Promise<unknown>;
-    getCurrentBikeData(): any;
-}
+import CyclingMode from '../../cycling-mode';
+import DaumAdapter from '../DaumAdapter';
+export default class DaumClassicAdapter extends DaumAdapter {
+    static NAME: string;
+    name: string;
+    id: string;
+    constructor(protocol: any, bike: any);
+    setID(id: any): void;
+    getID(): string;
+    getName(): string;
+    setName(name: any): void;
+    getPort(): any;
+    getSupportedCyclingModes(): Array<any>;
+    getDefaultCyclingMode(): CyclingMode;
+    check(): Promise<unknown>;
+    start(props: any): Promise<unknown>;
+    getCurrentBikeData(): any;
+}

package/lib/daum/classic/DaumClassicAdapter.js

@@ -1,146 +1,146 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const gd_eventlog_1 = require("gd-eventlog");
-const utils_1 = require("../../utils");
-const DaumAdapter_1 = __importDefault(require("../DaumAdapter"));
-const DaumClassicCyclingMode_1 = __importDefault(require("./DaumClassicCyclingMode"));
-const PROTOCOL_NAME = "Daum Classic";
-class DaumClassicAdapter extends DaumAdapter_1.default {
-    constructor(protocol, bike) {
-        super(protocol, bike);
-        this.logger = new gd_eventlog_1.EventLogger('DaumClassic');
-        this.name = PROTOCOL_NAME;
-        this.ignoreHrm = false;
-        this.ignorePower = false;
-        this.ignoreBike = false;
-        this.paused = undefined;
-        this.iv = undefined;
-        this.distanceInternal = undefined;
-        this.initData();
-    }
-    setID(id) {
-        this.id = id;
-    }
-    getID() {
-        return this.id;
-    }
-    getName() {
-        return this.name;
-    }
-    setName(name) {
-        this.name = name || PROTOCOL_NAME;
-    }
-    getPort() {
-        return this.bike.getPort();
-    }
-    getSupportedCyclingModes() {
-        const supported = super.getSupportedCyclingModes();
-        supported.push(DaumClassicCyclingMode_1.default);
-        return supported;
-    }
-    getDefaultCyclingMode() {
-        return new DaumClassicCyclingMode_1.default(this);
-    }
-    check() {
-        var info = {};
-        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: "check()", port: this.getPort() });
-            const iv = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                reject(new Error(`timeout`));
-            }), 5000);
-            try {
-                if (!this.bike.isConnected())
-                    yield this.bike.saveConnect();
-                const address = yield this.bike.getAddress();
-                info.bikeNo = address.bike;
-                const version = yield this.bike.getVersion();
-                info.serialNo = version.serialNo;
-                info.cockpit = version.cockpit;
-                this.setName('Daum ' + info.cockpit);
-                this.setID(info.serialNo);
-                clearTimeout(iv);
-                resolve(info);
-            }
-            catch (err) {
-                clearTimeout(iv);
-                reject(err);
-            }
-        }));
-    }
-    start(props) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'start()', props });
-            const opts = props || {};
-            const { user, bikeSettings } = opts;
-            if (user && user.weight)
-                this.userSettings.weight = user.weight;
-            if (bikeSettings && bikeSettings.weight)
-                this.bikeSettings.weight = bikeSettings.weight;
-            this.initData();
-            let startState = {};
-            return (0, utils_1.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () {
-                try {
-                    if (!this.bike.isConnected())
-                        yield this.bike.saveConnect();
-                    yield this.getBike().resetDevice();
-                    if (!startState.setProg) {
-                        yield this.getBike().setProg(0);
-                        startState.setProg = true;
-                    }
-                    if (!startState.setPerson) {
-                        yield this.getBike().setPerson(user);
-                        startState.setPerson = true;
-                    }
-                    if (!startState.setBikeType) {
-                        const bikeType = this.getCyclingMode().getSetting('bikeType') || 'race';
-                        yield this.getBike().setBikeType(bikeType.toLowerCase());
-                        startState.setBikeType = true;
-                    }
-                    if (!startState.startProg) {
-                        yield this.getBike().startProg();
-                        startState.startProg = true;
-                    }
-                    if (!startState.setGear) {
-                        yield this.bike.setGear(this.cyclingData.gear || (opts.gear || 10));
-                        startState.setGear = true;
-                    }
-                    const startRequest = this.getCyclingMode().getBikeInitRequest();
-                    yield this.sendRequest(startRequest);
-                    startState.checkRunData = true;
-                    const data = yield this.bike.runData();
-                    if (startRequest.targetPower && startRequest.targetPower !== 25 && data.power === 25) {
-                        throw new Error('invalid device response: runData');
-                    }
-                    return data;
-                }
-                catch (err) {
-                    if (startState.checkRunData) {
-                        startState = {};
-                    }
-                    throw (new Error(`could not start device, reason:${err.message}`));
-                }
-            }), 5, 1000)
-                .then(data => {
-                this.startUpdatePull();
-                return data;
-            });
-        });
-    }
-    getCurrentBikeData() {
-        return this.getBike().runData();
-    }
-}
-exports.default = DaumClassicAdapter;
-DaumClassicAdapter.NAME = PROTOCOL_NAME;
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const gd_eventlog_1 = require("gd-eventlog");
+const utils_1 = require("../../utils");
+const DaumAdapter_1 = __importDefault(require("../DaumAdapter"));
+const DaumClassicCyclingMode_1 = __importDefault(require("./DaumClassicCyclingMode"));
+const PROTOCOL_NAME = "Daum Classic";
+class DaumClassicAdapter extends DaumAdapter_1.default {
+    constructor(protocol, bike) {
+        super(protocol, bike);
+        this.logger = new gd_eventlog_1.EventLogger('DaumClassic');
+        this.name = PROTOCOL_NAME;
+        this.ignoreHrm = false;
+        this.ignorePower = false;
+        this.ignoreBike = false;
+        this.paused = undefined;
+        this.iv = undefined;
+        this.distanceInternal = undefined;
+        this.initData();
+    }
+    setID(id) {
+        this.id = id;
+    }
+    getID() {
+        return this.id;
+    }
+    getName() {
+        return this.name;
+    }
+    setName(name) {
+        this.name = name || PROTOCOL_NAME;
+    }
+    getPort() {
+        return this.bike.getPort();
+    }
+    getSupportedCyclingModes() {
+        const supported = super.getSupportedCyclingModes();
+        supported.push(DaumClassicCyclingMode_1.default);
+        return supported;
+    }
+    getDefaultCyclingMode() {
+        return new DaumClassicCyclingMode_1.default(this);
+    }
+    check() {
+        var info = {};
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: "check()", port: this.getPort() });
+            const iv = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                reject(new Error(`timeout`));
+            }), 5000);
+            try {
+                if (!this.bike.isConnected())
+                    yield this.bike.saveConnect();
+                const address = yield this.bike.getAddress();
+                info.bikeNo = address.bike;
+                const version = yield this.bike.getVersion();
+                info.serialNo = version.serialNo;
+                info.cockpit = version.cockpit;
+                this.setName('Daum ' + info.cockpit);
+                this.setID(info.serialNo);
+                clearTimeout(iv);
+                resolve(info);
+            }
+            catch (err) {
+                clearTimeout(iv);
+                reject(err);
+            }
+        }));
+    }
+    start(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'start()', props });
+            const opts = props || {};
+            const { user, bikeSettings } = opts;
+            if (user && user.weight)
+                this.userSettings.weight = user.weight;
+            if (bikeSettings && bikeSettings.weight)
+                this.bikeSettings.weight = bikeSettings.weight;
+            this.initData();
+            let startState = {};
+            return (0, utils_1.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    if (!this.bike.isConnected())
+                        yield this.bike.saveConnect();
+                    yield this.getBike().resetDevice();
+                    if (!startState.setProg) {
+                        yield this.getBike().setProg(0);
+                        startState.setProg = true;
+                    }
+                    if (!startState.setPerson) {
+                        yield this.getBike().setPerson(user);
+                        startState.setPerson = true;
+                    }
+                    if (!startState.setBikeType) {
+                        const bikeType = this.getCyclingMode().getSetting('bikeType') || 'race';
+                        yield this.getBike().setBikeType(bikeType.toLowerCase());
+                        startState.setBikeType = true;
+                    }
+                    if (!startState.startProg) {
+                        yield this.getBike().startProg();
+                        startState.startProg = true;
+                    }
+                    if (!startState.setGear) {
+                        yield this.bike.setGear(this.cyclingData.gear || (opts.gear || 10));
+                        startState.setGear = true;
+                    }
+                    const startRequest = this.getCyclingMode().getBikeInitRequest();
+                    yield this.sendRequest(startRequest);
+                    startState.checkRunData = true;
+                    const data = yield this.bike.runData();
+                    if (startRequest.targetPower && startRequest.targetPower !== 25 && data.power === 25) {
+                        throw new Error('invalid device response: runData');
+                    }
+                    return data;
+                }
+                catch (err) {
+                    if (startState.checkRunData) {
+                        startState = {};
+                    }
+                    throw (new Error(`could not start device, reason:${err.message}`));
+                }
+            }), 5, 1000)
+                .then(data => {
+                this.startUpdatePull();
+                return data;
+            });
+        });
+    }
+    getCurrentBikeData() {
+        return this.getBike().runData();
+    }
+}
+exports.default = DaumClassicAdapter;
+DaumClassicAdapter.NAME = PROTOCOL_NAME;

package/lib/daum/classic/DaumClassicCyclingMode.d.ts

@@ -1,13 +1,13 @@
-import CyclingMode, { CyclingModeProperty, IncyclistBikeData, Settings, UpdateRequest } from "../../CyclingMode";
-import SmartTrainerCyclingMode from "../SmartTrainerCyclingMode";
-import DaumAdapter from "../DaumAdapter";
-export default class DaumClassicCyclingMode extends SmartTrainerCyclingMode implements CyclingMode {
-    constructor(adapter: DaumAdapter, props?: Settings);
-    getName(): string;
-    getDescription(): string;
-    getProperties(): CyclingModeProperty[];
-    getProperty(name: string): CyclingModeProperty;
-    getBikeInitRequest(): UpdateRequest;
-    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
-    updateData(data: IncyclistBikeData): IncyclistBikeData;
-}
+import CyclingMode, { CyclingModeProperty, IncyclistBikeData, Settings, UpdateRequest } from "../../cycling-mode";
+import SmartTrainerCyclingMode from "../SmartTrainerCyclingMode";
+import DaumAdapter from "../DaumAdapter";
+export default class DaumClassicCyclingMode extends SmartTrainerCyclingMode implements CyclingMode {
+    constructor(adapter: DaumAdapter, props?: Settings);
+    getName(): string;
+    getDescription(): string;
+    getProperties(): CyclingModeProperty[];
+    getProperty(name: string): CyclingModeProperty;
+    getBikeInitRequest(): UpdateRequest;
+    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
+    updateData(data: IncyclistBikeData): IncyclistBikeData;
+}

package/lib/daum/classic/DaumClassicCyclingMode.js

@@ -1,97 +1,97 @@
-"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 CyclingMode_1 = require("../../CyclingMode");
-const SmartTrainerCyclingMode_1 = __importDefault(require("../SmartTrainerCyclingMode"));
-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: CyclingMode_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain'], default: 'Race' },
-    ]
-};
-class DaumClassicCyclingMode extends SmartTrainerCyclingMode_1.default {
-    constructor(adapter, props) {
-        super(adapter, props);
-        this.logger = adapter ? adapter.logger : undefined;
-        if (!this.logger)
-            this.logger = new gd_eventlog_1.EventLogger('DaumClassic');
-    }
-    getName() {
-        return config.name;
-    }
-    getDescription() {
-        return config.description;
-    }
-    getProperties() {
-        return config.properties;
-    }
-    getProperty(name) {
-        return config.properties.find(p => p.name === name);
-    }
-    getBikeInitRequest() {
-        return { slope: 0 };
-    }
-    sendBikeUpdate(request) {
-        const getData = () => {
-            if (!this.data)
-                return {};
-            const { gear, pedalRpm, slope, power, speed } = this.data;
-            return { gear, pedalRpm, slope, power, speed };
-        };
-        const event = Object.assign({}, this.event);
-        if (this.data === undefined)
-            event.noData = true;
-        if (request.slope !== undefined && (event.noData || Math.abs(request.slope - this.data.slope) >= 0.1))
-            event.slopeUpdate = true;
-        if (this.prevRequest === undefined)
-            event.initialCall = true;
-        this.logger.logEvent({ message: "processing update request", request, prev: this.prevRequest, data: getData(), event });
-        let newRequest = {};
-        if (request.slope === undefined && request.refresh && this.prevRequest) {
-            return this.prevRequest;
-        }
-        if (request.slope !== undefined) {
-            newRequest.slope = parseFloat(request.slope.toFixed(1));
-            this.data.slope = newRequest.slope;
-        }
-        this.prevRequest = JSON.parse(JSON.stringify(newRequest));
-        return newRequest;
-    }
-    updateData(data) {
-        try {
-            const prevData = this.data || {};
-            const prevRequest = this.prevRequest || {};
-            const bikeData = JSON.parse(JSON.stringify(data));
-            let power = bikeData.power || 0;
-            let slope = (prevData.slope !== undefined ? prevData.slope : prevRequest.slope || 0);
-            let speed = bikeData.speed || 0;
-            let distanceInternal = prevData.distanceInternal || 0;
-            let ts = Date.now();
-            if (bikeData.pedalRpm === 0 || bikeData.isPedalling === false) {
-                speed = 0;
-                power = 0;
-            }
-            else {
-                const duration = this.prevUpdateTS === 0 ? 0 : ((ts - this.prevUpdateTS) / 1000);
-                let v = speed / 3.6;
-                distanceInternal += (v * duration);
-            }
-            data.speed = parseFloat(speed.toFixed(1));
-            data.power = Math.round(power);
-            data.slope = slope;
-            data.distanceInternal = distanceInternal;
-            this.logger.logEvent({ message: "updateData result", data, bikeData, prevRequest: this.prevRequest || {}, prevSpeed: prevData.speed, event: this.event });
-            this.data = JSON.parse(JSON.stringify(data));
-            this.prevUpdateTS = ts;
-        }
-        catch (err) {
-            this.logger.logEvent({ message: 'error', fn: 'updateData()', error: err.message || err });
-        }
-        return data;
-    }
-}
-exports.default = DaumClassicCyclingMode;
+"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 cycling_mode_1 = require("../../cycling-mode");
+const SmartTrainerCyclingMode_1 = __importDefault(require("../SmartTrainerCyclingMode"));
+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: cycling_mode_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain'], default: 'Race' },
+    ]
+};
+class DaumClassicCyclingMode extends SmartTrainerCyclingMode_1.default {
+    constructor(adapter, props) {
+        super(adapter, props);
+        this.logger = adapter ? adapter.logger : undefined;
+        if (!this.logger)
+            this.logger = new gd_eventlog_1.EventLogger('DaumClassic');
+    }
+    getName() {
+        return config.name;
+    }
+    getDescription() {
+        return config.description;
+    }
+    getProperties() {
+        return config.properties;
+    }
+    getProperty(name) {
+        return config.properties.find(p => p.name === name);
+    }
+    getBikeInitRequest() {
+        return { slope: 0 };
+    }
+    sendBikeUpdate(request) {
+        const getData = () => {
+            if (!this.data)
+                return {};
+            const { gear, pedalRpm, slope, power, speed } = this.data;
+            return { gear, pedalRpm, slope, power, speed };
+        };
+        const event = Object.assign({}, this.event);
+        if (this.data === undefined)
+            event.noData = true;
+        if (request.slope !== undefined && (event.noData || Math.abs(request.slope - this.data.slope) >= 0.1))
+            event.slopeUpdate = true;
+        if (this.prevRequest === undefined)
+            event.initialCall = true;
+        this.logger.logEvent({ message: "processing update request", request, prev: this.prevRequest, data: getData(), event });
+        let newRequest = {};
+        if (request.slope === undefined && request.refresh && this.prevRequest) {
+            return this.prevRequest;
+        }
+        if (request.slope !== undefined) {
+            newRequest.slope = parseFloat(request.slope.toFixed(1));
+            this.data.slope = newRequest.slope;
+        }
+        this.prevRequest = JSON.parse(JSON.stringify(newRequest));
+        return newRequest;
+    }
+    updateData(data) {
+        try {
+            const prevData = this.data || {};
+            const prevRequest = this.prevRequest || {};
+            const bikeData = JSON.parse(JSON.stringify(data));
+            let power = bikeData.power || 0;
+            let slope = (prevData.slope !== undefined ? prevData.slope : prevRequest.slope || 0);
+            let speed = bikeData.speed || 0;
+            let distanceInternal = prevData.distanceInternal || 0;
+            let ts = Date.now();
+            if (bikeData.pedalRpm === 0 || bikeData.isPedalling === false) {
+                speed = 0;
+                power = 0;
+            }
+            else {
+                const duration = this.prevUpdateTS === 0 ? 0 : ((ts - this.prevUpdateTS) / 1000);
+                let v = speed / 3.6;
+                distanceInternal += (v * duration);
+            }
+            data.speed = parseFloat(speed.toFixed(1));
+            data.power = Math.round(power);
+            data.slope = slope;
+            data.distanceInternal = distanceInternal;
+            this.logger.logEvent({ message: "updateData result", data, bikeData, prevRequest: this.prevRequest || {}, prevSpeed: prevData.speed, event: this.event });
+            this.data = JSON.parse(JSON.stringify(data));
+            this.prevUpdateTS = ts;
+        }
+        catch (err) {
+            this.logger.logEvent({ message: 'error', fn: 'updateData()', error: err.message || err });
+        }
+        return data;
+    }
+}
+exports.default = DaumClassicCyclingMode;

package/lib/daum/classic/DaumClassicProtocol.d.ts

@@ -1,27 +1,27 @@
-import DeviceProtocolBase, { ScanProps, DeviceProtocol, DeviceSettings } from '../../DeviceProtocol';
-import Adapter from './DaumClassicAdapter';
-import { EventLogger } from 'gd-eventlog';
-export interface DaumClassicProtocolState {
-    activeScans: Array<any>;
-    scanning: boolean;
-    stopScanning?: boolean;
-}
-export interface DaumClassicScanProps extends ScanProps {
-    port: string;
-}
-export default class DaumClassicProtocol extends DeviceProtocolBase implements DeviceProtocol {
-    logger: EventLogger;
-    state: DaumClassicProtocolState;
-    constructor();
-    add(settings: DeviceSettings): Adapter;
-    getName(): string;
-    getInterfaces(): Array<string>;
-    isBike(): boolean;
-    isHrm(): boolean;
-    isPower(): boolean;
-    scan(props: DaumClassicScanProps): void;
-    addDevice(opts: any, portName: any): any;
-    stopScan(): Promise<boolean>;
-    isScanning(): boolean;
-    scanCommand(device: any, opts: any): any;
-}
+import DeviceProtocolBase, { ScanProps, DeviceProtocol, DeviceSettings } from '../../protocol';
+import Adapter from './DaumClassicAdapter';
+import { EventLogger } from 'gd-eventlog';
+export interface DaumClassicProtocolState {
+    activeScans: Array<any>;
+    scanning: boolean;
+    stopScanning?: boolean;
+}
+export interface DaumClassicScanProps extends ScanProps {
+    port: string;
+}
+export default class DaumClassicProtocol extends DeviceProtocolBase implements DeviceProtocol {
+    logger: EventLogger;
+    state: DaumClassicProtocolState;
+    constructor();
+    add(settings: DeviceSettings): Adapter;
+    getName(): string;
+    getInterfaces(): Array<string>;
+    isBike(): boolean;
+    isHrm(): boolean;
+    isPower(): boolean;
+    scan(props: DaumClassicScanProps): void;
+    addDevice(opts: any, portName: any): any;
+    stopScan(): Promise<boolean>;
+    isScanning(): boolean;
+    scanCommand(device: any, opts: any): any;
+}