incyclist-devices 1.3.0 → 1.4.1

package/lib/daum/classic/bike.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const indoorbike_js_1 = require("../indoorbike.js");
 const gd_eventlog_1 = require("gd-eventlog");
 const utils_1 = require("./utils");
 const utils_2 = require("../../utils");
@@ -9,10 +8,10 @@ const nop = () => { };
 const TIMEOUT_START = 15000;
 const TIMEOUT_CLOSE = 5000;
 const TIMEOUT_SEND = 2000;
-var SerialPort = undefined;
+var __SerialPort = undefined;
 class Daum8008 {
     constructor(opts = {}) {
-        this.logger = new gd_eventlog_1.EventLogger('DaumClassic');
+        this.logger = opts.logger || new gd_eventlog_1.EventLogger('DaumClassic');
         this.portName = opts.port || process.env.COM_PORT;
         this.settings = opts.settings || {};
         this.bikeData = {
@@ -20,7 +19,6 @@ class Daum8008 {
             bikeWeight: 10,
             maxPower: 800
         };
-        this.processor = new indoorbike_js_1.default(this, {});
         this.sp = undefined;
         this.error = undefined;
         this.opening = false;
@@ -31,7 +29,7 @@ class Daum8008 {
         this.queue = new utils_2.Queue();
     }
     static setSerialPort(spClass) {
-        SerialPort = spClass;
+        __SerialPort = spClass;
     }
     static getClassName() {
         return "Daum8008";
@@ -52,13 +50,13 @@ class Daum8008 {
         cb(200, user);
     }
     getUserWeight() {
-        if (this.settings === undefined || this.settings === null || this.settings.user === undefined || this.settings.user === null)
-            return utils_1.getWeight(undefined);
+        if (this.settings && this.settings.user && this.settings.user.weight)
+            return (0, utils_1.getWeight)(this.settings.user.weight);
         else
-            return utils_1.getWeight(this.settings.user.weight) - 10;
+            return (0, utils_1.getWeight)();
     }
     getBikeWeight() {
-        if (this.settings.weight) {
+        if (this.settings && this.settings.weight) {
             let m = this.settings.weight;
             if (m > 0 && m < 20)
                 return m;
@@ -74,19 +72,15 @@ class Daum8008 {
             if (this.sp === undefined) {
                 const settings = this.settings.port || {};
                 settings.autoOpen = false;
-                this.sp = new SerialPort(this.portName, settings);
+                this.sp = new __SerialPort(this.portName, settings);
                 this.sp.on('open', () => { this.onPortOpen(); });
                 this.sp.on('close', () => { this.onPortClose(); });
                 this.sp.on('error', (error) => { this.onPortError(error); });
-                this.firstOpen = true;
             }
-            else {
-                this.sp.open();
-            }
-            this.sp.open();
             this.cmdBusy = true;
             this.opening = true;
             this.closed = undefined;
+            this.sp.open();
         }
         catch (err) {
             this.logger.logEvent({ message: "startTraining:error:", error: err.message });
@@ -99,18 +93,26 @@ class Daum8008 {
                 return resolve(true);
             }
             this.connect();
-            const tTimeout = Date.now() + TIMEOUT_START;
+            const timeoutStart = this.settings.timeoutStart || TIMEOUT_START;
+            const tTimeout = Date.now() + timeoutStart;
             const iv = setInterval(() => {
                 if (this.isConnected()) {
+                    clearInterval(iv);
                     this.opening = false;
                     resolve(true);
-                    clearInterval(iv);
                 }
                 else {
+                    if (this.error) {
+                        clearInterval(iv);
+                        this.cmdBusy = false;
+                        reject(this.error);
+                        return;
+                    }
                     if (Date.now() > tTimeout) {
+                        clearInterval(iv);
                         this.opening = false;
+                        this.cmdBusy = false;
                         reject(new Error('timeout'));
-                        clearInterval(iv);
                     }
                 }
             }, 100);
@@ -123,25 +125,31 @@ class Daum8008 {
         }
         var serialPort = this.sp;
         this.closing = true;
-        if (this.queue !== undefined)
-            this.queue.clear();
         if (this.bikeCmdWorker !== undefined) {
             clearInterval(this.bikeCmdWorker);
             this.bikeCmdWorker = undefined;
         }
+        if (this.queue !== undefined)
+            this.queue.clear();
         let connected = this.connected;
         if (connected) {
             if (serialPort) {
                 serialPort.unpipe();
                 serialPort.flush();
-                serialPort.drain(() => {
+                if (this.cmdBusy) {
+                    serialPort.drain(() => {
+                        serialPort.close();
+                    });
+                }
+                else {
                     serialPort.close();
-                });
+                }
             }
         }
         else {
-            if (serialPort)
+            if (serialPort) {
                 serialPort.close();
+            }
         }
         this.cmdBusy = false;
     }
@@ -151,16 +159,14 @@ class Daum8008 {
             const tTimeout = Date.now() + TIMEOUT_CLOSE;
             const iv = setInterval(() => {
                 if (!this.closing || this.closed) {
-                    resolve(true);
                     clearInterval(iv);
+                    resolve(true);
                 }
                 else {
-                    if (this.sp)
-                        this.sp.close();
                     if (Date.now() > tTimeout) {
+                        clearInterval(iv);
                         this.closing = false;
                         reject(new Error('timeout'));
-                        clearInterval(iv);
                     }
                 }
             }, 100);
@@ -175,9 +181,6 @@ class Daum8008 {
         if (this.cmdStart !== undefined) {
             this.cmdStart = Date.now();
         }
-        if (this.firstOpen !== undefined) {
-            this.firstOpen = undefined;
-        }
         this.cmdBusy = false;
     }
     onPortClose() {
@@ -231,7 +234,7 @@ class Daum8008 {
         if (this.connected && this.cmdBusy) {
             if (this.cmdCurrent !== undefined && this.cmdCurrent.start !== undefined) {
                 const cmdInfo = this.cmdCurrent;
-                const timeout = (cmdInfo.options && cmdInfo.options.timeout) ? cmdInfo.options.timeout : TIMEOUT_SEND;
+                const timeout = (cmdInfo.options && cmdInfo.options.timeout) ? cmdInfo.options.timeout : (this.settings.timeoutMessage || TIMEOUT_SEND);
                 let d = Date.now() - cmdInfo.start;
                 if (d > timeout) {
                     this.logger.logEvent({ message: 'sendCommmand:timeout', port: this.getPort() });
@@ -269,6 +272,8 @@ class Daum8008 {
             options: options
         };
         this.queue.enqueue(cmdInfo);
+        if (this.queue.size() > 1)
+            this.logger.logEvent({ message: "sendCommand:adding:", cmd: logStr, hex: (0, utils_1.hexstr)(payload), queueSize: this.queue.size() });
         if (this.bikeCmdWorker === undefined) {
             this.startWorker();
         }
@@ -287,7 +292,7 @@ class Daum8008 {
             const parser = serialPort.pipe(new ByteLength({ length: expected }));
             parser.on('data', (data) => {
                 let duration = Date.now() - this.cmdStart;
-                this.logger.logEvent({ message: "sendCommand:received:", duration, hex: utils_1.hexstr(data), port: this.getPort() });
+                this.logger.logEvent({ message: "sendCommand:received:", duration, hex: (0, utils_1.hexstr)(data), port: this.getPort() });
                 serialPort.unpipe();
                 if (callbackErr !== undefined) {
                     if (data[0] !== payload[0]) {
@@ -300,7 +305,7 @@ class Daum8008 {
                 callback(data);
                 done();
             });
-            this.logger.logEvent({ message: "sendCommand:sending:", cmd: logStr, hex: utils_1.hexstr(payload), port: this.getPort() });
+            this.logger.logEvent({ message: "sendCommand:sending:", cmd: logStr, hex: (0, utils_1.hexstr)(payload), port: this.getPort() });
             this.cmdCurrent.start = this.cmdStart = Date.now();
             serialPort.write(payload);
         }
@@ -312,50 +317,56 @@ class Daum8008 {
     }
     checkCockpit(bikeNo = 0) {
         return new Promise((resolve, reject) => {
-            this.sendDaum8008Command(`checkCockpit(${bikeNo})`, [0x10, bikeNo], 3, (data) => resolve({ bike: data[1], version: data[2] }), (status, err) => reject(utils_1.buildError(status, err)));
+            this.sendDaum8008Command(`checkCockpit(${bikeNo})`, [0x10, bikeNo], 3, (data) => resolve({ bike: data[1], version: data[2] }), (status, err) => {
+                if (status === 408)
+                    return resolve({ bike: bikeNo, version: undefined });
+                reject((0, utils_1.buildError)(status, err));
+            });
         });
     }
     getAddress() {
         return new Promise((resolve, reject) => {
-            this.sendDaum8008Command(`getAddress()`, [0x11], 2, (data) => resolve({ bike: data[1] }), (status, err) => reject(utils_1.buildError(status, err)));
+            this.sendDaum8008Command(`getAddress()`, [0x11], 2, (data) => resolve({ bike: data[1] }), (status, err) => reject((0, utils_1.buildError)(status, err)));
         });
     }
     getVersion(bikeNo = 0) {
         return new Promise((resolve, reject) => {
-            this.sendDaum8008Command(`getVersion(${bikeNo})`, [0x73, bikeNo], 11, (data) => resolve({ bike: data[1], serialNo: utils_1.hexstr(data, 2, 8), cockpit: utils_1.getCockpit(data[10]) }), (status, err) => reject(utils_1.buildError(status, err)));
+            this.sendDaum8008Command(`getVersion(${bikeNo})`, [0x73, bikeNo], 11, (data) => resolve({ bike: data[1], serialNo: (0, utils_1.hexstr)(data, 2, 8), cockpit: (0, utils_1.getCockpit)(data[10]) }), (status, err) => reject((0, utils_1.buildError)(status, err)));
         });
     }
     resetDevice(bikeNo = 0) {
         return new Promise((resolve, reject) => {
-            this.sendDaum8008Command(`resetDevice(${bikeNo})`, [0x12, bikeNo], 2, (data) => resolve({}), (status, err) => reject(utils_1.buildError(status, err)));
+            this.sendDaum8008Command(`resetDevice(${bikeNo})`, [0x12, bikeNo], 2, (data) => resolve({}), (status, err) => reject((0, utils_1.buildError)(status, err)));
         });
     }
     startProg(bikeNo = 0) {
         return new Promise((resolve, reject) => {
-            this.sendDaum8008Command(`startProg(${bikeNo})`, [0x21, bikeNo], 3, (data) => resolve({ bike: data[1], pedalling: data[2] > 0 }), (status, err) => reject(utils_1.buildError(status, err)));
+            this.sendDaum8008Command(`startProg(${bikeNo})`, [0x21, bikeNo], 3, (data) => resolve({ bike: data[1], pedalling: data[2] > 0 }), (status, err) => reject((0, utils_1.buildError)(status, err)));
         });
     }
     stopProg(bikeNo = 0) {
         return new Promise((resolve, reject) => {
-            this.sendDaum8008Command(`stopProg(${bikeNo})`, [0x22, bikeNo], 3, (data) => resolve({ bike: data[1], pedalling: data[2] !== 0 }), (status, err) => reject(utils_1.buildError(status, err)));
+            this.sendDaum8008Command(`stopProg(${bikeNo})`, [0x22, bikeNo], 3, (data) => resolve({ bike: data[1], pedalling: data[2] !== 0 }), (status, err) => reject((0, utils_1.buildError)(status, err)));
         });
     }
     setProg(progNo = 0, bikeNo = 0) {
         return new Promise((resolve, reject) => {
-            this.sendDaum8008Command(`setProg(${bikeNo},${progNo})`, [0x23, bikeNo, progNo], 4, (data) => resolve({ bike: data[1], progNo: data[2], pedalling: data[3] !== 0 }), (status, err) => reject(utils_1.buildError(status, err)));
+            this.sendDaum8008Command(`setProg(${bikeNo},${progNo})`, [0x23, bikeNo, progNo], 4, (data) => resolve({ bike: data[1], progNo: data[2], pedalling: data[3] !== 0 }), (status, err) => reject((0, utils_1.buildError)(status, err)));
         });
     }
     setBikeType(bikeType, bikeNo = 0) {
-        const bikeVal = utils_1.getBikeType(bikeType);
+        const bikeVal = (0, utils_1.getBikeType)(bikeType);
         return new Promise((resolve, reject) => {
-            this.sendDaum8008Command(`setBikeType(${bikeNo},${bikeType})`, [0x69, bikeNo, 0, 0, bikeVal], 3, (data) => resolve({}), (status, err) => reject(utils_1.buildError(status, err)));
+            this.sendDaum8008Command(`setBikeType(${bikeNo},${bikeType})`, [0x69, bikeNo, 0, 0, bikeVal], 3, (data) => resolve({}), (status, err) => reject((0, utils_1.buildError)(status, err)));
         });
     }
     setPerson(user = {}, bikeNo = 0) {
-        const age = user.age !== undefined ? user.age : utils_1.getAge(user.birthday);
-        const gender = utils_1.getGender(user.sex);
-        const length = utils_1.getLength(user.length);
-        const weight = utils_1.getWeight(user.weight) + 10;
+        const age = user.age !== undefined ? user.age : (0, utils_1.getAge)(user.birthday);
+        const gender = (0, utils_1.getGender)(user.sex);
+        const length = (0, utils_1.getLength)(user.length);
+        const maxPower = this.settings.maxPower === undefined ? 800 : this.settings.maxPower;
+        const mUser = user.weight || this.getUserWeight();
+        const weight = (0, utils_1.getWeight)(mUser) + this.getBikeWeight();
         var cmd = [0x24, bikeNo, 0];
         cmd.push(age);
         cmd.push(gender);
@@ -364,18 +375,40 @@ class Daum8008 {
         cmd.push(0);
         cmd.push(0);
         cmd.push(3);
-        cmd.push(800 / 5);
+        cmd.push(Math.round(maxPower / 5));
         cmd.push(0);
         cmd.push(0);
         cmd.push(0);
         cmd.push(0);
         return new Promise((resolve, reject) => {
-            this.sendDaum8008Command(`setPerson(${bikeNo},${age},${gender},${length},${weight})`, cmd, 16, (data) => resolve({ bike: data[1], age, gender, length, weight }), (status, err) => reject(utils_1.buildError(status, err)));
+            this.sendDaum8008Command(`setPerson(${bikeNo},${age},${gender},${length},${weight})`, cmd, 16, (data) => {
+                let ok = true;
+                cmd.forEach((v, i) => {
+                    if (data[i] !== v) {
+                        if (i === 10 && v >= 160) {
+                            if (data[i] === 0 || data[i] === 80)
+                                return;
+                        }
+                        reject((0, utils_1.buildError)(512, 'illegal response'));
+                        ok = false;
+                    }
+                });
+                if (ok)
+                    resolve({ bike: data[1], age, gender, length, weight });
+            }, (status, err) => reject((0, utils_1.buildError)(status, err)));
         });
     }
     runData(bikeNo = 0) {
         return new Promise((resolve, reject) => {
-            this.sendDaum8008Command(`runData(${bikeNo})`, [0x40, bikeNo], 19, (data) => resolve(utils_1.parseRunData(data)), (status, err) => reject(utils_1.buildError(status, err)));
+            this.sendDaum8008Command(`runData(${bikeNo})`, [0x40, bikeNo], 19, (data) => {
+                try {
+                    const parsed = (0, utils_1.parseRunData)(data);
+                    resolve(parsed);
+                }
+                catch (e) {
+                    reject((0, utils_1.buildError)(500, e));
+                }
+            }, (status, err) => reject((0, utils_1.buildError)(status, err)));
         });
     }
     setGear(gear, bikeNo = 0) {
@@ -385,7 +418,7 @@ class Daum8008 {
         if (gear > 28)
             gearVal = 28;
         return new Promise((resolve, reject) => {
-            this.sendDaum8008Command(`setGear(${bikeNo},${gearVal})`, [0x53, bikeNo, gearVal], 3, (data) => resolve({ bike: data[1], gear: data[2] }), (status, err) => reject(utils_1.buildError(status, err)));
+            this.sendDaum8008Command(`setGear(${bikeNo},${gearVal})`, [0x53, bikeNo, gearVal], 3, (data) => resolve({ bike: data[1], gear: data[2] }), (status, err) => reject((0, utils_1.buildError)(status, err)));
         });
     }
     setPower(power, bikeNo = 0) {
@@ -400,7 +433,7 @@ class Daum8008 {
             if (power > 800)
                 powerRequest = 800;
             const powerVal = Math.round(powerRequest / 5);
-            this.sendDaum8008Command(`setPower(${bikeNo},${power})`, [0x51, bikeNo, powerVal], 3, (data) => resolve({ bike: data[1], power: (data[2] * 5) }), (status, err) => reject(utils_1.buildError(status, err)));
+            this.sendDaum8008Command(`setPower(${bikeNo},${power})`, [0x51, bikeNo, powerVal], 3, (data) => resolve({ bike: data[1], power: (data[2] * 5) }), (status, err) => reject((0, utils_1.buildError)(status, err)));
         });
     }
     setSlope(slope, bikeNo = 0) {
@@ -410,12 +443,12 @@ class Daum8008 {
                 return;
             }
             const cmd = [0x55, bikeNo];
-            const arr = utils_1.Float32ToIntArray(slope);
+            const arr = (0, utils_1.Float32ToIntArray)(slope);
             cmd.push(arr[3]);
             cmd.push(arr[2]);
             cmd.push(arr[1]);
             cmd.push(arr[0]);
-            this.sendDaum8008Command(`setSlope(${bikeNo},${slope})`, cmd, 6, (data) => resolve({ bike: data[1], slope: slope }), (status, err) => reject(utils_1.buildError(status, err)));
+            this.sendDaum8008Command(`setSlope(${bikeNo},${slope})`, cmd, 6, (data) => resolve({ bike: data[1], slope: slope }), (status, err) => reject((0, utils_1.buildError)(status, err)));
         });
     }
 }

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

@@ -1,9 +1,9 @@
-export declare function getCockpit(c: any): "Cardio" | "Fitness" | "Vita De Luxe" | "8008" | "8080" | "Therapie" | "Unknown";
+export declare function getCockpit(c: any): "Cardio" | "Fitness" | "Vita De Luxe" | "8008" | "8008 TRS" | "8080" | "Therapie" | "8008 TRS Pro" | "8008 TRS3" | "Unknown";
 export declare function getBikeType(type: any): 1 | 0;
 export declare function getAge(birthday: any): number;
 export declare function getGender(sex: any): 1 | 2;
-export declare function getLength(length: any): any;
-export declare function getWeight(weight: any): any;
+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;

package/lib/daum/classic/utils.js

@@ -11,10 +11,16 @@ function getCockpit(c) {
             return "Vita De Luxe";
         case 40:
             return "8008";
+        case 0x2A:
+            return "8008 TRS";
         case 50:
             return "8080";
         case 60:
             return "Therapie";
+        case 100:
+            return "8008 TRS Pro";
+        case 160:
+            return "8008 TRS3";
         default:
             return "Unknown";
     }
@@ -64,25 +70,27 @@ function getGender(sex) {
 }
 exports.getGender = getGender;
 function getLength(length) {
-    if (length === undefined)
+    if (length === undefined || length === null)
         return 180;
-    length = Number.parseInt(length);
-    if (length < 100)
+    let l = Math.round(length);
+    if (l < 100)
         return 100;
-    if (length > 220)
+    if (l > 220)
         return 220;
-    return length;
+    return l;
 }
 exports.getLength = getLength;
 function getWeight(weight) {
-    if (weight === undefined)
+    if (weight === undefined || weight === null)
         return 80;
-    weight = Number.parseInt(weight);
-    if (weight < 10)
+    let m = Math.round(weight);
+    if (isNaN(m))
+        return 80;
+    if (m < 10)
         return 10;
-    if (weight > 250)
+    if (m > 250)
         return 250;
-    return weight;
+    return m;
 }
 exports.getWeight = getWeight;
 function parseRunData(data) {

package/lib/daum/indoorbike.d.ts

@@ -12,7 +12,8 @@ export default class IndoorBikeProcessor {
     lastUpdate: any;
     hasBikeUpdate: boolean;
     logger: EventLogger;
-    constructor(bike: any, opts: any);
+    constructor(bike: any, opts?: any);
+    reset(): void;
     setValues(data: any): any;
     isAccelMode(): any;
     getSlope(data: any): any;

package/lib/daum/indoorbike.js

@@ -1,6 +1,9 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const calculations_1 = require("../calculations");
+const calculations_1 = __importDefault(require("../calculations"));
 const gd_eventlog_1 = require("gd-eventlog");
 const constants_1 = require("./constants");
 const DEFAULT_BIKE_WEIGHT = 10;
@@ -9,6 +12,10 @@ class IndoorBikeProcessor {
     constructor(bike, opts) {
         const props = opts || {};
         this.bike = bike;
+        this.logger = props.logger || new gd_eventlog_1.EventLogger('IndoorBike');
+        this.reset();
+    }
+    reset() {
         this.prevTS = 0;
         this.prevDistance = 0;
         this.prevRpm = 0;
@@ -19,28 +26,28 @@ class IndoorBikeProcessor {
         this.prevSettings = undefined;
         this.hasBikeUpdate = false;
         this.lastUpdate = {};
-        this.logger = props.logger || new gd_eventlog_1.EventLogger('IndoorBike');
     }
     setValues(data) {
         this.logger.logEvent({ message: "setValues request", data, prev: this.prevSettings });
         try {
-            if (this.bike === undefined || this.bike.settings === undefined) {
-                this.logger.logEvent({ message: "setValues result (no bike)", data });
+            if (!data || data.reset || Object.keys(data).length === 0) {
+                this.prevSettings = undefined;
                 return data;
             }
             if (data.refresh) {
-                if (this.prevSettings !== undefined)
-                    return this.prevSettings;
+                if (this.prevSettings !== undefined) {
+                    data.slope = this.prevSettings.slope;
+                    data.targetPower = this.prevSettings.targetPower;
+                    data.minPower = this.prevSettings.minPower;
+                    data.maxPower = this.prevSettings.maxPower;
+                    return data;
+                }
                 else {
                     return this.caclulateTargetPower(data);
                 }
             }
             let updateMode = false;
             const isSlopeUpdate = data.slope !== undefined && Object.keys(data).length === 1;
-            if (data.slope === undefined && data.targetPower === undefined && data.minPower === undefined && data.maxPower === undefined) {
-                data.slope = this.prevSlope;
-                updateMode = true;
-            }
             if (data.targetPower !== undefined) {
                 data.slope = undefined;
                 this.bike.settings.targetPower = data.targetPower;
@@ -67,9 +74,6 @@ class IndoorBikeProcessor {
                         data.targetPower = data.minPower;
                     }
                 }
-                if (data.targetPower !== undefined) {
-                    this.bike.settings.targetPower = data.targetPower;
-                }
             }
             if (!isSlopeUpdate)
                 this.prevSettings = JSON.parse(JSON.stringify(data));
@@ -111,13 +115,13 @@ class IndoorBikeProcessor {
     getValues(data, props = {}) {
         this.logger.logEvent({ message: "getValues request", data });
         try {
-            let rpm = data.pedalRpm;
-            let gear = data.gear;
-            let power = data.power;
+            let rpm = data.pedalRpm || 0;
+            let gear = data.gear || 0;
+            let power = data.power || 0;
             let slope = this.getSlope(data);
-            let speed = data.speed;
+            let speed = data.speed || 0;
             let m = this.getWeight(props);
-            let distanceInternal = this.prevDistance;
+            let distanceInternal = this.prevDistance || 0;
             let distance = Math.round(distanceInternal / 100);
             let ts = Date.now();
             let duration = this.prevTS === 0 ? 0 : ((ts - this.prevTS) / 1000);
@@ -126,9 +130,7 @@ class IndoorBikeProcessor {
                 power = 0;
             }
             else {
-                if (duration > 0) {
-                    speed = calculations_1.default.calculateSpeed(m, power, slope);
-                }
+                speed = calculations_1.default.calculateSpeed(m, power, slope);
                 let v = speed / 3.6;
                 distanceInternal += Math.round(v * duration);
                 distance = Math.round(distanceInternal / 100);

package/lib/daum/premium/DaumPremiumAdapter.d.ts

@@ -4,8 +4,8 @@ export default class DaumPremiumDevice extends DaumAdapter {
     constructor(protocol: any, bike: any);
     getName(): string;
     getPort(): any;
+    getInterface(): any;
     check(): Promise<unknown>;
     start(props: any): Promise<unknown>;
-    getCurrentBikeData(): any;
-    updateData(data: any, bikeData: any): any;
+    getCurrentBikeData(): Promise<any>;
 }

package/lib/daum/premium/DaumPremiumAdapter.js

@@ -8,10 +8,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 });
 const gd_eventlog_1 = require("gd-eventlog");
 const utils_1 = require("../../utils");
-const DaumAdapter_1 = require("../DaumAdapter");
+const DaumAdapter_1 = __importDefault(require("../DaumAdapter"));
 const PROTOCOL_NAME = "Daum Premium";
 class DaumPremiumDevice extends DaumAdapter_1.default {
     constructor(protocol, bike) {
@@ -32,10 +35,15 @@ class DaumPremiumDevice extends DaumAdapter_1.default {
     getPort() {
         return this.bike.getPort();
     }
+    getInterface() {
+        return this.bike.getInterface();
+    }
     check() {
         var info = {};
         return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
             this.logger.logEvent({ message: "check()", port: this.getPort() });
+            if (this.isStopped())
+                reject(new Error("device is stopped"));
             try {
                 if (!this.bike.isConnected())
                     yield this.bike.saveConnect();
@@ -52,16 +60,28 @@ class DaumPremiumDevice extends DaumAdapter_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             this.logger.logEvent({ message: 'start()', props });
             const opts = props || {};
+            var info = {};
             this.initData();
-            return utils_1.runWithRetries(() => __awaiter(this, void 0, void 0, function* () {
+            return (0, utils_1.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () {
+                if (this.isStopped())
+                    return;
                 try {
+                    if (!this.bike.isConnected()) {
+                        yield this.bike.saveConnect();
+                    }
+                    if (!info.deviceType) {
+                        info.deviceType = yield this.bike.getDeviceType();
+                    }
+                    if (!info.version) {
+                        info.version = yield this.bike.getProtocolVersion();
+                    }
                     const gear = yield this.bike.setGear(this.data.gear || (opts.gear || 10));
                     return gear;
                 }
                 catch (err) {
-                    throw err;
+                    throw (new Error(`could not start device, reason:${err.message}`));
                 }
-            }), 3, 11000)
+            }), 5, 1000)
                 .then(data => {
                 this.startUpdatePull();
                 return data;
@@ -69,22 +89,12 @@ class DaumPremiumDevice extends DaumAdapter_1.default {
         });
     }
     getCurrentBikeData() {
-        return this.getBike().getTrainingData();
-    }
-    updateData(data, bikeData) {
-        data.isPedalling = bikeData.cadence > 0;
-        data.power = bikeData.power;
-        data.pedalRpm = bikeData.cadence;
-        data.speed = bikeData.speed;
-        data.heartrate = bikeData.heartrate;
-        data.distance = bikeData.distance / 1000;
-        data.distanceInternal = bikeData.distance;
-        data.time = bikeData.time;
-        data.gear = bikeData.gear;
-        if (this.bike.processor !== undefined) {
-            data = this.bike.processor.getValues(data);
-        }
-        return data;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.bike.isConnected()) {
+                yield this.bike.saveConnect();
+            }
+            return this.getBike().getTrainingData();
+        });
     }
 }
 exports.default = DaumPremiumDevice;

package/lib/daum/premium/DaumPremiumProtocol.d.ts

@@ -1,14 +1,21 @@
-import DeviceProtocol from '../../DeviceProtocol';
+import DeviceProtocolBase, { DeviceProtocol, DeviceSettings } from '../../DeviceProtocol';
 import { EventLogger } from 'gd-eventlog';
 export interface DaumPremiumProtocolState {
     activeScans: Array<any>;
     scanning: boolean;
     stopScanning?: boolean;
 }
-export default class DaumPremiumProtocol extends DeviceProtocol {
+interface DaumPremiumSettings extends DeviceSettings {
+    interface: string;
+}
+interface DaumPremiumTCPSettings extends DaumPremiumSettings {
+    host: string;
+}
+export default class DaumPremiumProtocol extends DeviceProtocolBase implements DeviceProtocol {
     state: DaumPremiumProtocolState;
     logger: EventLogger;
     constructor();
+    add(settings: DaumPremiumSettings | DaumPremiumTCPSettings): any;
     getName(): string;
     getInterfaces(): string[];
     isBike(): boolean;
@@ -18,6 +25,8 @@ export default class DaumPremiumProtocol extends DeviceProtocol {
     addDevice(DeviceClass: any, opts: any, portName: any): any;
     scanTcpip(opts: any): void;
     scanSerial(opts: any): void;
+    isScanning(): boolean;
     stopScan(): Promise<boolean>;
     scanCommand(device: any, opts: any): void;
 }
+export {};