incyclist-devices 1.1.0 → 1.3.25

package/lib/ant/AntScanner.js

@@ -1,4 +1,23 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -8,14 +27,18 @@ 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 });
 exports.AntScanner = exports.AntProtocol = void 0;
 const gd_eventlog_1 = require("gd-eventlog");
-const DeviceProtocol_1 = require("../DeviceProtocol");
-const AntHrmAdapter_1 = require("./anthrm/AntHrmAdapter");
-const AntFEAdapter_1 = require("./antfe/AntFEAdapter");
+const DeviceProtocol_1 = __importStar(require("../DeviceProtocol"));
+const AntHrmAdapter_1 = __importDefault(require("./anthrm/AntHrmAdapter"));
+const AntFEAdapter_1 = __importDefault(require("./antfe/AntFEAdapter"));
 const LOGGER_NAME = 'ANT+Scanner';
 const DEFAULT_SCAN_TIMEOUT = 30000;
+const TIMEOUT_STARTUP = 3000;
 const hex = (n, len) => {
     const c = "0";
     let s = n.toString(16);
@@ -23,6 +46,19 @@ const hex = (n, len) => {
         return `0x${c.repeat(len - s.length)}${s}`;
     return `0x${s}`;
 };
+const isStickPresent = (stick, retries) => __awaiter(void 0, void 0, void 0, function* () {
+    let n = 0;
+    while (n < retries) {
+        try {
+            return stick.is_present();
+        }
+        catch (e) {
+            n++;
+            yield new Promise(resolve => setTimeout(resolve, 1000));
+        }
+    }
+    return false;
+});
 class AntProfile {
     constructor(profile, AntScannerClass, stick, message, onNewDevice, onData) {
         if (process.env.ANT_PROFILE_DEBUG)
@@ -63,13 +99,35 @@ class AntProtocol extends DeviceProtocol_1.default {
         this.activeScans = {};
         this.sensors = {};
         this.sticks = [];
+        this.scanning = false;
         this.profiles = [
             { name: 'Heartrate Monitor', Adapter: AntHrmAdapter_1.default },
             { name: 'Smart Trainer', Adapter: AntFEAdapter_1.default }
         ];
     }
+    add(settings) {
+        this.logger.logEvent({ message: 'adding device', settings });
+        const { profile, deviceID, port } = settings;
+        const profileInfo = this.profiles.find(i => i.name === profile);
+        if (profileInfo) {
+            let device;
+            try {
+                device = new profileInfo.Adapter(deviceID, port, undefined, this);
+                this.devices.push(device);
+                return device;
+            }
+            catch (err) {
+                this.logger.logEvent({ message: 'adding device error', error: err.message });
+                return;
+            }
+        }
+        this.logger.logEvent({ message: 'adding device: profile not found' });
+    }
+    getAnt() {
+        return this.ant || DeviceProtocol_1.default.getAnt();
+    }
     getName() { return 'Ant'; }
-    getInterfaces() { return DeviceProtocol_1.INTERFACE.ANT; }
+    getInterfaces() { return [DeviceProtocol_1.INTERFACE.ANT]; }
     isBike() { return true; }
     isHrm() { return true; }
     isPower() { return true; }
@@ -106,54 +164,190 @@ class AntProtocol extends DeviceProtocol_1.default {
         const info = this.getStickInfo(sticks);
         this.logger.logEvent({ message: 'stick info', info });
     }
-    getStick() {
-        if (!this.ant)
-            return;
-        const stick2 = new this.ant.GarminStick2();
-        if (stick2.is_present() && stick2.open()) {
-            this.logger.logEvent({ message: 'found GarminStick2' });
-            return stick2;
-        }
-        const stick3 = new this.ant.GarminStick3();
-        if (stick3.is_present() && stick3.open()) {
-            this.logger.logEvent({ message: 'found GarminStick3' });
-            return stick3;
+    getDetailedStickInfo(stick) {
+        const devices = stick.getDevices();
+        if (devices.length > 0) {
+            const device = devices[0];
+            try {
+                const config = JSON.parse(JSON.stringify(device.configDescriptor));
+                const interfaces = config ? config.interfaces : [];
+                delete config.interfaces;
+                this.logger.logEvent({ message: 'USB DeviceConfig', config, interfaces });
+            }
+            catch (err) {
+                this.logger.logEvent({ message: 'USB Error', error: err.message });
+            }
         }
-        return undefined;
     }
-    getSticks() {
+    getStick(onStart, onError) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.ant)
                 return;
-            let done = false;
-            const sticks = [];
-            while (!done) {
-                const stick = this.getStick();
-                if (stick) {
-                    const port = this.getUSBDeviceInfo(stick.device).port;
-                    sticks.push(stick);
-                    if (!this.sticks.find(i => i.port === port)) {
-                        this.sticks.push({ port, stick });
+            const startupAttempt = (stick, name) => {
+                return new Promise((resolve, reject) => {
+                    this.logger.logEvent({ message: `${name} startup attempt` });
+                    if (stick.scanConnected) {
+                        onStart(this);
+                        resolve(stick);
+                        return;
                     }
+                    if (isStickPresent(stick, 2)) {
+                        stick.on('error', (err) => {
+                            this.logger.logEvent({ message: `${name} startup error`, error: err.message });
+                            onError(err.message);
+                        });
+                        stick.on('startup', () => {
+                            if (stick.scanConnected)
+                                return;
+                            this.logger.logEvent({ message: `${name} startup completed` });
+                            stick.scanConnected = true;
+                            onStart(stick);
+                            resolve(stick);
+                        });
+                        const devices = stick.getDevices();
+                        if (devices && devices.length > 0) {
+                            devices.forEach(d => {
+                                d.closeFn = d.close;
+                                d.close = () => { };
+                            });
+                        }
+                        else {
+                            this.logger.logEvent({ message: `${name} startup failed: no devices ` });
+                            resolve(null);
+                        }
+                        this.getDetailedStickInfo(stick);
+                        let open = false;
+                        try {
+                            open = stick.open();
+                            if (open) {
+                                this.logger.logEvent({ message: `found ${name}` });
+                                const timeoutStartup = Date.now() + TIMEOUT_STARTUP;
+                                const iv = setInterval(() => {
+                                    if (!stick.scanConnected && Date.now() > timeoutStartup) {
+                                        clearInterval(iv);
+                                        this.logger.logEvent({ message: `${name} startup timeout` });
+                                    }
+                                    if (stick.scanConnected)
+                                        clearInterval(iv);
+                                }, 100);
+                                return stick;
+                            }
+                        }
+                        catch (openErr) {
+                            this.logger.logEvent({ message: 'Open Error', error: openErr.message });
+                        }
+                        if (devices && devices.length > 0) {
+                            devices.forEach(d => {
+                                d.close = d.closeFn;
+                            });
+                        }
+                        if (!open) {
+                            let detachedKernelDriver = false;
+                            while (devices.length) {
+                                let device;
+                                try {
+                                    device = devices.shift();
+                                    device.open();
+                                    const iface = device.interfaces[0];
+                                    try {
+                                        if (iface.isKernelDriverActive()) {
+                                            detachedKernelDriver = true;
+                                            iface.detachKernelDriver();
+                                        }
+                                    }
+                                    catch (kernelErr) {
+                                        this.logger.logEvent({ message: 'Kernel Error', error: kernelErr.message });
+                                    }
+                                    iface.claim();
+                                    break;
+                                }
+                                catch (deviceErr) {
+                                    this.logger.logEvent({ message: 'Device Error', error: deviceErr.message });
+                                    if (device) {
+                                        try {
+                                            device.close();
+                                        }
+                                        catch (_a) { }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    this.logger.logEvent({ message: `${name} startup failed: no stick present` });
+                    resolve(null);
+                });
+            };
+            let stick = undefined;
+            stick = yield startupAttempt(new this.ant.GarminStick2(), 'GarminStick2');
+            if (!stick)
+                stick = yield startupAttempt(new this.ant.GarminStick3(), 'GarminStick3');
+            if (!stick)
+                onError('No stick found');
+            else
+                return stick;
+        });
+    }
+    getFirstStick() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                if (!this.ant)
+                    return reject(new Error('Ant not supported'));
+                if (this.sticks && this.sticks.length > 0 && this.sticks[0].connected) {
+                    this.logger.logEvent({ message: 'stick already connected' });
+                    return resolve(this.sticks[0]);
                 }
-                else
-                    done = true;
-            }
-            const stickInfos = sticks.map(stick => { return { stick, port: this.getUSBDeviceInfo(stick.device).port }; });
-            for (let i = 0; i < sticks.length; i++) {
-                yield this.closeStick(sticks[i]);
-            }
-            return stickInfos;
+                try {
+                    let start = Date.now();
+                    let timeout = start + 5000;
+                    let found = false;
+                    const iv = setInterval(() => {
+                        if (!found && Date.now() > timeout) {
+                            clearInterval(iv);
+                            reject(new Error('timeout'));
+                        }
+                    }, 100);
+                    this.getStick((stick) => {
+                        clearInterval(iv);
+                        const port = this.getUSBDeviceInfo(stick.device).port;
+                        if (!this.sticks.find(i => i.port === port)) {
+                            this.sticks.push({ port, stick, connected: true });
+                        }
+                        resolve({ port, stick });
+                    }, (reason) => {
+                        resolve(undefined);
+                    });
+                }
+                catch (err) {
+                    this.logger.logEvent({ message: 'getFirstStick error', error: err.message, stack: err.stack });
+                }
+            }));
         });
     }
     closeStick(stick) {
+        this.logger.logEvent({ message: 'closing stick' });
         return new Promise((resolve, reject) => {
-            stick.once('shutdown', () => {
+            stick.on('shutdown', () => {
+                this.logger.logEvent({ message: 'stick shutdown' });
+                stick.removeAllListeners('shutdown');
+                const port = this.getUSBDeviceInfo(stick.device).port;
+                const idx = this.sticks.findIndex(i => i.port === port);
+                if (idx !== -1) {
+                    this.sticks[idx].connected = false;
+                }
+                this.sensors = {};
                 resolve(true);
             });
             try {
                 stick.detach_all();
-                setTimeout(() => { stick.close(); }, 1000);
+                setTimeout(() => {
+                    try {
+                        stick.close();
+                    }
+                    catch (err) { }
+                    this.logger.logEvent({ message: 'stick closed' });
+                    stick.scanConnected = false;
+                    this.sensors = {};
+                }, 1000);
             }
             catch (err) {
                 reject(err);
@@ -166,6 +360,7 @@ class AntProtocol extends DeviceProtocol_1.default {
         return this.closeStick(stick)
             .then(() => {
             state.isScanning = false;
+            this.scanning = this.stillScanning();
             if (state.iv) {
                 clearInterval(state.iv);
                 state.iv = undefined;
@@ -177,100 +372,119 @@ class AntProtocol extends DeviceProtocol_1.default {
             return true;
         });
     }
+    stillScanning() {
+        const ports = Object.keys(this.activeScans);
+        return ports.find(p => this.activeScans[p].isScanning) !== undefined;
+    }
     scanOnStick(stickInfo, props = {}) {
         const { stick, port } = stickInfo;
         const timeout = props.timeout || DEFAULT_SCAN_TIMEOUT;
         const { onDeviceFound, onScanFinished, onUpdate, id } = props;
+        this.logger.logEvent({ message: 'stick scan request', port, activeScans: this.activeScans });
+        if (process.env.ANT_DEBUG) {
+            stick.props = { debug: true };
+        }
         return new Promise((resolve, reject) => {
-            stick.once('startup', () => {
-                if (!port || (this.activeScans[port] && this.activeScans[port].isScanning))
-                    return;
-                if (!this.activeScans[port]) {
-                    this.activeScans[port] = { isScanning: false, stick };
-                }
-                const state = this.activeScans[port];
-                if (state.isScanning)
-                    return;
-                state.isScanning = true;
-                this.logger.logEvent({ message: 'start scan', port });
-                state.timeout = Date.now() + timeout;
-                const onNewDevice = (profile, deviceId) => {
-                    this.logger.logEvent({ message: 'found device', profile, id: deviceId });
-                    const profileInfo = this.profiles.find(i => i.name === profile);
-                    if (profileInfo) {
-                        let device;
-                        try {
-                            device = new profileInfo.Adapter(deviceId, port, stick, this, props);
+            if (!port)
+                return reject(new Error('busy'));
+            if (this.activeScans[port] && this.activeScans[port].isScanning)
+                return reject(new Error('busy'));
+            if (!this.activeScans[port]) {
+                this.activeScans[port] = { isScanning: false, stick };
+            }
+            const state = this.activeScans[port];
+            if (state.isScanning)
+                return reject(new Error('busy'));
+            state.isScanning = true;
+            this.logger.logEvent({ message: 'start scan', port });
+            state.timeout = Date.now() + timeout;
+            const onNewDevice = (profile, deviceId) => {
+                this.logger.logEvent({ message: 'found device', profile, id: deviceId });
+                const profileInfo = this.profiles.find(i => i.name === profile);
+                if (profileInfo) {
+                    let device;
+                    try {
+                        device = new profileInfo.Adapter(deviceId, port, stick, this, props);
+                        const existing = this.devices.find(d => (d.getID() === deviceId && d.getProfile() === profile));
+                        if (!existing)
                             this.devices.push(device);
-                        }
-                        catch (err) {
-                            console.log(err);
-                        }
-                        if (device && onDeviceFound) {
-                            onDeviceFound(device, this);
-                            device.setDetected(true);
-                        }
                     }
-                };
-                const onData = (profile, deviceId, data) => {
-                    const device = this.devices.find(d => d.getID() === deviceId);
-                    if (device) {
-                        const isHrm = device.isHrm();
-                        device.onDeviceData(data);
-                        if (device.isHrm() && !isHrm && onDeviceFound) {
-                            onDeviceFound(device, this);
-                        }
-                        if (onUpdate)
-                            onUpdate(device);
+                    catch (err) {
+                        this.logger.logEvent({ message: 'onNewDevice:ERROR', error: err.message });
                     }
-                };
-                const hrm = new AntProfile('Heartrate Monitor', this.ant.HeartRateScanner, stick, 'hbData', onNewDevice, onData);
-                const fe = new AntProfile('Smart Trainer', this.ant.FitnessEquipmentScanner, stick, 'fitnessData', onNewDevice, onData);
-                const power = new AntProfile('Power Meter', this.ant.BicyclePowerScanner, stick, 'powerData', onNewDevice, onData);
+                    if (device && onDeviceFound) {
+                        onDeviceFound(device, this);
+                        device.setDetected(true);
+                    }
+                }
+            };
+            const onData = (profile, deviceId, data) => {
+                const device = this.devices.find(d => d.getID() === deviceId);
+                if (device) {
+                    const isHrm = device.isHrm();
+                    device.onDeviceData(data);
+                    if (device.isHrm() && !isHrm && onDeviceFound) {
+                        onDeviceFound(device, this);
+                    }
+                    if (onUpdate)
+                        onUpdate(device);
+                }
+            };
+            const hrm = new AntProfile('Heartrate Monitor', this.ant.HeartRateScanner, stick, 'hbData', onNewDevice, onData);
+            const fe = new AntProfile('Smart Trainer', this.ant.FitnessEquipmentScanner, stick, 'fitnessData', onNewDevice, onData);
+            const power = new AntProfile('Power Meter', this.ant.BicyclePowerScanner, stick, 'powerData', onNewDevice, onData);
+            try {
                 hrm.getScanner().scan();
                 hrm.getScanner().on('attached', () => {
                     power.getScanner().scan();
                     fe.getScanner().scan();
                 });
-                state.iv = setInterval(() => {
-                    if (Date.now() > timeout) {
-                        this.logger.logEvent({ message: 'scan timeout', port });
-                        this.stopScanOnStick(stickInfo).then(() => {
-                            if (onScanFinished)
-                                onScanFinished(id);
-                            resolve(true);
-                        });
-                    }
-                }, timeout);
-            });
-            let opened = false;
-            try {
-                opened = stick.open();
             }
-            catch (err) { }
-            if (!opened) {
-                reject(new Error('stick could not be opened'));
-                return;
+            catch (err) {
+                this.logger.logEvent({ message: 'scan error', error: err.message });
             }
-            this.logger.log('stick opened', port);
+            state.iv = setInterval(() => {
+                if (Date.now() > timeout) {
+                    this.logger.logEvent({ message: 'scan timeout', port });
+                    this.stopScanOnStick(stickInfo).then(() => {
+                        if (onScanFinished)
+                            onScanFinished(id);
+                        resolve(true);
+                    });
+                }
+            }, timeout);
         });
     }
     scan(props) {
         return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'scan request', props });
+            this.scanning = true;
             this.logStickInfo();
-            const sticks = yield this.getSticks();
-            if (sticks && sticks.length > 0) {
-                const stick = sticks[0];
+            if (this.sensors && this.sensors.stick && this.sensors.stickOpen) {
+                try {
+                    yield this.closeStick(this.sensors.stick);
+                    this.sensors = {};
+                    this.devices = [];
+                }
+                catch (err) {
+                    this.logger.logEvent({ message: 'error on closing stick', error: err.message });
+                }
+            }
+            try {
+                const stick = yield this.getFirstStick();
+                if (!stick) {
+                    this.logger.logEvent({ message: 'no stick found' });
+                    return;
+                }
                 this.scanOnStick(stick, props);
             }
-            else {
-                this.logger.logEvent({ message: 'no stick found' });
+            catch (err) {
+                this.logger.logEvent({ message: 'scan request error', error: err.message });
             }
         });
     }
     stopScan() {
         return __awaiter(this, void 0, void 0, function* () {
-            console.log('stop scan requested');
             const activePorts = Object.keys(this.activeScans);
             for (let i = 0; i < activePorts.length; i++) {
                 const port = activePorts[i];
@@ -279,14 +493,25 @@ class AntProtocol extends DeviceProtocol_1.default {
                     yield this.stopScanOnStick({ port, stick: scanState.stick });
                 }
             }
-            console.log('scan stopped');
+            this.sensors = {};
             this.logger.logEvent({ message: 'scan stopped' });
+            this.scanning = false;
             return true;
         });
     }
+    waitForStickOpenedForSensor() {
+        return new Promise((resolve, reject) => {
+            const iv = setInterval(() => {
+                if (!this.sensors.stickOpening && !this.scanning) {
+                    clearInterval(iv);
+                    resolve(true);
+                }
+            }, 100);
+        });
+    }
     attachSensors(d, SensorClass, message) {
         return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
                 if (d === undefined) {
                     resolve(false);
                     return;
@@ -295,35 +520,49 @@ class AntProtocol extends DeviceProtocol_1.default {
                 if (devices.length === 0) {
                     return resolve(false);
                 }
+                this.logger.logEvent({ message: 'attachSensors', names: Array.isArray(d) ? d.map(dd => dd.getName()) : d.getName(), state: this.sensors });
+                if (this.sensors.stickOpening || this.scanning) {
+                    yield this.waitForStickOpenedForSensor();
+                }
+                this.sensors.stickOpening = true;
+                let stick;
                 if (!this.sensors.stick) {
-                    const stick = this.findStickByPort(devices[0].getPort());
-                    let opened = false;
-                    if (!stick.inUse) {
+                    this.logger.logEvent({ message: 'openStick', device: devices[0].getName() });
+                    let retryCnt = 0;
+                    while (!stick && retryCnt < 3) {
                         try {
-                            const open = stick.open();
-                            console.log('opened', open);
-                            opened = true;
+                            const stickInfo = yield this.getFirstStick();
+                            if (stickInfo && stickInfo.stick) {
+                                this.logger.logEvent({ message: 'stick opened', device: devices[0].getName() });
+                                stick = stickInfo.stick;
+                                this.sensors.stick = stick;
+                                this.sensors.stickOpen = true;
+                                this.sensors.stickStarted = true;
+                                this.sensors.stickOpening = false;
+                            }
+                            else {
+                                retryCnt++;
+                            }
                         }
                         catch (err) {
-                            console.log(err);
+                            retryCnt++;
+                            this.logger.logEvent({ message: 'stick open error', error: err.message, device: devices[0].getName() });
                         }
-                        if (!opened)
-                            return false;
                     }
-                    else {
-                        opened = true;
+                    if (!stick) {
+                        return reject(new Error('could not pen stick'));
                     }
-                    this.sensors.stick = stick;
-                    this.sensors.stickOpen = opened;
                 }
                 if (this.sensors.stickOpen) {
-                    console.log('create Sensor class');
                     if (!this.sensors.pending)
                         this.sensors.pending = [];
                     devices.forEach(device => {
                         const sensor = new SensorClass(this.sensors.stick);
+                        device.setSensor(sensor);
+                        device.setStick(stick);
                         sensor.on(message, (data) => { device.onDeviceData(data); });
                         sensor.on('eventData', (data) => { device.onDeviceEvent(data); });
+                        sensor.once('attached', () => { device.onAttached(); });
                         this.sensors.pending.push({ device, sensor, message });
                     });
                 }
@@ -331,30 +570,62 @@ class AntProtocol extends DeviceProtocol_1.default {
                     if (!this.sensors.attached)
                         this.sensors.attached = [];
                     const channelsUsed = this.sensors.attached.length;
-                    this.sensors.pending.forEach((i, idx) => {
-                        const channel = channelsUsed + idx;
-                        const { sensor } = i;
-                        console.log('attach ', channel, i.device.getID());
-                        sensor.attach(channel, i.device.getID());
-                        i.device.setChannel(channel);
-                        this.sensors.attached.push(i);
-                    });
-                    this.sensors.pending = [];
+                    try {
+                        this.sensors.pending.forEach((i, idx) => {
+                            const channel = channelsUsed + idx;
+                            const { sensor } = i;
+                            i.device.setChannel(channel);
+                            if (process.env.DEBUG)
+                                console.log('~~~~Ant: attach', channel, i.device.getID());
+                            sensor.attach(channel, i.device.getID());
+                            this.sensors.attached.push(i);
+                        });
+                        this.sensors.pending = [];
+                        resolve(true);
+                    }
+                    catch (err) {
+                        this.logger.logEvent({ message: 'error', fn: 'attachFromPending()', error: err.message || err });
+                        reject(err.message ? err : new Error(err));
+                    }
                 };
                 if (this.sensors.stickStarted) {
                     attachFromPending();
                 }
                 else {
-                    this.sensors.stick.once('startup', () => {
-                        console.log('started');
-                        this.sensors.stickStarted = true;
+                    const sensors = this.sensors;
+                    const stick = this.sensors.stick;
+                    stick.on('error', (err) => {
+                        this.logger.logEvent({ message: 'stick error', error: err.message });
+                    });
+                    stick.once('startup', () => {
+                        sensors.stickStarted = true;
                         setTimeout(attachFromPending, 1000);
                     });
                 }
-                resolve(true);
-            });
+            }));
         });
     }
+    detachSensor(adapter) {
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            const idx = (this.sensors && this.sensors.attached) ?
+                this.sensors.attached.findIndex(i => (i.device.getID() === adapter.getID() && i.device.getName() === adapter.getName())) : -1;
+            if (idx === -1)
+                return resolve(true);
+            this.sensors.attached.splice(idx, 1);
+            if (this.sensors.attached.length > 0)
+                return resolve(true);
+            const stick = this.sensors.stick;
+            if (stick === undefined)
+                return resolve(false);
+            try {
+                yield this.closeStick(stick);
+                resolve(true);
+            }
+            catch (err) {
+                reject(err);
+            }
+        }));
+    }
     closeSensor(device) {
         return __awaiter(this, void 0, void 0, function* () {
             const stick = this.findStickByPort(device.getPort());
@@ -363,7 +634,7 @@ class AntProtocol extends DeviceProtocol_1.default {
                     stick.close();
                 }
                 catch (err) {
-                    console.log(err);
+                    this.logger.logEvent({ message: 'closeSensor error', error: err.message, device: device ? device.getName() : 'unknown' });
                 }
             }
         });