incyclist-devices 1.5.38 → 2.0.0

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

@@ -0,0 +1,96 @@
+/// <reference types="node" />
+import { MockBindingInterface, MockPortBinding, CreatePortOptions } from '@serialport/binding-mock';
+import { BindingInterface } from '@serialport/bindings-interface';
+export type MockProps = {
+    interface: string;
+    path: string;
+};
+export interface DaumClassicMockBindingInterface extends BindingInterface<DaumClassicMockBinding> {
+    reset(): void;
+    createPort(path: string, opt?: CreatePortOptions): void;
+}
+export declare const DaumClassicMock: MockBindingInterface;
+export declare class DaumClassicMockImpl {
+    static _instance: DaumClassicMockImpl;
+    static getInstance(): DaumClassicMockImpl;
+    static reset(): void;
+    simulators: Map<string, DaumClassicSimulator>;
+    ports: {
+        path: string;
+        binding: DaumClassicMockBinding;
+    }[];
+    constructor();
+    setSimulator(path: string, simulator: DaumClassicSimulator): void;
+    getSimulator(path: any): DaumClassicSimulator;
+    reset(): void;
+    createPort(path: string, options?: CreatePortOptions): void;
+    list(): Promise<import("@serialport/bindings-interface").PortInfo[]>;
+    open(options: any): Promise<DaumClassicMockBinding>;
+}
+export type DaumClassicUser = {
+    weight: number;
+    length?: number;
+    age?: number;
+    sex?: number;
+    personNo?: number;
+    pctFat?: number;
+    coachingLevel?: number;
+    coachingFrequency?: number;
+    powerLimit?: number;
+    hrLimit?: number;
+    timeLimit?: number;
+    distLimit?: number;
+    kcalLimit?: number;
+};
+interface BikeData {
+    cockpitVersion: number;
+    isPedalling: boolean;
+    bikeType: number;
+    person: DaumClassicUser;
+}
+export declare class DaumClassicSimulator {
+    selectedBike: number;
+    bikes: BikeData[];
+    cadence: number;
+    gear: number;
+    slope: number;
+    progNo: number;
+    heartrate: number;
+    distance: number;
+    isPowerMode: boolean;
+    targetPower: number;
+    currentPower: number;
+    _timeoutResponse: number;
+    _simulateNoReponseCnt: number;
+    _simulateIllegalResponseCnt: number;
+    constructor();
+    reset(): void;
+    simulateTimeout(ms: number): void;
+    simulateNoResponse(cnt?: number): void;
+    simulateIllegalResponse(cnt?: number): void;
+    isPedalling(): 0 | 1;
+}
+export declare class DaumClassicMockBinding extends MockPortBinding {
+    prevCommand: Buffer;
+    simulator: DaumClassicSimulator;
+    handlers: Map<number, (payload: Buffer) => void>;
+    constructor(parent: MockPortBinding);
+    getPath(): string;
+    initHandlers(): void;
+    write(buffer: Buffer): Promise<void>;
+    emitData(data: string | Buffer): void;
+    onCheckCockpit(payload: Buffer): void;
+    onGetAddress(_payload: Buffer): void;
+    onGetVersion(payload: Buffer): void;
+    onResetDevice(payload: Buffer): void;
+    onStartProg(payload: Buffer): void;
+    onStopProg(payload: Buffer): void;
+    onSetProg(payload: Buffer): void;
+    onSetBikeType(payload: Buffer): void;
+    onSetPerson(payload: Buffer): void;
+    onRunData(payload: Buffer): void;
+    onSetGear(payload: Buffer): void;
+    onSetPower(payload: Buffer): void;
+    onSetSlope(payload: Buffer): void;
+}
+export {};

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

