incyclist-devices 1.3.0 → 1.4.1

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

@@ -20,7 +20,7 @@ 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, expectedResponse?: any): 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 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;
@@ -44,18 +52,20 @@ class AntFEAdapter extends AntAdapter_1.default {
     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() {
+        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) {
+                    this.logger.logEvent({ message: 'onDeviceData', data: deviceData });
                     this.data = this.updateData(this.data, deviceData);
                     const data = this.transformData(this.data);
                     this.onDataFn(data);
@@ -68,40 +78,45 @@ class AntFEAdapter extends AntAdapter_1.default {
     }
     onDeviceEvent(data) {
         try {
-            let stick = this.stick;
-            const msg = this.currentCmd && this.currentCmd.msg ? this.currentCmd.msg.readUInt8(2) : '';
-            const cmdInfo = this.currentCmd || {};
+            const cmdInfo = this.currentCmd;
+            if (!cmdInfo)
+                return;
+            const msg = cmdInfo.msg.readUInt8(2);
             const Constants = this.getProtocol().getAnt().Constants;
             const { expectedResponse } = cmdInfo;
-            if (this.currentCmd !== undefined && data.message === msg && expectedResponse === undefined && data.code === 0) {
-                this.currentCmd.response = { success: true };
-                return;
-            }
-            if (this.currentCmd !== undefined && data.message === msg && data.code !== 0) {
-                this.currentCmd.response = { success: false };
-                return;
-            }
-            if (this.currentCmd !== undefined && data.message === 1 && expectedResponse === undefined && (data.code === 5 || data.code === 3)) {
-                this.currentCmd.response = { success: true };
-                return;
-            }
-            if (this.currentCmd !== undefined && data.message === 1 && expectedResponse !== undefined && data.code === expectedResponse) {
-                this.currentCmd.response = { success: true };
-                return;
+            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 (this.currentCmd !== undefined && data.message === 1 && data.code === 6) {
-                this.stick.write(this.currentCmd.msg);
-                this.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 (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) {
@@ -112,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) {
@@ -148,102 +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()' });
-            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()' });
-        this.stopWorker();
-        const Messages = this.getProtocol().getAnt().Messages;
-        const stick = this.stick;
-        const channel = this.channel;
-        stick.write(Messages.openChannel(channel));
-        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-            if (!this.started && !this.connected)
-                return resolve(false);
-            try {
-                const protocol = this.getProtocol();
-                yield protocol.detachSensor(this);
-                this.started = false;
-                this.connected = false;
-                resolve(true);
-            }
-            catch (err) {
-                this.connected = false;
-                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()' });
+            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 });
             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) {
@@ -267,10 +344,20 @@ class AntFEAdapter extends AntAdapter_1.default {
         });
     }
     startWorker() {
+        this.logger.logEvent({ message: 'startWorker()' });
         if (this.queue === undefined) {
             this.queue = new utils_2.Queue();
         }
-        this.workerId = setInterval(() => { this.sendFromQueue(); }, 10);
+        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)
@@ -280,8 +367,9 @@ class AntFEAdapter extends AntAdapter_1.default {
         this.workerId = undefined;
     }
     sendFromQueue() {
-        if (this.queue === undefined)
+        if (this.queue === undefined) {
             return;
+        }
         if (this.currentCmd !== undefined) {
             const cmdInfo = this.currentCmd;
             if (this.currentCmd.response === undefined) {
@@ -304,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);
@@ -317,14 +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() });
-            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) {
-        if (!this.connected)
-            return;
         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})`;
@@ -363,9 +454,11 @@ class AntFEAdapter extends AntAdapter_1.default {
         });
     }
     sendBasicResistance(resistance) {
-        if (!this.connected)
-            return;
         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})`;
@@ -389,9 +482,11 @@ class AntFEAdapter extends AntAdapter_1.default {
         });
     }
     sendTargetPower(power) {
-        if (!this.connected)
-            return;
         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})`;
@@ -415,9 +510,11 @@ class AntFEAdapter extends AntAdapter_1.default {
         });
     }
     sendWindResistance(windCoeff, windSpeed, draftFactor) {
-        if (!this.connected)
-            return;
         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})`;
@@ -451,9 +548,11 @@ class AntFEAdapter extends AntAdapter_1.default {
         });
     }
     sendTrackResistance(slope, rrCoeff) {
-        if (!this.connected)
-            return;
         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,5 +1,7 @@
 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;
@@ -9,6 +11,6 @@ export default class AntHrmAdapter extends AntAdapter {
     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,10 +23,13 @@ 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; }
@@ -36,14 +43,16 @@ class AntHrmAdapter extends AntAdapter_1.default {
     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();
@@ -57,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;

package/lib/ant/utils.js

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