incyclist-devices 2.0.35 → 2.0.36

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

@@ -1,13 +1,14 @@
+import { IncyclistBikeData } from '../../..';
+import { DeviceType } from '../../../types/device';
 export declare const DEFAULT_AGE = 30;
 export declare const DEFAULT_USER_WEIGHT = 75;
 export declare const DEFAULT_BIKE_WEIGHT = 10;
-export declare function getCockpit(c: any): "Cardio" | "Fitness" | "Vita De Luxe" | "8008" | "8008 TRS" | "8080" | "Therapie" | "8008 TRS Pro" | "8008 TRS3" | "ergo_lyps Cardio Pro" | "Unknown";
-export declare function getBikeType(type: any): 0 | 1;
-export declare function getGender(sex: any): 1 | 2;
-export declare function getLength(length: any): number;
-export declare function getWeight(weight?: any): number;
-export declare function parseRunData(data: any): any;
-export declare function buildError(status: any, err: any): any;
-export declare function hexstr(arr: any, start?: any, len?: any): string;
-export declare function Float32ToHex(float32: any): any;
-export declare function Float32ToIntArray(float32: any): any[];
+export declare function getCockpit(c: number): "Cardio" | "Fitness" | "Vita De Luxe" | "8008" | "8008 TRS" | "8080" | "Therapie" | "8008 TRS Pro" | "8008 TRS3" | "ergo_lyps Cardio Pro" | "Unknown";
+export declare function getSerialNo(arr: Uint8Array, start: number, length: number): string;
+export declare function getBikeType(type?: DeviceType): number;
+export declare function getGender(sex: any): 0 | 1 | 2;
+export declare function getLength(length?: number): number;
+export declare function getWeight(weight?: number): number;
+export declare function parseRunData(data: any): IncyclistBikeData;
+export declare function between(v: number, min: number, max: number): number;
+export declare function buildSetSlopeCommand(bikeNo: any, slope: any): number[];

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Float32ToIntArray = exports.Float32ToHex = exports.hexstr = exports.buildError = exports.parseRunData = exports.getWeight = exports.getLength = exports.getGender = exports.getBikeType = exports.getCockpit = exports.DEFAULT_BIKE_WEIGHT = exports.DEFAULT_USER_WEIGHT = exports.DEFAULT_AGE = void 0;
+exports.buildSetSlopeCommand = exports.between = exports.parseRunData = exports.getWeight = exports.getLength = exports.getGender = exports.getBikeType = exports.getSerialNo = exports.getCockpit = exports.DEFAULT_BIKE_WEIGHT = exports.DEFAULT_USER_WEIGHT = exports.DEFAULT_AGE = void 0;
 exports.DEFAULT_AGE = 30;
 exports.DEFAULT_USER_WEIGHT = 75;
 exports.DEFAULT_BIKE_WEIGHT = 10;
@@ -31,18 +31,23 @@ function getCockpit(c) {
     }
 }
 exports.getCockpit = getCockpit;
+function getSerialNo(arr, start, length) {
+    const buffer = Buffer.from(arr.subarray(start, start + length));
+    return buffer.toString('hex');
+}
+exports.getSerialNo = getSerialNo;
 function getBikeType(type) {
+    const DAUM_CLASSIC_BT_MOUNTAIN = 1;
+    const DAUM_CLASSIC_BT_RACE = 0;
     if (type === undefined)
-        return 0;
+        return DAUM_CLASSIC_BT_RACE;
     switch (type) {
-        case "triathlon":
-            return 0;
-        case "race":
-            return 0;
-        case "mountain":
-            return 1;
-        default:
-            return 1;
+        case 'triathlon':
+            return DAUM_CLASSIC_BT_RACE;
+        case 'race':
+            return DAUM_CLASSIC_BT_RACE;
+        case 'mountain':
+            return DAUM_CLASSIC_BT_MOUNTAIN;
     }
 }
 exports.getBikeType = getBikeType;
