incyclist-devices 2.3.0 → 2.3.1

package/lib/ble/base/peripheral.js

@@ -19,6 +19,7 @@ class BlePeripheral {
         this.characteristics = {};
         this.subscribed = [];
         this.disconnecting = false;
+        this.onErrorHandler = this.onPeripheralError.bind(this);
         this.ble = interface_1.BleInterface.getInstance();
     }
     get services() {
@@ -29,31 +30,42 @@ class BlePeripheral {
     }
     connect() {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.getPeripheral().connectAsync();
+            if (this.isConnected())
+                return true;
+            const peripheral = this.getPeripheral();
+            yield peripheral.connectAsync();
             this.ble.registerConnected(this);
+            peripheral.once('disconnect', () => { this.onPeripheralDisconnect(); });
+            peripheral.on('error', this.onErrorHandler);
             this.connected = true;
-            return true;
+            return this.connected;
         });
     }
     disconnect() {
-        return __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, arguments, void 0, function* (connectionLost = false) {
             this.disconnecting = true;
             if (!this.isConnected())
                 return true;
-            yield this.unsubscribeAll();
+            yield this.unsubscribeAll(connectionLost);
             Object.keys(this.characteristics).forEach(uuid => {
                 const c = this.characteristics[uuid];
                 c.removeAllListeners();
             });
-            if (!this.getPeripheral().disconnectAsync) {
-                this.getPeripheral().disconnectAsync = () => {
-                    return new Promise((done) => { this.getPeripheral().disconnect(() => { done(); }); });
-                };
+            const peripheral = this.getPeripheral();
+            if (peripheral) {
+                if (!connectionLost) {
+                    if (!peripheral.disconnectAsync) {
+                        peripheral.disconnectAsync = () => {
+                            return new Promise((done) => { this.getPeripheral().disconnect(() => { done(); }); });
+                        };
+                    }
+                    yield this.getPeripheral().disconnectAsync();
+                }
+                peripheral.removeAllListeners();
             }
-            yield this.getPeripheral().disconnectAsync();
             this.connected = false;
             this.disconnecting = false;
-            return true;
+            return !this.connected;
         });
     }
     isConnected() {
@@ -65,13 +77,29 @@ class BlePeripheral {
     onDisconnect(callback) {
         this.onDisconnectHandler = callback;
     }
+    onPeripheralDisconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'disconnect' });
+            try {
+                yield this.disconnect(true);
+            }
+            catch (_a) { }
+            if (this.onDisconnectHandler)
+                this.onDisconnectHandler();
+        });
+    }
+    onPeripheralError(err) {
+        this.logEvent({ message: 'peripheral error', error: err.message });
+    }
     discoverServices() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.getPeripheral().discoverServicesAsync) {
+                this.logEvent({ message: 'discover services' });
                 const services = yield this.getPeripheral().discoverServicesAsync([]);
                 return services.map(s => s.uuid);
             }
             else {
+                this.logEvent({ message: 'discover services and characteristics' });
                 const res = yield this.getPeripheral().discoverSomeServicesAndCharacteristicsAsync([], []);
                 return res.services.map(s => s.uuid);
             }
