incyclist-devices 2.3.0 → 2.3.1

package/README.MD

@@ -19,6 +19,11 @@ __BLE__
 - Wahoo Smart Trainers (Wahoo specific service)
 - Tacx FE-C over BLE
 
+__Direct Connect (Wifi)__
+- Smart Trainers (FTMS)
+- Power Meters (CP)
+- Heartrate Monitors (HR)
+
 __Serial__
 - Daum Classic Ergo Bikes
 - Daum Premium Ergo Bikes  (also over TCP/IP)
@@ -41,6 +46,7 @@ As this library supports various OS( Linux, Windows, Mac) and Incyclist is based
 - Ant: specified by the [incyclist-ant-plus](https://github.com/incyclist/ant-plus) library
 - Serial: specified by the [serialport](https://serialport.io/) library
 - BLE: specified by the [noble](https://github.com/noble/noble) library
+- Wifi: a combination of Multicast DNS as provided by the [Bonjour](https://github.com/onlxltd/bonjour-service) library and createSocket() wich creates a Socket class from NodeJS net module
 
 __Ant Example__
 
@@ -76,6 +82,55 @@ const logger = new EventLogger('BLESample')
 const ble = InterfaceFactory.create('ble',{logger, log:true, binding:noble})
 ```
 
+__Direct Connect Example__
+```
+const { Bonjour } = require('bonjour-service')
+const net = require('net');
+
+const createBinding = ()=>{
+    return {
+        mdns: new MDNSBinding(),
+        net: {
+            createSocket: ()=>new net.Socket()
+        } 
+    }
+}
+
+class MDNSBinding {
+    
+    connect() {
+        this.bonjour = new Bonjour()
+        
+    }
+
+    disconnect() {
+        if (this.bonjour) {
+            this.bonjour.destroy()
+            this.bonjour = null
+        }
+    }
+
+    find(opts , onUp) {
+        this.bonjour.find(opts, (s)=>{ 
+            this.handleAnnouncement(s,onUp) 
+        })
+    }       
+
+    handleAnnouncement(service,callback) {
+        const {name,txt,port,referer,protocol} = service
+        const announcement = {
+            name,address:referer?.address,protocol,port,
+            serialNo:txt?.['serial-number'], 
+            serviceUUIDs:txt?.['ble-service-uuids']?.split(',')
+        }
+        if (callback)
+            callback(announcement)
+    }
+        
+}
+```
+
+
 ### Check availability of interface
 
 For some interfaces (ANT and BLE) it cannot be guaranteed that the underlying hardware supports the interface ( e.g. a USB stick might be required). Therefore this library offers a `connect` method, that allows to check if the interface is availabe

package/lib/antv2/base/adapter.d.ts

@@ -56,8 +56,8 @@ export default class AntAdapter<TDeviceData extends BaseDeviceData> extends Incy
     getProfile(): Profile;
     getLogData(data: any, excludeList: any): any;
     check(): Promise<boolean>;
-    checkCapabilities(): Promise<void>;
-    initControl(): Promise<void>;
+    protected checkCapabilities(): Promise<void>;
+    protected initControl(): Promise<void>;
     getDefaultStartupTimeout(): number;
     startPreChecks(props: AntDeviceProperties): Promise<'done' | 'connected' | 'connection-failed'>;
     resetStartStatus(): void;

package/lib/base/adpater.d.ts

@@ -11,6 +11,7 @@ export default class IncyclistDevice<P extends DeviceProperties> extends EventEm
     started: boolean;
     stopped: boolean;
     paused: boolean;
+    scanning: boolean;
     protected props: P;
     protected cyclingMode: ICyclingMode;
     protected logger: EventLogger;
@@ -37,6 +38,7 @@ export default class IncyclistDevice<P extends DeviceProperties> extends EventEm
     resume(): Promise<boolean>;
     connect(): Promise<boolean>;
     close(): Promise<boolean>;
+    resetData(): void;
     getControllerInfo(): ControllerConfig | undefined;
     isControllable(): boolean;
     getCapabilities(): IncyclistCapability[];
@@ -65,5 +67,7 @@ export default class IncyclistDevice<P extends DeviceProperties> extends EventEm
     getStartProps(startProps?: P): P;
     hasDataListeners(): boolean | OnDeviceDataCallback;
     onData(callback: OnDeviceDataCallback): void;
+    onScanStart(): void;
+    onScanStop(): void;
 }
 export type IncyclistDeviceAdapter = IncyclistDevice<DeviceProperties>;

package/lib/base/adpater.js

@@ -26,6 +26,7 @@ class IncyclistDevice extends events_1.default {
         this.started = false;
         this.stopped = false;
         this.paused = false;
+        this.scanning = false;
         this.user = {};
         this.data = {};
         this.cyclingMode = this.getDefaultCyclingMode();
@@ -100,6 +101,9 @@ class IncyclistDevice extends events_1.default {
     }
     connect() { throw new Error('not implemented'); }
     close() { throw new Error('not implemented'); }
+    resetData() {
+        delete this.lastUpdate;
+    }
     getControllerInfo() {
         const a = this.constructor;
         const config = a.controllers;
@@ -223,11 +227,15 @@ class IncyclistDevice extends events_1.default {
         const updateFrequency = this.getMaxUpdateFrequency();
         if (updateFrequency === -1 || updateFrequency === undefined)
             return true;
-        return (!this.lastUpdate || (Date.now() - this.lastUpdate) > updateFrequency);
+        const ok = (!this.lastUpdate || (Date.now() - this.lastUpdate) > updateFrequency);
+        return ok;
     }
     canEmitData() {
-        if (this.paused || this.stopped)
+        if (this.scanning)
+            return this.isUpdateWithinFrequency();
+        if (this.paused || this.stopped) {
             return false;
+        }
         return this.isUpdateWithinFrequency();
     }
     emitData(data) {
@@ -261,6 +269,12 @@ class IncyclistDevice extends events_1.default {
     onData(callback) {
         this.onDataFn = callback;
     }
+    onScanStart() {
+        this.scanning = true;
+    }
+    onScanStop() {
+        this.scanning = false;
+    }
 }
 IncyclistDevice.controllers = {};
 exports.default = IncyclistDevice;

package/lib/ble/adapter-factory.d.ts

@@ -1,30 +1,34 @@
 import BleAdapter from "./base/adapter";
-import { BleDeviceSettings, BleProtocol, TBleSensor } from "./types";
+import { BleDeviceSettings, BleProtocol } from "./types";
 import { DeviceProperties } from "../types";
+import { BleComms } from "./base/comms";
 import { BleDeviceData } from "./base/types";
-export interface BleAdapterInfo<T extends TBleSensor> {
+export interface BleAdapterInfo {
     protocol: BleProtocol;
-    Adapter: typeof BleAdapter<BleDeviceData, T>;
-    Comm: typeof TBleSensor;
+    Adapter: typeof BleAdapter<BleDeviceData, BleComms>;
+    Comm: typeof BleComms;
 }
-export default class BleAdapterFactory<T extends TBleSensor> {
-    transport: string;
-    static readonly _instances: Record<string, BleAdapterFactory<any>>;
-    implementations: BleAdapterInfo<any>[];
-    instances: Array<BleAdapter<BleDeviceData, T>>;
-    static getInstance(transport: string): BleAdapterFactory<any>;
-    constructor(transport: string);
-    getAdapterInfo(protocol: BleProtocol): BleAdapterInfo<T>;
-    getAll(): BleAdapterInfo<T>[];
-    createInstance(settings: BleDeviceSettings, props?: DeviceProperties): BleAdapter<BleDeviceData, T>;
+export default class BleAdapterFactory {
+    static _instance: BleAdapterFactory;
+    implementations: BleAdapterInfo[];
+    instances: Array<BleAdapter<BleDeviceData, BleComms>>;
+    static getInstance(): BleAdapterFactory;
+    constructor();
+    getAdapterInfo(protocol: BleProtocol): BleAdapterInfo;
+    getAll(): BleAdapterInfo[];
+    createInstance(settings: BleDeviceSettings, props?: DeviceProperties): BleAdapter<BleDeviceData, BleComms>;
     removeInstance(query: {
         settings?: BleDeviceSettings;
-        adapter?: BleAdapter<BleDeviceData, T>;
+        adapter?: BleAdapter<BleDeviceData, BleComms>;
     }): void;
-    find(settings?: BleDeviceSettings): BleAdapter<BleDeviceData, T>;
-    register(protocol: BleProtocol, Adapter: typeof BleAdapter<BleDeviceData, T>, Comm: typeof TBleSensor): void;
-    getAllInstances(): Array<BleAdapter<BleDeviceData, T>>;
-    getAllSupportedComms(): (typeof TBleSensor)[];
-    getAllSupportedAdapters(): Array<(typeof BleAdapter<BleDeviceData, T>)>;
+    find(settings?: BleDeviceSettings): BleAdapter<BleDeviceData, BleComms>;
+    register(protocol: BleProtocol, Adapter: typeof BleAdapter<BleDeviceData, BleComms>, Comm: typeof BleComms): void;
+    getAllInstances(): Array<BleAdapter<BleDeviceData, BleComms>>;
+    getAllSupportedComms(): (typeof BleComms)[];
+    getAllSupportedAdapters(): Array<(typeof BleAdapter<BleDeviceData, BleComms>)>;
     getAllSupportedServices(): string[];
+    getDeviceClasses(peripheral: any, props?: {
+        protocol?: BleProtocol;
+        services?: string[];
+    }): (typeof BleComms)[];
 }

package/lib/ble/adapter-factory.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const comms_utils_1 = require("./base/comms-utils");
 const utils_1 = require("./utils");
 class BleAdapterFactory {
-    static getInstance(transport) {
-        if (!BleAdapterFactory._instances[transport])
-            BleAdapterFactory._instances[transport] = new BleAdapterFactory(transport);
-        return BleAdapterFactory._instances[transport];
+    static getInstance() {
+        if (!BleAdapterFactory._instance)
+            BleAdapterFactory._instance = new BleAdapterFactory();
+        return BleAdapterFactory._instance;
     }
-    constructor(transport) {
-        this.transport = transport;
+    constructor() {
         this.implementations = [];
         this.instances = [];
     }
@@ -37,8 +37,7 @@ class BleAdapterFactory {
             return existing;
         }
         const info = this.getAdapterInfo(protocol);
-        console.log('~~~~ INFO:', info);
-        if (!(info === null || info === void 0 ? void 0 : info.Adapter))
+        if (!info || !info.Adapter)
             return;
         const adapter = new info.Adapter(adapterSettings, props);
         this.instances.push(adapter);
@@ -70,18 +69,42 @@ class BleAdapterFactory {
         return this.instances;
     }
     getAllSupportedComms() {
-        const supported = this.getAll();
+        const supported = BleAdapterFactory.getInstance().getAll();
         return supported.map(info => info.Comm);
     }
     getAllSupportedAdapters() {
-        const supported = this.getAll();
+        const supported = BleAdapterFactory.getInstance().getAll();
         return supported.map(info => info.Adapter);
     }
     getAllSupportedServices() {
-        const supported = this.getAll();
-        const res = ['180d', '1818', '1826', '6e40fec1'];
+        const supported = BleAdapterFactory.getInstance().getAll();
+        const res = [];
+        if (supported && supported.length > 0) {
+            supported.forEach(info => {
+                if (info && info.Comm && info.Comm.services) {
+                    info.Comm.services.forEach(s => {
+                        if (!res.includes(s))
+                            res.push(s);
+                    });
+                }
+            });
+        }
         return res;
     }
+    getDeviceClasses(peripheral, props = {}) {
+        let DeviceClasses;
+        const { protocol, services = peripheral.advertisement.serviceUuids } = props;
+        const classes = this.getAllSupportedComms();
+        DeviceClasses = (0, comms_utils_1.getDevicesFromServices)(classes, services);
+        if (protocol && DeviceClasses && DeviceClasses.length > 0) {
+            DeviceClasses = DeviceClasses.filter((C) => {
+                const device = new C({ peripheral });
+                if (device.getProtocol() !== protocol)
+                    return false;
+                return true;
+            });
+        }
+        return DeviceClasses;
+    }
 }
-BleAdapterFactory._instances = {};
 exports.default = BleAdapterFactory;

package/lib/ble/base/adapter.d.ts

@@ -1,5 +1,5 @@
 import IncyclistDevice from "../../base/adpater";
-import { BleDeviceProperties, BleDeviceSettings, BleStartProperties, IBlePeripheral } from "../types";
+import { BleDeviceProperties, BleDeviceSettings, BleStartProperties, IBleInterface, IBlePeripheral } from "../types";
 import { IAdapter, IncyclistBikeData, IncyclistAdapterData, DeviceProperties } from "../../types";
 import { BleDeviceData } from "./types";
 import { LegacyProfile } from "../../antv2/types";
@@ -21,7 +21,7 @@ export default class BleAdapter<TDeviceData extends BleDeviceData, TDevice exten
     waitForPeripheral(): Promise<void>;
     updateSensor(peripheral: IBlePeripheral): void;
     close(): Promise<boolean>;
-    getComms(): TDevice;
+    getSensor(): TDevice;
     isEqual(settings: BleDeviceSettings): boolean;
     isSame(adapter: IAdapter): boolean;
     isConnected(): boolean;
@@ -44,13 +44,16 @@ export default class BleAdapter<TDeviceData extends BleDeviceData, TDevice exten
     protected isStarting(): boolean;
     protected hasData(): boolean;
     protected waitForInitialData(startupTimeout: any): Promise<void>;
-    protected checkCapabilities(): void;
+    protected checkCapabilities(): Promise<void>;
     protected initControl(_props?: BleStartProperties): Promise<void>;
     protected startAdapter(startProps?: BleStartProperties): Promise<boolean>;
     startSensor(): Promise<boolean>;
+    protected onDisconnectDone(): Promise<void>;
     stop(): Promise<boolean>;
     pause(): Promise<boolean>;
     resume(): Promise<boolean>;
+    protected getBle(): IBleInterface<any>;
     update(): void;
     setCyclingMode(mode: string | ICyclingMode, settings?: any, sendInitCommands?: boolean): void;
+    onScanStart(): void;
 }

package/lib/ble/base/adapter.js

@@ -38,20 +38,20 @@ class BleAdapter extends adpater_1.default {
     }
     connect() {
         return __awaiter(this, void 0, void 0, function* () {
-            const iface = interface_factory_1.BleMultiTransportInterfaceFactory.createInstance(this.getInterface());
-            return yield iface.connect();
+            const ble = this.getBle();
+            return yield ble.connect();
         });
     }
     getPeripheral() {
-        const iface = interface_factory_1.BleMultiTransportInterfaceFactory.createInstance(this.getInterface());
-        const p = iface === null || iface === void 0 ? void 0 : iface.createPeripheralFromSettings(this.settings);
+        const ble = this.getBle();
+        const p = ble === null || ble === void 0 ? void 0 : ble.createPeripheralFromSettings(this.settings);
         return p;
     }
     waitForPeripheral() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'waiting for sensor ...' });
-            const iface = interface_factory_1.BleMultiTransportInterfaceFactory.createInstance(this.getInterface());
-            const peripheral = yield iface.waitForPeripheral(this.settings);
+            this.logEvent({ message: 'waiting for sensor ...', device: this.getName(), interface: this.getInterface() });
+            const ble = this.getBle();
+            const peripheral = yield ble.waitForPeripheral(this.settings);
             this.updateSensor(peripheral);
         });
     }
@@ -63,7 +63,7 @@ class BleAdapter extends adpater_1.default {
             return true;
         });
     }
-    getComms() {
+    getSensor() {
         return this.device;
     }
     isEqual(settings) {
@@ -87,6 +87,7 @@ class BleAdapter extends adpater_1.default {
         return (_a = this.device) === null || _a === void 0 ? void 0 : _a.isConnected();
     }
     resetData() {
+        super.resetData();
         this.dataMsgCount = 0;
         this.deviceData = {};
         this.data = {};
@@ -121,7 +122,7 @@ class BleAdapter extends adpater_1.default {
         if (this.isStopped() || this.isPaused())
             return;
         try {
-            this.logEvent({ message: 'refreshDeviceData', data: this.deviceData, isControllable: this.isControllable() });
+            this.logEvent({ message: 'refreshDeviceData', device: this.getName(), interface: this.getInterface(), data: this.deviceData, isControllable: this.isControllable() });
             if (this.isControllable()) {
                 const mappedData = this.mapData(this.deviceData);
                 const incyclistData = this.getCyclingMode().updateData(mappedData);
@@ -133,7 +134,7 @@ class BleAdapter extends adpater_1.default {
             this.emitData(this.data);
         }
         catch (err) {
-            this.logEvent({ message: 'error', fn: 'refreshDeviceData', error: err.message, stack: err.stack });
+            this.logEvent({ message: 'error', fn: 'refreshDeviceData', device: this.getName(), interface: this.getInterface(), error: err.message, stack: err.stack });
         }
     }
     onDeviceData(deviceData) {
@@ -141,9 +142,10 @@ class BleAdapter extends adpater_1.default {
             this.dataMsgCount++;
             this.lastDataTS = Date.now();
             this.deviceData = Object.assign({}, deviceData);
-            if (!this.canEmitData())
+            if (!this.canEmitData()) {
                 return;
-            this.logEvent({ message: 'onDeviceData', data: deviceData, isControllable: this.isControllable() });
+            }
+            this.logEvent({ message: 'onDeviceData', device: this.getName(), interface: this.getInterface(), data: deviceData, isControllable: this.isControllable() });
             if (this.isControllable()) {
                 const mappedData = this.mapData(deviceData);
                 const incyclistData = this.getCyclingMode().updateData(mappedData);
@@ -155,7 +157,7 @@ class BleAdapter extends adpater_1.default {
             this.emitData(this.data);
         }
         catch (err) {
-            this.logEvent({ message: 'Error', fn: 'onDeviceData', error: err.message, stack: err.stack });
+            this.logEvent({ message: 'Error', fn: 'onDeviceData', device: this.getName(), interface: this.getInterface(), error: err.message, stack: err.stack });
         }
     }
     mapData(deviceData) {
@@ -183,10 +185,7 @@ class BleAdapter extends adpater_1.default {
             this.stopped = false;
             if (wasPaused)
                 this.resume();
-            if (this.started && !wasPaused && !wasStopped) {
-                return 'done';
-            }
-            if (this.started && wasPaused) {
+            if (this.started && !wasStopped) {
                 return 'done';
             }
             const connected = yield this.connect();
@@ -200,6 +199,8 @@ class BleAdapter extends adpater_1.default {
             if (this.isStarting()) {
                 yield this.stop();
             }
+            const ble = this.getBle();
+            ble.once('disconnect-done', this.onDisconnectDone.bind(this));
             this.startTask = new task_1.InteruptableTask(this.startAdapter(startProps), {
                 timeout: startProps === null || startProps === void 0 ? void 0 : startProps.timeout,
                 name: 'start',
@@ -240,14 +241,16 @@ class BleAdapter extends adpater_1.default {
                 errorOnTimeout: false,
                 timeout: startupTimeout
             });
-            this.logEvent({ message: 'wait for sensor data', device: this.getName() });
+            this.logEvent({ message: 'wait for sensor data', device: this.getName(), interface: this.getInterface() });
             const hasData = yield waitTask.run();
             clearInterval(iv);
             if (hasData)
-                this.logEvent({ message: 'sensor data received', device: this.getName() });
+                this.logEvent({ message: 'sensor data received', device: this.getName(), interface: this.getInterface() });
         });
     }
     checkCapabilities() {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
     }
     initControl(_props) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -256,41 +259,52 @@ class BleAdapter extends adpater_1.default {
     startAdapter(startProps) {
         return __awaiter(this, void 0, void 0, function* () {
             const props = this.getStartProps(startProps);
-            const { timeout = this.getDefaultStartupTimeout() } = startProps;
+            const { timeout = this.getDefaultStartupTimeout() } = startProps !== null && startProps !== void 0 ? startProps : {};
             const wasPaused = this.paused;
             const preCheckResult = yield this.startPreChecks(props);
             if (preCheckResult === 'done') {
                 yield (0, utils_1.resolveNextTick)();
+                this.logEvent({ message: `start result: ${this.started ? 'success' : 'failed'}`, preCheckResult, device: this.getName(), interface: this.getInterface(), protocol: this.getProtocolName() });
                 return this.started;
             }
             if (preCheckResult === 'connection-failed') {
-                this.logEvent({ message: 'start result: error', error: 'could not start device, reason:could not connect', protocol: this.getProtocolName() });
+                this.logEvent({ message: 'start result: error', error: 'could not start device, reason:could not connect', device: this.getName(), interface: this.getInterface(), protocol: this.getProtocolName() });
                 yield (0, utils_1.resolveNextTick)();
                 return false;
             }
-            this.logEvent({ message: 'starting device', device: this.getName(), props, isStarted: this.started });
+            this.logEvent({ message: 'starting device', device: this.getName(), interface: this.getInterface(), props, isStarted: this.started });
             try {
+                this.resetData();
+                this.stopped = false;
                 const connected = yield this.startSensor();
                 if (connected) {
-                    this.logEvent({ message: 'peripheral connected', device: this.getName(), props });
+                    this.logEvent({ message: 'peripheral connected', device: this.getName(), interface: this.getInterface(), props });
                 }
                 else {
-                    this.logEvent({ message: 'peripheral connection failed', device: this.getName(), reason: 'unknown', props });
+                    this.logEvent({ message: 'peripheral connection failed', device: this.getName(), interface: this.getInterface(), reason: 'unknown', props });
+                    this.stopped = true;
                     return false;
                 }
                 yield this.waitForInitialData(timeout);
                 yield this.checkCapabilities();
                 if (this.hasCapability(types_1.IncyclistCapability.Control))
                     yield this.initControl(startProps);
-                this.resetData();
                 this.stopped = false;
                 this.started = true;
                 if (wasPaused)
                     this.resume();
+                if (!this.isStarting()) {
+                    this.started = false;
+                    this.stopped = true;
+                    return false;
+                }
+                this.logEvent({ message: 'start result: success', device: this.getName(), interface: this.getInterface(), protocol: this.getProtocolName() });
                 return true;
             }
             catch (err) {
-                this.logEvent({ message: 'start result: error', error: err.message, protocol: this.getProtocolName() });
+                this.logEvent({ message: 'start result: error', error: err.message, device: this.getName(), interface: this.getInterface(), protocol: this.getProtocolName() });
+                this.started = false;
+                this.stopped = true;
                 return false;
             }
         });
@@ -298,49 +312,62 @@ class BleAdapter extends adpater_1.default {
     startSensor() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            if (!((_a = this.getComms()) === null || _a === void 0 ? void 0 : _a.hasPeripheral())) {
+            if (!((_a = this.getSensor()) === null || _a === void 0 ? void 0 : _a.hasPeripheral())) {
                 yield this.waitForPeripheral();
             }
-            if (!this.getComms()) {
+            if (!this.getSensor()) {
                 return false;
             }
-            const connected = yield this.getComms().startSensor();
+            const sensor = this.getSensor();
+            const connected = yield sensor.startSensor();
+            yield sensor.subscribe();
             if (connected) {
-                this.getComms().on('data', this.onDeviceDataHandler);
-                this.getComms().on('disconnected', this.emit.bind(this));
-                this.getComms().on('error', console.log);
+                sensor.on('data', this.onDeviceDataHandler);
+                sensor.on('disconnected', this.emit.bind(this));
+                sensor.on('error', console.log);
             }
             return connected;
         });
     }
-    stop() {
+    onDisconnectDone() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'stopping device', device: this.getName() });
+            this.logEvent({ message: 'disconnecting device', device: this.getName(), interface: this.getInterface() });
             if (this.isStarting()) {
                 yield this.startTask.stop();
             }
             let reason = 'unknown';
             let stopped = false;
-            if (!this.getComms()) {
-                this.logEvent({ message: 'device stopped - not started yet', device: this.getName() });
-                return true;
-            }
-            this.getComms().reset();
+            const sensor = this.getSensor();
             try {
-                stopped = yield this.getComms().stopSensor();
+                stopped = yield sensor.stopSensor();
             }
             catch (err) {
                 reason = err.message;
             }
-            if (stopped) {
-                this.logEvent({ message: 'device stopped', device: this.getName() });
+            if (!stopped) {
+                this.logEvent({ message: 'disconnecting device failed', device: this.getName(), interface: this.getInterface(), reason });
             }
-            else {
-                this.logEvent({ message: 'stopping device failed', device: this.getName(), reason });
+        });
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'stopping device', device: this.getName(), interface: this.getInterface() });
+            if (this.isStarting()) {
+                yield this.startTask.stop();
             }
             this.started = false;
+            this.resetData();
+            if (!this.getSensor()) {
+                this.logEvent({ message: 'device stopped - not started yet', device: this.getName(), interface: this.getInterface() });
+                return true;
+            }
+            const sensor = this.getSensor();
+            sensor.reset();
+            this.resetData();
             this.stopped = true;
-            return stopped;
+            this.started = false;
+            this.logEvent({ message: 'device stopped', device: this.getName(), interface: this.getInterface() });
+            return this.stopped;
         });
     }
     pause() {
@@ -349,8 +376,8 @@ class BleAdapter extends adpater_1.default {
         });
         return __awaiter(this, void 0, void 0, function* () {
             const res = yield _super.pause.call(this);
-            const iface = interface_factory_1.BleMultiTransportInterfaceFactory.createInstance(this.getInterface());
-            iface.pauseLogging();
+            const ble = this.getBle();
+            ble.pauseLogging();
             return res;
         });
     }
@@ -359,17 +386,24 @@ class BleAdapter extends adpater_1.default {
             resume: { get: () => super.resume }
         });
         return __awaiter(this, void 0, void 0, function* () {
-            const iface = interface_factory_1.BleMultiTransportInterfaceFactory.createInstance(this.getInterface());
-            iface.resumeLogging();
+            const ble = this.getBle();
+            ble.resumeLogging();
             const res = yield _super.resume.call(this);
             return res;
         });
     }
+    getBle() {
+        return interface_factory_1.BleMultiTransportInterfaceFactory.createInstance(this.getInterface());
+    }
     update() {
     }
     setCyclingMode(mode, settings, sendInitCommands) {
         super.setCyclingMode(mode, settings, sendInitCommands);
         this.refreshDeviceData();
     }
+    onScanStart() {
+        if (!this.isStarted())
+            this.start();
+    }
 }
 exports.default = BleAdapter;