incyclist-devices 1.4.23 → 1.4.26

package/lib/ant/antpwr/pwr-adapter.js

@@ -0,0 +1,248 @@
+"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 });
+const gd_eventlog_1 = require("gd-eventlog");
+const AntAdapter_1 = __importDefault(require("../AntAdapter"));
+const utils_1 = require("../utils");
+const power_meter_1 = __importDefault(require("../../modes/power-meter"));
+const floatVal = (d) => d ? parseFloat(d) : d;
+const intVal = (d) => d ? parseInt(d) : d;
+const hex = (v) => Math.abs(v).toString(16).toUpperCase();
+const DEFAULT_START_TIMEOUT = 5000;
+class AntFEAdapter extends AntAdapter_1.default {
+    constructor(DeviceID, port, stick, protocol) {
+        super(protocol);
+        this.logger = new gd_eventlog_1.EventLogger('Ant+PWR');
+        this.logger.logEvent({ message: 'Ant+PWR Adapter created', DeviceID, port });
+        this.deviceID = DeviceID;
+        this.port = port;
+        this.stick = stick;
+        this.deviceData = {
+            DeviceID
+        };
+        this.data = {};
+        this.started = false;
+        this.starting = false;
+        this.connected = false;
+        this.mode = this.getDefaultCyclingMode();
+    }
+    isBike() { return true; }
+    isHrm() { return false; }
+    isPower() { return true; }
+    getProfile() {
+        return 'Power Meter';
+    }
+    getName() {
+        return `Ant+PWR ${this.deviceID}`;
+    }
+    getDisplayName() {
+        const { DeviceID, ManId } = this.deviceData;
+        return `${(0, utils_1.getBrand)(ManId)} PWR ${DeviceID}`;
+    }
+    getCyclingMode() {
+        if (!this.mode)
+            this.mode = this.getDefaultCyclingMode();
+        return this.mode;
+    }
+    getDefaultCyclingMode() {
+        return new power_meter_1.default(this);
+    }
+    onAttached() {
+        this.logger.logEvent({ message: 'Device connected' });
+        this.connected = true;
+    }
+    getLogData(data, excludeList) {
+        const logData = JSON.parse(JSON.stringify(data));
+        excludeList.forEach((key) => {
+            delete logData[key];
+        });
+        return logData;
+    }
+    onDeviceData(deviceData) {
+        if (!this.started || this.isStopped())
+            return;
+        this.deviceData = deviceData;
+        try {
+            if (this.onDataFn && !(this.ignoreBike && this.ignorePower) && !this.paused) {
+                if (!this.lastUpdate || (Date.now() - this.lastUpdate) > this.updateFrequency) {
+                    const logData = this.getLogData(deviceData, ['PairedDevices', 'RawData']);
+                    this.logger.logEvent({ message: 'onDeviceData', data: logData });
+                    let incyclistData = this.mapData(deviceData);
+                    incyclistData = this.getCyclingMode().updateData(incyclistData);
+                    const data = this.transformData(incyclistData);
+                    this.onDataFn(data);
+                    this.lastUpdate = Date.now();
+                }
+            }
+        }
+        catch (err) {
+        }
+    }
+    onDeviceEvent(data) {
+        try {
+            const cmdInfo = this.currentCmd;
+            if (!cmdInfo)
+                return;
+            const msg = cmdInfo.msg.readUInt8(2);
+            const Constants = this.getProtocol().getAnt().Constants;
+            const { expectedResponse } = cmdInfo;
+            if (data.message === msg) {
+                if (expectedResponse === undefined && data.code === Constants.EVENT_TRANSFER_TX_COMPLETED) {
+                    this.currentCmd.response = { success: true, message: hex(data.message), code: hex(data.code) };
+                    return;
+                }
+                if (expectedResponse === undefined && data.code !== Constants.EVENT_TRANSFER_TX_COMPLETED) {
+                    this.currentCmd.response = { success: false, message: hex(data.message), code: hex(data.code) };
+                    return;
+                }
+            }
+            if (data.message === 1) {
+                if (expectedResponse !== undefined && data.code === expectedResponse) {
+                    this.currentCmd.response = { success: true, message: hex(data.message), code: hex(data.code) };
+                    return;
+                }
+                if (expectedResponse === undefined && (data.code === Constants.EVENT_TRANSFER_TX_COMPLETED || data.code === 3)) {
+                    this.currentCmd.response = { success: true, message: hex(data.message), code: hex(data.code) };
+                    return;
+                }
+                if (data.code === Constants.EVENT_TRANSFER_TX_FAILED || data.code === Constants.EVENT_CHANNEL_COLLISION) {
+                    this.currentCmd.response = { success: false, message: hex(data.message), code: hex(data.code) };
+                    return;
+                }
+            }
+            if (this.currentCmd !== undefined && data.message === Constants.MESSAGE_CHANNEL_ACKNOWLEDGED_DATA && data.code === 31) {
+                this.logger.log("could not send (TRANSFER_IN_PROGRESS)");
+                this.currentCmd.response = { success: false, message: hex(data.message), code: hex(data.code) };
+                return;
+            }
+            this.logger.logEvent({ message: "Incoming Event ", event: { message: hex(data.message), code: hex(data.code) } });
+        }
+        catch (err) {
+            this.logger.logEvent({ message: 'Error', fn: 'parseEvent', event: { message: hex(data.message), code: hex(data.code) }, error: err.message || err });
+        }
+    }
+    sendUpdate(request) {
+        if (this.paused)
+            return;
+        this.getCyclingMode().sendBikeUpdate(request);
+    }
+    mapData(deviceData) {
+        const data = {
+            isPedalling: false,
+            power: 0,
+            pedalRpm: 0,
+            speed: 0,
+            heartrate: 0,
+            distanceInternal: 0,
+            slope: undefined,
+            time: undefined
+        };
+        data.slope = (deviceData.Slope !== undefined ? deviceData.Slope : data.slope);
+        data.power = (deviceData.Power !== undefined ? deviceData.Power : data.power);
+        data.pedalRpm = (deviceData.Cadence !== undefined ? deviceData.Cadence : data.pedalRpm);
+        data.time = (deviceData.TimeStamp !== undefined ? deviceData.TimeStamp : data.time);
+        data.isPedalling = data.pedalRpm > 0;
+        return data;
+    }
+    transformData(bikeData) {
+        if (bikeData === undefined)
+            return;
+        let distance = 0;
+        if (this.distanceInternal !== undefined && bikeData.distanceInternal !== undefined) {
+            distance = intVal(bikeData.distanceInternal - this.distanceInternal);
+        }
+        if (bikeData.distanceInternal !== undefined)
+            this.distanceInternal = bikeData.distanceInternal;
+        let data = {
+            speed: floatVal(bikeData.speed),
+            slope: floatVal(bikeData.slope),
+            power: intVal(bikeData.power),
+            cadence: intVal(bikeData.pedalRpm),
+            distance,
+            timestamp: Date.now()
+        };
+        if (this.ignorePower) {
+            delete data.power;
+            delete data.cadence;
+        }
+        if (this.ignoreBike) {
+            data = {};
+        }
+        return data;
+    }
+    start(props) {
+        const _super = Object.create(null, {
+            start: { get: () => super.start }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield _super.start.call(this, props);
+            this.logger.logEvent({ message: 'start()', props });
+            const opts = props || {};
+            const { args = {} } = opts;
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                if (this.ignoreBike && this.ignorePower) {
+                    this.logger.logEvent({ message: 'start() not done: bike disabled' });
+                    return resolve(false);
+                }
+                if (this.starting) {
+                    this.logger.logEvent({ message: 'start() not done: bike starting' });
+                    return resolve(false);
+                }
+                if (this.started) {
+                    this.logger.logEvent({ message: 'start() done: bike was already started' });
+                    return resolve(true);
+                }
+                this.starting = true;
+                const Ant = this.getProtocol().getAnt();
+                const protocol = this.getProtocol();
+                let start = Date.now();
+                let timeout = start + (args.timeout || DEFAULT_START_TIMEOUT);
+                const iv = setInterval(() => {
+                    if (Date.now() > timeout) {
+                        clearInterval(iv);
+                        this.starting = false;
+                        reject(new Error('timeout'));
+                    }
+                    if (this.isStopped()) {
+                        clearInterval(iv);
+                        this.starting = false;
+                        reject(new Error('stopped'));
+                    }
+                }, 100);
+                protocol.attachSensors(this, Ant.BicyclePowerSensor, 'powerData')
+                    .then(() => {
+                    this.starting = false;
+                    this.started = true;
+                    clearInterval(iv);
+                    resolve(true);
+                })
+                    .catch(err => reject(err));
+            }));
+        });
+    }
+    stop() {
+        const _super = Object.create(null, {
+            stop: { get: () => super.stop }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield _super.stop.call(this);
+            this.logger.logEvent({ message: 'stop()' });
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                this.starting = false;
+                return resolve(true);
+            }));
+        });
+    }
+}
+exports.default = AntFEAdapter;