@@ -92,8 +120,17 @@ class BlePeripheral {
             try {
                 if (this.disconnecting || !this.connected)
                     return false;
+                const onData = (data) => {
+                    try {
+                        callback(characteristicUUID, data);
+                    }
+                    catch (_a) { }
+                };
                 const subscription = this.subscribed.find(s => s.uuid === characteristicUUID);
                 if (subscription) {
+                    const c = this.getRawCharacteristic(characteristicUUID);
+                    if (c)
+                        c.on('data', onData);
                     return true;
                 }
                 const c = this.getRawCharacteristic(characteristicUUID);
@@ -114,12 +151,6 @@ class BlePeripheral {
                         }
                         else {
                             if (callback) {
-                                const onData = (data) => {
-                                    try {
-                                        callback(characteristicUUID, data);
-                                    }
-                                    catch (_a) { }
-                                };
                                 this.subscribed.push({ uuid: characteristicUUID, callback: onData });
                                 c.on('data', onData);
                             }
@@ -177,16 +208,16 @@ class BlePeripheral {
                     yield this.discoverAllCharacteristics();
                 }
                 const retry = [];
-                for (let i = 0; i < characteristics.length; i++) {
-                    const c = this.getRawCharacteristic(characteristics[i]);
+                for (const element of characteristics) {
+                    const c = this.getRawCharacteristic(element);
                     if (c === null || c === void 0 ? void 0 : c.properties.includes('notify')) {
                         const success = yield this.subscribe(c.uuid, callback);
                         if (!success)
                             retry.push(c);
                     }
                 }
-                for (let i = 0; i < retry.length; i++) {
-                    const c = retry[i];
+                for (const element of retry) {
+                    const c = element;
                     yield this.subscribe(c.uuid, callback);
                 }
                 return true;
@@ -214,6 +245,24 @@ class BlePeripheral {
             }
         });
     }
+    discoverSomeCharacteristics(characteristics) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const target = characteristics.map(c => (0, utils_1.fullUUID)(c));
+                const res = yield this.getPeripheral().discoverSomeServicesAndCharacteristicsAsync([], target);
+                const found = [];
+                res.characteristics.forEach(c => {
+                    this.characteristics[(0, utils_1.beautifyUUID)(c.uuid)] = c;
+                    found.push(c.uuid);
+                });
+                return found;
+            }
+            catch (err) {
+                this.logEvent({ message: 'Error', fn: 'discoverAllCharacteristics', error: err.message, stack: err.stack });
+                return [];
+            }
+        });
+    }
     subscribeAll(callback) {
         return __awaiter(this, void 0, void 0, function* () {
             const characteristics = yield this.discoverAllCharacteristics();
@@ -222,13 +271,16 @@ class BlePeripheral {
         });
     }
     unsubscribeAll() {
-        return __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, arguments, void 0, function* (connectionLost = false) {
+            if (connectionLost) {
+                this.subscribed = [];
+                return;
+            }
             const promises = [];
             this.subscribed.forEach(d => {
                 promises.push(this.unsubscribe(d.uuid));
             });
             yield Promise.allSettled(promises);
-            return true;
         });
     }
     read(characteristicUUID) {
@@ -280,6 +332,8 @@ class BlePeripheral {
         return this.characteristics[(0, utils_1.beautifyUUID)(uuid)];
     }
     logEvent(event) {
+        var _a;
+        event.peripheral = (_a = this.announcement) === null || _a === void 0 ? void 0 : _a.name;
         this.ble.logEvent(event);
     }
 }

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

