incyclist-devices 1.3.0 → 1.4.1

package/lib/daum/classic/DaumClassicCyclingMode.js

@@ -0,0 +1,98 @@
+"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 += Math.round(v * duration);
+            }
+            data.speed = parseFloat(speed.toFixed(1));
+            data.power = Math.round(power);
+            data.slope = slope;
+            data.distanceInternal = distanceInternal;
+            data.distance = Math.round(distanceInternal / 100);
+            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,4 +1,5 @@
-import DeviceProtocol, { ScanProps } from '../../DeviceProtocol';
+import DeviceProtocolBase, { ScanProps, DeviceProtocol, DeviceSettings } from '../../DeviceProtocol';
+import Adapter from './DaumClassicAdapter';
 import { EventLogger } from 'gd-eventlog';
 export interface DaumClassicProtocolState {
     activeScans: Array<any>;
@@ -8,12 +9,13 @@ export interface DaumClassicProtocolState {
 export interface DaumClassicScanProps extends ScanProps {
     port: string;
 }
-export default class DaumClassicProtocol extends DeviceProtocol {
+export default class DaumClassicProtocol extends DeviceProtocolBase implements DeviceProtocol {
     logger: EventLogger;
     state: DaumClassicProtocolState;
     constructor();
+    add(settings: DeviceSettings): Adapter;
     getName(): string;
-    getInterfaces(): string[];
+    getInterfaces(): Array<string>;
     isBike(): boolean;
     isHrm(): boolean;
     isPower(): boolean;

package/lib/daum/classic/DaumClassicProtocol.js

@@ -1,4 +1,23 @@
 "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);
+    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) {
@@ -8,12 +27,16 @@ 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 });
-const DeviceProtocol_1 = require("../../DeviceProtocol");
-const DeviceRegistry_1 = require("../../DeviceRegistry");
-const bike_1 = require("./bike");
-const DaumClassicAdapter_1 = require("./DaumClassicAdapter");
+const DeviceProtocol_1 = __importStar(require("../../DeviceProtocol"));
+const DeviceRegistry_1 = __importDefault(require("../../DeviceRegistry"));
+const bike_1 = __importDefault(require("./bike"));
+const DaumClassicAdapter_1 = __importDefault(require("./DaumClassicAdapter"));
 const gd_eventlog_1 = require("gd-eventlog");
+const DaumClassicAdapter_2 = __importDefault(require("./DaumClassicAdapter"));
 const PROTOCOL_NAME = "Daum Classic";
 const DefaultState = {
     activeScans: [],
@@ -27,6 +50,15 @@ class DaumClassicProtocol extends DeviceProtocol_1.default {
         this.logger = new gd_eventlog_1.EventLogger('DaumClassic');
         this.devices = [];
     }
+    add(settings) {
+        this.logger.logEvent({ message: 'adding device', settings });
+        const { port } = settings;
+        bike_1.default.setSerialPort(DeviceProtocol_1.default.getSerialPort());
+        const bike = new bike_1.default({ port });
+        let device = new DaumClassicAdapter_2.default(this, bike);
+        this.devices.push(device);
+        return device;
+    }
     getName() {
         return PROTOCOL_NAME;
     }
@@ -48,7 +80,7 @@ class DaumClassicProtocol extends DeviceProtocol_1.default {
         this.state.scanning = true;
         let device = this.addDevice(props, props.port);
         if (device) {
-            const iv = setInterval(() => { this.scanCommand(device, props); }, 500);
+            const iv = setInterval(() => { this.scanCommand(device, props); }, 1000);
             this.state.activeScans.push({ iv, device, props });
         }
     }
@@ -60,7 +92,8 @@ class DaumClassicProtocol extends DeviceProtocol_1.default {
             this.devices.push(device);
         }
         else {
-            const idx = this.devices.findIndex(d => d.getBike().getPort() === portName);
+            const devices = this.devices;
+            const idx = devices.findIndex(d => d.getBike().getPort() === portName);
             if (idx === -1) {
                 const bike = new bike_1.default(opts);
                 device = new DaumClassicAdapter_1.default(this, bike);
@@ -123,7 +156,7 @@ class DaumClassicProtocol extends DeviceProtocol_1.default {
             return;
         scan.scanning = true;
         return device.check()
-            .then(() => {
+            .then(() => __awaiter(this, void 0, void 0, function* () {
             if (this.state.stopScanning)
                 return;
             const { onDeviceFound, onScanFinished, id } = opts;
@@ -133,10 +166,16 @@ class DaumClassicProtocol extends DeviceProtocol_1.default {
             if (onScanFinished) {
                 onScanFinished(id);
             }
+            try {
+                yield device.getBike().saveClose();
+            }
+            catch (err) {
+                this.logger.logEvent({ message: 'scanCommand warning: Could not close port', error: err.message });
+            }
             clearInterval(scan.iv);
             scan.iv = undefined;
             scan.scanning = false;
-        })
+        }))
             .catch(() => {
             scan.scanning = false;
         });

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

@@ -0,0 +1,23 @@
+import { EventLogger } from "gd-eventlog";
+import CyclingMode, { CyclingModeProperty, IncyclistBikeData, Settings, UpdateRequest } from "../../CyclingMode";
+import DaumClassicAdapter from "./DaumClassicAdapter";
+export default class ERGCyclingMode implements CyclingMode {
+    adapter: DaumClassicAdapter;
+    logger: EventLogger;
+    prevData: IncyclistBikeData;
+    prevRequest: UpdateRequest;
+    prevUpdateTS: number;
+    hasBikeUpdate: boolean;
+    settings: Settings;
+    constructor(adapter: DaumClassicAdapter, props?: Settings);
+    setAdapter(adapter: DaumClassicAdapter): void;
+    getName(): string;
+    getDescription(): string;
+    getProperties(): CyclingModeProperty[];
+    getProperty(name: string): CyclingModeProperty;
+    setSetting(name: string, value: any): void;
+    getSetting(name: string): any;
+    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
+    updateData(data: IncyclistBikeData): IncyclistBikeData;
+    caclulateTargetPower(request: any, updateMode?: boolean): any;
+}

package/lib/daum/classic/ERGCyclingMode.js

@@ -0,0 +1,171 @@
+"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 settings = {
+    name: "ERG",
+    description: "Ergometer mode:\n Keeps power constant. Calculates speed based on power and slope",
+    properties: [
+        { name: 'Starting Power', description: 'Starting power in watts', type: CyclingMode_1.CyclingModeProperyType.Integer, default: 50 }
+    ]
+};
+class ERGCyclingMode {
+    constructor(adapter, props) {
+        this.prevUpdateTS = 0;
+        this.hasBikeUpdate = false;
+        this.settings = {};
+        this.setAdapter(adapter);
+        this.logger = new gd_eventlog_1.EventLogger('ERGMode');
+    }
+    setAdapter(adapter) {
+        this.adapter = adapter;
+    }
+    getName() {
+        return settings.name;
+    }
+    getDescription() {
+        return settings.description;
+    }
+    getProperties() {
+        return settings.properties;
+    }
+    getProperty(name) {
+        return undefined;
+    }
+    setSetting(name, value) {
+        this.settings[name] = value;
+    }
+    getSetting(name) {
+        const res = this.settings[name];
+        if (res)
+            return res;
+        const prop = this.getProperty(name);
+        if (prop && prop.default)
+            return prop.default;
+        return undefined;
+    }
+    sendBikeUpdate(request) {
+        this.logger.logEvent({ message: "setValues request", request, prev: this.prevRequest });
+        try {
+            if (!request || request.reset || Object.keys(request).length === 0) {
+                this.prevRequest = undefined;
+                return request;
+            }
+            if (request.refresh) {
+                if (this.prevRequest !== undefined && !this.hasBikeUpdate) {
+                    request.slope = this.prevRequest.slope;
+                    request.targetPower = this.prevRequest.targetPower;
+                    request.minPower = this.prevRequest.minPower;
+                    request.maxPower = this.prevRequest.maxPower;
+                    return request;
+                }
+                else {
+                    return this.caclulateTargetPower(request);
+                }
+            }
+            const isSlopeUpdate = request.slope !== undefined && Object.keys(request).length === 1;
+            if (request.targetPower !== undefined) {
+                delete request.slope;
+            }
+            else if (request.maxPower !== undefined && request.minPower !== undefined && request.maxPower === request.minPower) {
+                request.targetPower = request.maxPower;
+                delete request.slope;
+            }
+            else {
+                if (request.slope !== undefined || (this.prevData !== undefined && this.prevData.slope !== undefined)) {
+                    request = this.caclulateTargetPower(request, false);
+                }
+                if (request.maxPower !== undefined) {
+                    if (request.targetPower !== undefined && request.targetPower > request.maxPower) {
+                        request.targetPower = request.maxPower;
+                    }
+                }
+                if (request.minPower !== undefined) {
+                    if (request.targetPower !== undefined && request.targetPower < request.minPower) {
+                        request.targetPower = request.minPower;
+                    }
+                }
+            }
+            if (!isSlopeUpdate)
+                this.prevRequest = JSON.parse(JSON.stringify(request));
+        }
+        catch (err) {
+            this.logger.logEvent({ message: "setValues Exception", error: err.message, stack: err.stack });
+        }
+        this.logger.logEvent({ message: "setValues result", data: request });
+        this.hasBikeUpdate = false;
+        return request;
+    }
+    updateData(data) {
+        this.logger.logEvent({ message: "updateData", data });
+        const getSlope = () => {
+            if (data.slope)
+                return data.slope;
+            if (this.prevData && this.prevData.slope)
+                return this.prevData.slope;
+            if (this.prevRequest && this.prevRequest.slope)
+                return this.prevRequest.slope;
+            return 0;
+        };
+        try {
+            const prevData = this.prevData || {};
+            let rpm = data.pedalRpm || 0;
+            let gear = data.gear || 0;
+            let power = data.power || 0;
+            let slope = getSlope();
+            let speed = data.speed || 0;
+            let m = this.adapter.getWeight();
+            let distanceInternal = prevData.distanceInternal || 0;
+            let distance = Math.round(distanceInternal / 100);
+            let ts = Date.now();
+            let duration = this.prevUpdateTS === 0 ? 0 : ((ts - this.prevUpdateTS) / 1000);
+            if (rpm === 0 || data.isPedalling === false) {
+                speed = 0;
+                power = 0;
+            }
+            else {
+                speed = calculations_1.default.calculateSpeed(m, power, slope);
+                let v = speed / 3.6;
+                distanceInternal += Math.round(v * duration);
+                distance = Math.round(distanceInternal / 100);
+            }
+            data.speed = parseFloat(speed.toFixed(1));
+            data.power = Math.round(power);
+            data.distanceInternal = Math.round(distanceInternal);
+            data.distance = distance;
+            data.slope = slope;
+            data.pedalRpm = rpm;
+            if (this.prevData === undefined || gear !== prevData.gear || rpm !== prevData.pedalRpm) {
+                this.hasBikeUpdate = true;
+            }
+            this.prevData = data;
+            this.prevUpdateTS = ts;
+        }
+        catch (err) {
+            this.logger.logEvent({ message: 'error', fn: 'updateData()', error: err.message || err });
+        }
+        this.logger.logEvent({ message: "updateData result", data });
+        return data;
+    }
+    caclulateTargetPower(request, updateMode = true) {
+        const bikeType = 'race';
+        const defaultPower = this.getSetting('Starting Power') || 50;
+        const m = this.adapter.getWeight();
+        const prevData = this.prevData || {};
+        if (prevData.pedalRpm !== undefined && prevData.gear !== undefined && (!updateMode || prevData.pedalRpm !== 0)) {
+            var speed = calculations_1.default.calculateSpeedDaum(prevData.gear, prevData.pedalRpm, bikeType);
+            var power = calculations_1.default.calculatePower(m, speed / 3.6, 0);
+            request.targetPower = power;
+        }
+        else {
+            request.targetPower = request.targetPower || defaultPower;
+        }
+        delete request.slope;
+        return request;
+    }
+}
+exports.default = ERGCyclingMode;

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

@@ -1,59 +1,63 @@
+import { EventLogger } from 'gd-eventlog';
+import { Queue } from '../../utils';
+declare type SuccessCallbackFn = (data: any) => void;
+declare type ErrorCallbackFn = (status: number, error: any) => void;
+interface CommandInstructions {
+    logStr: string;
+    payload: Array<number>;
+    expected: number;
+    callback: SuccessCallbackFn;
+    callbackErr: ErrorCallbackFn;
+    options?: any;
+}
 export default class Daum8008 {
-    static setSerialPort(spClass: any): void;
-    static getClassName(): string;
-    constructor(opts?: {});
     logger: EventLogger;
-    portName: any;
+    portName: string;
     settings: any;
-    bikeData: {
-        userWeight: number;
-        bikeWeight: number;
-        maxPower: number;
-    };
-    processor: IndoorBikeProcessor;
+    bikeData: any;
     sp: any;
-    error: any;
+    error: Error;
     opening: boolean;
     connected: boolean;
     closing: boolean;
     closed: boolean;
     cmdBusy: boolean;
-    queue: Queue<any>;
+    queue: Queue<CommandInstructions>;
+    bikeCmdWorker: any;
+    cmdStart: number;
+    cmdCurrent: any;
+    constructor(opts?: any);
+    static setSerialPort(spClass: any): void;
+    static getClassName(): string;
     getType(): string;
-    getPort(): any;
+    getPort(): string;
     isConnected(): boolean;
     setUser(user: any, callback: any): void;
-    getUserWeight(): any;
+    getUserWeight(): number;
     getBikeWeight(): any;
     connect(): void;
-    firstOpen: boolean;
-    saveConnect(): Promise<any>;
+    saveConnect(): Promise<unknown>;
     close(): void;
-    bikeCmdWorker: NodeJS.Timeout;
-    saveClose(): Promise<any>;
+    saveClose(): Promise<unknown>;
     onPortOpen(): void;
-    cmdStart: number;
     onPortClose(): void;
     onPortError(err: any): void;
     startWorker(): void;
     sendDaum8008CommandfromQueue(): any;
-    cmdCurrent: any;
-    sendDaum8008Command(logStr: any, payload: any, expected: any, callback: any, callbackErr: any, options: any): void;
+    sendDaum8008Command(logStr: any, payload: any, expected: any, callback?: any, callbackErr?: any, options?: any): void;
     send(cmdInfo: any): void;
-    checkCockpit(bikeNo?: number): Promise<any>;
-    getAddress(): Promise<any>;
-    getVersion(bikeNo?: number): Promise<any>;
-    resetDevice(bikeNo?: number): Promise<any>;
-    startProg(bikeNo?: number): Promise<any>;
-    stopProg(bikeNo?: number): Promise<any>;
-    setProg(progNo?: number, bikeNo?: number): Promise<any>;
-    setBikeType(bikeType: any, bikeNo?: number): Promise<any>;
-    setPerson(user?: {}, bikeNo?: number): Promise<any>;
-    runData(bikeNo?: number): Promise<any>;
-    setGear(gear: any, bikeNo?: number): Promise<any>;
-    setPower(power: any, bikeNo?: number): Promise<any>;
-    setSlope(slope: any, bikeNo?: number): Promise<any>;
+    checkCockpit(bikeNo?: number): Promise<unknown>;
+    getAddress(): Promise<unknown>;
+    getVersion(bikeNo?: number): Promise<unknown>;
+    resetDevice(bikeNo?: number): Promise<unknown>;
+    startProg(bikeNo?: number): Promise<unknown>;
+    stopProg(bikeNo?: number): Promise<unknown>;
+    setProg(progNo?: number, bikeNo?: number): Promise<unknown>;
+    setBikeType(bikeType: any, bikeNo?: number): Promise<unknown>;
+    setPerson(user?: any, bikeNo?: number): Promise<unknown>;
+    runData(bikeNo?: number): Promise<unknown>;
+    setGear(gear: any, bikeNo?: number): Promise<unknown>;
+    setPower(power: any, bikeNo?: number): Promise<unknown>;
+    setSlope(slope: any, bikeNo?: number): Promise<unknown>;
 }
-import { EventLogger } from "gd-eventlog";
-import IndoorBikeProcessor from "../indoorbike.js";
-import { Queue } from "../../utils.js";
+export {};