incyclist-devices 1.2.0 → 1.4.0

package/lib/ant/antfe/AntFEAdapter.d.ts

@@ -12,6 +12,7 @@ export default class AntFEAdapter extends AntAdapter {
     isBike(): boolean;
     isHrm(): boolean;
     isPower(): boolean;
+    getProfile(): string;
     getName(): string;
     getDisplayName(): string;
     onAttached(): void;
@@ -19,10 +20,11 @@ export default class AntFEAdapter extends AntAdapter {
     onDeviceEvent(data: any): void;
     updateData(data: any, deviceData: any): any;
     transformData(bikeData: any): any;
-    start(props?: any): Promise<unknown>;
+    start(props?: any): Promise<any>;
     stop(): Promise<boolean>;
     sendUpdate(request: any): Promise<void>;
-    send(msg: any, logStr: any, callback?: any): void;
+    send(msg: any, logStr: any, callback?: any, expectedResponse?: any): void;
+    sendAsync(msg: any, logStr: any, expectedResponse: any): Promise<unknown>;
     startWorker(): void;
     stopWorker(): void;
     sendFromQueue(): void;

package/lib/ant/antfe/AntFEAdapter.js

@@ -8,19 +8,27 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const gd_eventlog_1 = require("gd-eventlog");
-const AntAdapter_1 = require("../AntAdapter");
+const AntAdapter_1 = __importDefault(require("../AntAdapter"));
 const utils_1 = require("../utils");
 const utils_2 = require("../../utils");
 const floatVal = (d) => d ? parseFloat(d) : d;
 const intVal = (d) => d ? parseInt(d) : d;
-const TIMEOUT_ACK = 500;
-const TIMEOUT_START = 5000;
+const hex = (v) => Math.abs(v).toString(16).toUpperCase();
+const TIMEOUT_ACK = 5000;
+const TIMEOUT_START = 10000;
+const TIMEOUT_ATTACH = 3000;
+const DEFAULT_USER_WEIGHT = 75;
+const DEFAULT_BIKE_WEIGHT = 12.75;
 class AntFEAdapter extends AntAdapter_1.default {
     constructor(DeviceID, port, stick, protocol) {
         super(protocol);
         this.logger = new gd_eventlog_1.EventLogger('Ant+FE');
+        this.logger.logEvent({ message: 'Ant+FE Adapter created', DeviceID, port });
         this.deviceID = DeviceID;
         this.port = port;
         this.stick = stick;
@@ -35,35 +43,29 @@ class AntFEAdapter extends AntAdapter_1.default {
     isBike() { return true; }
     isHrm() { return this.deviceData.HeartRate !== undefined; }
     isPower() { return true; }
+    getProfile() {
+        return 'Smart Trainer';
+    }
     getName() {
         return `Ant+FE ${this.deviceID}`;
     }
     getDisplayName() {
         const { DeviceID, ManId, ComputedHeartRate } = this.deviceData;
         const hrmStr = ComputedHeartRate ? ` (${ComputedHeartRate})` : '';
-        return `${utils_1.getBrand(ManId)} FE ${DeviceID}${hrmStr}`;
+        return `${(0, utils_1.getBrand)(ManId)} FE ${DeviceID}${hrmStr}`;
     }
     onAttached() {
-        console.log('~~attched', this.getName(), this.channel);
-        const Messages = this.getProtocol().getAnt().Messages;
-        const stick = this.stick;
-        const channel = this.channel;
-        const { DeviceID } = this.deviceData;
-        stick.write(Messages.assignChannel(channel, "transmit"));
-        stick.write(Messages.setFrequency(channel, 57));
-        stick.write(Messages.setPeriod(channel, 8192));
-        stick.write(Messages.setDevice(channel, DeviceID, 0x11, 0x0));
-        stick.write(Messages.openChannel(channel));
+        this.logger.logEvent({ message: 'Device connected' });
         this.connected = true;
     }
     onDeviceData(deviceData) {
-        if (!this.started)
+        if (!this.started || this.isStopped())
             return;
         this.deviceData = deviceData;
         try {
             if (this.onDataFn && !(this.ignoreHrm && this.ignoreBike && this.ignorePower) && !this.paused) {
                 if (!this.lastUpdate || (Date.now() - this.lastUpdate) > this.updateFrequency) {
-                    console.log('~~deviceData', deviceData);
+                    this.logger.logEvent({ message: 'onDeviceData', data: deviceData });
                     this.data = this.updateData(this.data, deviceData);
                     const data = this.transformData(this.data);
                     this.onDataFn(data);
@@ -76,24 +78,45 @@ class AntFEAdapter extends AntAdapter_1.default {
     }
     onDeviceEvent(data) {
         try {
-            const Constants = this.getProtocol().getAnt().Constants;
-            let stick = this.stick;
-            if (stick.currentCmd !== undefined && data.message === 1 && data.code === Constants.EVENT_TRANSFER_TX_COMPLETED) {
-                stick.currentCmd.response = { success: true };
+            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 (stick.currentCmd !== undefined && data.message === 1 && data.code === Constants.EVENT_TRANSFER_TX_FAILED) {
-                stick.currentCmd.response = { success: false };
-                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 (stick.currentCmd !== undefined && data.message === Constants.MESSAGE_CHANNEL_ACKNOWLEDGED_DATA && data.code === 31) {
+            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: data });
+            this.logger.logEvent({ message: "Incoming Event ", event: { message: hex(data.message), code: hex(data.code) } });
         }
         catch (err) {
-            this.logger.logEvent({ message: 'Error', fn: 'parseEvent', data: utils_2.hexstr(data), error: err.message });
+            this.logger.logEvent({ message: 'Error', fn: 'parseEvent', event: { message: hex(data.message), code: hex(data.code) }, error: err.message || err });
         }
     }
     updateData(data, deviceData) {
@@ -104,10 +127,18 @@ class AntFEAdapter extends AntAdapter_1.default {
         data.power = (deviceData.InstantaneousPower !== undefined ? deviceData.InstantaneousPower : data.power);
         data.pedalRpm = (deviceData.Cadence !== undefined ? deviceData.Cadence : data.pedalRpm);
         data.heartrate = (deviceData.HeartRate !== undefined ? deviceData.HeartRate : data.heartrate);
-        if (deviceData.Distance !== undefined) {
+        if (deviceData.Distance !== undefined && deviceData.Distance !== 0) {
             data.distanceInternal = deviceData.Distance - data.distanceOffs;
             data.distance = data.distanceInternal / 1000;
         }
+        else {
+            if (this.lastUpdate && deviceData.Cadence !== undefined && deviceData.Cadence > 0 && data.speed) {
+                const t = (Date.now() - this.lastUpdate) / 1000;
+                const prevDistance = data.distanceInternal || 0;
+                data.distanceInternal = Math.round(data.speed / 3.6 * t) + prevDistance;
+                data.distance = data.distanceInternal / 1000;
+            }
+        }
         return data;
     }
     transformData(bikeData) {
@@ -140,89 +171,156 @@ class AntFEAdapter extends AntAdapter_1.default {
         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()' });
-            console.log('~~start', this.started, this.connected, this.starting);
-            const opts = props || {};
+            const args = props || {};
             return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                if (this.ignoreHrm && this.ignoreBike && this.ignorePower)
+                if (this.ignoreHrm && 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' });
+                    this.startWorker();
                     return resolve(true);
                 }
                 this.starting = true;
                 const Ant = this.getProtocol().getAnt();
                 const protocol = this.getProtocol();
-                protocol.attachSensors(this, Ant.FitnessEquipmentSensor, 'fitnessData')
-                    .then(() => __awaiter(this, void 0, void 0, function* () {
+                let start = Date.now();
+                let timeout = start + (args.timeout || TIMEOUT_ATTACH);
+                const ivAttach = setInterval(() => {
+                    if (Date.now() > timeout) {
+                        clearInterval(ivAttach);
+                        this.starting = false;
+                        reject(new Error('timeout'));
+                    }
+                    if (this.isStopped()) {
+                        clearInterval(ivAttach);
+                        this.starting = false;
+                        reject(new Error('stopped'));
+                    }
+                }, 100);
+                try {
+                    if (!this.connected) {
+                        this.logger.logEvent({ message: 'attach device ...' });
+                        yield protocol.attachSensors(this, Ant.FitnessEquipmentSensor, 'fitnessData');
+                    }
+                    clearInterval(ivAttach);
                     this.startWorker();
                     const tsStart = Date.now();
                     const iv = setInterval(() => __awaiter(this, void 0, void 0, function* () {
                         if (this.connected) {
                             clearInterval(iv);
-                            try {
-                                yield this.sendTrackResistance(0.0);
-                                yield this.sendUserConfiguration(opts.userWeight || 72, opts.bikeWeight || 12.75, opts.wheelDiameter, opts.gearRatio);
-                            }
-                            catch (err) {
-                                console.log('~~~err:', err);
-                            }
-                            this.started = true;
-                            this.starting = false;
-                            resolve(true);
+                            let status = {
+                                trackResistanceSent: false,
+                                userSent: false,
+                            };
+                            (0, utils_2.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () {
+                                if (this.isStopped())
+                                    resolve(false);
+                                try {
+                                    if (!status.trackResistanceSent) {
+                                        yield this.sendTrackResistance(0.0);
+                                        status.trackResistanceSent = true;
+                                    }
+                                    if (!status.userSent) {
+                                        yield this.sendUserConfiguration(args.userWeight || DEFAULT_USER_WEIGHT, args.bikeWeight || DEFAULT_BIKE_WEIGHT, args.wheelDiameter, args.gearRatio);
+                                        status.userSent = true;
+                                    }
+                                    this.started = true;
+                                    this.starting = false;
+                                    resolve(true);
+                                }
+                                catch (err) {
+                                    throw (new Error(`could not start device, reason:${err.message || err}`));
+                                }
+                            }), 5, 1500)
+                                .catch(err => {
+                                this.logger.logEvent({ message: 'start() error', error: err.message || err });
+                                this.starting = false;
+                                reject(err);
+                            });
                         }
                         else if ((Date.now() - tsStart) > TIMEOUT_START) {
                             clearInterval(iv);
-                            this.started = true;
                             try {
                                 yield protocol.detachSensor(this);
                             }
                             catch (err) { }
+                            this.started = false;
                             this.starting = false;
-                            reject(new Error('timeout'));
+                            reject(new Error('could not start device, reason:timeout'));
                         }
                     }), 50);
-                }))
-                    .catch(err => {
+                }
+                catch (err) {
+                    this.logger.logEvent({ message: 'start() error', error: err.message });
                     this.starting = false;
-                    reject(err);
-                });
+                    reject(new Error(`could not start device, reason:${err.message}`));
+                }
             }));
         });
     }
     stop() {
-        this.logger.logEvent({ message: 'stop()' });
-        console.log('~~~stop', this.started, this.connected);
-        this.stopWorker();
-        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-            return resolve(true);
-        }));
+        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()' });
+            this.stopWorker();
+            const Messages = this.getProtocol().getAnt().Messages;
+            const stick = this.stick;
+            const channel = this.channel;
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                this.starting = false;
+                return resolve(true);
+                if (!this.started && !this.connected)
+                    return resolve(false);
+                try {
+                    stick.write(Messages.openChannel(channel));
+                    const protocol = this.getProtocol();
+                    yield protocol.detachSensor(this);
+                    this.started = false;
+                    this.connected = false;
+                    this.logger.logEvent({ message: 'stop() finished' });
+                    resolve(true);
+                }
+                catch (err) {
+                    this.connected = false;
+                    this.logger.logEvent({ message: 'stop() error', error: err.message });
+                    reject(err);
+                }
+            }));
+        });
     }
     sendUpdate(request) {
         return __awaiter(this, void 0, void 0, function* () {
             this.logger.logEvent({ message: "sendBikeUpdate():", request });
-            console.log('~~sendUpdate', request);
             try {
+                const isReset = (!request || request.reset || Object.keys(request).length === 0);
                 if (request.slope !== undefined) {
-                    yield this.sendTrackResistance(request.slope);
+                    yield (0, utils_2.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () { return yield this.sendTrackResistance(request.slope); }), 2, 100);
                 }
                 if (request.targetPower !== undefined) {
-                    yield this.sendTargetPower(request.targetPower);
+                    yield (0, utils_2.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () { return yield this.sendTargetPower(request.targetPower); }), 2, 100);
                 }
                 else if (request.maxPower !== undefined) {
                     if (this.data.power && this.data.power > request.maxPower)
-                        yield this.sendTargetPower(request.maxPower);
+                        yield (0, utils_2.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () { return yield this.sendTargetPower(request.maxPower); }), 2, 100);
                 }
                 else if (request.minPower !== undefined) {
                     if (this.data.power && this.data.power < request.minPower)
-                        yield this.sendTargetPower(request.minPower);
-                }
-                if (request.maxHrm !== undefined) {
-                }
-                if (request.minHrm !== undefined) {
+                        yield (0, utils_2.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () { return yield this.sendTargetPower(request.minPower); }), 2, 100);
                 }
             }
             catch (err) {
@@ -230,17 +328,36 @@ class AntFEAdapter extends AntAdapter_1.default {
             }
         });
     }