@@ -51,7 +56,7 @@ function getGender(sex) {
         return 2;
     switch (sex) {
         case "M":
-            return 1;
+            return 0;
         case "F":
             return 1;
         default:
@@ -62,82 +67,42 @@ exports.getGender = getGender;
 function getLength(length) {
     if (length === undefined || length === null)
         return 180;
-    let l = Math.round(length);
-    if (l < 100)
-        return 100;
-    if (l > 220)
-        return 220;
-    return l;
+    const l = Math.round(length);
+    return between(l, 100, 220);
 }
 exports.getLength = getLength;
 function getWeight(weight) {
     if (weight === undefined || weight === null)
         return 80;
     let m = Math.round(weight);
-    if (isNaN(m))
-        return 80;
-    if (m < 10)
-        return 10;
-    if (m > 250)
-        return 250;
-    return m;
+    return between(m, 10, 250);
 }
 exports.getWeight = getWeight;
 function parseRunData(data) {
     const bikeData = {};
     bikeData.isPedalling = (data[4] > 0);
     bikeData.power = data[5] * 5;
-    bikeData.cadence = data[6];
+    bikeData.pedalRpm = data[6];
     bikeData.speed = data[7];
     bikeData.heartrate = data[14];
-    bikeData.distance = (data[9] * 256 + data[8]) / 10;
     bikeData.distanceInternal = (data[9] * 256 + data[8]) * 100;
     bikeData.time = (data[11] * 256 + data[10]);
     bikeData.gear = data[16];
     return bikeData;
 }
 exports.parseRunData = parseRunData;
-function buildError(status, err) {
-    const message = err && err.message ? err.message : err;
-    const error = new Error(message);
-    error.status = status;
-    return error;
+function between(v, min, max) {
+    if (v < min)
+        return min;
+    if (v > max)
+        return max;
+    return v;
 }
-exports.buildError = buildError;
-function hexstr(arr, start, len) {
-    var str = "";
-    if (start === undefined)
-        start = 0;
-    if (len === undefined) {
-        len = arr.length;
-    }
-    if (len - start > arr.length) {
-        len = arr.length - start;
-    }
-    var j = start;
-    for (var i = 0; i < len; i++) {
-        var hex = Math.abs(arr[j++]).toString(16);
-        if (i !== 0)
-            str += " ";
-        str += hex;
-    }
-    return str;
-}
-exports.hexstr = hexstr;
-function Float32ToHex(float32) {
-    function getHex(i) { return ('00' + i.toString(16)).slice(-2).toUpperCase(); }
-    var view = new DataView(new ArrayBuffer(4));
-    view.setFloat32(0, float32);
-    return Array.apply(null, { length: 4 }).map((_, i) => getHex(view.getUint8(i))).join('');
-}
-exports.Float32ToHex = Float32ToHex;
-function Float32ToIntArray(float32) {
-    var view = new DataView(new ArrayBuffer(4));
-    view.setFloat32(0, float32);
-    var arr = [];
-    for (let i = 0; i < 4; i++) {
-        arr.push(view.getUint8(i));
-    }
-    return arr;
+exports.between = between;
+function buildSetSlopeCommand(bikeNo, slope) {
+    const buffer = Buffer.from([0x55, bikeNo, 0, 0, 0, 0]);
+    buffer.writeFloatLE(slope, 2);
+    const cmd = Array.from(buffer);
+    return cmd;
 }
-exports.Float32ToIntArray = Float32ToIntArray;
+exports.buildSetSlopeCommand = buildSetSlopeCommand;

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

@@ -1,15 +1,14 @@
-import { DeviceProperties } from '../../../types/device';
 import { SerialInterface } from '../..';
 import { SerialDeviceSettings } from '../../adapter';
 import { SerialCommProps } from '../../comm';
 import DaumAdapter from '../DaumAdapter';
 import { Daum8iDeviceProperties } from './types';
-export default class DaumPremiumAdapter extends DaumAdapter {
+import { IncyclistBikeData } from '../../..';
+export default class DaumPremiumAdapter extends DaumAdapter<SerialDeviceSettings, Daum8iDeviceProperties> {
     static NAME: string;
     commProps: SerialCommProps;
     _startRetryTimeout: number;
-    constructor(settings: SerialDeviceSettings, props?: DeviceProperties);
-    logEvent(event: any): void;
+    constructor(settings: SerialDeviceSettings, props?: Daum8iDeviceProperties);
     getName(): string;
     getUniqueName(): string;
     getPort(): any;
@@ -19,10 +18,8 @@ export default class DaumPremiumAdapter extends DaumAdapter {
     isEqual(settings: SerialDeviceSettings): boolean;
     getSupportedCyclingModes(): Array<any>;
     check(): Promise<boolean>;
-    pause(): Promise<boolean>;
-    resume(): Promise<boolean>;
     startRide(props?: Daum8iDeviceProperties): Promise<boolean>;
     start(props?: Daum8iDeviceProperties): Promise<boolean>;
     launch(props?: Daum8iDeviceProperties, isRelaunch?: boolean): Promise<boolean>;
-    getCurrentBikeData(): Promise<any>;
+    getCurrentBikeData(): Promise<IncyclistBikeData>;
 }

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

@@ -60,15 +60,6 @@ class DaumPremiumAdapter extends DaumAdapter_1.default {
         this.distanceInternal = undefined;
         this.initData();
     }
-    logEvent(event) {
-        if (this.logger) {
-            this.logger.logEvent(event);
-        }
-        const w = global.window;
-        if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.BLE_DEBUG) {
-            console.log('~~~ DaumPremium', event);
-        }
-    }
     getName() {
         return 'Daum8i';
     }
@@ -136,26 +127,6 @@ class DaumPremiumAdapter extends DaumAdapter_1.default {
             }));
         });
     }
