incyclist-devices 1.4.61 → 1.4.64

package/lib/ble/ble-device.d.ts

@@ -11,7 +11,6 @@ declare type CommandQueueItem = {
     data: Buffer;
     resolve: any;
     reject: any;
-    timeout: any;
 };
 export declare abstract class BleDevice extends BleDeviceClass {
     id: string;

package/lib/ble/ble-device.js

@@ -47,9 +47,7 @@ class BleDevice extends ble_1.BleDeviceClass {
         if (this.logger) {
             this.logger.logEvent(event);
         }
-        if (process.env.BLE_DEBUG) {
-            console.log('~~~BLE:', event);
-        }
+        console.log('~~~BLE:', event);
     }
     setLogger(logger) {
         this.logger = logger;
@@ -246,6 +244,7 @@ class BleDevice extends ble_1.BleDeviceClass {
             if (writeIdx !== -1) {
                 const writeItem = this.writeQueue[writeIdx];
                 this.writeQueue.splice(writeIdx, 1);
+                console.log('~~~ write queue', this.writeQueue);
                 if (writeItem.resolve)
                     writeItem.resolve(data);
             }
@@ -253,34 +252,58 @@ class BleDevice extends ble_1.BleDeviceClass {
     }
     write(characteristicUuid, data, withoutResponse = false) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!withoutResponse && this.subscribedCharacteristics.find(c => c === characteristicUuid) === undefined) {
+            try {
                 const connector = this.ble.getConnector(this.peripheral);
-                connector.on(characteristicUuid, (uuid, data) => {
-                    this.onData(uuid, data);
-                });
-                yield connector.subscribe(characteristicUuid);
-                this.subscribedCharacteristics.push(characteristicUuid);
-            }
-            return new Promise((resolve, reject) => {
-                const characteristic = this.characteristics.find(c => c.uuid === characteristicUuid || (0, ble_1.uuid)(c.uuid) === characteristicUuid);
-                if (!characteristic) {
-                    reject(new Error('Characteristic not found'));
-                    return;
-                }
-                if (withoutResponse) {
-                    characteristic.write(data, withoutResponse);
-                    resolve(new ArrayBuffer(0));
-                    return;
+                const isAlreadySubscribed = connector.isSubscribed(characteristicUuid);
+                console.log('~~~ write ', characteristicUuid, data.toString('hex'), isAlreadySubscribed, this.subscribedCharacteristics);
+                if (!withoutResponse && !isAlreadySubscribed) {
+                    const connector = this.ble.getConnector(this.peripheral);
+                    connector.on(characteristicUuid, (uuid, data) => {
+                        this.onData(uuid, data);
+                    });
+                    this.logEvent({ message: 'write:subscribing ', characteristic: characteristicUuid });
+                    yield connector.subscribe(characteristicUuid);
+                    this.subscribedCharacteristics.push(characteristicUuid);
                 }
-                const writeId = this.writeQueue.length;
-                this.writeQueue.push({ uuid: characteristicUuid.toLocaleLowerCase(), data, resolve, reject, timeout: Date.now() + 1000 });
-                characteristic.write(data, withoutResponse, (err) => {
-                    if (err) {
-                        this.writeQueue.splice(writeId, 1);
-                        reject(err);
+                return new Promise((resolve, reject) => {
+                    const characteristic = this.characteristics.find(c => c.uuid === characteristicUuid || (0, ble_1.uuid)(c.uuid) === characteristicUuid);
+                    if (!characteristic) {
+                        reject(new Error('Characteristic not found'));
+                        return;
+                    }
+                    if (withoutResponse) {
+                        this.logEvent({ message: 'writing' });
+                        characteristic.write(data, withoutResponse);
+                        resolve(new ArrayBuffer(0));
+                        return;
+                    }
+                    else {
+                        const writeId = this.writeQueue.length;
+                        let messageDeleted = false;
+                        this.writeQueue.push({ uuid: characteristicUuid.toLocaleLowerCase(), data, resolve, reject });
+                        const to = setTimeout(() => {
+                            console.log('~~~ write timeout');
+                            if (this.writeQueue.length > writeId && !messageDeleted)
+                                this.writeQueue.splice(writeId, 1);
+                            this.logEvent({ message: 'writing response', err: 'timeout' });
+                            reject(new Error('timeout'));
+                        }, 1000);
+                        this.logEvent({ message: 'writing' });
+                        characteristic.write(data, withoutResponse, (err) => {
+                            clearTimeout(to);
+                            this.logEvent({ message: 'writing response', err });
+                            if (err) {
+                                this.writeQueue.splice(writeId, 1);
+                                messageDeleted = true;
+                                reject(err);
+                            }
+                        });
                     }
                 });
-            });
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', fn: '', error: err.message || err, stack: err.stack });
+            }
         });
     }
     read(characteristicUuid) {

package/lib/ble/ble-peripheral.d.ts

@@ -22,6 +22,7 @@ export default class BlePeripheralConnector {
     reconnect(): Promise<void>;
     onDisconnect(): void;
     initialize(enforce?: boolean): Promise<void>;
+    isSubscribed(characteristicUuid: string): boolean;
     subscribeAll(callback: (characteristicUuid: string, data: any) => void): Promise<string[]>;
     subscribe(characteristicUuid: string): Promise<boolean>;
     onData(characteristicUuid: string, data: any): void;

package/lib/ble/ble-peripheral.js

@@ -31,9 +31,7 @@ class BlePeripheralConnector {
         if (this.logger) {
             this.logger.logEvent(event);
         }
-        if (process.env.BLE_DEBUG) {
-            console.log('~~~BLE:', event);
-        }
+        console.log('~~~BLE:', event);
     }
     connect() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -86,6 +84,9 @@ class BlePeripheralConnector {
             this.state.isInitialized = this.characteristics !== undefined && this.services !== undefined;
         });
     }
+    isSubscribed(characteristicUuid) {
+        return this.state.subscribed.find(c => c === characteristicUuid || (0, ble_1.uuid)(c) === characteristicUuid || c === (0, ble_1.uuid)(characteristicUuid)) !== undefined;
+    }
     subscribeAll(callback) {
         return __awaiter(this, void 0, void 0, function* () {
             const cnt = this.characteristics.length;
@@ -101,9 +102,10 @@ class BlePeripheralConnector {
                         c.on('data', (data, _isNotification) => {
                             this.onData((0, ble_1.uuid)(c.uuid), data);
                         });
-                        if (callback)
+                        if (callback) {
                             this.on((0, ble_1.uuid)(c.uuid), callback);
-                        this.logEvent({ message: 'subscribe', peripheral: this.peripheral.address, characteristic: c.uuid });
+                        }
+                        this.logEvent({ message: 'subscribe', peripheral: this.peripheral.address, characteristic: c.uuid, uuid: (0, ble_1.uuid)(c.uuid) });
                         if (this.state.subscribed.find(uuid => uuid === c.uuid) === undefined) {
                             try {
                                 yield this.subscribe(c.uuid);
@@ -117,7 +119,7 @@ class BlePeripheralConnector {
                     }
                 }
                 catch (err) {
-                    console.log('~~~ error', err);
+                    this.logEvent({ message: 'error', fn: 'subscribeAll()', error: err.message || err, stack: err.stack });
                 }
             }
             this.state.isSubscribing = false;
@@ -126,21 +128,34 @@ class BlePeripheralConnector {
         });
     }
     subscribe(characteristicUuid) {
+        this.logEvent({ message: 'subscribe', characteristic: characteristicUuid, characteristics: this.characteristics.map(c => ({ characteristic: c.uuid, uuid: (0, ble_1.uuid)(c.uuid) })) });
         return new Promise((resolve, reject) => {
-            const characteristic = this.characteristics.find(c => c.uuid === characteristicUuid || (0, ble_1.uuid)(c.uuid) === characteristicUuid);
-            if (!characteristic) {
-                reject(new Error('Characteristic not found'));
-                return;
+            try {
+                const characteristic = this.characteristics.find(c => c.uuid === characteristicUuid || (0, ble_1.uuid)(c.uuid) === characteristicUuid);
+                this.logEvent({ message: 'subscribe', peripheral: this.peripheral.address, characteristic: characteristic.uuid, uuid: (0, ble_1.uuid)(characteristic.uuid) });
+                if (!characteristic) {
+                    reject(new Error('Characteristic not found'));
+                    return;
+                }
+                characteristic.on('data', (data, _isNotification) => {
+                    this.onData(characteristicUuid, data);
+                });
+                const to = setTimeout(() => {
+                    this.logEvent({ message: 'subscribe result', characteristic: characteristicUuid, error: 'timeout' });
+                    reject(new Error('timeout'));
+                }, 3000);
+                characteristic.subscribe((err) => {
+                    clearTimeout(to);
+                    this.logEvent({ message: 'subscribe result', characteristic: characteristicUuid, error: err });
+                    if (err)
+                        reject(err);
+                    else
+                        resolve(true);
+                });
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', error: err.message || err, stack: err.stack });
             }
-            characteristic.on('data', (data, _isNotification) => {
-                this.onData(characteristicUuid, data);
-            });
-            characteristic.subscribe((err) => {
-                if (err)
-                    reject(err);
-                else
-                    resolve(true);
-            });
         });
     }
     onData(characteristicUuid, data) {

package/lib/ble/fm.d.ts

@@ -16,7 +16,7 @@ declare type PowerData = {
     rpm: number;
     raw?: string;
 };
-declare type IndoorBikeData = {
+export declare type IndoorBikeData = {
     speed?: number;
     averageSpeed?: number;
     cadence?: number;
@@ -45,6 +45,7 @@ export default class BleFitnessMachineDevice extends BleDevice {
     data: IndoorBikeData;
     features: IndoorBikeFeatures;
     hasControl: boolean;
+    isCheckingControl: boolean;
     isCPSubscribed: boolean;
     crr: number;
     cw: number;

package/lib/ble/fm.js

@@ -86,6 +86,7 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
         super(props);
         this.features = undefined;
         this.hasControl = false;
+        this.isCheckingControl = false;
         this.isCPSubscribed = false;
         this.crr = 0.0033;
         this.cw = 0.6;
@@ -148,7 +149,7 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
         }
         catch (err) {
         }
-        return Object.assign(Object.assign({}, this.data), { raw: data.toString('hex') });
+        return Object.assign(Object.assign({}, this.data), { raw: `2a37:${data.toString('hex')}` });
     }
     setCrr(crr) { this.crr = crr; }
     getCrr() { return this.crr; }
@@ -215,7 +216,7 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
             this.data.remainingTime = data.readUInt16LE(offset);
             offset += 2;
         }
-        return Object.assign(Object.assign({}, this.data), { raw: data.toString('hex') });
+        return Object.assign(Object.assign({}, this.data), { raw: `2ad2:${data.toString('hex')}` });
     }
     parseFitnessMachineStatus(_data) {
         const data = Buffer.from(_data);
@@ -252,7 +253,7 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
                     default: break;
                 }
         }
-        return Object.assign(Object.assign({}, this.data), { raw: data.toString('hex') });
+        return Object.assign(Object.assign({}, this.data), { raw: `2ada:${data.toString('hex')}` });
     }
     getFitnessMachineFeatures() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -286,6 +287,11 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
             case '2ada':
                 res = this.parseFitnessMachineStatus(data);
                 break;
+            case '2a63':
+            case '2a5b':
+            case '347b0011-7635-408b-8918-8ff3949ce592':
+                this.logger.logEvent({ message: 'onBleData', raw: `uuid:${data.toString('hex')}` });
+                break;
             default:
                 break;
         }
@@ -295,6 +301,7 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
     writeFtmsMessage(requestedOpCode, data) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
+                this.logEvent({ message: 'fmts:write', data: data.toString('hex') });
                 const res = yield this.write(FTMS_CP, data);
                 const responseData = Buffer.from(res);
                 const opCode = responseData.readUInt8(0);
@@ -302,19 +309,25 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
                 const result = responseData.readUInt8(2);
                 if (opCode !== 128 || request !== requestedOpCode)
                     throw new Error('Illegal response ');
+                this.logEvent({ message: 'fmts:write result', res, result });
                 return result;
             }
             catch (err) {
-                this.logEvent({ message: 'writeFtmsMessage failed', opCode: requestedOpCode, reason: err.message });
+                this.logEvent({ message: 'fmts:write failed', opCode: requestedOpCode, reason: err.message });
                 return 4;
             }
         });
     }
     requestControl() {
         return __awaiter(this, void 0, void 0, function* () {
+            let to = undefined;
+            if (this.isCheckingControl) {
+                to = setTimeout(() => { }, 3500);
+            }
             if (this.hasControl)
                 return true;
             this.logEvent({ message: 'requestControl' });
+            this.isCheckingControl = true;
             const data = Buffer.alloc(1);
             data.writeUInt8(0, 0);
             const res = yield this.writeFtmsMessage(0, data);
@@ -324,6 +337,9 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
             else {
                 this.logEvent({ message: 'requestControl failed' });
             }
+            this.isCheckingControl = false;
+            if (to)
+                clearTimeout(to);
             return this.hasControl;
         });
     }