-    send(msg, logStr, callback) {
+    send(msg, logStr, callback, expectedResponse) {
         if (this.workerId === undefined) {
             return;
         }
-        this.queue.enqueue({ msg, logStr, callback });
+        this.queue.enqueue({ msg, logStr, callback, expectedResponse });
+    }
+    sendAsync(msg, logStr, expectedResponse) {
+        return new Promise((resolve, reject) => {
+            this.send(msg, logStr, (res, err) => {
+                if (err)
+                    return reject(err);
+                resolve(res);
+            }, expectedResponse);
+        });
     }
     startWorker() {
+        this.logger.logEvent({ message: 'startWorker()' });
         if (this.queue === undefined) {
             this.queue = new utils_2.Queue();
         }
-        this.workerId = setInterval(() => { this.sendFromQueue(); }, 100);
+        if (this.workerId)
+            return;
+        this.workerId = setInterval(() => {
+            try {
+                this.sendFromQueue();
+            }
+            catch (err) {
+                this.logger.logEvent({ message: 'sendFromQueue error', error: err.message });
+            }
+        }, 10);
     }
     stopWorker() {
         if (!this.workerId)
@@ -250,8 +367,9 @@ class AntFEAdapter extends AntAdapter_1.default {
         this.workerId = undefined;
     }
     sendFromQueue() {
-        if (this.queue === undefined || !this.connected)
+        if (this.queue === undefined) {
             return;
+        }
         if (this.currentCmd !== undefined) {
             const cmdInfo = this.currentCmd;
             if (this.currentCmd.response === undefined) {
@@ -261,7 +379,6 @@ class AntFEAdapter extends AntAdapter_1.default {
                     timeout = TIMEOUT_ACK;
                 let duration = Date.now() - tsStart;
                 if (duration > timeout) {
-                    console.log('~~~timeout');
                     this.logger.logEvent({ message: 'timeout', cmd: logStr, timeout: `${timeout}ms` });
                     this.currentCmd = undefined;
                     if (callback !== undefined) {
@@ -275,7 +392,7 @@ class AntFEAdapter extends AntAdapter_1.default {
                 this.currentCmd = undefined;
                 if (callback !== undefined) {
                     if (response && response.success === false) {
-                        callback(undefined, new Error('error'));
+                        callback(undefined, new Error(`ANT error ${response.code}`));
                         return;
                     }
                     callback(response);
@@ -288,13 +405,17 @@ class AntFEAdapter extends AntAdapter_1.default {
             this.currentCmd = this.queue.dequeue();
             this.currentCmd.tsStart = Date.now();
             const { msg, logStr } = this.currentCmd;
-            this.logger.logEvent({ message: "sending", cmd: logStr, msg: utils_2.hexstr(msg), queueSize: this.queue.size() });
-            console.log('~~sending', logStr, utils_2.hexstr(msg));
-            this.stick.write(msg);
+            this.logger.logEvent({ message: "sending", cmd: logStr, msg: (0, utils_2.hexstr)(msg), queueSize: this.queue.size() });
+            if (this.stick)
+                this.stick.write(msg);
         }
     }
     sendUserConfiguration(userWeight, bikeWeight, wheelDiameter, gearRatio) {
         return new Promise((resolve, reject) => {
+            if (!this.connected)
+                reject(new Error('not connected'));
+            if (!this.queue)
+                this.startWorker();
             var payload = [];
             payload.push(this.channel);
             const logStr = `sendUserConfiguration(${userWeight},${bikeWeight},${wheelDiameter},${gearRatio})`;
@@ -334,6 +455,10 @@ class AntFEAdapter extends AntAdapter_1.default {
     }
     sendBasicResistance(resistance) {
         return new Promise((resolve, reject) => {
+            if (!this.connected)
+                reject(new Error('not connected'));
+            if (!this.queue)
+                this.startWorker();
             var payload = [];
             payload.push(this.channel);
             const logStr = `sendBasicResistance(${resistance})`;
@@ -358,6 +483,10 @@ class AntFEAdapter extends AntAdapter_1.default {
     }
     sendTargetPower(power) {
         return new Promise((resolve, reject) => {
+            if (!this.connected)
+                reject(new Error('not connected'));
+            if (!this.queue)
+                this.startWorker();
             var payload = [];
             payload.push(this.channel);
             const logStr = `sendTargetPower(${power})`;
@@ -382,6 +511,10 @@ class AntFEAdapter extends AntAdapter_1.default {
     }
     sendWindResistance(windCoeff, windSpeed, draftFactor) {
         return new Promise((resolve, reject) => {
+            if (!this.connected)
+                reject(new Error('not connected'));
+            if (!this.queue)
+                this.startWorker();
             var payload = [];
             payload.push(this.channel);
             const logStr = `sendWindResistance(${windCoeff},${windSpeed},${draftFactor})`;
@@ -416,6 +549,10 @@ class AntFEAdapter extends AntAdapter_1.default {
     }
     sendTrackResistance(slope, rrCoeff) {
         return new Promise((resolve, reject) => {
+            if (!this.connected)
+                reject(new Error('not connected'));
+            if (!this.queue)
+                this.startWorker();
             var payload = [];
             payload.push(this.channel);
             const logStr = `sendTrackResistance(${slope},${rrCoeff})`;

package/lib/ant/anthrm/AntHrmAdapter.d.ts

@@ -1,13 +1,16 @@
 import AntAdapter from '../AntAdapter';
 export default class AntHrmAdapter extends AntAdapter {
+    started: boolean;
+    starting: boolean;
     constructor(DeviceID: any, port: any, stick: any, protocol: any);
     isBike(): boolean;
     isHrm(): boolean;
     isPower(): boolean;
+    getProfile(): string;
     getName(): string;
     getDisplayName(): string;
     onDeviceData(deviceData: any): void;
     updateData(data: any, deviceData: any): any;
-    start(): Promise<unknown>;
+    start(props?: any): Promise<any>;
     stop(): Promise<boolean>;
 }

package/lib/ant/anthrm/AntHrmAdapter.js

@@ -8,10 +8,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const gd_eventlog_1 = require("gd-eventlog");
-const AntAdapter_1 = require("../AntAdapter");
+const AntAdapter_1 = __importDefault(require("../AntAdapter"));
 const utils_1 = require("../utils");
+const DEFAULT_START_TIMEOUT = 5000;
 class AntHrmAdapter extends AntAdapter_1.default {
     constructor(DeviceID, port, stick, protocol) {
         super(protocol);
@@ -19,28 +23,36 @@ class AntHrmAdapter extends AntAdapter_1.default {
         this.deviceID = DeviceID;
         this.port = port;
         this.stick = stick;
+        this.paused = false;
         this.deviceData = {
             DeviceID
         };
         this.data = {};
+        this.started = false;
+        this.starting = false;
     }
     isBike() { return false; }
     isHrm() { return true; }
     isPower() { return false; }
+    getProfile() {
+        return 'Heartrate Monitor';
+    }
     getName() {
         return `Ant+Hrm ${this.deviceID}`;
     }
     getDisplayName() {
         const { DeviceID, manID, ComputedHeartRate } = this.deviceData;
         const hrmStr = ComputedHeartRate ? ` (${ComputedHeartRate})` : '';
-        return `${utils_1.getBrand(manID)} Hrm ${DeviceID}${hrmStr}`;
+        return `${(0, utils_1.getBrand)(manID)} Hrm ${DeviceID}${hrmStr}`;
     }
     onDeviceData(deviceData) {
+        if (!this.started)
+            return;
         this.deviceData = deviceData;
         try {
             if (this.onDataFn && !this.ignoreHrm && !this.paused) {
-                if (!this.lastUpdate || (Date.now() - this.lastUpdate) > this.updateFrequency) {
-                    console.log('~~deviceData', deviceData);
+                if (this.lastUpdate === undefined || (Date.now() - this.lastUpdate) > this.updateFrequency) {
+                    this.logger.logEvent({ message: 'onDeviceData', data: deviceData });
                     const data = this.updateData(this.data, deviceData);
                     this.onDataFn(data);
                     this.lastUpdate = Date.now();
@@ -54,34 +66,76 @@ class AntHrmAdapter extends AntAdapter_1.default {
         data.heartrate = deviceData.ComputedHeartRate;
         return data;
     }
-    start() {
+    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()' });
+            const args = props || {};
             return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
                 if (this.ignoreHrm)
                     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.HeartRateSensor, 'hbData')
-                    .then(() => resolve(true))
+                    .then(() => {
+                    this.starting = false;
+                    this.started = true;
+                    clearInterval(iv);
+                    resolve(true);
+                })
                     .catch(err => reject(err));
             }));
         });
     }
     stop() {
-        this.logger.logEvent({ message: 'stop()' });
-        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-            if (this.ignoreHrm)
-                return resolve(false);
-            try {
-                const protocol = this.getProtocol();
-                yield protocol.detachSensor(this);
-                resolve(true);
-            }
-            catch (err) {
-                reject(err);
-            }
-        }));
+        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);
+                this.started = false;
+                if (this.ignoreHrm)
+                    return resolve(false);
+                try {
+                    const protocol = this.getProtocol();
+                    yield protocol.detachSensor(this);
+                    resolve(true);
+                }
+                catch (err) {
+                    reject(err);
+                }
+            }));
+        });
     }
 }
 exports.default = AntHrmAdapter;