@@ -0,0 +1,365 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DaumClassicMockBinding = exports.DaumClassicSimulator = exports.DaumClassicMockImpl = exports.DaumClassicMock = void 0;
+const binding_mock_1 = require("@serialport/binding-mock");
+const __1 = require("../../");
+const utils_1 = require("../../../utils/utils");
+const calculations_1 = __importDefault(require("../../../utils/calculations"));
+exports.DaumClassicMock = {
+    reset() {
+        DaumClassicMockImpl.getInstance().reset();
+    },
+    createPort(path, options = {}) {
+        return DaumClassicMockImpl.getInstance().createPort(path, options);
+    },
+    list() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return DaumClassicMockImpl.getInstance().list();
+        });
+    },
+    open(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return DaumClassicMockImpl.getInstance().open(options);
+        });
+    }
+};
+class DaumClassicMockImpl {
+    static getInstance() {
+        if (!DaumClassicMockImpl._instance)
+            DaumClassicMockImpl._instance = new DaumClassicMockImpl();
+        return DaumClassicMockImpl._instance;
+    }
+    static reset() {
+        DaumClassicMockImpl._instance = undefined;
+        __1.SerialPortProvider._instance = undefined;
+        __1.SerialInterface._instances = [];
+    }
+    constructor() {
+        this.simulators = new Map();
+        this.ports = [];
+    }
+    setSimulator(path, simulator) {
+        this.simulators.set(path, simulator);
+    }
+    getSimulator(path) {
+        return this.simulators.get(path);
+    }
+    reset() {
+        binding_mock_1.MockBinding.reset();
+    }
+    createPort(path, options = {}) {
+        return binding_mock_1.MockBinding.createPort(path, options);
+    }
+    list() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return binding_mock_1.MockBinding.list();
+        });
+    }
+    open(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const port = yield binding_mock_1.MockBinding.open(options);
+            return new DaumClassicMockBinding(port);
+        });
+    }
+}
+exports.DaumClassicMockImpl = DaumClassicMockImpl;
+const DEFAULT_BIKE_DATA = {
+    cockpitVersion: 3,
+    isPedalling: false,
+    bikeType: 0,
+    person: { weight: 75, length: 180, age: 30, sex: 0 }
+};
+class DaumClassicSimulator {
+    constructor() {
+        this.selectedBike = 0;
+        this.bikes = [];
+        this._timeoutResponse = 0;
+        this._simulateNoReponseCnt = 0;
+        this._simulateIllegalResponseCnt = 0;
+        for (let i = 0; i < 10; i++)
+            this.bikes.push(Object.assign({}, DEFAULT_BIKE_DATA));
+        this.reset();
+    }
+    reset() {
+        this.cadence = 0;
+        this.slope = 0;
+        this.gear = 1;
+        this.progNo = 0;
+        this.heartrate = 0;
+        this.distance = 0;
+        this.targetPower = 25;
+        this.currentPower = 25;
+        this.isPowerMode = false;
+        this._timeoutResponse = 0;
+        this._simulateNoReponseCnt = 0;
+        this._simulateIllegalResponseCnt = 0;
+    }
+    simulateTimeout(ms) {
+        this._timeoutResponse = ms;
+    }
+    simulateNoResponse(cnt = 1) {
+        this._simulateNoReponseCnt += cnt;
+    }
+    simulateIllegalResponse(cnt = 1) {
+        this._simulateIllegalResponseCnt += cnt;
+    }
+    isPedalling() {
+        if (this.cadence && this.cadence > 0)
+            return 1;
+        return 0;
+    }
+}
+exports.DaumClassicSimulator = DaumClassicSimulator;
+class DaumClassicMockBinding extends binding_mock_1.MockPortBinding {
+    constructor(parent) {
+        super(parent.port, parent.openOptions);
+        this.prevCommand = null;
+        this.simulator = DaumClassicMockImpl.getInstance().getSimulator(this.getPath());
+        if (!this.simulator) {
+            this.simulator = new DaumClassicSimulator();
+            DaumClassicMockImpl.getInstance().setSimulator(this.getPath(), this.simulator);
+        }
+        this.initHandlers();
+    }
+    getPath() {
+        return this.port.info.path;
+    }
+    initHandlers() {
+        this.handlers = new Map();
+        this.handlers.set(0x10, this.onCheckCockpit.bind(this));
+        this.handlers.set(0x11, this.onGetAddress.bind(this));
+        this.handlers.set(0x73, this.onGetVersion.bind(this));
+        this.handlers.set(0x12, this.onResetDevice.bind(this));
+        this.handlers.set(0x21, this.onStartProg.bind(this));
+        this.handlers.set(0x22, this.onStopProg.bind(this));
+        this.handlers.set(0x23, this.onSetProg.bind(this));
+        this.handlers.set(0x69, this.onSetBikeType.bind(this));
+        this.handlers.set(0x24, this.onSetPerson.bind(this));
+        this.handlers.set(0x40, this.onRunData.bind(this));
+        this.handlers.set(0x53, this.onSetGear.bind(this));
+        this.handlers.set(0x51, this.onSetPower.bind(this));
+        this.handlers.set(0x55, this.onSetSlope.bind(this));
+    }
+    write(buffer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!Buffer.isBuffer(buffer)) {
+                throw new TypeError('"buffer" is not a Buffer');
+            }
+            if (!this.isOpen || !this.port) {
+                throw new Error('Port is not open');
+            }
+            if (this.writeOperation) {
+                throw new Error('Overlapping writes are not supported and should be queued by the serialport object');
+            }
+            if (buffer.length == 0)
+                return;
+            this.writeOperation = (() => __awaiter(this, void 0, void 0, function* () {
+                yield (0, utils_1.resolveNextTick)();
+                if (!this.isOpen || !this.port) {
+                    throw new Error('Write canceled');
+                }
+                try {
+                    const cmd = buffer.readUInt8(0);
+                    const handler = this.handlers.get(cmd);
+                    const payload = buffer.subarray(1);
+                    if (this.simulator._simulateNoReponseCnt > 0) {
+                        this.simulator._simulateNoReponseCnt--;
+                        return;
+                    }
+                    const to = this.simulator._timeoutResponse || 5;
+                    if (handler)
+                        setTimeout(() => { handler(payload); }, to);
+                }
+                catch (err) {
+                }
+                this.writeOperation = null;
+            }))();
+            return this.writeOperation;
+        });
+    }
+    emitData(data) {
+        if (!this.isOpen || !this.port)
+            return;
+        super.emitData(data);
+    }
+    onCheckCockpit(payload) {
+        const bikeNo = payload.readUInt8(0);
+        if (bikeNo >= 0 && bikeNo < 10) {
+            const response = Buffer.from([0x10, bikeNo, this.simulator.bikes[bikeNo].cockpitVersion]);
+            this.emitData(response);
+        }
+    }
+    onGetAddress(_payload) {
+        const response = Buffer.from([0x11, this.simulator.selectedBike]);
+        this.emitData(response);
+    }
+    onGetVersion(payload) {
+        const bikeNo = payload.readUInt8(0);
+        if (bikeNo >= 0 && bikeNo < 10) {
+            const response = Buffer.from([0x73, bikeNo, this.simulator.bikes[bikeNo].cockpitVersion]);
+            this.emitData(response);
+        }
+    }
+    onResetDevice(payload) {
+        const bikeNo = payload.readUInt8(0);
+        if (bikeNo >= 0 && bikeNo < 10) {
+            const response = Buffer.from([0x12, bikeNo]);
+            this.simulator.bikes[bikeNo] = DEFAULT_BIKE_DATA;
+            this.emitData(response);
+        }
+    }
+    onStartProg(payload) {
+        const bikeNo = payload.readUInt8(0);
+        if (bikeNo >= 0 && bikeNo < 10) {
+            const isPedalling = this.simulator.isPedalling();
+            const response = Buffer.from([0x21, bikeNo, isPedalling ? 1 : 0]);
+            this.emitData(response);
+        }
+    }
+    onStopProg(payload) {
+        const bikeNo = payload.readUInt8(0);
+        if (bikeNo >= 0 && bikeNo < 10) {
+            const isPedalling = this.simulator.isPedalling();
+            const response = Buffer.from([0x22, bikeNo, isPedalling]);
+            this.emitData(response);
+        }
+    }
+    onSetProg(payload) {
+        const bikeNo = payload.readUInt8(0);
+        const progNo = payload.readUInt8(1);
+        if (bikeNo >= 0 && bikeNo < 10) {
+            const isPedalling = this.simulator.isPedalling();
+            this.simulator.progNo = progNo;
+            const response = Buffer.from([0x23, bikeNo, progNo, isPedalling]);
+            this.emitData(response);
+        }
+    }
+    onSetBikeType(payload) {
+        const bikeNo = payload.readUInt8(0);
+        const bikeType = payload.readUInt8(3);
+        if (bikeNo >= 0 && bikeNo < 10) {
+            const { isPedalling } = this.simulator.bikes[bikeNo];
+            this.simulator.bikes[bikeNo].bikeType = bikeType;
+            const response = Buffer.from([0x69, bikeNo, bikeType]);
+            this.emitData(response);
+        }
+    }
+    onSetPerson(payload) {
+        const bikeNo = payload.readUInt8(0);
+        const personNo = payload.readUInt8(1);
+        const age = payload.readUInt8(2);
+        const sex = payload.readUInt8(3);
+        const length = payload.readUint8(4);
+        const weight = payload.readUint8(5);
+        const pctFat = payload.readUint8(6);
+        const coachingLevel = payload.readUint8(7);
+        const coachingFrequency = payload.readUint8(8);
+        const powerLimit = payload.readUint8(9);
+        const hrLimit = payload.readUint8(10);
+        const timeLimit = payload.readUint8(11);
+        const distLimit = payload.readUint8(12);
+        const kcalLimit = payload.readUint8(13);
+        if (bikeNo >= 0 && bikeNo < 10) {
+            this.simulator.bikes[bikeNo].person = {
+                personNo, age, sex, length, weight, pctFat,
+                coachingLevel, coachingFrequency, powerLimit,
+                hrLimit, timeLimit, distLimit, kcalLimit
+            };
+            const isPedalling = this.simulator.isPedalling();
+            let response;
+            if (this.simulator._simulateIllegalResponseCnt > 0) {
+                response = Buffer.from([0x24, bikeNo, personNo, age, sex,
+                    length, weight, pctFat, coachingLevel, coachingFrequency,
+                    powerLimit + 10, hrLimit, timeLimit, distLimit, kcalLimit,
+                    isPedalling]);
+            }
+            else {
+                response = Buffer.from([0x24, bikeNo, personNo, age, sex,
+                    length, weight, pctFat, coachingLevel, coachingFrequency,
+                    powerLimit, hrLimit, timeLimit, distLimit, kcalLimit,
+                    isPedalling]);
+            }
+            this.emitData(response);
+        }
+    }
+    onRunData(payload) {
+        const { cadence, gear, slope, heartrate, distance, progNo, isPowerMode, currentPower } = this.simulator;
+        const bike = this.simulator.bikes[this.simulator.selectedBike];
+        const { person, bikeType } = bike;
+        const { personNo, weight } = person;
+        const bikeNo = payload.readUInt8(0);
+        const isPedalling = this.simulator.isPedalling() + 128;
+        let speed, power;
+        speed = calculations_1.default.calculateSpeedDaum(gear, cadence, bikeType);
+        if (isPowerMode) {
+            power = currentPower;
+        }
+        else {
+            power = calculations_1.default.calculatePower(weight + 10, speed / 3.6, slope, { bikeType });
+        }
+        if (power < 25)
+            power = 25;
+        if (cadence === 0)
+            power = 0;
+        power = Math.round(power / 5);
+        const dist1 = distance / 1000 - Math.floor(distance / 1000 / 256);
+        const dist2 = Math.floor(distance / 1000 / 256);
+        if (bikeNo >= 0 && bikeNo < 10) {
+            const response = Buffer.from([0x40, bikeNo, progNo, personNo,
+                isPedalling, power, cadence, Math.floor(speed),
+                dist1, dist2, 0, 0, 0, 0, heartrate, 0, gear, 0, 0
+            ]);
+            this.emitData(response);
+        }
+    }
+    onSetGear(payload) {
+        const bikeNo = payload.readUInt8(0);
+        const gear = payload.readUInt8(1);
+        if (bikeNo >= 0 && bikeNo < 10) {
+            this.simulator.gear = gear;
+            const response = Buffer.from([0x53, bikeNo, gear]);
+            this.emitData(response);
+        }
+    }
+    onSetPower(payload) {
+        const bikeNo = payload.readUInt8(0);
+        const power = payload.readUInt8(1);
+        if (bikeNo >= 0 && bikeNo < 10) {
+            this.simulator.targetPower = power;
+            this.simulator.isPowerMode = true;
+            setTimeout(() => { this.simulator.currentPower = power; }, 1000);
+            const response = Buffer.from([0x51, bikeNo, power]);
+            this.emitData(response);
+        }
+    }
+    onSetSlope(payload) {
+        const bike = this.simulator.bikes[this.simulator.selectedBike];
+        const { person } = bike;
+        const { personNo } = person;
+        const { currentPower, cadence } = this.simulator;
+        const bikeNo = payload.readUInt8(0);
+        const slope = payload.readFloatLE(1);
+        const retVal0 = payload.readUInt8(1);
+        const isPedalling = this.simulator.isPedalling() + 128;
+        const power = cadence > 0 ? Math.floor(currentPower / 5) : 0;
+        if (bikeNo >= 0 && bikeNo < 10) {
+            this.simulator.slope = slope;
+            this.simulator.isPowerMode = false;
+            const response = Buffer.from([0x55, bikeNo, retVal0, personNo, isPedalling, power]);
+            this.emitData(response);
+        }
+    }
+}
+exports.DaumClassicMockBinding = DaumClassicMockBinding;

