incyclist-devices 2.0.35 → 2.0.36

package/lib/serial/daum/premium/consts.d.ts

@@ -0,0 +1,6 @@
+export declare const DEFAULT_TIMEOUT = 10000;
+export declare const DEFAULT_ACK_TIMEOUT = 11000;
+export declare const DEFAULT_BUSY_TIMEOUT = 5000;
+export declare const MAX_DATA_BLOCK_SIZE = 512;
+export declare const DS_BITS_OFF = 0;
+export declare const DS_BITS_ENDLESS_RACE = 2;

package/lib/serial/daum/premium/consts.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DS_BITS_ENDLESS_RACE = exports.DS_BITS_OFF = exports.MAX_DATA_BLOCK_SIZE = exports.DEFAULT_BUSY_TIMEOUT = exports.DEFAULT_ACK_TIMEOUT = exports.DEFAULT_TIMEOUT = void 0;
+exports.DEFAULT_TIMEOUT = 10000;
+exports.DEFAULT_ACK_TIMEOUT = 11000;
+exports.DEFAULT_BUSY_TIMEOUT = 5000;
+exports.MAX_DATA_BLOCK_SIZE = 512;
+exports.DS_BITS_OFF = 0;
+exports.DS_BITS_ENDLESS_RACE = 2;

package/lib/serial/daum/premium/mock.d.ts

@@ -28,6 +28,26 @@ export declare class Daum8iMockImpl {
     list(): Promise<import("@serialport/bindings-interface").PortInfo[]>;
     open(options: any): Promise<Daum8iMockBinding>;
 }
