incyclist-devices 1.4.9 → 1.4.12

package/lib/kettler/ergo-racer/modes/power-meter.js

@@ -0,0 +1,78 @@
+"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 calculations_1 = __importDefault(require("../../../calculations"));
+const 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 CyclingMode_1.CyclingModeBase {
+    constructor(adapter, props) {
+        super(adapter, props);
+        this.prevUpdateTS = 0;
+        this.hasBikeUpdate = false;
+        this.logger = adapter ? adapter.getLogger() : undefined;
+        if (!this.logger)
+            this.logger = new gd_eventlog_1.EventLogger('PowerMeter');
+    }
+    getName() {
+        return config.name;
+    }
+    getDescription() {
+        return config.description;
+    }
+    getProperties() {
+        return config.properties;
+    }
+    getProperty(name) {
+        return config.properties.find(p => p.name === name);
+    }
+    getBikeInitRequest() {
+        return {};
+    }
+    sendBikeUpdate(request) {
+        if (request.slope)
+            this.data.slope = request.slope;
+        this.logger.logEvent({ message: "processing update request", request, prev: this.prevRequest });
+        this.prevRequest = {};
+        return {};
+    }
+    updateData(data) {
+        try {
+            const prevData = this.data || {};
+            const prevRequest = this.prevRequest || {};
+            const bikeData = JSON.parse(JSON.stringify(data));
+            let power = data.power || 0;
+            let speed = data.speed || 0;
+            let slope = (prevData.slope !== undefined ? prevData.slope : prevRequest.slope || 0);
+            let distanceInternal = prevData.distanceInternal || 0;
+            if (!bikeData.pedalRpm || bikeData.isPedalling === false) {
+                speed = 0;
+                power = 0;
+            }
+            let ts = Date.now();
+            const m = this.adapter.getWeight();
+            speed = calculations_1.default.calculateSpeed(m, power, slope);
+            let v = speed / 3.6;
+            let duration = this.prevUpdateTS === 0 ? 0 : ((ts - this.prevUpdateTS) / 1000);
+            distanceInternal += Math.round(v * duration);
+            data.speed = parseFloat(speed.toFixed(1));
+            data.power = Math.round(power);
+            data.distanceInternal = Math.round(distanceInternal);
+            data.slope = slope;
+            this.logger.logEvent({ message: "updateData result", data, bikeData, prevRequest: {}, prevSpeed: prevData.speed });
+            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 = PowerMeterCyclingMode;

package/lib/kettler/ergo-racer/protocol.d.ts

@@ -0,0 +1,41 @@
+/// <reference types="node" />
+import DeviceProtocolBase, { DeviceProtocol, DeviceSettings, ScanProps } from '../../DeviceProtocol';
+import KettlerRacerAdapter from './adapter';
+export interface KettlerRacerScanProps extends ScanProps {
+    port: string;
+}
+declare enum ScanState {
+    IDLE = 0,
+    SCANNING = 1,
+    STOPPING = 2,
+    STOPPED = 3
+}
+export interface ScanDescription {
+    device: KettlerRacerAdapter;
+    port: string;
+    iv: NodeJS.Timeout;
+    state: ScanState;
+    props: KettlerRacerScanProps;
+}
+export declare class KettlerRacerProtocol extends DeviceProtocolBase implements DeviceProtocol {
+    private state;
+    private logger;
+    private activeScans;
+    constructor();
+    getSerialPort(): any;
+    getInterfaces(): string[];
+    getName(): string;
+    isBike(): boolean;
+    isHrm(): boolean;
+    isPower(): boolean;
+    add(settings: DeviceSettings): any;
+    scan(props: KettlerRacerScanProps): void;
+    checkDevice(port: string): boolean;
+    doScan(port: string): Promise<void>;
+    doStopScan(job: ScanDescription): Promise<void>;
+    isJobStopped(job: ScanDescription): boolean;
+    waitForStop(timeout?: number): Promise<boolean>;
+    stopScan(): Promise<boolean>;
+    isScanning(): boolean;
+}
+export {};

package/lib/kettler/ergo-racer/protocol.js

@@ -0,0 +1,191 @@
+"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 __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const DeviceProtocol_1 = __importStar(require("../../DeviceProtocol"));
+const gd_eventlog_1 = require("gd-eventlog");
+const DeviceRegistry_1 = __importDefault(require("../../DeviceRegistry"));
+const adapter_1 = __importDefault(require("./adapter"));
+const PROTOCOL_NAME = 'Kettler Racer';
+var ScanState;
+(function (ScanState) {
+    ScanState[ScanState["IDLE"] = 0] = "IDLE";
+    ScanState[ScanState["SCANNING"] = 1] = "SCANNING";
+    ScanState[ScanState["STOPPING"] = 2] = "STOPPING";
+    ScanState[ScanState["STOPPED"] = 3] = "STOPPED";
+})(ScanState || (ScanState = {}));
+class KettlerRacerProtocol extends DeviceProtocol_1.default {
+    constructor() {
+        super();
+        this.state = ScanState.IDLE;
+        this.logger = new gd_eventlog_1.EventLogger('KettlerRacer');
+        this.activeScans = [];
+        this.devices = [];
+    }
+    getSerialPort() {
+        return DeviceProtocol_1.default.getSerialPort();
+    }
+    getInterfaces() {
+        return [DeviceProtocol_1.INTERFACE.SERIAL];
+    }
+    getName() {
+        return PROTOCOL_NAME;
+    }
+    isBike() {
+        return true;
+    }
+    isHrm() {
+        return true;
+    }
+    isPower() {
+        return true;
+    }
+    add(settings) {
+        this.logger.logEvent({ message: 'adding device', settings });
+        if (this.devices.length > 0) {
+            const found = this.devices.find(d => d.getPort() === settings.port);
+            if (found)
+                return found;
+        }
+        let device = new adapter_1.default(this, settings);
+        this.devices.push(device);
+        return device;
+    }
+    scan(props) {
+        this.logger.logEvent({ message: 'start scan', id: props.id, port: props.port });
+        this.state = ScanState.SCANNING;
+        const isAlreadyKnownOrScanning = this.checkDevice(props.port);
+        if (!isAlreadyKnownOrScanning) {
+            const port = props.port;
+            const name = PROTOCOL_NAME;
+            const device = new adapter_1.default(this, { name, port });
+            const iv = setInterval(() => { this.doScan(port); }, 1000);
+            this.activeScans.push({ iv, device, port, state: ScanState.IDLE, props });
+        }
+    }
+    checkDevice(port) {
+        if (this.devices.length > 0 && this.devices.findIndex(d => d.getPort() === port) >= 0)
+            return true;
+        if (this.activeScans.length > 0 && this.activeScans.findIndex(d => d.port === port) >= 0)
+            return true;
+        return false;
+    }
+    doScan(port) {
+        const job = this.activeScans.find(d => d.port === port);
+        if (!job)
+            return;
+        if (this.state === ScanState.STOPPING || job.state === ScanState.STOPPING)
+            return;
+        const device = job.device;
+        if (device && (device.isDetected() || device.isSelected()))
+            return;
+        this.state = ScanState.SCANNING;
+        job.state = ScanState.SCANNING;
+        return device.check()
+            .then((found) => __awaiter(this, void 0, void 0, function* () {
+            if (found) {
+                if (this.state === ScanState.STOPPING || this.state === ScanState.STOPPED)
+                    return;
+                const { onDeviceFound, onScanFinished, id } = job.props;
+                device.setDetected();
+                if (onDeviceFound)
+                    onDeviceFound(device, device.getProtocol());
+                if (onScanFinished) {
+                    onScanFinished(id);
+                }
+            }
+            job.state = ScanState.STOPPED;
+            try {
+                yield device.waitForClosed();
+            }
+            catch (err) {
+                this.logger.logEvent({ message: 'scanCommand warning: Could not close port', error: err.message });
+            }
+            clearInterval(job.iv);
+            job.iv = null;
+            job.state = ScanState.STOPPED;
+            const idxActiveScan = this.activeScans.findIndex(d => d.state !== ScanState.STOPPED);
+            if (idxActiveScan === -1) {
+                this.state = ScanState.STOPPED;
+            }
+        }))
+            .catch(() => {
+            job.state = ScanState.STOPPED;
+        });
+    }
+    doStopScan(job) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!job)
+                return;
+            if (job.state === ScanState.STOPPING || job.state === ScanState.STOPPED)
+                return;
+            job.state = ScanState.STOPPING;
+            clearInterval(job.iv);
+            job.iv = null;
+        });
+    }
+    isJobStopped(job) {
+        return job.state === ScanState.STOPPED && !job.iv;
+    }
+    waitForStop(timeout) {
+        return new Promise((resolve) => {
+            let timedOut = false;
+            if (timeout)
+                setTimeout(() => { timedOut = true; }, timeout);
+            const iv = setInterval(() => {
+                const idxActiveScan = this.activeScans.findIndex(d => this.isJobStopped(d) === false);
+                if (idxActiveScan === -1) {
+                    clearInterval(iv);
+                    resolve(true);
+                    return;
+                }
+                if (timedOut) {
+                    clearInterval(iv);
+                    resolve(false);
+                    return;
+                }
+            }, 500);
+        });
+    }
+    stopScan() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.state === ScanState.STOPPING || this.state === ScanState.STOPPED)
+                return;
+            this.state = ScanState.STOPPING;
+            this.logger.logEvent({ message: 'stop scan', activeScans: this.activeScans.map(j => j.port) });
+            this.activeScans.forEach(job => this.doStopScan(job));
+            const stopped = yield this.waitForStop();
+            if (!stopped) {
+                this.logger.logEvent({ message: 'scanCommand warning: stop scan timeout' });
+            }
+            else {
+                this.logger.logEvent({ message: 'stop scan completed' });
+            }
+            this.activeScans = [];
+            this.state = ScanState.IDLE;
+            return true;
+        });
+    }
+    isScanning() {
+        return this.state === ScanState.SCANNING;
+    }
+}
+exports.KettlerRacerProtocol = KettlerRacerProtocol;
+DeviceRegistry_1.default.register(new KettlerRacerProtocol());

