incyclist-devices 1.4.2 → 1.4.5

package/lib/CyclingMode.d.ts

@@ -31,7 +31,6 @@ export declare type IncyclistBikeData = {
     pedalRpm: number;
     speed: number;
     heartrate: number;
-    distance: number;
     distanceInternal: number;
     time?: number;
     gear?: number;

package/lib/Device.d.ts

@@ -1,6 +1,17 @@
 import { DeviceProtocol, Device } from './DeviceProtocol';
 import CyclingMode from './CyclingMode';
-export declare type OnDeviceDataCallback = (data: any) => void;
+export declare type DeviceData = {
+    speed?: number;
+    slope?: number;
+    power?: number;
+    cadence?: number;
+    heartrate?: number;
+    distance?: number;
+    timestamp?: number;
+    deviceTime?: number;
+    deviceDistanceCounter?: number;
+};
+export declare type OnDeviceDataCallback = (data: DeviceData) => void;
 export interface Bike {
     setCyclingMode(mode: CyclingMode | string, settings?: any): void;
     getSupportedCyclingModes(): Array<any>;

package/lib/daum/DaumAdapter.d.ts

@@ -1,6 +1,6 @@
 import { EventLogger } from 'gd-eventlog';
-import CyclingMode from '../CyclingMode';
-import DeviceAdapterBase, { Bike, DeviceAdapter } from '../Device';
+import CyclingMode, { IncyclistBikeData } from '../CyclingMode';
+import DeviceAdapterBase, { Bike, DeviceAdapter, DeviceData } from '../Device';
 import { User } from '../types/user';
 interface DaumAdapter {
     getCurrentBikeData(): Promise<any>;
@@ -13,7 +13,8 @@ export default class DaumAdapterBase extends DeviceAdapterBase implements Device
     distanceInternal: number;
     paused: boolean;
     stopped: boolean;
-    data: any;
+    daumRunData: IncyclistBikeData;
+    deviceData: DeviceData;
     currentRequest: any;
     requests: Array<any>;
     iv: any;
@@ -56,7 +57,7 @@ export default class DaumAdapterBase extends DeviceAdapterBase implements Device
     sendRequests(): Promise<void>;
     bikeSync(): Promise<void>;
     updateData(prev: any, bikeData: any): void;
-    transformData(): void;
+    transformData(): DeviceData;
     sendRequest(request: any): Promise<any>;
     refreshRequests(): void;
     processClientRequest(request: any): Promise<unknown>;

package/lib/daum/DaumAdapter.js

@@ -29,7 +29,16 @@ class DaumAdapterBase extends Device_1.default {
         this.bike = bike;
         this.stopped = false;
         this.paused = false;
-        this.data = {};
+        this.daumRunData = {
+            isPedalling: false,
+            time: 0,
+            power: 0,
+            pedalRpm: 0,
+            speed: 0,
+            distanceInternal: 0,
+            heartrate: 0
+        };
+        this.deviceData = {};
         const options = props || {};
         this.cyclingMode = options.cyclingMode;
         this.setUserSettings(options.userSettings);
@@ -114,15 +123,16 @@ class DaumAdapterBase extends Device_1.default {
         this.distanceInternal = undefined;
         this.paused = false;
         this.stopped = false;
-        this.data = {
-            time: 0,
-            slope: 0,
-            distance: 0,
-            speed: 0,
+        this.daumRunData = {
             isPedalling: false,
+            time: 0,
             power: 0,
-            distanceInternal: 0
+            pedalRpm: 0,
+            speed: 0,
+            distanceInternal: 0,
+            heartrate: 0
         };
+        this.deviceData = {};
         this.currentRequest = {};
         this.requests = [];
         const name = this.getCyclingMode().getName();
@@ -200,14 +210,14 @@ class DaumAdapterBase extends Device_1.default {
     }
     sendData() {
         if (this.onDataFn)
-            this.onDataFn(this.data);
+            this.onDataFn(this.deviceData);
     }
     update() {
         return __awaiter(this, void 0, void 0, function* () {
             this.updateBusy = true;
             this.getCurrentBikeData()
                 .then(bikeData => {
-                this.updateData(this.data, bikeData);
+                this.updateData(this.daumRunData, bikeData);
                 this.transformData();
                 this.updateBusy = false;
             })
@@ -262,35 +272,32 @@ class DaumAdapterBase extends Device_1.default {
         data.pedalRpm = bikeData.cadence;
         data.speed = bikeData.speed;
         data.heartrate = bikeData.heartrate;
-        data.distance = bikeData.distance / 100;
-        data.distanceInternal = bikeData.distance;
+        data.distanceInternal = bikeData.distanceInternal;
         data.gear = bikeData.gear;
-        if (this.tsPrevData && data.isPedalling) {
-            this.adapterTime = Date.now() - this.tsPrevData;
-        }
-        this.tsPrevData = Date.now();
-        data.time = Math.round(this.adapterTime || 0);
+        data.time = bikeData.time;
         if (bikeData.slope)
             data.slope = bikeData.slope;
-        this.data = this.getCyclingMode().updateData(data);
+        this.daumRunData = this.getCyclingMode().updateData(data);
     }
     transformData() {
-        if (this.data === undefined)
+        if (this.daumRunData === undefined)
             return;
         let distance = 0;
-        if (this.distanceInternal !== undefined && this.data.distanceInternal !== undefined) {
-            distance = (0, utils_1.intVal)(this.data.distanceInternal - this.distanceInternal);
+        if (this.distanceInternal !== undefined && this.daumRunData.distanceInternal !== undefined) {
+            distance = (0, utils_1.intVal)(this.daumRunData.distanceInternal - this.distanceInternal);
         }
-        if (this.data.distanceInternal !== undefined)
-            this.distanceInternal = this.data.distanceInternal;
+        if (this.daumRunData.distanceInternal !== undefined)
+            this.distanceInternal = this.daumRunData.distanceInternal;
         let data = {
-            speed: (0, utils_1.floatVal)(this.data.speed),
-            slope: (0, utils_1.floatVal)(this.data.slope),
-            power: (0, utils_1.intVal)(this.data.power),
-            cadence: (0, utils_1.intVal)(this.data.pedalRpm),
-            heartrate: (0, utils_1.intVal)(this.data.heartrate),
+            speed: (0, utils_1.floatVal)(this.daumRunData.speed),
+            slope: (0, utils_1.floatVal)(this.daumRunData.slope),
+            power: (0, utils_1.intVal)(this.daumRunData.power),
+            cadence: (0, utils_1.intVal)(this.daumRunData.pedalRpm),
+            heartrate: (0, utils_1.intVal)(this.daumRunData.heartrate),
             distance,
-            timestamp: Date.now()
+            timestamp: Date.now(),
+            deviceTime: this.daumRunData.time,
+            deviceDistanceCounter: this.daumRunData.distanceInternal
         };
         if (this.ignoreHrm)
             delete data.heartrate;
@@ -301,7 +308,7 @@ class DaumAdapterBase extends Device_1.default {
         if (this.ignoreBike) {
             data = { heartrate: data.heartrate };
         }
-        this.data = data;
+        this.deviceData = data;
     }
     sendRequest(request) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -331,10 +338,10 @@ class DaumAdapterBase extends Device_1.default {
         });
     }
     refreshRequests() {
-        if (!this.data.isPedalling || this.data.pedalRpm === 0)
+        if (!this.daumRunData.isPedalling || this.daumRunData.pedalRpm === 0)
             return;
-        let bikeRequest = this.getCyclingMode().sendBikeUpdate({ refresh: true });
-        const prev = this.requests[this.requests.length - 1];
+        let bikeRequest = this.getCyclingMode().sendBikeUpdate({ refresh: true }) || {};
+        const prev = this.requests[this.requests.length - 1] || {};
         if (bikeRequest.targetPower !== undefined && bikeRequest.targetPower !== prev.targetPower) {
             this.logEvent({ message: 'add request', request: bikeRequest });
             this.requests.push(bikeRequest);
@@ -342,7 +349,7 @@ class DaumAdapterBase extends Device_1.default {
     }
     processClientRequest(request) {
         if (request.slope !== undefined) {
-            this.data.slope = request.slope;
+            this.daumRunData.slope = request.slope;
         }
         return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
             let bikeRequest = this.getCyclingMode().sendBikeUpdate(request);

package/lib/daum/ERGCyclingMode.js

@@ -146,7 +146,6 @@ class ERGCyclingMode extends CyclingMode_1.CyclingModeBase {
             let speed;
             let m = this.adapter.getWeight();
             let distanceInternal = prevData.distanceInternal || 0;
-            let distance = Math.round(distanceInternal / 100);
             let ts = Date.now();
             let duration = this.prevUpdateTS === 0 ? 0 : ((ts - this.prevUpdateTS) / 1000);
             if (rpm === 0 || bikeData.isPedalling === false) {
@@ -157,12 +156,10 @@ class ERGCyclingMode extends CyclingMode_1.CyclingModeBase {
                 speed = calculations_1.default.calculateSpeed(m, power, slope, { bikeType });
                 let v = speed / 3.6;
                 distanceInternal += Math.round(v * duration);
-                distance = Math.round(distanceInternal / 100);
             }
             data.speed = parseFloat(speed.toFixed(1));
             data.power = Math.round(power);
             data.distanceInternal = Math.round(distanceInternal);
-            data.distance = distance;
             data.slope = slope;
             data.pedalRpm = rpm;
             data.gear = gear;

package/lib/daum/PowerMeterCyclingMode.js

@@ -64,7 +64,6 @@ class PowerMeterCyclingMode extends CyclingMode_1.CyclingModeBase {
             data.speed = parseFloat(speed.toFixed(1));
             data.power = Math.round(power);
             data.distanceInternal = Math.round(distanceInternal);
-            data.distance = Math.round(distanceInternal / 100);
             data.slope = slope;
             this.logger.logEvent({ message: "updateData result", data, bikeData, prevRequest: {}, prevSpeed: prevData.speed });
             this.data = JSON.parse(JSON.stringify(data));

package/lib/daum/classic/DaumClassicAdapter.js

@@ -104,7 +104,7 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
                         startState.startProg = true;
                     }
                     if (!startState.setGear) {
-                        yield this.bike.setGear(this.data.gear || (opts.gear || 10));
+                        yield this.bike.setGear(this.daumRunData.gear || (opts.gear || 10));
                         startState.setGear = true;
                     }
                     const startRequest = this.getCyclingMode().getBikeInitRequest();

package/lib/daum/classic/DaumClassicCyclingMode.js

@@ -84,7 +84,6 @@ class DaumClassicCyclingMode extends SmartTrainerCyclingMode_1.default {
             data.power = Math.round(power);
             data.slope = slope;
             data.distanceInternal = distanceInternal;
-            data.distance = Math.round(distanceInternal / 100);
             this.logger.logEvent({ message: "updateData result", data, bikeData, prevRequest: this.prevRequest || {}, prevSpeed: prevData.speed, event: this.event });
             this.data = JSON.parse(JSON.stringify(data));
             this.prevUpdateTS = ts;

package/lib/daum/classic/utils.js

@@ -123,7 +123,7 @@ function hexstr(arr, start, len) {
 }
 exports.hexstr = hexstr;
 function Float32ToHex(float32) {
-    function getHex(i) { return ('00' + i.toString(16)).slice(-2); }
+    function getHex(i) { return ('00' + i.toString(16)).slice(-2).toUpperCase(); }
     var view = new DataView(new ArrayBuffer(4));
     view.setFloat32(0, float32);
     return Array.apply(null, { length: 4 }).map((_, i) => getHex(view.getUint8(i))).join('');

package/lib/daum/premium/DaumClassicCyclingMode.js

@@ -55,19 +55,23 @@ class DaumClassicCyclingMode extends PowerMeterCyclingMode_1.default {
             let power = data.power || 0;
             let speed = data.speed || 0;
             let slope = (prevData.slope !== undefined ? prevData.slope : prevRequest.slope || 0);
-            let distanceInternal = prevData.distanceInternal || 0;
+            let distanceBike = data.distanceInternal || 0;
+            let distancePrev = prevData.distanceInternal || 0;
+            let distanceInternal = distanceBike;
+            let ts = Date.now();
             if (!bikeData.pedalRpm || bikeData.isPedalling === false) {
                 speed = 0;
                 power = 0;
             }
-            let ts = Date.now();
-            let v = speed / 3.6;
-            let duration = this.prevUpdateTS === 0 ? 0 : ((ts - this.prevUpdateTS) / 1000);
-            distanceInternal += Math.round(v * duration);
+            if (distanceBike < distancePrev) {
+                this.logger.logEvent({ message: '~~~ distance overflow', distanceBike, distancePrev });
+                let v = speed / 3.6;
+                let duration = this.prevUpdateTS === 0 ? 0 : ((ts - this.prevUpdateTS) / 1000);
+                distanceInternal = distancePrev + Math.round(v * duration);
+            }
             data.speed = parseFloat(speed.toFixed(1));
             data.power = Math.round(power);
             data.distanceInternal = Math.round(distanceInternal);
-            data.distance = Math.round(distanceInternal / 100);
             data.slope = slope;
             this.logger.logEvent({ message: "updateData result", data, bikeData, prevRequest: {}, prevSpeed: prevData.speed });
             this.data = JSON.parse(JSON.stringify(data));

package/lib/daum/premium/DaumPremiumAdapter.js

@@ -111,8 +111,11 @@ class DaumPremiumDevice extends DaumAdapter_1.default {
                     else {
                         info.person = true;
                     }
-                    const gear = yield this.bike.setGear(this.data.gear || (opts.gear || 10));
-                    return gear;
+                    if (!this.getCyclingMode().getModeProperty('eppSupport')) {
+                        const gear = yield this.bike.setGear(this.daumRunData.gear || (opts.gear || 10));
+                        return gear;
+                    }
+                    return;
                 }
                 catch (err) {
                     console.error(err);

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

@@ -78,7 +78,7 @@ declare class Daum8i {
         heartrate: number;
         speed: number;
         slope: number;
-        distance: number;
+        distanceInternal: number;
         cadence: number;
         power: number;
         physEnergy: number;

package/lib/daum/premium/bike.js

@@ -592,7 +592,6 @@ class Daum8i {
             .then((res) => {
             const resData = Uint8Array.from(res, x => x.charCodeAt(0));
             const cmd = (0, utils_1.esc2bin)(resData);
-            console.log('~~~ cmd', cmd);
             return cmd;
         });
     }
@@ -711,17 +710,27 @@ class Daum8i {
         });
     }
     setPerson(person) {
+        this.logger.logEvent({ message: 'setPerson() request' });
         return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PERSON_SET, 'BF', (0, utils_1.getPersonData)(person))
             .then((res) => {
             const buffer = Buffer.from(res);
-            return buffer.readInt16LE(0) === utils_1.ReservedCommands.PERSON_SET;
+            const success = buffer.readInt16LE(0) === utils_1.ReservedCommands.PERSON_SET;
+            this.logger.logEvent({ message: 'setPerson() response', success, buffer });
+            if (!success)
+                throw new Error('Illegal Response');
+            return true;
         });
     }
     programUploadInit() {
+        this.logger.logEvent({ message: 'programUploadInit() request' });
         return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PROGRAM_LIST_BEGIN, 'BF')
             .then((res) => {
             const buffer = Buffer.from(res);
-            return buffer.readInt16LE(0) === utils_1.ReservedCommands.PROGRAM_LIST_BEGIN;
+            const success = buffer.readInt16LE(0) === utils_1.ReservedCommands.PROGRAM_LIST_BEGIN;
+            this.logger.logEvent({ message: 'programUploadInit() response', success, buffer });
+            if (!success)
+                throw new Error('Illegal Response');
+            return true;
         });
     }
     programUploadStart(bikeType, route) {
@@ -741,12 +750,15 @@ class Daum8i {
         payload.writeInt16LE(0, 30);
         payload.writeInt32LE(7, 32);
         payload.writeInt32LE(epp.length, 36);
+        this.logger.logEvent({ message: 'programUploadStart() request' });
         return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PROGRAM_LIST_NEW_PROGRAM, 'BF', payload)
             .then((res) => {
             const buffer = Buffer.from(res);
             if (buffer.readInt16LE(0) === utils_1.ReservedCommands.PROGRAM_LIST_NEW_PROGRAM) {
+                this.logger.logEvent({ message: 'programUploadStart() response', success: true });
                 return epp;
             }
+            this.logger.logEvent({ message: 'programUploadStart() response', success: false });
             throw new Error('Illegal Response');
         });
     }
@@ -760,23 +772,31 @@ class Daum8i {
         payload.writeInt32LE(offset, 4);
         const chunk = Buffer.from(epp.slice(offset, offset + size));
         chunk.copy(payload, 8);
+        this.logger.logEvent({ message: 'programUploadSendBlock() request', offset, size });
         return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PROGRAM_LIST_CONTINUE_PROGRAM, 'BF', payload)
             .then((res) => {
             const buffer = Buffer.from(res);
             let success = buffer.readInt16LE(0) === utils_1.ReservedCommands.PROGRAM_LIST_CONTINUE_PROGRAM;
-            console.log('~~ Buffer', buffer, buffer.readInt16LE(2), buffer.readInt8(4));
             success = success && (buffer.readInt16LE(2) === 1);
             success = success && (buffer.readInt8(4) === 1);
+            this.logger.logEvent({ message: 'programUploadSendBlock() response' });
             if (!success)
                 throw new Error('Illegal Response');
-            return success;
+            return true;
+            ;
         });
     }
     programUploadDone() {
+        this.logger.logEvent({ message: 'programUploadDone() request' });
         return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PROGRAM_LIST_END, 'BF')
             .then((res) => {
             const buffer = Buffer.from(res);
-            return buffer.readInt16LE(0) === utils_1.ReservedCommands.PROGRAM_LIST_END;
+            const success = buffer.readInt16LE(0) === utils_1.ReservedCommands.PROGRAM_LIST_END;
+            this.logger.logEvent({ message: 'programUploadDone() response', success });
+            if (!success)
+                throw new Error('Illegal Response');
+            return true;
+            ;
         });
     }
     programUpload(bikeType, route) {
@@ -800,10 +820,16 @@ class Daum8i {
     startProgram(programId = 1) {
         const payload = Buffer.alloc(2);
         payload.writeInt16LE(programId, 0);
+        this.logger.logEvent({ message: 'startProgram() request', programId });
         return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PROGRAM_LIST_START, 'BF', payload)
             .then((res) => {
             const buffer = Buffer.from(res);
-            return buffer.readInt16LE(0) === utils_1.ReservedCommands.PROGRAM_LIST_START;
+            const success = buffer.readInt16LE(0) === utils_1.ReservedCommands.PROGRAM_LIST_START;
+            this.logger.logEvent({ message: 'startProgram() request', programId, success });
+            if (!success)
+                throw new Error('Illegal Response');
+            return true;
+            ;
         });
     }
     setGear(gear) {

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

@@ -49,7 +49,7 @@ export declare function parseTrainingData(payload: any): {
     heartrate: number;
     speed: number;
     slope: number;
-    distance: number;
+    distanceInternal: number;
     cadence: number;
     power: number;
     physEnergy: number;

package/lib/daum/premium/utils.js

@@ -258,9 +258,9 @@ function routeToEpp(route, date) {
     let offset = 0;
     const name = route.name || '';
     const description = route.description || '';
-    const minElevation = Math.min(...route.points.map(p => p.elevation));
-    const maxElevation = Math.max(...route.points.map(p => p.elevation));
-    const sampleRate = route.points.length !== 0 ? route.totalDistance / route.points.length : 0;
+    const minElevation = route.minElevation ? route.minElevation : 0;
+    const maxElevation = route.maxElevation ? route.minElevation : Math.max(...route.points.map(p => p.elevation));
+    const sampleRate = route.points.length !== 0 ? Math.round(route.totalDistance / route.points.length) : 0;
     buffer.writeUInt32LE(fileTime.low, offset);
     offset += 4;
     buffer.writeUInt32LE(fileTime.high, offset);
@@ -314,9 +314,9 @@ function parseTrainingData(payload) {
     const data = {
         time: parseInt(vals[0]),
         heartrate: parseInt(vals[1]),
-        speed: parseFloat(vals[2]),
+        speed: parseFloat(vals[2]) * 3.6,
         slope: parseFloat(vals[3]),
-        distance: parseInt(vals[4]),
+        distanceInternal: parseInt(vals[4]),
         cadence: parseFloat(vals[5]),
         power: parseInt(vals[6]),
         physEnergy: parseFloat(vals[7]),

package/lib/types/route.d.ts

@@ -18,4 +18,7 @@ export declare type Route = {
     description?: string;
     lapMode: boolean;
     totalDistance: number;
+    minElevation?: number;
+    maxElevation?: number;
+    sampleRate?: number;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-devices",
-  "version": "1.4.2",
+  "version": "1.4.5",
   "dependencies": {
     "@serialport/parser-byte-length": "^9.0.1",
     "@serialport/parser-delimiter": "^9.0.1",