+type Program = {
+    lapMode: boolean;
+    id?: number;
+    started?: boolean;
+};
+type trainingData = {
+    time: number;
+    heartrate: number;
+    v: number;
+    slope: number;
+    distanceInternal: number;
+    pedalRpm: number;
+    power: number;
+    physEnergy: number;
+    realEnergy: number;
+    torque: number;
+    gear: number;
+    deviceState: number;
+    speedStatus: number;
+};
 export declare class Daum8MockSimulator {
     protoVersion: string;
     dashboardVersion: string;
@@ -38,16 +58,21 @@ export declare class Daum8MockSimulator {
     currentPower: number;
     loadControl: number;
     person: User;
+    program: Program;
+    data: trainingData;
     _isSimulateACKTimeout: boolean;
     _isSimulateCheckSumError: boolean;
+    _isSimulateReservedError: boolean;
     _timeoutResponse: number;
     timeoutNAKRetry: number;
     simulateACKTimeout(): void;
     simulateTimeout(ms: number): void;
     simulateChecksumError(): void;
+    simulateReservedError(): void;
     onNAK(): void;
     onACK(): void;
 }
+export declare function parseProgramListNewData(buffer: Buffer): Program;
 export declare class Daum8iMockBinding extends MockPortBinding {
     waitingForCommand: boolean;
     waitingForAck: boolean;
@@ -59,7 +84,7 @@ export declare class Daum8iMockBinding extends MockPortBinding {
     initHandlers(): void;
     write(buffer: Buffer): Promise<void>;
     processData(buffer: Buffer): Promise<void>;
-    createResponse(cmd: string, payload: Buffer): Buffer;
+    createResponse(cmd: string, payload: Buffer, binary?: boolean): Buffer;
     emitData(data: string | Buffer): void;
     onGetProtcolVersion(_payload: Buffer): void;
     onGetDashboardVersion(_payload: Buffer): void;
@@ -71,5 +96,11 @@ export declare class Daum8iMockBinding extends MockPortBinding {
     onReservedCommand(payload: Buffer): void;
     onPersonSet(payload: Buffer): void;
     onPersonGet(): void;
+    onProgramListBegin(): void;
+    onProgramListNewProgram(payload: Buffer): void;
+    onProgramListEnd(): void;
+    onProgramListContinueProgram(): void;
+    onProgramListStart(payload: Buffer): void;
     onGetTrainingData(_payload: Buffer): void;
 }
+export {};

package/lib/serial/daum/premium/mock.js

@@ -9,12 +9,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Daum8iMockBinding = exports.Daum8MockSimulator = exports.Daum8iMockImpl = exports.Daum8iMock = void 0;
+exports.Daum8iMockBinding = exports.parseProgramListNewData = exports.Daum8MockSimulator = exports.Daum8iMockImpl = exports.Daum8iMock = void 0;
 const binding_mock_1 = require("@serialport/binding-mock");
 const __1 = require("../../");
 const user_1 = require("../../../types/user");
 const utils_1 = require("../../../utils/utils");
 const utils_2 = require("./utils");
+const consts_1 = require("./consts");
 exports.Daum8iMock = {
     reset() {
         Daum8iMockImpl.getInstance().reset();
@@ -73,6 +74,21 @@ class Daum8iMockImpl {
     }
 }
 exports.Daum8iMockImpl = Daum8iMockImpl;
+const DEFAULT_TRAINING_DATA = {
+    time: 0,
+    heartrate: 0,
+    v: 0,
+    slope: 0,
+    distanceInternal: 0,
+    pedalRpm: 0,
+    power: 0,
+    physEnergy: 0,
+    realEnergy: 0,
+    torque: 0,
+    gear: 10,
+    deviceState: 1,
+    speedStatus: 0
+};
 class Daum8MockSimulator {
     constructor() {
         this.protoVersion = '201';
@@ -84,8 +100,10 @@ class Daum8MockSimulator {
         this.currentPower = 0;
         this.loadControl = 1;
         this.person = { weight: 75, length: 180, age: 30, sex: user_1.Gender.MALE };
+        this.data = DEFAULT_TRAINING_DATA;
         this._isSimulateACKTimeout = false;
         this._isSimulateCheckSumError = false;
+        this._isSimulateReservedError = false;
         this._timeoutResponse = 0;
         this.timeoutNAKRetry = 1000;
     }
@@ -98,10 +116,19 @@ class Daum8MockSimulator {
     simulateChecksumError() {
         this._isSimulateCheckSumError = true;
     }
+    simulateReservedError() {
+        this._isSimulateReservedError = true;
+    }
     onNAK() { }
     onACK() { }
 }
 exports.Daum8MockSimulator = Daum8MockSimulator;
+function parseProgramListNewData(buffer) {
+    const wBits = buffer.readInt16LE(30);
+    const lapMode = wBits === consts_1.DS_BITS_ENDLESS_RACE;
+    return { lapMode };
+}
+exports.parseProgramListNewData = parseProgramListNewData;
 class Daum8iMockBinding extends binding_mock_1.MockPortBinding {
     constructor(parent) {
         super(parent.port, parent.openOptions);
@@ -214,8 +241,14 @@ class Daum8iMockBinding extends binding_mock_1.MockPortBinding {
             }
         });
     }
-    createResponse(cmd, payload) {
-        const buffer = Buffer.from((0, utils_2.buildMessage)(cmd, payload));
+    createResponse(cmd, payload, binary = false) {
+        let buffer;
+        if (binary) {
+            buffer = Buffer.from((0, utils_2.buildMessage)(cmd, (0, utils_2.bin2esc)(payload)));
+        }
+        else {
+            buffer = Buffer.from((0, utils_2.buildMessage)(cmd, payload));
+        }
         this.prevCommand = Buffer.from(buffer);
         if (this.simulator._isSimulateCheckSumError) {
             this.simulator._isSimulateCheckSumError = false;
@@ -267,20 +300,110 @@ class Daum8iMockBinding extends binding_mock_1.MockPortBinding {
     }
     onReservedCommand(payload) {
         const cmd = payload.readInt16LE(0);
-        const length = payload.readUint16LE(2);
-        const data = (0, utils_2.esc2bin)(payload.subarray(4, 4 + length - 1));
+        const data = (0, utils_2.esc2bin)(payload.subarray(4, 4 + payload.length - 1));
         switch (cmd) {
-            case utils_2.ReservedCommands.PERSON_SET: this.onPersonSet(Buffer.from(data));
-            case utils_2.ReservedCommands.PERSON_GET: this.onPersonGet();
+            case utils_2.ReservedCommands.PERSON_SET:
+                this.onPersonSet(Buffer.from(data));
+                break;
+            case utils_2.ReservedCommands.PERSON_GET:
+                this.onPersonGet();
+                break;
+            case utils_2.ReservedCommands.PROGRAM_LIST_BEGIN:
+                this.onProgramListBegin();
+                break;
+            case utils_2.ReservedCommands.PROGRAM_LIST_NEW_PROGRAM:
+                this.onProgramListNewProgram(Buffer.from(data));
+                break;
+            case utils_2.ReservedCommands.PROGRAM_LIST_CONTINUE_PROGRAM:
+                this.onProgramListContinueProgram();
+                break;
+            case utils_2.ReservedCommands.PROGRAM_LIST_END:
+                this.onProgramListEnd();
+                break;
+            case utils_2.ReservedCommands.PROGRAM_LIST_START:
+                this.onProgramListStart(Buffer.from(data));
+                break;
         }
     }
     onPersonSet(payload) {
         this.simulator.person = (0, utils_2.parsePersonData)(payload);
-        this.emitData(this.createResponse('M70', Buffer.from('07000000', 'hex')));
+        if (this.simulator._isSimulateReservedError) {
+            this.emitData(this.createResponse('M70', Buffer.from('08000000', 'hex')));
+            this.simulator._isSimulateReservedError = false;
+        }
+        else
+            this.emitData(this.createResponse('M70', Buffer.from('07000000', 'hex'), true));
     }
     onPersonGet() {
     }
+    onProgramListBegin() {
+        if (this.simulator._isSimulateReservedError) {
+            this.emitData(this.createResponse('M70', Buffer.from('07000000', 'hex'), true));
+            this.simulator._isSimulateReservedError = false;
+        }
+        else
+            this.emitData(this.createResponse('M70', Buffer.from('08000000', 'hex'), true));
+    }
+    onProgramListNewProgram(payload) {
+        this.simulator.program = parseProgramListNewData(payload);
+        if (this.simulator._isSimulateReservedError) {
+            this.emitData(this.createResponse('M70', Buffer.from('08000000', 'hex'), true));
+            this.simulator._isSimulateReservedError = false;
+        }
+        else
+            this.emitData(this.createResponse('M70', Buffer.from('09000000', 'hex'), true));
+    }
+    onProgramListEnd() {
+        if (this.simulator._isSimulateReservedError) {
+            this.emitData(this.createResponse('M70', Buffer.from('08000000', 'hex'), true));
+            this.simulator._isSimulateReservedError = false;
+        }
+        else
+            this.emitData(this.createResponse('M70', Buffer.from('0B00010001', 'hex'), true));
+    }
+    onProgramListContinueProgram() {
+        if (this.simulator._isSimulateReservedError) {
+            this.emitData(this.createResponse('M70', Buffer.from('08000000', 'hex'), true));
+            this.simulator._isSimulateReservedError = false;
+        }
+        else
+            this.emitData(this.createResponse('M70', Buffer.from('0A00010001', 'hex'), true));
+    }
+    onProgramListStart(payload) {
+        if (this.simulator._isSimulateReservedError) {
+            this.emitData(this.createResponse('M70', Buffer.from('08000000', 'hex'), true));
+            this.simulator._isSimulateReservedError = false;
+        }
+        else {
+            try {
+                if (!this.simulator.program)
+                    this.simulator.program = { lapMode: false };
+                this.simulator.program.id = payload.readInt16LE(0);
+                this.simulator.program.started = true;
+            }
+            catch (err) {
+                console.log('~~~ ERROR', payload, err, payload.toString('hex'));
+            }
+            this.emitData(this.createResponse('M70', Buffer.from('0C00000', 'hex'), true));
+        }
+    }
     onGetTrainingData(_payload) {
+        const GS = Buffer.from([0x1D]).toString();
+        const { time, heartrate, v, slope, distanceInternal, pedalRpm, power, physEnergy, realEnergy, torque, gear, deviceState, speedStatus } = this.simulator.data;
+        const res = `${time}` + GS +
+            `${heartrate}` + GS +
+            `${v}` + GS +
+            `${slope}` + GS +
+            `${distanceInternal}` + GS +
+            `${pedalRpm}` + GS +
+            `${power}` + GS +
+            `${physEnergy}` + GS +
+            `${realEnergy}` + GS +
+            `${torque}` + GS +
+            `${gear}` + GS +
+            `${deviceState}` + GS +
+            `${speedStatus}`;
+        this.emitData(this.createResponse('X70', Buffer.from(res)));
     }
 }
 exports.Daum8iMockBinding = Daum8iMockBinding;

package/lib/serial/daum/premium/modes/daum-classic.d.ts

@@ -1,8 +1,8 @@
 import CyclingMode, { CyclingModeProperty, IncyclistBikeData, Settings, UpdateRequest } from "../../../../modes/cycling-mode";
-import DaumAdapter from "../../DaumAdapter";
 import DaumPowerMeterCyclingMode from "../../DaumPowerMeterCyclingMode";
+import { ControllableDeviceAdapter } from "../../../..";
 export default class DaumClassicCyclingMode extends DaumPowerMeterCyclingMode implements CyclingMode {
-    constructor(adapter: DaumAdapter, props?: Settings);
+    constructor(adapter: ControllableDeviceAdapter, props?: Settings);
     getName(): string;
     getDescription(): string;
     getProperties(): CyclingModeProperty[];

package/lib/serial/daum/premium/modes/daum-classic.js

@@ -16,7 +16,7 @@ const config = {
 class DaumClassicCyclingMode extends DaumPowerMeterCyclingMode_1.default {
     constructor(adapter, props) {
         super(adapter, props);
-        this.logger = adapter ? adapter.logger : undefined;
+        this.logger = adapter ? adapter.getLogger() : undefined;
         if (!this.logger)
             this.logger = new gd_eventlog_1.EventLogger('DaumClassic');
         this.setModeProperty('eppSupport', true);

package/lib/serial/daum/premium/types.d.ts

@@ -1,5 +1,21 @@
-import { DeviceProperties } from "../../../types/device";
+import { DaumBikeData, DeviceProperties } from "../../../types/device";
 import { Route } from "../../../types/route";
+import { Queue } from "../../../utils/utils";
+import { Request, Response } from "../../comms";
+export declare class CheckSumError extends Error {
+    constructor();
+}
+export declare class ACKTimeout extends Error {
+    constructor();
+}
+export declare class BusyTimeout extends Error {
+    constructor();
+}
+export declare class ResponseTimeout extends Error {
+    constructor();
+}
+export interface DaumPremiumBikeData extends DaumBikeData {
+}
 export type OnDeviceStartCallback = (completed: number, total: number) => void;
 export type DaumPremiumAdapterProps = {
     path: string;
@@ -10,3 +26,21 @@ export interface Daum8iDeviceProperties extends DeviceProperties {
     gear?: number;
     onStatusUpdate?: OnDeviceStartCallback;
 }
+export interface DaumPremiumRequest extends Request {
+    command: string;
+    payload?: string | Uint8Array;
+}
+export interface ResponseObject extends Response {
+    type: ResponseType;
+    cmd?: string;
+    data?: string;
+    error?: Error;
+}
+export type ResponseType = 'ACK' | 'NAK' | 'Response' | 'Error';
+export type DaumPremiumCommsState = {
+    waitingForStart?: boolean;
+    waitingForACK?: boolean;
+    waitingForEnd?: boolean;
+    partialCmd?: any;
+    data: Queue<ResponseObject>;
+};

package/lib/serial/daum/premium/types.js

@@ -1,2 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseTimeout = exports.BusyTimeout = exports.ACKTimeout = exports.CheckSumError = void 0;
+class CheckSumError extends Error {
+    constructor() {
+        super();
+        this.message = 'checksum incorrect';
+    }
+}
+exports.CheckSumError = CheckSumError;
+class ACKTimeout extends Error {
+    constructor() {
+        super();
+        this.message = 'ACK timeout';
+    }
+}
+exports.ACKTimeout = ACKTimeout;
+class BusyTimeout extends Error {
+    constructor() {
+        super();
+        this.message = 'BUSY timeout';
+    }
+}
+exports.BusyTimeout = BusyTimeout;
+class ResponseTimeout extends Error {
+    constructor() {
+        super();
+        this.message = 'RESP timeout';
+    }
+}
+exports.ResponseTimeout = ResponseTimeout;

package/lib/serial/daum/premium/utils.d.ts

@@ -1,13 +1,20 @@
 /// <reference types="node" />
+import { IncyclistBikeData } from "../../..";
 import { Route } from "../../../types/route";
 import { User } from "../../../types/user";
-export declare function bin2esc(arr: any): any[];
-export declare function esc2bin(arr: any): any[];
+export declare const DEBUG_LOGGER: {
+    log: (e: any, ...args: any[]) => void;
+    logEvent: (event: any) => void;
+};
+export declare const validateHost: (host: string) => string;
+export declare const validatePath: (path: string) => string;
+export declare function bin2esc(arr: Uint8Array): Uint8Array;
+export declare function esc2bin(arr: Uint8Array): Uint8Array;
 export declare function checkSum(cmdArr: any, payload: any): string;
 export declare function buildMessage(command: any, payload?: any): any[];
 export declare function getMessageData(command: any): any[];
 export declare function hexstr(arr: any, start?: any, len?: any): string;
-export declare function ascii(c: any): any;
+export declare function ascii(c: string): number;
 export declare function getAsciiArrayFromStr(str: any): any[];
 export declare enum ReservedCommands {
     RESULT_RESET = 0,
@@ -40,20 +47,6 @@ export declare const FileTimeSupport: {
     fromDate: (date: Date) => any;
 };
 export declare function routeToEpp(route: Route, date?: Date): Uint8Array;
-export declare function parseTrainingData(payload: string): {
-    time: number;
-    heartrate: number;
-    speed: number;
-    slope: number;
-    distanceInternal: number;
-    cadence: number;
-    power: number;
-    physEnergy: number;
-    realEnergy: number;
-    torque: number;
-    gear: number;
-    deviceState: number;
-    speedStatus: string;
-};
+export declare function parseTrainingData(payload: string): IncyclistBikeData;
 export declare function getPersonData(user: User): Buffer;
 export declare function parsePersonData(buffer: Buffer): User;

package/lib/serial/daum/premium/utils.js

@@ -3,14 +3,31 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parsePersonData = exports.getPersonData = exports.parseTrainingData = exports.routeToEpp = exports.FileTimeSupport = exports.getBikeType = exports.BikeType = exports.ReservedCommands = exports.getAsciiArrayFromStr = exports.ascii = exports.hexstr = exports.getMessageData = exports.buildMessage = exports.checkSum = exports.esc2bin = exports.bin2esc = void 0;
+exports.parsePersonData = exports.getPersonData = exports.parseTrainingData = exports.routeToEpp = exports.FileTimeSupport = exports.getBikeType = exports.BikeType = exports.ReservedCommands = exports.getAsciiArrayFromStr = exports.ascii = exports.hexstr = exports.getMessageData = exports.buildMessage = exports.checkSum = exports.esc2bin = exports.bin2esc = exports.validatePath = exports.validateHost = exports.DEBUG_LOGGER = void 0;
 const user_1 = require("../../../types/user");
 const win32filetime_1 = __importDefault(require("win32filetime"));
 const sum = (arr) => arr.reduce((a, b) => a + b, 0);
+exports.DEBUG_LOGGER = {
+    log: (e, ...args) => console.log(e, ...args),
+    logEvent: (event) => console.log(JSON.stringify(event))
+};
+const validateHost = (host) => {
+    const ipParts = host.split('.');
+    if (ipParts.length > 1)
+        return ipParts.map(p => Number(p)).join('.');
+    return host;
+};
+exports.validateHost = validateHost;
+const validatePath = (path) => {
+    const parts = path.split(':');
+    if (parts.length < 2)
+        return path;
+    const host = (0, exports.validateHost)(parts[0]);
+    const port = parts[1];
+    return `${host}:${port}`;
+};
+exports.validatePath = validatePath;
 function bin2esc(arr) {
-    if (arr === undefined) {
-        return;
-    }
     const res = [];
     arr.forEach(v => {
         switch (v) {
@@ -42,13 +59,10 @@ function bin2esc(arr) {
                 res.push(v);
         }
     });
-    return res;
+    return new Uint8Array(res);
 }
 exports.bin2esc = bin2esc;
 function esc2bin(arr) {
-    if (arr === undefined) {
-        return;
-    }
     const res = [];
     let escaped = false;
     arr.forEach((v, idx) => {
@@ -84,7 +98,7 @@ function esc2bin(arr) {
             res.push(v);
         }
     });
-    return res;
+    return new Uint8Array(res);
 }
 exports.esc2bin = esc2bin;
 function checkSum(cmdArr, payload) {
@@ -147,8 +161,6 @@ function hexstr(arr, start, len) {
 }
 exports.hexstr = hexstr;
 function ascii(c) {
-    if (c === undefined || c === null)
-        return;
     return c.charCodeAt(0);
 }
 exports.ascii = ascii;
@@ -258,7 +270,6 @@ function routeToEpp(route, date) {
 exports.routeToEpp = routeToEpp;
 function parseTrainingData(payload) {
     const GS = 0x1D;
-    const speedVals = ['ok', 'too low', 'too high'];
     const gearVal = (v) => v > 0 ? v - 1 : undefined;
     const vals = payload.split(String.fromCharCode(GS));
     const data = {
@@ -267,15 +278,11 @@ function parseTrainingData(payload) {
         speed: parseFloat(vals[2]) * 3.6,
         slope: parseFloat(vals[3]),
         distanceInternal: parseInt(vals[4]),
-        cadence: parseFloat(vals[5]),
+        pedalRpm: parseFloat(vals[5]),
         power: parseInt(vals[6]),
-        physEnergy: parseFloat(vals[7]),
-        realEnergy: parseFloat(vals[8]),
-        torque: parseFloat(vals[9]),
         gear: gearVal(parseInt(vals[10])),
-        deviceState: parseInt(vals[11]),
-        speedStatus: speedVals[parseInt(vals[12])],
     };
+    data.isPedalling = (data.pedalRpm > 0);
     return data;
 }
 exports.parseTrainingData = parseTrainingData;

package/lib/serial/serial-interface.js

@@ -294,8 +294,9 @@ class SerialInterface extends events_1.default {
                     }
                 }
                 catch (err) {
-                    console.log('~~~ERROR', err);
+                    this.logEvent({ message: 'error', fn: 'scan#detect ports', error: err.message, interface: this.ifaceName, port, excludes: this.inUse });
                 }
+                paths = paths.filter(p => !this.inUse.includes(p.path));
                 if (!paths || paths.length === 0) {
                     this.logEvent({ message: 'scanning: no ports detected', interface: this.ifaceName, paths: paths.map(p => p.path), timeout });
                     yield (0, utils_1.sleep)(1000);
@@ -303,7 +304,6 @@ class SerialInterface extends events_1.default {
                 if (Date.now() > toExpiresAt)
                     timeOutExpired = true;
             } while (this.isScanning && !timeOutExpired && paths.length === 0);
-            paths = paths.filter(p => !this.inUse.includes(p.path));
             if (paths.length === 0) {
                 this.logEvent({ message: 'nothing to scan ' });
                 if (this.toScan) {
@@ -352,6 +352,7 @@ class SerialInterface extends events_1.default {
                 clearTimeout(this.toScan);
                 this.toScan = null;
             }
+            this.isScanning = false;
             this.scanEvents.emit('stop');
             return true;
         });

package/lib/types/adapter.d.ts

@@ -5,8 +5,10 @@ import { IncyclistCapability } from "./capabilities";
 import { DeviceData } from "./data";
 import { DeviceProperties, DeviceSettings } from "./device";
 import { User } from "./user";
+import { EventLogger } from "gd-eventlog";
 export type OnDeviceDataCallback = (data: DeviceData) => void;
 export interface IncyclistDeviceAdapter extends EventEmitter {
+    getLogger(): EventLogger;
     connect(): Promise<boolean>;
     close(): Promise<boolean>;
     check(): Promise<boolean>;

package/lib/types/device.d.ts

@@ -9,11 +9,22 @@ export declare const INTERFACE: {
     USB: string;
     SIMULATOR: string;
 };
+export type DeviceType = 'race' | 'mountain' | 'triathlon';
 export type Device = {
     getID(): string;
     getName(): string;
     getInterface(): string;
 };
+export type DaumBikeData = {
+    cadence: number;
+    speed: number;
+    power: number;
+    heartrate: number;
+    distanceInternal: number;
+    gear: number;
+    time: number;
+    slope?: number;
+};
 export type DeviceProperties = {
     user?: User;
     userWeight?: number;

package/lib/types/route.d.ts

@@ -5,11 +5,6 @@ export type Point = {
     distance: number;
     slope?: number;
 };
-export declare enum RouteType {
-    FREE_RIDE = "free ride",
-    FOLLOW_ROUTE = "follow route",
-    VIDEO = "video"
-}
 export type Route = {
     programId: number;
     points: Point[];

package/lib/types/route.js

@@ -1,9 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RouteType = void 0;
-var RouteType;
-(function (RouteType) {
-    RouteType["FREE_RIDE"] = "free ride";
-    RouteType["FOLLOW_ROUTE"] = "follow route";
-    RouteType["VIDEO"] = "video";
-})(RouteType || (exports.RouteType = RouteType = {}));

package/lib/utils/calculations.js

@@ -22,8 +22,6 @@ class C {
             throw new IllegalArgumentException("m must be a positive number");
         if (power === undefined || power === null || power < 0)
             throw new IllegalArgumentException("power must be a positive number");
-        if (slope === undefined || slope === null)
-            slope = 0;
         const _rho = props.rho || rho;
         const _cRR = props.cRR || cRR;
         const _cwA = props.cwA || cwABike[props.bikeType || 'race'] || cwABike.race;
@@ -64,11 +62,9 @@ class C {
             throw new IllegalArgumentException("m must be a positive number");
         if (v === undefined || v === null || v < 0)
             throw new IllegalArgumentException("v must be a positive number");
-        if (slope === undefined || slope === null)
-            slope = 0;
         let _rho = props.rho || rho;
         let _cRR = props.cRR || cRR;
-        let _cwA = props.cwA || cwABike[props.bikeType || 'race'] || cwABike.race;
+        let _cwA = props.cwA || cwABike[props.bikeType || 'race'];
         let sl = Math.sin(Math.atan(slope / 100));
         let P = (0.5 * _rho * _cwA) * Math.pow(v, 3.0) + (sl + _cRR) * m * g * v;
         return P;

package/lib/utils/utils.d.ts

@@ -5,7 +5,7 @@ export declare function floatVal(d?: number | string): number;
 export declare function intVal(d?: number | string): number;
 export declare function hexstr(arr: any, start?: any, len?: any): string;
 export declare class Queue<T> {
-    data: Array<T>;
+    protected data: Array<T>;
     constructor(values?: Array<T>);
     size(): number;
     clear(): void;
@@ -13,3 +13,4 @@ export declare class Queue<T> {
     dequeue(): T;
     enqueue(value: T): void;
 }
+export declare function waitWithTimeout(promise: Promise<any>, timeout: number, onTimeout?: () => void): Promise<any>;