incyclist-devices 1.5.38 → 2.0.0-beta.1

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,24 @@
+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;
+    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>;
+}

package/lib/{daum/premium/DaumPremiumAdapter.js → serial/daum/premium/adapter.js}

@@ -13,19 +13,49 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const gd_eventlog_1 = require("gd-eventlog");
-const utils_1 = require("../../utils");
+const device_1 = require("../../../types/device");
+const __1 = require("../..");
+const serial_interface_1 = require("../../serial-interface");
+const utils_1 = require("../../../utils/utils");
 const DaumAdapter_1 = __importDefault(require("../DaumAdapter"));
-const DaumClassicCyclingMode_1 = __importDefault(require("./DaumClassicCyclingMode"));
+const comms_1 = __importDefault(require("./comms"));
+const daum_classic_1 = __importDefault(require("./modes/daum-classic"));
 const PROTOCOL_NAME = "Daum Premium";
-class DaumPremiumDevice extends DaumAdapter_1.default {
-    constructor(protocol, bike) {
-        super(protocol, bike);
+const DAUM_PREMIUM_DEFAULT_PORT = 51955;
+const START_RETRY_TIMEOUT = 1500;
+const DEFAULT_GEAR = 10;
+const getBikeProps = (props) => {
+    const { host, port = DAUM_PREMIUM_DEFAULT_PORT, interface: ifaceName } = props;
+    let serial;
+    if (ifaceName && typeof ifaceName === 'string') {
+        serial = __1.SerialInterface.getInstance({ ifaceName });
+    }
+    else {
+        serial = props.interface;
+    }
+    if (!serial || !serial.binding)
+        throw new Error(`unknonwn interface: ${ifaceName}`);
+    if (serial.getName() === serial_interface_1.SerialInterfaceType.TCPIP) {
+        const path = `${host}:${port}`;
+        return { serial, path };
+    }
+    else {
+        const path = `${port}`;
+        return { serial, path };
+    }
+};
+class DaumPremiumAdapter extends DaumAdapter_1.default {
+    constructor(settings, props) {
+        const logger = new gd_eventlog_1.EventLogger('DaumPremium');
+        const commProps = Object.assign(Object.assign({}, getBikeProps(settings)), { logger });
+        const bike = new comms_1.default(commProps);
+        super(settings, props);
+        this._startRetryTimeout = START_RETRY_TIMEOUT;
         this.bike = bike;
-        this.logger = new gd_eventlog_1.EventLogger('DaumPremium');
+        this.logger = logger;
         this.ignoreHrm = false;
         this.ignorePower = false;
         this.ignoreBike = false;
-        this.paused = undefined;
         this.iv = undefined;
         this.distanceInternal = undefined;
         this.initData();
@@ -37,30 +67,52 @@ class DaumPremiumDevice extends DaumAdapter_1.default {
         return this.bike.getPort();
     }
     getInterface() {
-        return this.bike.getInterface();
+        var _a;
+        return (_a = this.bike) === null || _a === void 0 ? void 0 : _a.getInterface();
+    }
+    getProtocolName() {
+        return PROTOCOL_NAME;
+    }
+    isEqual(settings) {
+        if (this.getInterface() === device_1.INTERFACE.TCPIP) {
+            const equal = super.isEqual(settings);
+            if (!equal)
+                return false;
+            const as = this.settings;
+            return (settings.host === as.host);
+        }
+        else {
+            return super.isEqual(settings);
+        }
     }
     getSupportedCyclingModes() {
         const supported = super.getSupportedCyclingModes();
-        supported.push(DaumClassicCyclingMode_1.default);
+        supported.push(daum_classic_1.default);
         return supported;
     }
     check() {
-        var info = {};
-        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: "check()", port: this.getPort() });
+        return __awaiter(this, void 0, void 0, function* () {
+            var info = {};
             if (this.isStopped())
-                reject(new Error("device is stopped"));
-            try {
-                if (!this.bike.isConnected())
-                    yield this.bike.saveConnect();
-                info.deviceType = yield this.bike.getDeviceType();
-                info.version = yield this.bike.getProtocolVersion();
-                resolve(info);
-            }
-            catch (err) {
-                reject(err);
-            }
-        }));
+                return false;
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                this.logger.logEvent({ message: "checking device", port: this.getPort() });
+                try {
+                    const connected = yield this.connect();
+                    if (!connected)
+                        resolve(false);
+                    info.deviceType = yield this.bike.getDeviceType();
+                    info.version = yield this.bike.getProtocolVersion();
+                    yield this.bike.close();
+                    this.logger.logEvent({ message: "checking device success", port: this.getPort(), info });
+                    resolve(true);
+                }
+                catch (err) {
+                    this.logger.logEvent({ message: "checking device failed", port: this.getPort(), reason: err.message || err });
+                    resolve(false);
+                }
+            }));
+        });
     }
     pause() {
         const _super = Object.create(null, {
@@ -82,7 +134,7 @@ class DaumPremiumDevice extends DaumAdapter_1.default {
             return resumed;
         });
     }
-    startRide(props) {
+    startRide(props = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             this.logger.logEvent({ message: 'relaunch of device' });
             try {
@@ -95,7 +147,7 @@ class DaumPremiumDevice extends DaumAdapter_1.default {
             }
         });
     }
-    start(props) {
+    start(props = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             this.logger.logEvent({ message: 'initial start of device' });
             try {
@@ -108,15 +160,11 @@ class DaumPremiumDevice extends DaumAdapter_1.default {
             }
         });
     }
-    launch(props, isRelaunch = false) {
+    launch(props = {}, isRelaunch = false) {
         return __awaiter(this, void 0, void 0, function* () {
-            const opts = props || {};
-            if (opts.user && opts.user.weight)
-                this.userSettings.weight = opts.user.weight;
-            if (opts.bikeSettings && opts.bikeSettings.weight)
-                this.bikeSettings.weight = opts.bikeSettings.weight;
-            const user = opts.user || this.userSettings;
-            const route = opts.route;
+            this.setBikeProps(props);
+            const user = this.user;
+            const { route, onStatusUpdate, gear } = props;
             var info = {};
             this.initData();
             if (isRelaunch) {
@@ -124,9 +172,7 @@ class DaumPremiumDevice extends DaumAdapter_1.default {
             }
             return (0, utils_1.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () {
                 try {
-                    if (!isRelaunch && !this.bike.isConnected()) {
-                        yield this.bike.saveConnect();
-                    }
+                    yield this.connect();
                     if (!info.deviceType) {
                         info.deviceType = yield this.bike.getDeviceType();
                     }
@@ -135,27 +181,32 @@ class DaumPremiumDevice extends DaumAdapter_1.default {
                     }
                     if (this.getCyclingMode().getModeProperty('eppSupport')) {
                         const bikeType = this.getCyclingMode().getSetting('bikeType');
-                        if (!info.upload)
-                            info.upload = yield this.bike.programUpload(bikeType, route, props.onStatusUpdate);
+                        if (!info.upload) {
+                            info.upload = yield this.bike.programUpload(bikeType, route, onStatusUpdate);
+                            if (!info.upload)
+                                throw new Error('Epp Upload failed');
+                        }
                         if (!info.started) {
                             const programId = route ? route.programId : 0;
                             info.started = yield this.bike.startProgram(programId);
+                            if (!info.started) {
+                                throw new Error('Epp start failed');
+                            }
                         }
                     }
                     if (!info.person && this.getCyclingMode().getModeProperty('setPersonSupport')) {
                         info.person = yield this.bike.setPerson(user);
                     }
                     if (!this.getCyclingMode().getModeProperty('eppSupport')) {
-                        const gear = yield this.bike.setGear(this.cyclingData.gear || (opts.gear || 10));
-                        return gear;
+                        info.gear = yield this.bike.setGear(this.cyclingData.gear || gear || DEFAULT_GEAR);
                     }
                     return;
                 }
                 catch (err) {
                     throw (new Error(`could not start device, reason:${err.message}`));
                 }
-            }), 5, 1500)
-                .then(data => {
+            }), 5, this._startRetryTimeout)
+                .then(() => {
                 this.stopped = false;
                 this.paused = false;
                 this.startUpdatePull();
@@ -166,11 +217,13 @@ class DaumPremiumDevice extends DaumAdapter_1.default {
     getCurrentBikeData() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.bike.isConnected()) {
-                yield this.bike.saveConnect();
+                const connected = yield this.bike.connect();
+                if (!connected)
+                    return;
             }
             return this.getBike().getTrainingData();
         });
     }
 }
-exports.default = DaumPremiumDevice;
-DaumPremiumDevice.NAME = PROTOCOL_NAME;
+exports.default = DaumPremiumAdapter;
+DaumPremiumAdapter.NAME = PROTOCOL_NAME;