@@ -12,6 +12,7 @@ export declare class TBleSensor extends EventEmitter implements IBleSensor {
     constructor(peripheral: IBlePeripheral, props?: {
         logger?: EventLogger;
     });
+    getDetectionPriority(): number;
     getProfile(): LegacyProfile;
     getProtocol(): BleProtocol;
     getServiceUUids(): string[];
@@ -19,7 +20,7 @@ export declare class TBleSensor extends EventEmitter implements IBleSensor {
     hasPeripheral(): boolean;
     startSensor(reconnect?: boolean): Promise<boolean>;
     protected getRequiredCharacteristics(): Array<string>;
-    protected subscribe(): Promise<boolean>;
+    subscribe(): Promise<boolean>;
     stopSensor(): Promise<boolean>;
     reconnectSensor(): Promise<void>;
     reset(): void;

package/lib/ble/base/sensor.js

@@ -28,6 +28,11 @@ class TBleSensor extends events_1.default {
         this.reset();
         this.onDataHandler = this.onData.bind(this);
     }
+    getDetectionPriority() {
+        var _a;
+        const C = this.constructor;
+        return (_a = C['detectionPriority']) !== null && _a !== void 0 ? _a : 0;
+    }
     getProfile() {
         const C = this.constructor;
         return C['profile'];
@@ -69,7 +74,7 @@ class TBleSensor extends events_1.default {
                 return false;
             if (!reconnect)
                 this.peripheral.onDisconnect(this.reconnectSensor.bind(this));
-            return yield this.subscribe();
+            return true;
         });
     }
     getRequiredCharacteristics() {
@@ -96,11 +101,19 @@ class TBleSensor extends events_1.default {
     }
     reconnectSensor() {
         return __awaiter(this, void 0, void 0, function* () {
+            let connected = false;
+            let subscribed = false;
             let success = false;
             do {
-                success = yield this.startSensor(true);
+                if (!connected) {
+                    connected = yield this.startSensor(true);
+                }
+                if (connected && !subscribed) {
+                    subscribed = yield this.subscribe();
+                }
+                success = connected && subscribed;
                 if (!success) {
-                    yield (0, utils_1.sleep)(5000);
+                    yield (0, utils_1.sleep)(1000);
                 }
             } while (!success || this.stopRequested);
         });
@@ -114,10 +127,16 @@ class TBleSensor extends events_1.default {
     }
     read(characteristicUUID) {
         var _a;
+        if (!this.isConnected()) {
+            return Promise.reject(new Error('not connected'));
+        }
         return (_a = this.peripheral) === null || _a === void 0 ? void 0 : _a.read(characteristicUUID);
     }
     write(characteristicUUID, data, options) {
         var _a;
+        if (!this.isConnected()) {
+            return Promise.reject(new Error('not connected'));
+        }
         return (_a = this.peripheral) === null || _a === void 0 ? void 0 : _a.write(characteristicUUID, data, options);
     }
     onData(characteristic, data) {

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

@@ -1,8 +1,8 @@
 import { EventLogger } from 'gd-eventlog';
 import BleAdapterFactory from './adapter-factory';
-import { BleInterfaceProps, BlePeripheral, BleDeviceSettings, BleProtocol, BleBinding, BleInterfaceState, BleScanProps, BleCharacteristic, IBleInterface } from './types';
+import { BleInterfaceProps, BlePeripheral, BleDeviceSettings, BleProtocol, BleBinding, BleInterfaceState, BleScanProps, BleCharacteristic } from './types';
 import { BleComms } from './base/comms';
-import { IncyclistScanProps } from '../types';
+import { IncyclistInterface, IncyclistScanProps } from '../types';
 import BlePeripheralCache from './peripheral-cache';
 import EventEmitter from 'events';
 export interface ScanState {
@@ -31,7 +31,7 @@ export interface BleDeviceClassInfo {
     services: string[];
     id: string;
 }
-export default class BleInterface extends EventEmitter implements IBleInterface {
+export default class BleInterface extends EventEmitter implements IncyclistInterface {
     scanState: ScanState;
     connectState: ConnectState;
     peripheralCache: BlePeripheralCache;
@@ -62,8 +62,7 @@ export default class BleInterface extends EventEmitter implements IBleInterface
     pauseLogging(debugOnly?: boolean): void;
     resumeLogging(): void;
     protected isDebugEnabled(): boolean;
-    logEvent(event: any): void;
-    logError(err: Error, fn: string, args?: any): void;
+    protected logEvent(event: any): void;
     protected onStateChange(state: BleInterfaceState): void;
     protected onError(err: any): void;
     connect(to?: number): Promise<boolean>;
@@ -80,8 +79,6 @@ export default class BleInterface extends EventEmitter implements IBleInterface
     }): Promise<any>;
     scanForDevice(comms: BleComms, props: IncyclistScanProps): Promise<BlePeripheral>;
     scan(props?: BleScanProps): Promise<BleDeviceSettings[]>;
-    protected legacyScan(props?: BleScanProps): Promise<BleDeviceSettings[]>;
     stopScan(): Promise<boolean>;
     isScanning(): boolean;
-    getLogger(): EventLogger;
 }

package/lib/ble/ble-interface.js

@@ -118,10 +118,6 @@ class BleInterface extends events_1.default {
             console.log('~~~ BLE', event);
         }
     }
-    logError(err, fn, args) {
-        const logInfo = args || {};
-        this.logEvent(Object.assign(Object.assign({ message: 'Error', fn }, logInfo), { error: err.message, stack: err.stack }));
-    }
     onStateChange(state) {
         if (state !== 'poweredOn') {
             this.logEvent({ message: 'Ble disconnected', });
@@ -146,12 +142,10 @@ class BleInterface extends events_1.default {
             this.resumeLogging();
             const timeout = this.props.timeout || to || 2000;
             const connect = new Promise((resolve, reject) => {
-                this.logEvent({ message: 'Ble connect request', timeout });
+                this.logEvent({ message: 'Ble connect request' });
                 if (!this.getBinding())
                     return reject(new Error('no binding defined'));
-                this.connectState.isConnecting = true;
                 this.connectState.timeout = setTimeout(() => {
-                    console.log('connect timeout');
                     this.connectState.isConnected = false;
                     this.connectState.isConnecting = false;
                     this.connectState.timeout = null;
@@ -500,13 +494,8 @@ class BleInterface extends events_1.default {
     }
     scan() {
         return __awaiter(this, arguments, void 0, function* (props = {}) {
-            return yield this.legacyScan(props);
-        });
-    }
-    legacyScan() {
-        return __awaiter(this, arguments, void 0, function* (props = {}) {
-            this.resumeLogging();
             this.logEvent({ message: 'starting scan ..' });
+            this.resumeLogging();
             const { timeout, protocol, protocols } = props;
             const requestedProtocols = protocols || [];
             if (protocol && !requestedProtocols.find(p => p === protocol))
@@ -629,8 +618,5 @@ class BleInterface extends events_1.default {
     isScanning() {
         return this.scanState.isScanning === true;
     }
-    getLogger() {
-        return this.logger;
-    }
 }
 exports.default = BleInterface;

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

@@ -18,7 +18,6 @@ export default class BlePeripheralConnector implements IBlePeripheralConnector {
     private emitter;
     constructor(peripheral: BlePeripheral);
     logEvent(event: any): void;
-    logError(err: Error, fn: string, args?: any): void;
     connect(): Promise<void>;
     reconnect(): Promise<void>;
     onDisconnect(): void;

package/lib/ble/ble-peripheral.js

@@ -12,12 +12,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const ble_interface_1 = __importDefault(require("./ble-interface"));
+const gd_eventlog_1 = require("gd-eventlog");
 const events_1 = __importDefault(require("events"));
 const utils_1 = require("./utils");
-const interface_1 = require("./base/interface");
 class BlePeripheralConnector {
     constructor(peripheral) {
-        this.ble = interface_1.BleInterface.getInstance();
+        this.ble = ble_interface_1.default.getInstance();
         this.peripheral = peripheral;
         this.emitter = new events_1.default();
         if (!this.peripheral || !this.ble)
@@ -25,13 +26,16 @@ class BlePeripheralConnector {
         this.state = { subscribed: [], isConnected: false, isConnecting: false, isInitialized: false, isInitializing: false, isSubscribing: false };
         this.services = [];
         this.characteristics = [];
-        this.logger = this.ble.getLogger();
+        this.logger = new gd_eventlog_1.EventLogger('BLE');
     }
     logEvent(event) {
-        this.ble.logEvent(event);
-    }
-    logError(err, fn, args) {
-        this.ble.logError(err, fn, args);
+        if (this.logger) {
+            this.logger.logEvent(event);
+        }
+        const w = global.window;
+        if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.BLE_DEBUG) {
+            console.log('~~~ BLE', event);
+        }
     }
     connect() {
         return __awaiter(this, void 0, void 0, function* () {

package/lib/ble/characteristics/csc/features.d.ts

@@ -0,0 +1,10 @@
+import { CharacteristicParser } from "../types";
+export type BleCSCFeatures = {
+    wheelRevolutionData?: boolean;
+    crankRevolutionData?: boolean;
+    multipleSensorLocations?: boolean;
+};
+export declare class CscFeatures implements CharacteristicParser<BleCSCFeatures> {
+    parse(buffer: Buffer): BleCSCFeatures;
+    reset(): void;
+}

package/lib/ble/characteristics/csc/features.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CscFeatures = void 0;
+const utils_1 = require("../../utils");
+class CscFeatures {
+    parse(buffer) {
+        const data = Buffer.from(buffer);
+        const value = data.readUInt8(0);
+        const bool = (bitNo) => (value & (0, utils_1.bit)(bitNo)) > 0;
+        return {
+            wheelRevolutionData: bool(0),
+            crankRevolutionData: bool(1),
+            multipleSensorLocations: bool(2)
+        };
+    }
+    reset() {
+    }
+}
+exports.CscFeatures = CscFeatures;

package/lib/ble/characteristics/csc/measurement.d.ts

@@ -0,0 +1,33 @@
+import { CrankData } from "../../cp";
+import { CharacteristicParser, Feature } from "../types";
+export type CyclingCadenceAndSpeed = {
+    cadence?: number;
+    speed?: number;
+};
+export declare class CscMeasurement implements CharacteristicParser<CyclingCadenceAndSpeed> {
+    protected data: CyclingCadenceAndSpeed;
+    protected prevCrankData: CrankData;
+    protected currentCrankData: CrankData;
+    protected prevWheelData: CrankData;
+    protected currentWheelData: CrankData;
+    protected timeOffset: number;
+    protected cw: number;
+    constructor(data?: CyclingCadenceAndSpeed);
+    setWheelCircumference(wheelCircumference: any): void;
+    parse(buffer: Buffer, features?: Feature): CyclingCadenceAndSpeed;
+    protected parseCrankData(crankData: any): {
+        rpm?: undefined;
+        time?: undefined;
+    } | {
+        rpm: number;
+        time: any;
+    };
+    protected parseWheelData(wheelData: any): {
+        speed?: undefined;
+        time?: undefined;
+    } | {
+        speed: number;
+        time: any;
+    };
+    reset(): void;
+}

package/lib/ble/characteristics/csc/measurement.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CscMeasurement = void 0;
+class CscMeasurement {
+    constructor(data = {}) {
+        this.data = data;
+        this.prevCrankData = undefined;
+        this.currentCrankData = undefined;
+        this.prevWheelData = undefined;
+        this.currentWheelData = undefined;
+        this.timeOffset = 0;
+        this.cw = 2.1;
+    }
+    setWheelCircumference(wheelCircumference) {
+        this.cw = wheelCircumference;
+    }
+    parse(buffer, features) {
+        const data = Buffer.from(buffer);
+        let offset = 0;
+        const flags = data.readUInt8(offset);
+        offset++;
+        if (flags & 0x01) {
+            const wheelData = {
+                revolutions: data.readUInt32LE(offset),
+                time: data.readUInt16LE(offset + 4)
+            };
+            const { speed } = this.parseWheelData(wheelData);
+            this.data.speed = speed;
+            offset += 6;
+        }
+        if (flags & 0x02) {
+            const crankData = {
+                revolutions: data.readUInt16LE(offset),
+                time: data.readUInt16LE(offset + 2)
+            };
+            const { rpm } = this.parseCrankData(crankData);
+            this.data.cadence = rpm;
+        }
+        return this.data;
+    }
+    parseCrankData(crankData) {
+        if (!this.prevCrankData) {
+            this.prevCrankData = Object.assign(Object.assign({}, crankData), { cntUpdateMissing: -1 });
+            return {};
+        }
+        const c = this.currentCrankData = crankData;
+        const p = this.prevCrankData;
+        let rpm = this.data.cadence;
+        let hasUpdate = c.time !== p.time;
+        if (hasUpdate) {
+            let time = c.time - p.time;
+            let revs = c.revolutions - p.revolutions;
+            if (c.time < p.time) {
+                time += 0x10000;
+                this.timeOffset += 0x10000;
+            }
+            if (c.revolutions < p.revolutions)
+                revs += 0x10000;
+            rpm = 1024 * 60 * revs / time;
+        }
+        else if (p.cntUpdateMissing < 0 || p.cntUpdateMissing > 2) {
+            rpm = 0;
+        }
+        const cntUpdateMissing = p.cntUpdateMissing;
+        this.prevCrankData = this.currentCrankData;
+        if (hasUpdate)
+            this.prevCrankData.cntUpdateMissing = 0;
+        else
+            this.prevCrankData.cntUpdateMissing = cntUpdateMissing + 1;
+        return { rpm, time: this.timeOffset + c.time };
+    }
+    parseWheelData(wheelData) {
+        if (!this.prevWheelData) {
+            this.prevWheelData = Object.assign(Object.assign({}, wheelData), { cntUpdateMissing: -1 });
+            return {};
+        }
+        const c = this.currentWheelData = wheelData;
+        const p = this.prevWheelData;
+        let speed = this.data.speed;
+        let hasUpdate = c.time !== p.time;
+        if (hasUpdate) {
+            let time = c.time - p.time;
+            let revs = c.revolutions - p.revolutions;
+            if (c.time < p.time) {
+                time += 0x10000;
+                this.timeOffset += 0x10000;
+            }
+            const rps = 1024 * revs / time;
+            speed = rps * this.cw;
+        }
+        else if (p.cntUpdateMissing < 0 || p.cntUpdateMissing > 2) {
+            speed = 0;
+        }
+        const cntUpdateMissing = p.cntUpdateMissing;
+        this.prevWheelData = this.currentWheelData;
+        if (hasUpdate)
+            this.prevWheelData.cntUpdateMissing = 0;
+        else
+            this.prevWheelData.cntUpdateMissing = cntUpdateMissing + 1;
+        return { speed, time: this.timeOffset + c.time };
+    }
+    reset() {
+        this.data = {};
+        this.prevCrankData = undefined;
+        this.currentCrankData = undefined;
+        this.timeOffset = 0;
+    }
+}
+exports.CscMeasurement = CscMeasurement;

package/lib/ble/characteristics/types.d.ts

@@ -0,0 +1,6 @@
+export interface Feature {
+}
+export interface CharacteristicParser<T> {
+    parse(buffer: Buffer, features?: Feature): T;
+    reset(): void;
+}

package/lib/ble/characteristics/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/ble/consts.d.ts

@@ -11,4 +11,5 @@ export declare const CSP_FEATURE = "2a65";
 export declare const HR_MEASUREMENT = "2a37";
 export declare const CSC = "1816";
 export declare const CSC_MEASUREMENT = "2a5b";
+export declare const CSC_FEATURE = "2a5c";
 export declare const ELITE_TRAINER_SVC = "347b0001";

package/lib/ble/consts.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ELITE_TRAINER_SVC = exports.CSC_MEASUREMENT = exports.CSC = exports.HR_MEASUREMENT = exports.CSP_FEATURE = exports.CSP_MEASUREMENT = exports.CSP = exports.POWER_RANGE = exports.RES_LEVEL_RANGE = exports.FTMS_FEATURE = exports.INDOOR_BIKE_DATA = exports.FTMS_STATUS = exports.FTMS_CP = exports.FTMS = void 0;
+exports.ELITE_TRAINER_SVC = exports.CSC_FEATURE = exports.CSC_MEASUREMENT = exports.CSC = exports.HR_MEASUREMENT = exports.CSP_FEATURE = exports.CSP_MEASUREMENT = exports.CSP = exports.POWER_RANGE = exports.RES_LEVEL_RANGE = exports.FTMS_FEATURE = exports.INDOOR_BIKE_DATA = exports.FTMS_STATUS = exports.FTMS_CP = exports.FTMS = void 0;
 exports.FTMS = '1826';
 exports.FTMS_CP = '2ad9';
 exports.FTMS_STATUS = '2ada';
@@ -14,4 +14,5 @@ exports.CSP_FEATURE = '2a65';
 exports.HR_MEASUREMENT = '2a37';
 exports.CSC = '1816';
 exports.CSC_MEASUREMENT = '2a5b';
+exports.CSC_FEATURE = '2a5c';
 exports.ELITE_TRAINER_SVC = '347b0001';

package/lib/ble/cp/comm.d.ts

@@ -1,5 +1,5 @@
 import { CrankData, PowerData } from './types';
-import { BleComms } from '../base/sensor';
+import { BleComms } from '../base/comms';
 import { LegacyProfile } from '../../antv2/types';
 import { BleProtocol, IBlePeripheralConnector } from '../types';
 export default class BleCyclingPowerDevice extends BleComms {

package/lib/ble/cp/comm.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const consts_1 = require("../consts");
 const utils_1 = require("../utils");
-const sensor_1 = require("../base/sensor");
-class BleCyclingPowerDevice extends sensor_1.BleComms {
+const comms_1 = require("../base/comms");
+class BleCyclingPowerDevice extends comms_1.BleComms {
     constructor() {
         super(...arguments);
         this.instantaneousPower = undefined;

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

@@ -0,0 +1,17 @@
+import BleAdapter from '../base/adapter';
+import { BleDeviceSettings, IBlePeripheral } from '../types';
+import { DeviceProperties, IncyclistCapability, IAdapter, IncyclistAdapterData } from '../../types';
+import { LegacyProfile } from '../../antv2/types';
+import { BleCyclingSpeedCadenceDevice } from './sensor';
+import { CSCData } from './types';
+export declare class BleCSCAdapter extends BleAdapter<CSCData, BleCyclingSpeedCadenceDevice> {
+    protected static INCYCLIST_PROFILE_NAME: LegacyProfile;
+    protected static CAPABILITIES: IncyclistCapability[];
+    constructor(settings: BleDeviceSettings, props?: DeviceProperties);
+    protected checkCapabilities(): Promise<void>;
+    isSame(device: IAdapter): boolean;
+    updateSensor(peripheral: IBlePeripheral): void;
+    getProfile(): LegacyProfile;
+    getDisplayName(): string;
+    mapData(deviceData: CSCData): IncyclistAdapterData;
+}