@@ -335,6 +351,10 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
             if (!this.hasControl)
                 return;
             const hasControl = yield this.requestControl();
+            if (!hasControl) {
+                this.logEvent({ message: 'setTargetPower failed', reason: 'control is disabled' });
+                return true;
+            }
             const data = Buffer.alloc(3);
             data.writeUInt8(5, 0);
             data.writeInt16LE(Math.round(power), 1);
@@ -345,7 +365,8 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
     setSlope(slope) {
         return __awaiter(this, void 0, void 0, function* () {
             this.logEvent({ message: 'setSlope', slope });
-            if (!this.hasControl)
+            const hasControl = yield this.requestControl();
+            if (!hasControl)
                 return;
             const { windSpeed, crr, cw } = this;
             return yield this.setIndoorBikeSimulation(windSpeed, slope, crr, cw);
@@ -577,7 +598,7 @@ class FmAdapter extends Device_1.default {
                                 break;
                         }
                     }
-                    this.device.requestControl();
+                    yield this.device.requestControl();
                     const startRequest = this.getCyclingMode().getBikeInitRequest();
                     yield this.sendUpdate(startRequest);
                     bleDevice.on('data', (data) => {

package/lib/ble/incyclist-protocol.js

@@ -40,6 +40,7 @@ const fm_1 = __importStar(require("./fm"));
 const hrm_1 = __importStar(require("./hrm"));
 const pwr_1 = __importStar(require("./pwr"));
 const wahoo_kickr_1 = __importDefault(require("./wahoo-kickr"));
+const tacx_1 = __importDefault(require("./tacx"));
 class BleProtocol extends DeviceProtocol_1.default {
     constructor(binding) {
         super();
@@ -67,7 +68,7 @@ class BleProtocol extends DeviceProtocol_1.default {
             const { id, name, address } = bleDevice;
             return { id, name, address };
         };
-        switch (profile.toLocaleLowerCase()) {
+        switch (profile.toLowerCase()) {
             case 'hr':
             case 'heartrate monitor':
                 return new hrm_1.HrmAdapter(fromDevice ? bleDevice : new hrm_1.default(props()), this);
@@ -75,14 +76,17 @@ class BleProtocol extends DeviceProtocol_1.default {
             case 'smart trainer':
             case 'wahoo smart trainer':
             case 'fitness machine':
+            case tacx_1.default.PROFILE.toLowerCase():
                 let device;
                 if (fromDevice)
                     device = bleDevice;
                 else {
                     device = this.ble.findDeviceInCache(Object.assign(Object.assign({}, props()), { profile }));
                     if (!device) {
-                        if (profile.toLocaleLowerCase() === 'wahoo smart trainer')
+                        if (profile.toLowerCase() === 'wahoo smart trainer')
                             device = new wahoo_kickr_1.default(props());
+                        else if (profile === tacx_1.default.PROFILE)
+                            device = new tacx_1.default(props());
                         else
                             device = new fm_1.default(props());
                     }

package/lib/ble/pwr.js

@@ -111,6 +111,8 @@ class BleCyclingPowerDevice extends ble_device_1.BleDevice {
                 this.accTorque = data.readUInt16LE(offset);
                 offset += 2;
             }
+            if (flags & 0x10) {
+            }
             if (flags & 0x20) {
                 const crankData = {
                     revolutions: data.readUInt16LE(offset),
@@ -125,7 +127,7 @@ class BleCyclingPowerDevice extends ble_device_1.BleDevice {
         catch (err) {
         }
         const { instantaneousPower, balance, accTorque, rpm, time } = this;
-        return { instantaneousPower, balance, accTorque, rpm, time, raw: data.toString('hex') };
+        return { instantaneousPower, balance, accTorque, rpm, time, raw: `2a63:${data.toString('hex')}` };
     }
     onData(characteristic, data) {
         super.onData(characteristic, data);

package/lib/ble/tacx.d.ts

@@ -0,0 +1,72 @@
+/// <reference types="node" />
+import BleProtocol from './incyclist-protocol';
+import { BleDeviceClass } from './ble';
+import DeviceAdapter from '../Device';
+import BleFitnessMachineDevice, { FmAdapter, IndoorBikeData } from './fm';
+interface BleFeBikeData extends IndoorBikeData {
+    EquipmentType?: 'Treadmill' | 'Elliptical' | 'StationaryBike' | 'Rower' | 'Climber' | 'NordicSkier' | 'Trainer' | 'General';
+    RealSpeed?: number;
+    VirtualSpeed?: number;
+    HeartRateSource?: 'HandContact' | 'EM' | 'ANT+';
+    State?: 'OFF' | 'READY' | 'IN_USE' | 'FINISHED';
+    EventCount?: number;
+    AccumulatedPower?: number;
+    TrainerStatus?: number;
+    TargetStatus?: 'OnTarget' | 'LowSpeed' | 'HighSpeed';
+}
+declare type CrankData = {
+    revolutions?: number;
+    time?: number;
+    cntUpdateMissing?: number;
+};
+export default class TacxAdvancedFitnessMachineDevice extends BleFitnessMachineDevice {
+    static services: string[];
+    static characteristics: string[];
+    static PROFILE: string;
+    prevCrankData: CrankData;
+    currentCrankData: CrankData;
+    timeOffset: number;
+    tsPrevWrite: any;
+    data: BleFeBikeData;
+    hasFECData: boolean;
+    constructor(props?: any);
+    init(): Promise<boolean>;
+    getProfile(): string;
+    getServiceUUids(): string[];
+    isBike(): boolean;
+    isPower(): boolean;
+    isHrm(): boolean;
+    parseCrankData(crankData: any): {
+        rpm: number;
+        time: any;
+    };
+    parsePower(_data: Buffer): IndoorBikeData;
+    resetState(): void;
+    parseFEState(capStateBF: number): void;
+    parseGeneralFE(data: Buffer): BleFeBikeData;
+    parseTrainerData(data: Buffer): BleFeBikeData;
+    parseFECMessage(_data: Buffer): BleFeBikeData;
+    onData(characteristic: string, data: Buffer): void;
+    getChecksum(message: any[]): number;
+    buildMessage(payload?: number[], msgID?: number): Buffer;
+    sendMessage(message: Buffer): Promise<boolean>;
+    sendUserConfiguration(userWeight: any, bikeWeight: any, wheelDiameter: any, gearRatio: any): Promise<boolean>;
+    sendBasicResistance(resistance: any): Promise<boolean>;
+    sendTargetPower(power: any): Promise<boolean>;
+    sendWindResistance(windCoeff: any, windSpeed: any, draftFactor: any): Promise<boolean>;
+    sendTrackResistance(slope: any, rrCoeff?: any): Promise<boolean>;
+    setTargetPower(power: number): Promise<boolean>;
+    setSlope(slope: any): Promise<boolean>;
+    reset(): void;
+}
+export declare class TacxBleFEAdapter extends FmAdapter {
+    static PROFILE: string;
+    device: TacxAdvancedFitnessMachineDevice;
+    constructor(device: BleDeviceClass, protocol: BleProtocol);
+    isSame(device: DeviceAdapter): boolean;
+    getProfile(): string;
+    start(props?: any): Promise<any>;
+    pause(): Promise<boolean>;
+    resume(): Promise<boolean>;
+}
+export {};

package/lib/ble/tacx.js

@@ -0,0 +1,639 @@
+"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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TacxBleFEAdapter = void 0;
+const ble_interface_1 = __importDefault(require("./ble-interface"));
+const Device_1 = require("../Device");
+const gd_eventlog_1 = require("gd-eventlog");
+const fm_1 = __importStar(require("./fm"));
+const TACX_FE_C_BLE = '6e40fec1';
+const TACX_FE_C_RX = '6e40fec2';
+const TACX_FE_C_TX = '6e40fec3';
+const SYNC_BYTE = 0xA4;
+const DEFAULT_CHANNEL = 5;
+const ACKNOWLEDGED_DATA = 0x4F;
+const PROFILE_ID = 'Tacx FE-C over BLE';
+const cwABike = {
+    race: 0.35,
+    triathlon: 0.29,
+    mountain: 0.57
+};
+const cRR = 0.0036;
+var ANTMessages;
+(function (ANTMessages) {
+    ANTMessages[ANTMessages["calibrationCommand"] = 1] = "calibrationCommand";
+    ANTMessages[ANTMessages["calibrationStatus"] = 2] = "calibrationStatus";
+    ANTMessages[ANTMessages["generalFE"] = 16] = "generalFE";
+    ANTMessages[ANTMessages["generalSettings"] = 17] = "generalSettings";
+    ANTMessages[ANTMessages["trainerData"] = 25] = "trainerData";
+    ANTMessages[ANTMessages["basicResistance"] = 48] = "basicResistance";
+    ANTMessages[ANTMessages["targetPower"] = 49] = "targetPower";
+    ANTMessages[ANTMessages["windResistance"] = 50] = "windResistance";
+    ANTMessages[ANTMessages["trackResistance"] = 51] = "trackResistance";
+    ANTMessages[ANTMessages["feCapabilities"] = 54] = "feCapabilities";
+    ANTMessages[ANTMessages["userConfiguration"] = 55] = "userConfiguration";
+    ANTMessages[ANTMessages["requestData"] = 70] = "requestData";
+    ANTMessages[ANTMessages["commandStatus"] = 71] = "commandStatus";
+    ANTMessages[ANTMessages["manufactererData"] = 80] = "manufactererData";
+    ANTMessages[ANTMessages["productInformation"] = 81] = "productInformation";
+})(ANTMessages || (ANTMessages = {}));
+class TacxAdvancedFitnessMachineDevice extends fm_1.default {
+    constructor(props) {
+        super(props);
+        this.prevCrankData = undefined;
+        this.currentCrankData = undefined;
+        this.timeOffset = 0;
+        this.tsPrevWrite = undefined;
+        this.data = {};
+        this.hasFECData = false;
+    }
+    init() {
+        const _super = Object.create(null, {
+            init: { get: () => super.init }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.logEvent({ message: 'get device info' });
+                yield _super.init.call(this);
+                this.logEvent({ message: 'device info', deviceInfo: this.deviceInfo, features: this.features });
+            }
+            catch (err) {
+                return Promise.resolve(false);
+            }
+        });
+    }
+    getProfile() {
+        return TacxAdvancedFitnessMachineDevice.PROFILE;
+    }
+    getServiceUUids() {
+        return TacxAdvancedFitnessMachineDevice.services;
+    }
+    isBike() {
+        return true;
+    }
+    isPower() {
+        return true;
+    }
+    isHrm() {
+        return this.hasService('180d');
+    }
+    parseCrankData(crankData) {
+        if (!this.prevCrankData)
+            this.prevCrankData = { revolutions: 0, time: 0, cntUpdateMissing: -1 };
+        const c = this.currentCrankData = crankData;
+        const p = this.prevCrankData;
+        let rpm = this.data.cadence;
+        let hasUpdate = c.time !== p.time;
+        if (hasUpdate) {
+            let time = c.time - p.time;
+            let revs = c.revolutions - p.revolutions;
+            if (c.time < p.time) {
+                time += 0x10000;
+                this.timeOffset += 0x10000;
+            }
+            if (c.revolutions < p.revolutions)
+                revs += 0x10000;
+            rpm = 1024 * 60 * revs / time;
+        }
+        else {
+            if (p.cntUpdateMissing < 0 || p.cntUpdateMissing > 2) {
+                rpm = 0;
+            }
+        }
+        const cntUpdateMissing = p.cntUpdateMissing;
+        this.prevCrankData = this.currentCrankData;
+        if (hasUpdate)
+            this.prevCrankData.cntUpdateMissing = 0;
+        else
+            this.prevCrankData.cntUpdateMissing = cntUpdateMissing + 1;
+        return { rpm, time: this.timeOffset + c.time };
+    }
+    parsePower(_data) {
+        const data = Buffer.from(_data);
+        try {
+            let offset = 4;
+            const flags = data.readUInt16LE(0);
+            this.data.instantaneousPower = data.readUInt16LE(2);
+            if (flags & 0x1)
+                data.readUInt8(offset++);
+            if (flags & 0x4) {
+                data.readUInt16LE(offset);
+                offset += 2;
+            }
+            if (flags & 0x20) {
+                const crankData = {
+                    revolutions: data.readUInt16LE(offset),
+                    time: data.readUInt16LE(offset + 2)
+                };
+                const { rpm, time } = this.parseCrankData(crankData);
+                this.data.cadence = rpm;
+                this.data.time = time;
+                offset += 4;
+            }
+        }
+        catch (err) {
+        }
+        const { instantaneousPower, cadence, time } = this.data;
+        return { instantaneousPower, cadence, time, raw: data.toString('hex') };
+    }
+    resetState() {
+        const state = this.data;
+        delete state.time;
+        delete state.totalDistance;
+        delete state.RealSpeed;
+        delete state.VirtualSpeed;
+        delete state.heartrate;
+        delete state.HeartRateSource;
+        delete state.EventCount;
+        delete state.cadence;
+        delete state.AccumulatedPower;
+        delete state.instantaneousPower;
+        delete state.averagePower;
+        delete state.TrainerStatus;
+        delete state.TargetStatus;
+    }
+    parseFEState(capStateBF) {
+        switch ((capStateBF & 0x70) >> 4) {
+            case 1:
+                this.data.State = 'OFF';
+                break;
+            case 2:
+                this.data.State = 'READY';
+                this.resetState();
+                break;
+            case 3:
+                this.data.State = 'IN_USE';
+                break;
+            case 4:
+                this.data.State = 'FINISHED';
+                break;
+            default:
+                delete this.data.State;
+                break;
+        }
+        if (capStateBF & 0x80) {
+        }
+    }
+    parseGeneralFE(data) {
+        const equipmentTypeBF = data.readUInt8(1);
+        let elapsedTime = data.readUInt8(2);
+        let distance = data.readUInt8(3);
+        const speed = data.readUInt16LE(4);
+        const heartRate = data.readUInt8(6);
+        const capStateBF = data.readUInt8(7);
+        switch (equipmentTypeBF & 0x1F) {
+            case 19:
+                this.data.EquipmentType = 'Treadmill';
+                break;
+            case 20:
+                this.data.EquipmentType = 'Elliptical';
+                break;
+            case 21:
+                this.data.EquipmentType = 'StationaryBike';
+                break;
+            case 22:
+                this.data.EquipmentType = 'Rower';
+                break;
+            case 23:
+                this.data.EquipmentType = 'Climber';
+                break;
+            case 24:
+                this.data.EquipmentType = 'NordicSkier';
+                break;
+            case 25:
+                this.data.EquipmentType = 'Trainer';
+                break;
+            default:
+                this.data.EquipmentType = 'General';
+                break;
+        }
+        if (heartRate !== 0xFF) {
+            switch (capStateBF & 0x03) {
+                case 3: {
+                    this.data.heartrate = heartRate;
+                    this.data.HeartRateSource = 'HandContact';
+                    break;
+                }
+                case 2: {
+                    this.data.heartrate = heartRate;
+                    this.data.HeartRateSource = 'EM';
+                    break;
+                }
+                case 1: {
+                    this.data.heartrate = heartRate;
+                    this.data.HeartRateSource = 'ANT+';
+                    break;
+                }
+                default: {
+                    delete this.data.heartrate;
+                    delete this.data.HeartRateSource;
+                    break;
+                }
+            }
+        }
+        elapsedTime /= 4;
+        const oldElapsedTime = (this.data.time || 0) % 64;
+        if (elapsedTime !== oldElapsedTime) {
+            if (oldElapsedTime > elapsedTime) {
+                elapsedTime += 64;
+            }
+        }
+        this.data.time = (this.data.time || 0) + elapsedTime - oldElapsedTime;
+        if (capStateBF & 0x04) {
+            const oldDistance = (this.data.time || 0) % 256;
+            if (distance !== oldDistance) {
+                if (oldDistance > distance) {
+                    distance += 256;
+                }
+            }
+            this.data.totalDistance = (this.data.totalDistance || 0) + distance - oldDistance;
+        }
+        else {
+            delete this.data.totalDistance;
+        }
+        this.data.speed = speed / 1000;
+        if (capStateBF & 0x08) {
+            this.data.VirtualSpeed = speed / 1000;
+            delete this.data.RealSpeed;
+        }
+        else {
+            delete this.data.VirtualSpeed;
+            this.data.RealSpeed = speed / 1000;
+        }
+        this.parseFEState(capStateBF);
+        return this.data;
+    }
+    parseTrainerData(data) {
+        const oldEventCount = this.data.EventCount || 0;
+        let eventCount = data.readUInt8(1);
+        const cadence = data.readUInt8(2);
+        let accPower = data.readUInt16LE(3);
+        const power = data.readUInt16LE(5) & 0xFFF;
+        const trainerStatus = data.readUInt8(6) >> 4;
+        const flagStateBF = data.readUInt8(7);
+        if (eventCount !== oldEventCount) {
+            this.data.EventCount = eventCount;
+            if (oldEventCount > eventCount) {
+                eventCount += 255;
+            }
+        }
+        if (cadence !== 0xFF) {
+            this.data.cadence = cadence;
+        }
+        if (power !== 0xFFF) {
+            this.data.instantaneousPower = power;
+            const oldAccPower = (this.data.AccumulatedPower || 0) % 65536;
+            if (accPower !== oldAccPower) {
+                if (oldAccPower > accPower) {
+                    accPower += 65536;
+                }
+            }
+            this.data.AccumulatedPower = (this.data.AccumulatedPower || 0) + accPower - oldAccPower;
+            this.data.averagePower = (accPower - oldAccPower) / (eventCount - oldEventCount);
+        }
+        this.data.TrainerStatus = trainerStatus;
+        switch (flagStateBF & 0x03) {
+            case 0:
+                this.data.TargetStatus = 'OnTarget';
+                break;
+            case 1:
+                this.data.TargetStatus = 'LowSpeed';
+                break;
+            case 2:
+                this.data.TargetStatus = 'HighSpeed';
+                break;
+            default:
+                delete this.data.TargetStatus;
+                break;
+        }
+        this.parseFEState(flagStateBF);
+        return this.data;
+    }
+    parseFECMessage(_data) {
+        const data = Buffer.from(_data);
+        const c = data.readUInt8(0);
+        if (c !== SYNC_BYTE) {
+            this.logEvent({ message: 'SYNC missing', raw: data.toString('hex') });
+            return;
+        }
+        const len = data.readUInt8(1);
+        const messageId = data.readUInt8(4);
+        this.hasFECData = true;
+        let res;
+        switch (messageId) {
+            case ANTMessages.generalFE:
+                res = this.parseGeneralFE(data.slice(4, len + 2));
+                break;
+            case ANTMessages.trainerData:
+                res = this.parseTrainerData(data.slice(4, len + 2));
+                break;
+        }
+        res.raw = data.toString('hex');
+        return res;
+    }
+    onData(characteristic, data) {
+        super.onData(characteristic, data);
+        const uuid = characteristic.toLocaleLowerCase();
+        let res = undefined;
+        if (uuid && uuid.startsWith(TACX_FE_C_RX)) {
+            res = this.parseFECMessage(data);
+        }
+        else {
+            switch (uuid) {
+                case '2a63':
+                    if (!this.hasFECData)
+                        res = this.parsePower(data);
+                    break;
+                case '2ad2':
+                    if (!this.hasFECData)
+                        res = this.parseIndoorBikeData(data);
+                    break;
+                case '2a37':
+                    res = this.parseHrm(data);
+                    break;
+                case '2ada':
+                    if (!this.hasFECData)
+                        res = this.parseFitnessMachineStatus(data);
+                    break;
+                default:
+                    break;
+            }
+        }
+        if (res)
+            this.emit('data', res);
+    }
+    getChecksum(message) {
+        let checksum = 0;
+        message.forEach((byte) => {
+            checksum = (checksum ^ byte) % 0xFF;
+        });
+        return checksum;
+    }
+    buildMessage(payload = [], msgID = 0x00) {
+        const m = [];
+        m.push(SYNC_BYTE);
+        m.push(payload.length);
+        m.push(msgID);
+        payload.forEach((byte) => {
+            m.push(byte);
+        });
+        m.push(this.getChecksum(m));
+        return Buffer.from(m);
+    }
+    sendMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.write(TACX_FE_C_TX, message, true);
+            return true;
+        });
+    }
+    sendUserConfiguration(userWeight, bikeWeight, wheelDiameter, gearRatio) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const logStr = `sendUserConfiguration(${userWeight},${bikeWeight},${wheelDiameter},${gearRatio})`;
+            this.logEvent({ message: logStr });
+            var m = userWeight === undefined ? 0xFFFF : userWeight;
+            var mb = bikeWeight === undefined ? 0xFFF : bikeWeight;
+            var d = wheelDiameter === undefined ? 0xFF : wheelDiameter;
+            var gr = gearRatio === undefined ? 0x00 : gearRatio;
+            var dOffset = 0xFF;
+            if (m !== 0xFFFF)
+                m = Math.trunc(m * 100);
+            if (mb !== 0xFFF)
+                mb = Math.trunc(mb * 20);
+            if (d !== 0xFF) {
+                d = d * 1000;
+                dOffset = d % 10;
+                d = Math.trunc(d / 10);
+            }
+            if (gr !== 0x00) {
+                gr = Math.trunc(gr / 0.03);
+            }
+            var payload = [];
+            payload.push(DEFAULT_CHANNEL);
+            payload.push(0x37);
+            payload.push(m & 0xFF);
+            payload.push((m >> 8) & 0xFF);
+            payload.push(0xFF);
+            payload.push(((mb & 0xF) << 4) | (dOffset & 0xF));
+            payload.push((mb >> 4) & 0xF);
+            payload.push(d & 0xFF);
+            payload.push(gr & 0xFF);
+            const data = this.buildMessage(payload, ACKNOWLEDGED_DATA);
+            return yield this.sendMessage(data);
+        });
+    }
+    sendBasicResistance(resistance) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const logStr = `sendBasicResistance(${resistance})`;
+            this.logEvent({ message: logStr });
+            var res = resistance === undefined ? 0 : resistance;
+            res = res / 0.5;
+            var payload = [];
+            payload.push(DEFAULT_CHANNEL);
+            payload.push(0x30);
+            payload.push(0xFF);
+            payload.push(0xFF);
+            payload.push(0xFF);
+            payload.push(0xFF);
+            payload.push(0xFF);
+            payload.push(0xFF);
+            payload.push(res & 0xFF);
+            const data = this.buildMessage(payload, ACKNOWLEDGED_DATA);
+            return yield this.sendMessage(data);
+        });
+    }
+    sendTargetPower(power) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const logStr = `sendTargetPower(${power})`;
+            this.logEvent({ message: logStr });
+            var p = power === undefined ? 0x00 : power;
+            p = p * 4;
+            var payload = [];
+            payload.push(DEFAULT_CHANNEL);
+            payload.push(0x31);
+            payload.push(0xFF);
+            payload.push(0xFF);
+            payload.push(0xFF);
+            payload.push(0xFF);
+            payload.push(0xFF);
+            payload.push(p & 0xFF);
+            payload.push((p >> 8) & 0xFF);
+            const data = this.buildMessage(payload, ACKNOWLEDGED_DATA);
+            return yield this.sendMessage(data);
+        });
+    }
+    sendWindResistance(windCoeff, windSpeed, draftFactor) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const logStr = `sendWindResistance(${windCoeff},${windSpeed},${draftFactor})`;
+            this.logEvent({ message: logStr });
+            var wc = windCoeff === undefined ? 0xFF : windCoeff;
+            var ws = windSpeed === undefined ? 0xFF : windSpeed;
+            var df = draftFactor === undefined ? 0xFF : draftFactor;
+            if (wc !== 0xFF) {
+                wc = Math.trunc(wc / 0.01);
+            }
+            if (ws !== 0xFF) {
+                ws = Math.trunc(ws + 127);
+            }
+            if (df !== 0xFF) {
+                df = Math.trunc(df / 0.01);
+            }
+            var payload = [];
+            payload.push(DEFAULT_CHANNEL);
+            payload.push(0x32);
+            payload.push(0xFF);
+            payload.push(0xFF);
+            payload.push(0xFF);
+            payload.push(0xFF);
+            payload.push(wc & 0xFF);
+            payload.push(ws & 0xFF);
+            payload.push(df & 0xFF);
+            const data = this.buildMessage(payload, ACKNOWLEDGED_DATA);
+            return yield this.sendMessage(data);
+        });
+    }
+    sendTrackResistance(slope, rrCoeff) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const logStr = `sendTrackResistance(${slope},${rrCoeff})`;
+            this.logEvent({ message: logStr });
+            var s = slope === undefined ? 0xFFFF : slope;
+            var rr = rrCoeff === undefined ? 0xFF : rrCoeff;
+            if (s !== 0xFFFF) {
+                s = Math.trunc((s + 200) / 0.01);
+            }
+            if (rr !== 0xFF) {
+                rr = Math.trunc(rr / 0.00005);
+            }
+            var payload = [];
+            payload.push(DEFAULT_CHANNEL);
+            payload.push(0x33);
+            payload.push(0xFF);
+            payload.push(0xFF);
+            payload.push(0xFF);
+            payload.push(0xFF);
+            payload.push(s & 0xFF);
+            payload.push((s >> 8) & 0xFF);
+            payload.push(rr & 0xFF);
+            const data = this.buildMessage(payload, ACKNOWLEDGED_DATA);
+            return yield this.sendMessage(data);
+        });
+    }
+    setTargetPower(power) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.data.targetPower !== undefined && this.data.targetPower === power)
+                return true;
+            return yield this.sendTargetPower(power);
+        });
+    }
+    setSlope(slope) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.sendTrackResistance(slope, this.crr);
+        });
+    }
+    reset() {
+        this.data = {};
+    }
+}
+exports.default = TacxAdvancedFitnessMachineDevice;
+TacxAdvancedFitnessMachineDevice.services = [TACX_FE_C_BLE];
+TacxAdvancedFitnessMachineDevice.characteristics = ['2acc', '2ad2', '2ad6', '2ad8', '2ad9', '2ada', TACX_FE_C_RX, TACX_FE_C_TX];
+TacxAdvancedFitnessMachineDevice.PROFILE = PROFILE_ID;
+ble_interface_1.default.register('TacxBleFEDevice', 'tacx-ble-fec', TacxAdvancedFitnessMachineDevice, TacxAdvancedFitnessMachineDevice.services);
+class TacxBleFEAdapter extends fm_1.FmAdapter {
+    constructor(device, protocol) {
+        super(device, protocol);
+        this.device = device;
+        this.ble = protocol.ble;
+        this.cyclingMode = this.getDefaultCyclingMode();
+        this.logger = new gd_eventlog_1.EventLogger('BLE-FEC-Tacx');
+        if (this.device)
+            this.device.setLogger(this.logger);
+    }
+    isSame(device) {
+        if (!(device instanceof TacxBleFEAdapter))
+            return false;
+        const adapter = device;
+        return (adapter.getName() === this.getName() && adapter.getProfile() === this.getProfile());
+    }
+    getProfile() {
+        return TacxBleFEAdapter.PROFILE;
+    }
+    start(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'start requested', profile: this.getProfile(), props });
+            if (this.ble.isScanning())
+                yield this.ble.stopScan();
+            try {
+                const bleDevice = yield this.ble.connectDevice(this.device);
+                bleDevice.setLogger(this.logger);
+                if (bleDevice) {
+                    this.device = bleDevice;
+                    const mode = this.getCyclingMode();
+                    if (mode && mode.getSetting('bikeType')) {
+                        const bikeType = mode.getSetting('bikeType').toLowerCase();
+                        this.device.setCrr(cRR);
+                        switch (bikeType) {
+                            case 'race':
+                                this.device.setCw(cwABike.race);
+                                break;
+                            case 'triathlon':
+                                this.device.setCw(cwABike.triathlon);
+                                break;
+                            case 'mountain':
+                                this.device.setCw(cwABike.mountain);
+                                break;
+                        }
+                    }
+                    const { user, wheelDiameter, gearRatio } = props || {};
+                    const userWeight = (user && user.weight ? user.weight : Device_1.DEFAULT_USER_WEIGHT);
+                    const bikeWeight = Device_1.DEFAULT_BIKE_WEIGHT;
+                    this.device.sendTrackResistance(0.0);
+                    this.device.sendUserConfiguration(userWeight, bikeWeight, wheelDiameter, gearRatio);
+                    const startRequest = this.getCyclingMode().getBikeInitRequest();
+                    yield this.sendUpdate(startRequest);
+                    bleDevice.on('data', (data) => {
+                        this.onDeviceData(data);
+                    });
+                    return true;
+                }
+            }
+            catch (err) {
+                this.logger.logEvent({ message: 'start result: error', error: err.message, profile: this.getProfile() });
+                throw new Error(`could not start device, reason:${err.message}`);
+            }
+        });
+    }
+    pause() { this.paused = true; return Promise.resolve(true); }
+    resume() { this.paused = false; return Promise.resolve(true); }
+}
+exports.TacxBleFEAdapter = TacxBleFEAdapter;
+TacxBleFEAdapter.PROFILE = PROFILE_ID;

