incyclist-devices 2.0.35 → 2.0.36

package/lib/serial/daum/DaumAdapter.js

@@ -12,13 +12,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractDaumAdapter = void 0;
 const ERGCyclingMode_1 = __importDefault(require("./ERGCyclingMode"));
 const SmartTrainerCyclingMode_1 = __importDefault(require("./SmartTrainerCyclingMode"));
 const DaumPowerMeterCyclingMode_1 = __importDefault(require("./DaumPowerMeterCyclingMode"));
 const utils_1 = require("../../utils/utils");
 const adapter_1 = require("../adapter");
 const capabilities_1 = require("../../types/capabilities");
-class DaumAdapterBase extends adapter_1.SerialIncyclistDevice {
+class AbstractDaumAdapter extends adapter_1.SerialIncyclistDevice {
+}
+exports.AbstractDaumAdapter = AbstractDaumAdapter;
+class DaumAdapter extends AbstractDaumAdapter {
     constructor(settings, props) {
         super(settings, props);
         this.requests = [];
@@ -107,7 +111,7 @@ class DaumAdapterBase extends adapter_1.SerialIncyclistDevice {
         return true;
     }
     isSame(device) {
-        if (!(device instanceof DaumAdapterBase))
+        if (!(device instanceof DaumAdapter))
             return false;
         const adapter = device;
         return (adapter.getName() === this.getName() && adapter.getPort() === this.getPort());
@@ -135,6 +139,26 @@ class DaumAdapterBase extends adapter_1.SerialIncyclistDevice {
         const settings = this.getCyclingMode().getSettings();
         this.setCyclingMode(name, settings);
     }
+    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;
+        });
+    }
     start(props) {
         throw new Error('Method not implemented.');
     }
@@ -192,9 +216,21 @@ class DaumAdapterBase extends adapter_1.SerialIncyclistDevice {
         this.logger.logEvent(event);
         const w = global.window;
         if (w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) {
-            console.log('~~~ Serial', event);
+            console.log(`~~~ ${this.logger.getName()}`, event);
         }
     }
+    reconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.bike.close();
+                const connected = yield this.bike.connect();
+                return connected;
+            }
+            catch (err) {
+                return false;
+            }
+        });
+    }
     stop() {
         if (this.stopped)
             return Promise.resolve(true);
@@ -243,15 +279,14 @@ class DaumAdapterBase extends adapter_1.SerialIncyclistDevice {
             this.updateBusy = true;
             this.getCurrentBikeData()
                 .then(bikeData => {
-                const incyclistData = this.updateData(this.cyclingData, bikeData);
+                const incyclistData = this.updateData(bikeData);
                 const data = this.transformData(incyclistData);
                 this.updateBusy = false;
                 this.emitData(data);
             })
                 .catch(err => {
                 this.logEvent({ message: 'bike update error', error: err.message, stack: err.stack });
-                const { isPedalling, power, pedalRpm, speed, distanceInternal, heartrate, slope } = this.cyclingData;
-                const incyclistData = this.updateData(this.cyclingData, { isPedalling, power, pedalRpm, speed, distanceInternal, heartrate, slope });
+                const incyclistData = this.updateData(this.cyclingData);
                 this.transformData(incyclistData);
                 this.updateBusy = false;
             });
@@ -297,16 +332,18 @@ class DaumAdapterBase extends adapter_1.SerialIncyclistDevice {
             yield this.update();
         });
     }