package/lib/simulator/Simulator.js

@@ -1,28 +1,15 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (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);
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
     return result;
 };
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Simulator = void 0;
 const DeviceProtocol_1 = __importStar(require("../DeviceProtocol"));
 const DeviceRegistry_1 = __importDefault(require("../DeviceRegistry"));
 const Device_1 = __importDefault(require("../Device"));

package/lib/types/command.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+export interface Command {
+    logStr?: string;
+    message: string | Buffer;
+    timeout?: number;
+    onError: (err: Error) => void;
+    onResponse: (response: string | Buffer) => void;
+}

package/lib/types/command.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/route.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RouteType = void 0;
 var RouteType;
 (function (RouteType) {
     RouteType["FREE_RIDE"] = "free ride";

package/lib/types/user.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Gender = void 0;
 var Gender;
 (function (Gender) {
     Gender["MALE"] = "M";

package/lib/utils.js

@@ -9,11 +9,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Queue = exports.hexstr = exports.intVal = exports.floatVal = exports.runWithRetries = exports.sleep = void 0;
-const sleep = (ms) => {
+exports.sleep = (ms) => {
     return new Promise(resolve => setTimeout(resolve, ms));
 };
-exports.sleep = sleep;
 function runWithRetries(fn, maxRetries, timeBetween) {
     return new Promise((resolve, reject) => {
         let retries = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-devices",
-  "version": "1.4.9",
+  "version": "1.4.12",
   "dependencies": {
     "@serialport/parser-byte-length": "^9.0.1",
     "@serialport/parser-delimiter": "^9.0.1",