package/lib/ant/utils.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBrand = (manId) => {
+exports.getBrand = void 0;
+const getBrand = (manId) => {
     if (manId === undefined)
         return "ANT+";
     switch (manId) {
@@ -19,3 +20,4 @@ exports.getBrand = (manId) => {
             return "ANT+";
     }
 };
+exports.getBrand = getBrand;

package/lib/calculations.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.solveCubic = exports.IllegalArgumentException = void 0;
 const g = 9.80665;
 const rho = 1.2041;
 const cwABike = {
@@ -7,7 +8,6 @@ const cwABike = {
     triathlon: 0.29,
     mountain: 0.57
 };
-const k = 0.01090;
 const cRR = 0.0036;
 class IllegalArgumentException extends Error {
     constructor(message) {
@@ -28,7 +28,7 @@ class C {
         const _cRR = props.cRR || cRR;
         const _cwA = props.cwA || cwABike[props.bikeType || 'race'] || cwABike.race;
         let sl = Math.atan(slope / 100);
-        let c1 = 0.5 * _rho * _cwA + 2 * k;
+        let c1 = 0.5 * _rho * _cwA;
         let c2 = (sl + _cRR) * m * g;
         let p = c2 / c1;
         let q = -1.0 * power / c1;
@@ -70,7 +70,7 @@ class C {
         let _cRR = props.cRR || cRR;
         let _cwA = props.cwA || cwABike[props.bikeType || 'race'] || cwABike.race;
         let sl = Math.sin(Math.atan(slope / 100));
-        let P = (0.5 * _rho * _cwA + 2 * k) * Math.pow(v, 3.0) + (sl + _cRR) * m * g * v;
+        let P = (0.5 * _rho * _cwA) * Math.pow(v, 3.0) + (sl + _cRR) * m * g * v;
         return P;
     }
     static calculateSpeedDaum(gear, rpm, bikeType) {

package/lib/daum/DaumAdapter.d.ts

@@ -13,7 +13,7 @@ export default class DaumAdapterBase extends DeviceAdapterBase implements Device
     distanceInternal: number;
     paused: boolean;
     stopped: boolean;
-    daumRunData: IncyclistBikeData;
+    cyclingData: IncyclistBikeData;
     deviceData: DeviceData;
     currentRequest: any;
     requests: Array<any>;
@@ -56,7 +56,7 @@ export default class DaumAdapterBase extends DeviceAdapterBase implements Device
     update(): Promise<void>;
     sendRequests(): Promise<void>;
     bikeSync(): Promise<void>;
-    updateData(prev: any, bikeData: any): void;
+    updateData(prev: any, bikeData: any): IncyclistBikeData;
     transformData(): DeviceData;
     sendRequest(request: any): Promise<any>;
     refreshRequests(): void;

package/lib/daum/DaumAdapter.js

@@ -1,4 +1,23 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 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) {
@@ -8,13 +27,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
-    result["default"] = mod;
-    return result;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -22,7 +34,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const Device_1 = __importStar(require("../Device"));
 const ERGCyclingMode_1 = __importDefault(require("./ERGCyclingMode"));
 const SmartTrainerCyclingMode_1 = __importDefault(require("./SmartTrainerCyclingMode"));
-const PowerMeterCyclingMode_1 = __importDefault(require("./PowerMeterCyclingMode"));
+const DaumPowerMeterCyclingMode_1 = __importDefault(require("./DaumPowerMeterCyclingMode"));
 const utils_1 = require("../utils");
 class DaumAdapterBase extends Device_1.default {
     constructor(props, bike) {
@@ -34,7 +46,7 @@ class DaumAdapterBase extends Device_1.default {
         this.bike = bike;
         this.stopped = false;
         this.paused = false;
-        this.daumRunData = {
+        this.cyclingData = {
             isPedalling: false,
             time: 0,
             power: 0,
@@ -67,7 +79,7 @@ class DaumAdapterBase extends Device_1.default {
         this.cyclingMode.setSettings(settings);
     }
     getSupportedCyclingModes() {
-        return [ERGCyclingMode_1.default, SmartTrainerCyclingMode_1.default, PowerMeterCyclingMode_1.default];
+        return [ERGCyclingMode_1.default, SmartTrainerCyclingMode_1.default, DaumPowerMeterCyclingMode_1.default];
     }
     getCyclingMode() {
         if (!this.cyclingMode)
@@ -128,7 +140,7 @@ class DaumAdapterBase extends Device_1.default {
         this.distanceInternal = undefined;
         this.paused = false;
         this.stopped = false;
-        this.daumRunData = {
+        this.cyclingData = {
             isPedalling: false,
             time: 0,
             power: 0,
@@ -229,12 +241,15 @@ class DaumAdapterBase extends Device_1.default {
             this.updateBusy = true;
             this.getCurrentBikeData()
                 .then(bikeData => {
-                this.updateData(this.daumRunData, bikeData);
+                this.updateData(this.cyclingData, bikeData);
                 this.transformData();
                 this.updateBusy = false;
             })
                 .catch(err => {
                 this.logEvent({ message: 'bike update error', error: err.message, stack: err.stack });
+                const { isPedalling, power, pedalRpm, speed, distanceInternal, heartrate, slope } = this.cyclingData;
+                this.updateData(this.cyclingData, { isPedalling, power, pedalRpm, speed, distanceInternal, heartrate, slope });
+                this.transformData();
                 this.updateBusy = false;
             });
         });
@@ -289,27 +304,28 @@ class DaumAdapterBase extends Device_1.default {
         data.time = bikeData.time;
         if (bikeData.slope)
             data.slope = bikeData.slope;
-        this.daumRunData = this.getCyclingMode().updateData(data);
+        this.cyclingData = this.getCyclingMode().updateData(data);
+        return this.cyclingData;
     }
     transformData() {
-        if (this.daumRunData === undefined)
+        if (this.cyclingData === undefined)
             return;
         let distance = 0;
-        if (this.distanceInternal !== undefined && this.daumRunData.distanceInternal !== undefined) {
-            distance = utils_1.intVal(this.daumRunData.distanceInternal - this.distanceInternal);
+        if (this.distanceInternal !== undefined && this.cyclingData.distanceInternal !== undefined) {
+            distance = (0, utils_1.intVal)(this.cyclingData.distanceInternal - this.distanceInternal);
         }
-        if (this.daumRunData.distanceInternal !== undefined)
-            this.distanceInternal = this.daumRunData.distanceInternal;
+        if (this.cyclingData.distanceInternal !== undefined)
+            this.distanceInternal = this.cyclingData.distanceInternal;
         let data = {
-            speed: utils_1.floatVal(this.daumRunData.speed),
-            slope: utils_1.floatVal(this.daumRunData.slope),
-            power: utils_1.intVal(this.daumRunData.power),
-            cadence: utils_1.intVal(this.daumRunData.pedalRpm),
-            heartrate: utils_1.intVal(this.daumRunData.heartrate),
+            speed: (0, utils_1.floatVal)(this.cyclingData.speed),
+            slope: (0, utils_1.floatVal)(this.cyclingData.slope),
+            power: (0, utils_1.intVal)(this.cyclingData.power),
+            cadence: (0, utils_1.intVal)(this.cyclingData.pedalRpm),
+            heartrate: (0, utils_1.intVal)(this.cyclingData.heartrate),
             distance,
             timestamp: Date.now(),
-            deviceTime: this.daumRunData.time,
-            deviceDistanceCounter: this.daumRunData.distanceInternal
+            deviceTime: this.cyclingData.time,
+            deviceDistanceCounter: this.cyclingData.distanceInternal
         };
         if (this.ignoreHrm)
             delete data.heartrate;
@@ -350,7 +366,7 @@ class DaumAdapterBase extends Device_1.default {
         });
     }
     refreshRequests() {
-        if (!this.daumRunData.isPedalling || this.daumRunData.pedalRpm === 0)
+        if (!this.cyclingData.isPedalling || this.cyclingData.pedalRpm === 0)
             return;
         let bikeRequest = this.getCyclingMode().sendBikeUpdate({ refresh: true }) || {};
         const prev = this.requests[this.requests.length - 1] || {};
@@ -361,7 +377,7 @@ class DaumAdapterBase extends Device_1.default {
     }
     processClientRequest(request) {
         if (request.slope !== undefined) {
-            this.daumRunData.slope = request.slope;
+            this.cyclingData.slope = request.slope;
         }
         return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
             let bikeRequest = this.getCyclingMode().sendBikeUpdate(request);

package/lib/daum/DaumPowerMeterCyclingMode.d.ts

@@ -0,0 +1,8 @@
+import CyclingMode, { UpdateRequest } from "../CyclingMode";
+import PowerMeterCyclingMode from "../modes/power-meter";
+export default class DaumPowerMeterCyclingMode extends PowerMeterCyclingMode implements CyclingMode {
+    prevRequest: UpdateRequest;
+    hasBikeUpdate: boolean;
+    getBikeInitRequest(): UpdateRequest;
+    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
+}

package/lib/daum/DaumPowerMeterCyclingMode.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const power_meter_1 = __importDefault(require("../modes/power-meter"));
+class DaumPowerMeterCyclingMode extends power_meter_1.default {
+    constructor() {
+        super(...arguments);
+        this.hasBikeUpdate = false;
+    }
+    getBikeInitRequest() {
+        return { slope: 0 };
+    }
+    sendBikeUpdate(request) {
+        super.sendBikeUpdate(request);
+        this.prevRequest = {};
+        return {};
+    }
+}
+exports.default = DaumPowerMeterCyclingMode;

package/lib/daum/ERGCyclingMode.d.ts

@@ -1,17 +1,14 @@
-import { EventLogger } from "gd-eventlog";
-import CyclingMode, { CyclingModeBase, CyclingModeProperty, IncyclistBikeData, UpdateRequest } from "../CyclingMode";
+import CyclingMode, { CyclingModeProperty, IncyclistBikeData, UpdateRequest } from "../CyclingMode";
 import DaumAdapter from "./DaumAdapter";
+import PowerBasedCyclingModeBase from "../modes/power-base";
 export declare type ERGEvent = {
     rpmUpdated?: boolean;
     gearUpdated?: boolean;
     starting?: boolean;
     tsStart?: number;
 };
-export default class ERGCyclingMode extends CyclingModeBase implements CyclingMode {
-    logger: EventLogger;
-    data: IncyclistBikeData;
+export default class ERGCyclingMode extends PowerBasedCyclingModeBase implements CyclingMode {
     prevRequest: UpdateRequest;
-    prevUpdateTS: number;
     hasBikeUpdate: boolean;
     chain: number[];
     cassette: number[];

package/lib/daum/ERGCyclingMode.js

@@ -3,9 +3,9 @@ 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 CyclingMode_1 = require("../CyclingMode");
 const calculations_1 = __importDefault(require("../calculations"));
+const power_base_1 = __importDefault(require("../modes/power-base"));
 const config = {
     name: "ERG",
     description: "Calculates speed based on power and slope. Power is either set by workout or calculated based on gear and cadence",
@@ -14,15 +14,12 @@ const config = {
         { key: 'startPower', name: 'Starting Power', description: 'Initial power in Watts at start of training', type: CyclingMode_1.CyclingModeProperyType.Integer, default: 50, min: 25, max: 800 },
     ]
 };
-class ERGCyclingMode extends CyclingMode_1.CyclingModeBase {
+class ERGCyclingMode extends power_base_1.default {
     constructor(adapter, props) {
         super(adapter, props);
-        this.prevUpdateTS = 0;
         this.hasBikeUpdate = false;
         this.event = {};
-        this.logger = adapter.logger || new gd_eventlog_1.EventLogger('ERGMode');
-        this.data = {};
-        this.logger.logEvent({ message: 'constructor', props });
+        this.initLogger('ERGMode');
     }
     getName() {
         return config.name;
@@ -132,7 +129,6 @@ class ERGCyclingMode extends CyclingMode_1.CyclingModeBase {
         const prevRequest = this.prevRequest || {};
         const data = this.data || {};
         const bikeType = this.getSetting('bikeType').toLowerCase();
-        console.log('~~~ bikeType', bikeType);
         delete this.event.gearUpdated;
         delete this.event.rpmUpdated;
         if (prevData === {} || prevData.speed === undefined || prevData.speed === 0) {
@@ -140,32 +136,25 @@ class ERGCyclingMode extends CyclingMode_1.CyclingModeBase {
             this.event.tsStart = Date.now();
         }
         try {
-            let rpm = bikeData.pedalRpm || 0;
-            let gear = bikeData.gear || 0;
+            const rpm = bikeData.pedalRpm || 0;
+            const gear = bikeData.gear || 0;
             let power = bikeData.power || 0;
-            let slope = (prevData.slope !== undefined ? prevData.slope : prevRequest.slope || 0);
-            let speed;
-            let m = this.adapter.getWeight();
-            let distanceInternal = prevData.distanceInternal || 0;
-            let ts = Date.now();
-            let duration = this.prevUpdateTS === 0 ? 0 : ((ts - this.prevUpdateTS) / 1000);
-            if (rpm === 0 || bikeData.isPedalling === false) {
-                speed = 0;
+            const slope = (prevData.slope !== undefined ? prevData.slope : prevRequest.slope || 0);
+            const distanceInternal = prevData.distanceInternal || 0;
+            if (!bikeData.pedalRpm || bikeData.isPedalling === false) {
                 power = 0;
             }
-            else {
-                speed = calculations_1.default.calculateSpeed(m, power, slope, { bikeType });
-                let v = speed / 3.6;
-                distanceInternal += Math.round(v * duration);
-            }
+            const m = this.getWeight();
+            const t = this.getTimeSinceLastUpdate();
+            const { speed, distance } = this.calculateSpeedAndDistance(power, slope, m, t, { bikeType });
             data.speed = parseFloat(speed.toFixed(1));
             data.power = Math.round(power);
-            data.distanceInternal = distanceInternal;
+            data.distanceInternal = Math.round(distanceInternal + distance);
             data.slope = slope;
             data.pedalRpm = rpm;
             data.gear = gear;
-            if (data.time !== undefined)
-                data.time += duration;
+            if (data.time !== undefined && !(this.event.starting && !bikeData.pedalRpm))
+                data.time += t;
             else
                 data.time = 0;
             data.heartrate = bikeData.heartrate;
@@ -176,7 +165,6 @@ class ERGCyclingMode extends CyclingMode_1.CyclingModeBase {
             if (rpm && rpm !== prevData.pedalRpm) {
                 this.event.rpmUpdated = true;
             }
-            this.prevUpdateTS = ts;
         }
         catch (err) {
             this.logger.logEvent({ message: 'error', fn: 'updateData()', error: err.message || err });
@@ -188,7 +176,7 @@ class ERGCyclingMode extends CyclingMode_1.CyclingModeBase {
     calculateTargetPower(request, updateMode = true) {
         const bikeType = this.getSetting('bikeType').toLowerCase();
         const defaultPower = this.getSetting('startPower');
-        let m = this.adapter.getWeight();
+        let m = this.getWeight();
         const prevData = this.data || {};
         let target;
         if (prevData.pedalRpm && prevData.gear && (!updateMode || prevData.pedalRpm !== 0)) {

package/lib/daum/SmartTrainerCyclingMode.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.direction = void 0;
 const gd_eventlog_1 = require("gd-eventlog");
 const CyclingMode_1 = require("../CyclingMode");
 const calculations_1 = __importDefault(require("../calculations"));

package/lib/daum/classic/DaumClassicAdapter.js

@@ -86,7 +86,7 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
             const { user } = props;
             this.initData();
             let startState = {};
-            return utils_1.runWithRetries(() => __awaiter(this, void 0, void 0, function* () {
+            return (0, utils_1.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () {
                 try {
                     if (!this.bike.isConnected())
                         yield this.bike.saveConnect();
@@ -109,7 +109,7 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
                         startState.startProg = true;
                     }
                     if (!startState.setGear) {
-                        yield this.bike.setGear(this.daumRunData.gear || (opts.gear || 10));
+                        yield this.bike.setGear(this.cyclingData.gear || (opts.gear || 10));
                         startState.setGear = true;
                     }
                     const startRequest = this.getCyclingMode().getBikeInitRequest();