-    updateData(prev, bikeData) {
+    updateData(bikeData) {
         let data = {};
-        data.isPedalling = bikeData.cadence > 0;
+        data.isPedalling = bikeData.pedalRpm > 0;
         data.power = bikeData.power;
-        data.pedalRpm = bikeData.cadence;
+        data.pedalRpm = bikeData.pedalRpm;
         data.speed = bikeData.speed;
         data.heartrate = bikeData.heartrate;
         data.distanceInternal = bikeData.distanceInternal;
-        data.gear = bikeData.gear;
-        data.time = bikeData.time;
+        if (bikeData.gear)
+            data.gear = bikeData.gear;
+        if (bikeData.time)
+            data.time = bikeData.time;
         if (bikeData.slope)
             data.slope = bikeData.slope;
         this.cyclingData = this.getCyclingMode().updateData(data);
@@ -396,4 +433,4 @@ class DaumAdapterBase extends adapter_1.SerialIncyclistDevice {
         throw new Error('Method not implemented.');
     }
 }
-exports.default = DaumAdapterBase;
+exports.default = DaumAdapter;

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

@@ -1,6 +1,6 @@
 import CyclingMode, { CyclingModeProperty, IncyclistBikeData, UpdateRequest } from "../../modes/cycling-mode";
-import DaumAdapter from "./DaumAdapter";
 import PowerBasedCyclingModeBase from "../../modes/power-base";
+import { ControllableDeviceAdapter } from "../..";
 export type ERGEvent = {
     rpmUpdated?: boolean;
     gearUpdated?: boolean;
@@ -14,7 +14,7 @@ export default class ERGCyclingMode extends PowerBasedCyclingModeBase implements
     cassette: number[];
     event: ERGEvent;
     static isERG: boolean;
-    constructor(adapter: DaumAdapter, props?: any);
+    constructor(adapter: ControllableDeviceAdapter, props?: any);
     getName(): string;
     getDescription(): string;
     getProperties(): CyclingModeProperty[];

package/lib/serial/daum/ERGCyclingMode.js

@@ -183,7 +183,7 @@ class ERGCyclingMode extends power_base_1.default {
             }
         }
         catch (err) {
-            this.logger.logEvent({ message: 'error', fn: 'updateData()', error: err.message || err });
+            this.logger.logEvent({ message: 'error', fn: 'updateData()', error: err.message || err, stack: err.stack });
         }
         this.logger.logEvent({ message: "updateData result", data, bikeData, prevRequest, prevSpeed });
         this.data = data;

package/lib/serial/daum/SmartTrainerCyclingMode.d.ts

@@ -1,6 +1,6 @@
 import { EventLogger } from "gd-eventlog";
 import CyclingMode, { CyclingModeProperty, IncyclistBikeData, Settings, UpdateRequest, CyclingModeBase } from "../../modes/cycling-mode";
-import DaumAdapter from "./DaumAdapter";
+import { ControllableDeviceAdapter } from "../..";
 interface STUpdateRequest extends UpdateRequest {
     calculatedPower?: number;
     delta?: number;
@@ -25,11 +25,12 @@ export default class SmartTrainerCyclingMode extends CyclingModeBase implements
     chain: number[];
     cassette: number[];
     event: STEvent;
-    constructor(adapter: DaumAdapter, props?: Settings);
+    constructor(adapter: ControllableDeviceAdapter, props?: Settings);
     getName(): string;
     getDescription(): string;
     getProperties(): CyclingModeProperty[];
     getProperty(name: string): CyclingModeProperty;
+    getWeight(): number;
     getBikeInitRequest(): STUpdateRequest;
     useGearSimulation(): boolean;
     getMinMaxGears(source: string): [number, number];

package/lib/serial/daum/SmartTrainerCyclingMode.js

@@ -7,6 +7,7 @@ exports.direction = void 0;
 const gd_eventlog_1 = require("gd-eventlog");
 const cycling_mode_1 = require("../../modes/cycling-mode");
 const calculations_1 = __importDefault(require("../../utils/calculations"));
+const utils_1 = require("./classic/utils");
 const SEC_DELAY = 3;
 const config = {
     name: "SmartTrainer",
@@ -30,7 +31,7 @@ class SmartTrainerCyclingMode extends cycling_mode_1.CyclingModeBase {
         super(adapter, props);
         this.prevUpdateTS = 0;
         this.event = {};
-        this.logger = adapter ? adapter.logger : undefined;
+        this.logger = adapter ? adapter.getLogger() : undefined;
         if (!this.logger)
             this.logger = new gd_eventlog_1.EventLogger('SmartTrainer');
     }
@@ -46,6 +47,11 @@ class SmartTrainerCyclingMode extends cycling_mode_1.CyclingModeBase {
     getProperty(name) {
         return config.properties.find(p => p.name === name);
     }
+    getWeight() {
+        const a = this.adapter;
+        const m = (a) ? a.getWeight() : utils_1.DEFAULT_BIKE_WEIGHT + utils_1.DEFAULT_USER_WEIGHT;
+        return m;
+    }
     getBikeInitRequest() {
         const startPower = this.getSetting('startPower');
         return { targetPower: startPower };
@@ -220,8 +226,7 @@ class SmartTrainerCyclingMode extends cycling_mode_1.CyclingModeBase {
                 this.event.gearUpdate = gear > prevData.gear ? direction.up : direction.down;
             if (rpm !== prevData.pedalRpm)
                 this.event.rpmUpdate = true;
-            const adapter = this.adapter;
-            let m = adapter.getWeight();
+            let m = this.getWeight();
             let distanceInternal = prevData.distanceInternal || 0;
             let distance = (distanceInternal / 100);
             let ts = Date.now();
@@ -268,7 +273,7 @@ class SmartTrainerCyclingMode extends cycling_mode_1.CyclingModeBase {
         const prevRequest = this.prevRequest || {};
         const minPower = this.getSetting('minPower');
         const bikeType = this.getSetting('bikeType').toLowerCase();
-        const m = this.adapter.getWeight();
+        const m = this.getWeight();
         let speed = bikeSpeed;
         const Ekin = (m, speed) => {
             const v = speed / 3.6;
@@ -307,7 +312,7 @@ class SmartTrainerCyclingMode extends cycling_mode_1.CyclingModeBase {
         const defaultPower = this.getSetting('startPower');
         const minPower = this.getSetting('minPower');
         const bikeType = this.getSetting('bikeType').toLowerCase();
-        const m = this.adapter.getWeight();
+        const m = this.getWeight();
         const prevData = this.data || {};
         const slope = parseFloat((request.slope === undefined ? prevData.slope || 0 : request.slope).toFixed(1));
         let target = request.targetPower || defaultPower;

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

@@ -1,4 +1,4 @@
-import CyclingMode from '../../../modes/cycling-mode';
+import CyclingMode, { IncyclistBikeData } from '../../../modes/cycling-mode';
 import DaumAdapter from '../DaumAdapter';
 import { DeviceProperties } from '../../../types/device';
 import { SerialDeviceSettings } from '../../adapter';
@@ -6,14 +6,14 @@ import SerialInterface from '../../serial-interface';
 export interface DaumClassicDeviceProperties extends DeviceProperties {
     gear?: number;
 }
-export default class DaumClassicAdapter extends DaumAdapter {
+export default class DaumClassicAdapter extends DaumAdapter<SerialDeviceSettings, DaumClassicDeviceProperties> {
     static NAME: string;
     name: string;
     id: string;
     started: boolean;
     startPromise: Promise<unknown>;
     checkPromise: Promise<boolean>;
-    constructor(settings: SerialDeviceSettings, props?: DeviceProperties);
+    constructor(settings: SerialDeviceSettings, props?: DaumClassicDeviceProperties);
     setID(id: any): void;
     getID(): string;
     getName(): string;
@@ -25,11 +25,9 @@ export default class DaumClassicAdapter extends DaumAdapter {
     getSerialInterface(): SerialInterface;
     check(): Promise<boolean>;
     performCheck(): Promise<boolean>;
-    pause(): Promise<boolean>;
-    resume(): Promise<boolean>;
     startRide(props?: DaumClassicDeviceProperties): Promise<boolean>;
     start(props?: DaumClassicDeviceProperties): Promise<boolean>;
     launch(props: DaumClassicDeviceProperties, isRelaunch?: boolean): Promise<boolean>;
     performStart(props?: DaumClassicDeviceProperties, isRelaunch?: boolean): Promise<unknown>;
-    getCurrentBikeData(): any;
+    getCurrentBikeData(): Promise<IncyclistBikeData>;
 }

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

@@ -144,26 +144,6 @@ class DaumClassicAdapter 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' });
@@ -286,9 +266,11 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
         }), 5, 1000);
     }
     getCurrentBikeData() {
-        if (this.stopped)
-            return;
-        return this.getBike().runData();
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.stopped)
+                return;
+            return this.getBike().runData();
+        });
     }
 }
 DaumClassicAdapter.NAME = PROTOCOL_NAME;

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

@@ -1,67 +1,35 @@
-import { EventLogger } from 'gd-eventlog';
-import { Queue } from '../../../utils/utils';
 import { User } from '../../../types/user';
-import { SerialInterface, SerialPortProvider } from '../..';
-import { SerialCommProps } from '../../comm';
-type SuccessCallbackFn = (data: any) => void;
-type ErrorCallbackFn = (status: number, error: any) => void;
-interface CommandInstructions {
-    logStr: string;
-    payload: Array<number>;
-    expected: number;
-    callback: SuccessCallbackFn;
-    callbackErr: ErrorCallbackFn;
-    options?: any;
+import { ClassicBikeResponse, DaumClassicCommsState, DaumClassicRequest, DaumClassicResponse, GetVersionReponse, ProgResponse, SetGearRepsonse, SetPowerRepsonse, SetProgResponse, SetSlopeRepsonse, checkCockpitReponse } from './types';
+import SerialPortComms from '../../comms';
+import { DeviceType } from '../../../types/device';
+import { IncyclistBikeData } from '../../..';
+export default class Daum8008 extends SerialPortComms<DaumClassicCommsState, DaumClassicRequest, DaumClassicResponse> {
+    validatePath(path: string): string;
+    getDefaultLoggerName(): string;
+    onConnected(): void;
+    getTimeoutValue(): number;
+    initForResponse(expected: any): Promise<void>;
+    waitForResponse(): Promise<DaumClassicResponse>;
+    doSend(expected: number, payload: Uint8Array): Promise<DaumClassicResponse>;
+    send(request: DaumClassicRequest): Promise<DaumClassicResponse>;
+    sendCommand(logString: string, command: number[], expected: any): Promise<Uint8Array>;
+    checkCockpit(bikeNo?: number): Promise<checkCockpitReponse>;
+    getAddress(): Promise<ClassicBikeResponse>;
+    getVersion(bikeNo?: number): Promise<GetVersionReponse>;
+    resetDevice(bikeNo?: number): Promise<ClassicBikeResponse>;
+    startProg(bikeNo?: number): Promise<ProgResponse>;
+    stopProg(bikeNo?: number): Promise<ProgResponse>;
+    setProg(progNo?: number, bikeNo?: number): Promise<SetProgResponse>;
+    setBikeType(bikeType: DeviceType, bikeNo?: number): Promise<ClassicBikeResponse>;
+    setPerson(user?: User, bikeNo?: number): Promise<{
+        bike: number;
+        age: number;
+        gender: number;
+        length: number;
+        weight: number;
+    }>;
+    runData(bikeNo?: number): Promise<IncyclistBikeData>;
+    setGear(gear: number, bikeNo?: number): Promise<SetGearRepsonse>;
+    setPower(power: number, bikeNo?: number): Promise<SetPowerRepsonse>;
+    setSlope(slope: number, bikeNo?: number): Promise<SetSlopeRepsonse>;
 }
-export default class Daum8008 {
-    logger: EventLogger;
-    portName: string;
-    sp: any;
-    error: Error;
-    opening: boolean;
-    connected: boolean;
-    closing: boolean;
-    closed: boolean;
-    cmdBusy: boolean;
-    queue: Queue<CommandInstructions>;
-    bikeCmdWorker: any;
-    cmdStart: number;
-    cmdCurrent: any;
-    isLoggingPaused: boolean;
-    spp: SerialPortProvider;
-    serial: SerialInterface;
-    _timeoutSend: number;
-    constructor(props: SerialCommProps);
-    static setSerialPort(spClass: any): void;
-    static getClassName(): string;
-    getType(): string;
-    getPort(): string;
-    isConnected(): boolean;
-    pauseLogging(): void;
-    resumeLogging(): void;
-    logEvent(e: any): void;
-    connect(): Promise<boolean>;
-    close(): Promise<void>;
-    flush(): Promise<void>;
-    onPortClose(): Promise<void>;
-    onPortError(err: any): void;
-    startWorker(): void;
-    stopWorker(): void;
-    sendDaum8008CommandfromQueue(): any;
-    sendDaum8008Command(logStr: any, payload: any, expected: any, callback?: any, callbackErr?: any, options?: any): void;
-    send(cmdInfo: any): void;
-    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?: User, 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>;
-}
-export {};