package/lib/daum/ERGCyclingMode.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const CyclingMode_1 = require("../CyclingMode");
 const calculations_1 = __importDefault(require("../calculations"));
 const power_base_1 = __importDefault(require("../modes/power-base"));
+const MIN_SPEED = 10;
 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",
@@ -147,9 +148,15 @@ class ERGCyclingMode extends power_base_1.default {
             const m = this.getWeight();
             const t = this.getTimeSinceLastUpdate();
             const { speed, distance } = this.calculateSpeedAndDistance(power, slope, m, t, { bikeType });
-            data.speed = speed;
+            if (power === 0 && speed < MIN_SPEED) {
+                data.speed = Math.round(prevData.speed - 1) < 0 ? 0 : Math.round(prevData.speed - 1);
+                data.distanceInternal = distanceInternal + data.speed / 3.6 * t;
+            }
+            else {
+                data.speed = speed;
+                data.distanceInternal = distanceInternal + distance;
+            }
             data.power = Math.round(power);
-            data.distanceInternal = distanceInternal + distance;
             data.slope = slope;
             data.pedalRpm = rpm;
             data.gear = gear;

package/lib/modes/power-meter.js

@@ -49,8 +49,8 @@ class PowerMeterCyclingMode extends power_base_1.default {
             let power = bikeData.power || 0;
             const slope = prevData.slope || 0;
             const distanceInternal = prevData.distanceInternal || 0;
-            if (bikeData.pedalRpm === 0 || bikeData.isPedalling === false) {
-                power = 0;
+            if (power > 0) {
+                data.isPedalling = true;
             }
             const m = this.getWeight();
             const t = this.getTimeSinceLastUpdate();
@@ -62,8 +62,8 @@ class PowerMeterCyclingMode extends power_base_1.default {
                 data.distanceInternal = distanceInternal + data.speed / 3.6 * t;
             }
             else {
-                data.speed = (power === 0 && speed < MIN_SPEED) ? 0 : speed;
-                data.distanceInternal = (power === 0 && speed < MIN_SPEED) ? distanceInternal : distanceInternal + distance;
+                data.speed = speed;
+                data.distanceInternal = distanceInternal + distance;
             }
             if (props.log)
                 this.logger.logEvent({ message: "updateData result", data, bikeData, prevSpeed: prevData.speed, stopped: speed < MIN_SPEED });

package/lib/modes/simulator.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const gd_eventlog_1 = require("gd-eventlog");
 const CyclingMode_1 = require("../CyclingMode");
 const power_base_1 = __importDefault(require("./power-base"));
+const MIN_SPEED = 10;
 const config = {
     name: "Simulator",
     description: "Simulates a ride with constant speed or power output",
@@ -106,6 +107,14 @@ class SimulatorCyclingMode extends power_base_1.default {
                 speed = res.speed;
                 distance = res.distance;
             }
+            if (power === 0 && speed < MIN_SPEED) {
+                data.speed = Math.round(prevData.speed - 1) < 0 ? 0 : Math.round(prevData.speed - 1);
+                data.distanceInternal = distanceInternal + data.speed / 3.6 * t;
+            }
+            else {
+                data.speed = speed;
+                data.distanceInternal = distanceInternal + distance;
+            }
             data.speed = speed;
             data.power = Math.round(power);
             data.distanceInternal = distanceInternal + distance;

package/lib/simulator/Simulator.js

@@ -218,6 +218,8 @@ class Simulator extends Device_1.default {
             return;
         }
         const prevDist = this.data.distanceInternal;
+        const d = this.data;
+        const prevTime = d.deviceTime;
         this.data = this.getCyclingMode().updateData(this.data);
         let data = {
             speed: this.data.speed,
@@ -230,6 +232,9 @@ class Simulator extends Device_1.default {
             deviceTime: (Date.now() - this.startTS) / 1000,
             deviceDistanceCounter: this.data.distanceInternal
         };
+        if (this.isBot) {
+            this.logger.logEvent(Object.assign({ message: 'Coach update', prevDist, prevTime }, data));
+        }
         this.paused = (this.data.speed === 0);
         if (this.ignoreHrm)
             delete data.heartrate;

package/package.json

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