package/lib/{daum/classic/DaumClassicCyclingMode.d.ts → serial/daum/classic/modes/daum-classic.d.ts}

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

package/lib/{daum/classic/DaumClassicCyclingMode.js → serial/daum/classic/modes/daum-classic.js}

@@ -4,8 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const gd_eventlog_1 = require("gd-eventlog");
-const cycling_mode_1 = require("../../cycling-mode");
-const SmartTrainerCyclingMode_1 = __importDefault(require("../SmartTrainerCyclingMode"));
+const cycling_mode_1 = require("../../../../modes/cycling-mode");
+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",

package/lib/{daum → serial/daum}/classic/utils.d.ts

@@ -2,7 +2,7 @@ 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): 1 | 0;
+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;

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

@@ -0,0 +1,25 @@
+import { DeviceProperties } from '../../../types/device';
+import { SerialDeviceSettings } from '../../adapter';
+import { SerialCommProps } from '../../comm';
+import DaumAdapter from '../DaumAdapter';
+import { Daum8iDeviceProperties } from './types';
+export default class DaumPremiumAdapter extends DaumAdapter {
+    static NAME: string;
+    commProps: SerialCommProps;
+    _startRetryTimeout: number;
+    constructor(settings: SerialDeviceSettings, props?: DeviceProperties);
+    getName(): string;
+    getUniqueName(): string;
+    getPort(): any;
+    getInterface(): string;
+    getProtocolName(): string;
+    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>;
+}