-    pause() {
-        const _super = Object.create(null, {
-            pause: { get: () => super.pause }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const paused = yield _super.pause.call(this);
-            this.bike.pauseLogging();
-            return paused;
-        });
-    }
-    resume() {
-        const _super = Object.create(null, {
-            resume: { get: () => super.resume }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const resumed = yield _super.resume.call(this);
-            this.bike.resumeLogging();
-            return resumed;
-        });
-    }
     startRide(props = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             this.logEvent({ message: 'relaunch of device' });
@@ -193,7 +164,9 @@ class DaumPremiumAdapter extends DaumAdapter_1.default {
             yield this.stop();
             return (0, utils_1.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () {
                 try {
-                    yield this.connect();
+                    const connected = yield this.connect();
+                    if (!connected)
+                        throw new Error('not connected');
                     if (!info.deviceType) {
                         info.deviceType = yield this.bike.getDeviceType();
                     }
@@ -224,6 +197,10 @@ class DaumPremiumAdapter extends DaumAdapter_1.default {
                     return;
                 }
                 catch (err) {
+                    if (!info.deviceType) {
+                        yield (0, utils_1.sleep)(500);
+                        yield this.reconnect();
+                    }
                     throw (new Error(`could not start device, reason:${err.message}`));
                 }
             }), 5, this._startRetryTimeout)

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

@@ -1,123 +1,46 @@
 /// <reference types="node" />
 import { ReservedCommands } from './utils';
-import { SerialInterface, SerialPortProvider } from '../..';
-import { EventLogger } from 'gd-eventlog';
 import { User } from "../../../types/user";
 import { Route } from "../../../types/route";
-import { SerialCommProps } from "../../comm";
-import { SerialPortStream } from "@serialport/stream";
 import { OnDeviceStartCallback } from "./types";
-import { Queue } from "../../../utils/utils";
-export type ResponseObject = {
-    type: ResponseType;
-    data?: string;
-    error?: Error;
-};
-export type ResponseType = 'ACK' | 'NAK' | 'Response' | 'Error';
-export type Daum8iCommsState = {
-    waitingForStart?: boolean;
-    waitingForACK?: boolean;
-    waitingForEnd?: boolean;
-    partialCmd?: any;
-    data: Queue<ResponseObject>;
-};
-export type ConnectionState = 'Connecting' | 'Connected' | 'Disconnected' | 'Disconnecting';
-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 default class Daum8i {
-    logger: EventLogger;
-    serial: SerialInterface;
-    path: string;
-    tcpipConnection: {
-        host: string;
-        port: string;
-    };
-    port: string;
-    settings: any;
-    props: any;
-    protected sp: SerialPortStream;
-    protected connectState: ConnectionState;
-    protected connectPromise: Promise<SerialPortStream>;
-    protected disconnectPromise: Promise<boolean>;
-    protected writePromise: Promise<void>;
-    protected sendCmdPromise: Promise<string>;
-    protected actualBikeType?: string;
-    protected recvState: Daum8iCommsState;
-    bikeData: any;
-    isLoggingPaused: boolean;
-    spp: SerialPortProvider;
-    serialportProps: any;
-    constructor(props: SerialCommProps);
-    getInterface(): string;
-    getPort(): string;
-    isConnected(): boolean;
-    pauseLogging(): void;
-    resumeLogging(): void;
-    logEvent(e: any): void;
-    connect(): Promise<boolean>;
-    closePort(): Promise<boolean>;
-    cleanupPort(): void;
-    close(): Promise<boolean>;
-    flush(): Promise<void>;
-    onPortClose(): Promise<void>;
-    onPortError(error: Error): Promise<void>;
-    isSending(): boolean;
-    rejectCurrent(error: Error): void;
-    getTimeoutValue(cmd?: any): number;
+import SerialPortComms from "../../comms";
+import { DaumPremiumCommsState, DaumPremiumRequest, ResponseObject } from "./types";
+import { IncyclistBikeData } from "../../..";
+export default class Daum8i extends SerialPortComms<DaumPremiumCommsState, DaumPremiumRequest, ResponseObject> {
+    validatePath(path: string): string;
+    getDefaultLoggerName(): string;
+    getAckTimeoutValue(): number;
+    getTimeoutValue(): number;
+    onConnected(): void;
+    getInitialCommsState(): DaumPremiumCommsState;
+    setState(ack: boolean, start: boolean, end: boolean): void;
     onData(data: any, depth?: number): any;
-    waitWithTimeout(promise: Promise<any>, timeout: number, onTimeout?: () => void): Promise<any>;
-    sendDaum8iCommand(command: string, payload?: string | any[]): Promise<string>;
-    onIgnored(payload: string): void;
-    onACK(): void;
-    onNAK: () => void;
+    send(request: DaumPremiumRequest): Promise<ResponseObject>;
+    sendStrCommand(logString: string, command: string, payload?: string | Uint8Array): Promise<string>;
+    sendBinaryCommand(logString: string, command: string, payload?: string | Uint8Array): Promise<string>;
     waitForACK(): Promise<boolean>;
-    waitForResponse(): Promise<string>;
-    portWrite(buffer: Buffer): Promise<void>;
+    waitForResponse(): Promise<ResponseObject>;
     write(buffer: Buffer, ackExpected?: boolean): Promise<void>;
-    sendACK(): Promise<void>;
-    sendNAK(): Promise<void>;
-    sendReservedDaum8iCommand(command: ReservedCommands, data?: Buffer): Promise<any[]>;
+    sendACK(logPayload: any): Promise<void>;
+    sendNAK(logPayload: any): Promise<void>;
     getProtocolVersion(): Promise<string>;
     getDashboardVersion(): Promise<string>;
-    getDeviceType(): Promise<any>;
-    getActualBikeType(): Promise<any>;
-    setActualBikeType(actualBikeType: any): Promise<any>;
-    getTrainingData(): Promise<{
-        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;
-    }>;
-    setLoadControl(enabled: any): Promise<boolean>;
+    getDeviceType(): Promise<string>;
+    getActualBikeType(): Promise<string>;
+    setActualBikeType(actualBikeType: any): Promise<string>;
+    getTrainingData(): Promise<IncyclistBikeData>;
+    setLoadControl(enabled: boolean): Promise<boolean>;
     getLoadControl(): Promise<boolean>;
-    setPower(power: any): Promise<number>;
-    getPower(power: any): Promise<number>;
+    setPower(power: number | string): Promise<number>;
+    getPower(): Promise<number>;
+    setGear(gear: number): Promise<number>;
+    getGear(): Promise<number>;
+    sendReservedDaum8iCommand(logString: string, command: ReservedCommands, data?: Buffer): Promise<Uint8Array>;
     setPerson(person: User): Promise<boolean>;
     programUploadInit(): Promise<boolean>;
     programUploadStart(bikeType: string, route?: Route): Promise<Uint8Array>;
     programUploadSendBlock(epp: Uint8Array, offset: number): Promise<boolean>;
     programUploadDone(): Promise<boolean>;
-    programUpload(bikeType: string, route: Route, onStatusUpdate?: OnDeviceStartCallback): Promise<boolean>;
     startProgram(programId?: number): Promise<boolean>;
-    setGear(gear: any): Promise<number>;
-    getGear(): Promise<number>;
+    programUpload(bikeType: string, route: Route, onStatusUpdate?: OnDeviceStartCallback): Promise<boolean>;
 }