incyclist-devices 1.4.3 → 1.4.6

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,18 @@
 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 declare type OnDeviceStartCallback = (completed: number, total: number) => 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,16 +156,14 @@ 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.distanceInternal = distanceInternal;
             data.slope = slope;
             data.pedalRpm = rpm;
             data.gear = gear;
-            if (data.time)
+            if (data.time !== undefined)
                 data.time += duration;
             else
                 data.time = 0;

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

@@ -64,6 +64,7 @@ class DaumClassicCyclingMode extends PowerMeterCyclingMode_1.default {
                 power = 0;
             }
             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);
@@ -71,7 +72,6 @@ class DaumClassicCyclingMode extends PowerMeterCyclingMode_1.default {
             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.d.ts

@@ -1,4 +1,3 @@
-import { Route } from '../../types/route';
 import DaumAdapter from '../DaumAdapter';
 export default class DaumPremiumDevice extends DaumAdapter {
     static NAME: string;
@@ -8,7 +7,6 @@ export default class DaumPremiumDevice extends DaumAdapter {
     getInterface(): any;
     getSupportedCyclingModes(): Array<any>;
     check(): Promise<unknown>;
-    initClassic(route: Route): Promise<boolean>;
     start(props: any): Promise<unknown>;
     getCurrentBikeData(): Promise<any>;
 }

package/lib/daum/premium/DaumPremiumAdapter.js

@@ -62,20 +62,6 @@ class DaumPremiumDevice extends DaumAdapter_1.default {
             }
         }));
     }
-    initClassic(route) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!route)
-                return true;
-            let res;
-            const bikeType = this.getCyclingMode().getSetting('bikeType');
-            res = yield this.bike.programUpload(bikeType, route);
-            if (!res)
-                return false;
-            res = yield this.bike.startProgram(route.programId);
-            if (!res)
-                return false;
-        });
-    }
     start(props) {
         return __awaiter(this, void 0, void 0, function* () {
             this.logger.logEvent({ message: 'start()' });
@@ -99,26 +85,27 @@ class DaumPremiumDevice extends DaumAdapter_1.default {
                     if (!info.version) {
                         info.version = yield this.bike.getProtocolVersion();
                     }
-                    if (!info.init && this.getCyclingMode().getModeProperty('setPersonSupport')) {
-                        info.init = yield this.initClassic(route);
+                    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.started)
+                            info.started = yield this.bike.startProgram(route.programId);
                     }
-                    else {
-                        info.init = true;
-                    }
-                    if (!info.person && this.getCyclingMode().getModeProperty('eppSupport')) {
+                    if (!info.person && this.getCyclingMode().getModeProperty('setPersonSupport')) {
                         info.person = yield this.bike.setPerson(user);
                     }
-                    else {
-                        info.person = true;
+                    if (!this.getCyclingMode().getModeProperty('eppSupport')) {
+                        const gear = yield this.bike.setGear(this.daumRunData.gear || (opts.gear || 10));
+                        return gear;
                     }
-                    const gear = yield this.bike.setGear(this.data.gear || (opts.gear || 10));
-                    return gear;
+                    return;
                 }
                 catch (err) {
                     console.error(err);
                     throw (new Error(`could not start device, reason:${err.message}`));
                 }
-            }), 5, 1000)
+            }), 5, 1500)
                 .then(data => {
                 this.startUpdatePull();
                 return data;

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

@@ -4,6 +4,7 @@ import { Queue } from '../../utils';
 import { EventLogger } from 'gd-eventlog';
 import { User } from "../../types/user";
 import { Route } from "../../types/route";
+import { OnDeviceStartCallback } from "../../Device";
 declare class Daum8i {
     portName: string;
     logger: EventLogger;
@@ -78,7 +79,7 @@ declare class Daum8i {
         heartrate: number;
         speed: number;
         slope: number;
-        distance: number;
+        distanceInternal: number;
         cadence: number;
         power: number;
         physEnergy: number;
@@ -98,7 +99,7 @@ declare class Daum8i {
     programUploadStart(bikeType: BikeType, route: Route): Promise<Uint8Array>;
     programUploadSendBlock(epp: Uint8Array, offset: number): Promise<boolean>;
     programUploadDone(): Promise<boolean>;
-    programUpload(bikeType: BikeType, route: Route): Promise<boolean>;
+    programUpload(bikeType: BikeType, route: Route, onStatusUpdate?: OnDeviceStartCallback): Promise<boolean>;
     startProgram(programId?: number): Promise<boolean>;
     setGear(gear: any): Promise<number>;
     getGear(): Promise<number>;

package/lib/daum/premium/bike.js

@@ -710,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) {
@@ -740,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');
         });
     }
@@ -759,35 +772,48 @@ 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;
             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) {
+    programUpload(bikeType, route, onStatusUpdate) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.programUploadInit();
             const epp = yield this.programUploadStart(bikeType, route);
             let success = true;
             let done = false;
             let offset = 0;
+            if (onStatusUpdate)
+                onStatusUpdate(0, epp.length);
             while (success && !done) {
                 success = yield this.programUploadSendBlock(epp, offset);
                 offset += MAX_DATA_BLOCK_SIZE;
                 done = offset >= epp.length;
+                if (onStatusUpdate)
+                    onStatusUpdate(done ? epp.length : offset, epp.length);
             }
             if (done) {
                 return yield this.programUploadDone();
@@ -798,10 +824,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

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPersonData = exports.parseTrainingData = exports.routeToEpp = exports.getBikeType = exports.BikeType = exports.ReservedCommands = exports.Int32ToIntArray = exports.Int16ToIntArray = exports.Float32ToIntArray = exports.Float32ToHex = exports.getAsciiArrayFromStr = exports.asciiArrayToString = exports.charArrayToString = exports.ascii = exports.append = exports.getHex = exports.hexstr = exports.getMessageData = exports.buildMessage = exports.checkSum = exports.esc2bin = exports.bin2esc = void 0;
 const user_1 = require("../../types/user");
-const utils_1 = require("../classic/utils");
 const win32filetime_1 = __importDefault(require("win32filetime"));
 const sum = (arr) => arr.reduce((a, b) => a + b, 0);
 function bin2esc(arr) {
@@ -258,9 +257,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 +313,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]),
@@ -360,15 +359,15 @@ function getPersonData(user) {
     }
     buffer.writeInt32LE(user.sex === user_1.Gender.FEMALE ? 2 : 1, offset);
     offset += 4;
-    buffer.writeInt32LE(user.age !== undefined ? user.age : utils_1.DEFAULT_AGE, offset);
+    buffer.writeInt32LE(user.age !== undefined ? user.age : 1, offset);
     offset += 4;
-    buffer.writeInt32LE(user.length !== undefined ? user.length : 180, offset);
+    buffer.writeInt32LE(user.length !== undefined ? user.length : 175, offset);
     offset += 4;
-    buffer.writeFloatLE(user.weight !== undefined ? user.weight : utils_1.DEFAULT_USER_WEIGHT, offset);
+    buffer.writeFloatLE(user.weight !== undefined ? user.weight : 70, offset);
     offset += 4;
     buffer.writeFloatLE(0, offset);
     offset += 4;
-    buffer.writeUInt32LE(0, offset);
+    buffer.writeUInt32LE(1, offset);
     offset += 4;
     return buffer;
 }

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.3",
+  "version": "1.4.6",
   "dependencies": {
     "@serialport/parser-byte-length": "^9.0.1",
     "@serialport/parser-delimiter": "^9.0.1",