incyclist-devices 2.3.0 → 2.3.1

package/lib/ble/csc/adapter.js

@@ -0,0 +1,66 @@
+"use strict";
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        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.BleCSCAdapter = void 0;
+const gd_eventlog_1 = require("gd-eventlog");
+const adapter_1 = __importDefault(require("../base/adapter"));
+const types_1 = require("../../types");
+const sensor_1 = require("./sensor");
+class BleCSCAdapter extends adapter_1.default {
+    constructor(settings, props) {
+        super(settings, props);
+        this.logger = new gd_eventlog_1.EventLogger('Ble-CSC');
+        this.device = new sensor_1.BleCyclingSpeedCadenceDevice(this.getPeripheral(), { logger: this.logger });
+        this.capabilities = BleCSCAdapter.CAPABILITIES;
+    }
+    checkCapabilities() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const before = this.capabilities.join(',');
+            const sensor = this.getSensor();
+            if (!sensor)
+                return;
+            const features = yield sensor.getFeatures();
+            if (!(features === null || features === void 0 ? void 0 : features.wheelRevolutionData))
+                this.capabilities = this.capabilities.filter(c => c !== types_1.IncyclistCapability.Speed);
+            if (!(features === null || features === void 0 ? void 0 : features.crankRevolutionData))
+                this.capabilities = this.capabilities.filter(c => c !== types_1.IncyclistCapability.Cadence);
+            const after = this.capabilities.join(',');
+            if (before !== after) {
+                this.logEvent({ message: 'device capabilities updated', name: this.getSettings().name, interface: this.getSettings().interface, capabilities: this.capabilities });
+                this.emit('device-info', this.getSettings(), { capabilities: this.capabilities });
+            }
+        });
+    }
+    isSame(device) {
+        if (!(device instanceof BleCSCAdapter))
+            return false;
+        return this.isEqual(device.settings);
+    }
+    updateSensor(peripheral) {
+        this.device = new sensor_1.BleCyclingSpeedCadenceDevice(peripheral, { logger: this.logger });
+    }
+    getProfile() {
+        return BleCSCAdapter.INCYCLIST_PROFILE_NAME;
+    }
+    getDisplayName() {
+        return this.getName();
+    }
+    mapData(deviceData) {
+        const { cadence, speed } = deviceData;
+        return { cadence, speed };
+    }
+}
+exports.BleCSCAdapter = BleCSCAdapter;
+BleCSCAdapter.INCYCLIST_PROFILE_NAME = 'Speed + Cadence Sensor';
+BleCSCAdapter.CAPABILITIES = [types_1.IncyclistCapability.Speed, types_1.IncyclistCapability.Cadence];

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

@@ -0,0 +1,3 @@
+export * from './adapter';
+export * from './sensor';
+export * from './types';

package/lib/ble/csc/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./adapter"), exports);
+__exportStar(require("./sensor"), exports);
+__exportStar(require("./types"), exports);

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

@@ -0,0 +1,21 @@
+import { LegacyProfile } from '../../antv2/types';
+import { BleProtocol } from '../types';
+import { TBleSensor } from '../base/sensor';
+import { CharacteristicParser } from '../characteristics/types';
+import { CyclingCadenceAndSpeed } from '../characteristics/csc/measurement';
+import { BleCSCFeatures, CscFeatures } from '../characteristics/csc/features';
+export declare class BleCyclingSpeedCadenceDevice extends TBleSensor {
+    static readonly profile: LegacyProfile;
+    static readonly protocol: BleProtocol;
+    static readonly services: string[];
+    static readonly characteristics: string[];
+    static readonly detectionPriority = 1;
+    protected data: CyclingCadenceAndSpeed;
+    protected parsers: Record<string, CharacteristicParser<any>>;
+    protected featureParser: CscFeatures;
+    constructor(peripheral: any, props?: any);
+    protected getRequiredCharacteristics(): Array<string>;
+    getFeatures(): Promise<BleCSCFeatures>;
+    onData(characteristic: string, data: Buffer): boolean;
+    reset(): void;
+}

package/lib/ble/csc/sensor.js

@@ -0,0 +1,64 @@
+"use strict";
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BleCyclingSpeedCadenceDevice = void 0;
+const consts_1 = require("../consts");
+const utils_1 = require("../utils");
+const sensor_1 = require("../base/sensor");
+const measurement_1 = require("../characteristics/csc/measurement");
+const features_1 = require("../characteristics/csc/features");
+class BleCyclingSpeedCadenceDevice extends sensor_1.TBleSensor {
+    constructor(peripheral, props) {
+        super(peripheral, props);
+        this.parsers = {};
+        this.data = {};
+        const measurement = new measurement_1.CscMeasurement();
+        this.featureParser = new features_1.CscFeatures();
+        this.parsers[(0, utils_1.beautifyUUID)(consts_1.CSC_MEASUREMENT)] = measurement;
+    }
+    getRequiredCharacteristics() {
+        return [consts_1.CSC_MEASUREMENT];
+    }
+    getFeatures() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const data = yield this.read(consts_1.CSC_FEATURE);
+                return this.featureParser.parse(data);
+            }
+            catch (err) {
+                this.logEvent({ message: 'read failed', characteristic: consts_1.CSC_FEATURE, reason: err.message });
+            }
+        });
+    }
+    onData(characteristic, data) {
+        const hasData = super.onData(characteristic, data);
+        if (!hasData)
+            return false;
+        const uuid = (0, utils_1.beautifyUUID)(characteristic);
+        const parser = this.parsers[uuid];
+        if (!parser) {
+            return false;
+        }
+        const parsed = parser.parse(data);
+        this.data = Object.assign(Object.assign({}, this.data), parsed);
+        this.emit('data', this.data);
+        return true;
+    }
+    reset() {
+        this.data = {};
+    }
+}
+exports.BleCyclingSpeedCadenceDevice = BleCyclingSpeedCadenceDevice;
+BleCyclingSpeedCadenceDevice.profile = 'Speed + Cadence Sensor';
+BleCyclingSpeedCadenceDevice.protocol = 'csc';
+BleCyclingSpeedCadenceDevice.services = [consts_1.CSC];
+BleCyclingSpeedCadenceDevice.characteristics = [consts_1.CSC_MEASUREMENT, consts_1.CSC_FEATURE];
+BleCyclingSpeedCadenceDevice.detectionPriority = 1;

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

@@ -0,0 +1,6 @@
+import { BleDeviceData } from "../base/types";
+export interface CSCData extends BleDeviceData {
+    speed?: number;
+    cadence?: number;
+    raw?: string;
+}

package/lib/ble/csc/types.js

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

package/lib/ble/elite/comms.d.ts

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

package/lib/ble/elite/comms.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const _1 = require(".");
-const sensor_1 = require("../base/sensor");
+const comms_1 = require("../base/comms");
 const consts_1 = require("../consts");
 const utils_1 = require("../utils");
-class BleEliteDevice extends sensor_1.BleComms {
+class BleEliteDevice extends comms_1.BleComms {
     constructor(props) {
         super(props);
         this.instantaneousPower = undefined;

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

@@ -3,12 +3,8 @@ import { BleDeviceSettings, BleProtocol } from "../types";
 import { DeviceProperties } from "../../types";
 import { BleDeviceData } from "../base/types";
 import { TBleSensor } from "../base/sensor";
-export interface BleAdapterInfo<T extends TBleSensor> {
-    protocol: BleProtocol;
-    Adapter: typeof BleAdapter<BleDeviceData, T>;
-    Sensor: typeof TBleSensor;
-}
-export declare class BleAdapterFactory<T extends TBleSensor> {
+import { BleAdapterInfo, TBleAdapterFactory } from "./types";
+export declare class BleAdapterFactory<T extends TBleSensor> implements TBleAdapterFactory<T> {
     transport: string;
     static readonly _instances: Record<string, BleAdapterFactory<any>>;
     implementations: BleAdapterInfo<any>[];
@@ -29,4 +25,10 @@ export declare class BleAdapterFactory<T extends TBleSensor> {
     getAllSupportedAdapters(): Array<(typeof BleAdapter<BleDeviceData, T>)>;
     getServices(info: BleAdapterInfo<T>): string[];
     getAllSupportedServices(): string[];
+    getProtocol(services: string[]): BleProtocol;
+    protected getMatchingSensors(services: string[], props?: {
+        protocol?: BleProtocol;
+        services?: string[];
+    }): TBleSensor[];
+    getSensorsFromServices(sensorTypes: (typeof TBleSensor)[], services: string | string[]): TBleSensor[];
 }

package/lib/ble/factories/adapter-factory.js

@@ -99,6 +99,39 @@ class BleAdapterFactory {
         }
         return res;
     }
+    getProtocol(services) {
+        const matching = this.getMatchingSensors(services);
+        if (!(matching === null || matching === void 0 ? void 0 : matching.length)) {
+            return;
+        }
+        if (matching.length === 1) {
+            return matching[0].getProtocol();
+        }
+        matching.sort((a, b) => b.getDetectionPriority() - a.getDetectionPriority());
+        return matching[0].getProtocol();
+    }
+    getMatchingSensors(services, props = {}) {
+        let sensors;
+        const { protocol } = props;
+        const classes = this.getAllSupportedSensors();
+        sensors = this.getSensorsFromServices(classes, services);
+        if (protocol && (sensors === null || sensors === void 0 ? void 0 : sensors.length) > 0) {
+            return sensors.filter(sensor => {
+                if (sensor.getProtocol() !== protocol)
+                    return false;
+                return true;
+            });
+        }
+        return sensors;
+    }
+    getSensorsFromServices(sensorTypes, services) {
+        if (!sensorTypes || !Array.isArray(sensorTypes) || sensorTypes.length === 0) {
+            return [];
+        }
+        let serviceUUIDs = Array.isArray(services) ? services : [services];
+        const types = sensorTypes.map(SensorType => new SensorType(null)).filter(sensor => sensor.isMatching(serviceUUIDs));
+        return types;
+    }
 }
 exports.BleAdapterFactory = BleAdapterFactory;
 BleAdapterFactory._instances = {};

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

@@ -0,0 +1,18 @@
+import { DeviceProperties } from "../../types";
+import BleAdapter from "../base/adapter";
+import { TBleSensor } from "../base/sensor";
+import { BleDeviceData } from "../base/types";
+import { BleDeviceSettings, BleProtocol } from "../types";
+export interface TBleAdapterFactory<T extends TBleSensor> {
+    createInstance(settings: BleDeviceSettings, props?: DeviceProperties): BleAdapter<BleDeviceData, T>;
+    removeInstance(query: {
+        settings?: BleDeviceSettings;
+        adapter?: BleAdapter<BleDeviceData, T>;
+    }): void;
+    getProtocol(services: string[]): BleProtocol;
+}
+export interface BleAdapterInfo<T extends TBleSensor> {
+    protocol: BleProtocol;
+    Adapter: typeof BleAdapter<BleDeviceData, T>;
+    Sensor: typeof TBleSensor;
+}

package/lib/ble/factories/types.js

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

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

@@ -7,8 +7,9 @@ import { IAdapter, IncyclistAdapterData, IncyclistBikeData } from '../../types';
 import { LegacyProfile } from '../../antv2/types';
 export default class BleFmAdapter extends BleAdapter<IndoorBikeData, BleFitnessMachineDevice> {
     protected static INCYCLIST_PROFILE_NAME: LegacyProfile;
-    distanceInternal: number;
-    connectPromise: Promise<boolean>;
+    protected distanceInternal: number;
+    protected connectPromise: Promise<boolean>;
+    protected requestControlRetryDelay: number;
     constructor(settings: BleDeviceSettings, props?: BleDeviceProperties);
     updateSensor(peripheral: IBlePeripheral): void;
     isSame(device: IAdapter): boolean;
@@ -22,7 +23,7 @@ export default class BleFmAdapter extends BleAdapter<IndoorBikeData, BleFitnessM
     protected setConstants(): void;
     protected establishControl(): Promise<boolean>;
     protected sendInitialRequest(): Promise<void>;
-    protected checkCapabilities(): void;
+    protected checkCapabilities(): Promise<void>;
     sendUpdate(request: any, enforced?: boolean): Promise<void>;
     sendInitCommands(): Promise<boolean>;
 }

package/lib/ble/fm/adapter.js

@@ -20,11 +20,12 @@ const sensor_1 = __importDefault(require("./sensor"));
 const adapter_1 = __importDefault(require("../base/adapter"));
 const consts_1 = require("./consts");
 const types_1 = require("../../types");
-const task_1 = require("../../utils/task");
+const utils_1 = require("../../utils/utils");
 class BleFmAdapter extends adapter_1.default {
     constructor(settings, props) {
         super(settings, props);
         this.distanceInternal = 0;
+        this.requestControlRetryDelay = 1000;
         this.logger = new gd_eventlog_1.EventLogger('BLE-FM');
         this.device = new sensor_1.default(this.getPeripheral(), { logger: this.logger });
         this.capabilities = [
@@ -46,7 +47,7 @@ class BleFmAdapter extends adapter_1.default {
     getSupportedCyclingModes() {
         var _a;
         const modes = [power_meter_1.default];
-        const features = (_a = this.getComms()) === null || _a === void 0 ? void 0 : _a.features;
+        const features = (_a = this.getSensor()) === null || _a === void 0 ? void 0 : _a.features;
         if (!features)
             return [power_meter_1.default, antble_smarttrainer_1.default, antble_erg_1.default];
         if (features.setPower === undefined || features.setPower)
@@ -57,7 +58,7 @@ class BleFmAdapter extends adapter_1.default {
     }
     getDefaultCyclingMode() {
         var _a;
-        const features = (_a = this.getComms()) === null || _a === void 0 ? void 0 : _a.features;
+        const features = (_a = this.getSensor()) === null || _a === void 0 ? void 0 : _a.features;
         if (!features)
             return new antble_smarttrainer_1.default(this);
         if (features.setSlope === undefined || features.setSlope)
@@ -117,15 +118,16 @@ class BleFmAdapter extends adapter_1.default {
     }
     initControl(_startProps) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isStarting())
+                return;
             this.setConstants();
             yield this.establishControl();
-            this.setConstants();
             yield this.sendInitialRequest();
         });
     }
     setConstants() {
         const mode = this.getCyclingMode();
-        const sensor = this.getComms();
+        const sensor = this.getSensor();
         if (mode === null || mode === void 0 ? void 0 : mode.getSetting('bikeType')) {
             const bikeType = mode.getSetting('bikeType').toLowerCase();
             sensor.setCrr(consts_1.cRR);
@@ -146,38 +148,30 @@ class BleFmAdapter extends adapter_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.isStarting())
                 return false;
-            let waitTask;
-            let iv;
-            const sensor = this.getComms();
-            const wait = () => {
-                const res = new Promise((resolve) => {
-                    iv = setInterval(() => __awaiter(this, void 0, void 0, function* () {
-                        if (!this.isStarting() || !(waitTask === null || waitTask === void 0 ? void 0 : waitTask.isRunning)) {
-                            resolve(false);
-                            clearInterval(iv);
-                            return;
+            let hasControl = false;
+            let tryCnt = 0;
+            const sensor = this.getSensor();
+            return new Promise((resolve) => {
+                this.startTask.notifyOnStop(() => {
+                    resolve(false);
+                });
+                const waitUntilControl = () => __awaiter(this, void 0, void 0, function* () {
+                    while (!hasControl && this.isStarting()) {
+                        if (tryCnt++ === 0) {
+                            this.logEvent({ message: 'requesting control', device: this.getName(), interface: this.getInterface() });
                         }
-                        const hasControl = yield sensor.requestControl();
+                        hasControl = yield sensor.requestControl();
                         if (hasControl) {
-                            clearInterval(iv);
-                            resolve(true);
+                            this.logEvent({ message: 'control granted', device: this.getName(), interface: this.getInterface() });
+                            resolve(this.isStarting());
                         }
-                        else if (!this.isStarting() || !(waitTask === null || waitTask === void 0 ? void 0 : waitTask.isRunning)) {
-                            resolve(false);
-                            clearInterval(iv);
+                        else {
+                            yield (0, utils_1.sleep)(this.requestControlRetryDelay);
                         }
-                    }), 1000);
+                    }
                 });
-                return res;
-            };
-            waitTask = new task_1.InteruptableTask(wait(), {
-                errorOnTimeout: false,
-                timeout: 10000
+                waitUntilControl();
             });
-            const hasControl = yield waitTask.run();
-            clearInterval(iv);
-            if (!hasControl && this.isStarting())
-                throw new Error('could not establish control');
         });
     }
     sendInitialRequest() {
@@ -187,22 +181,33 @@ class BleFmAdapter extends adapter_1.default {
         });
     }
     checkCapabilities() {
-        var _a, _b, _c;
-        const before = this.capabilities.join(',');
-        const sensor = this.getComms();
-        if (((_a = sensor.features) === null || _a === void 0 ? void 0 : _a.heartrate) && !this.hasCapability(types_1.IncyclistCapability.HeartRate)) {
-            this.capabilities.push(types_1.IncyclistCapability.HeartRate);
-        }
-        if (((_b = sensor.features) === null || _b === void 0 ? void 0 : _b.cadence) && !this.hasCapability(types_1.IncyclistCapability.Cadence)) {
-            this.capabilities.push(types_1.IncyclistCapability.Cadence);
-        }
-        if (((_c = sensor.features) === null || _c === void 0 ? void 0 : _c.power) && !this.hasCapability(types_1.IncyclistCapability.Power)) {
-            this.capabilities.push(types_1.IncyclistCapability.Power);
-        }
-        const after = this.capabilities.join(',');
-        if (before !== after) {
-            this.emit('device-info', this.getSettings(), { capabilities: this.capabilities });
-        }
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const before = this.capabilities.join(',');
+            const sensor = this.getSensor();
+            if (!sensor.features) {
+                try {
+                    yield sensor.getFitnessMachineFeatures();
+                }
+                catch (err) {
+                    this.logEvent({ message: 'error getting fitness machine features', device: this.getName(), interface: this.getInterface(), error: err });
+                }
+            }
+            if (((_a = sensor.features) === null || _a === void 0 ? void 0 : _a.heartrate) && !this.hasCapability(types_1.IncyclistCapability.HeartRate)) {
+                this.capabilities.push(types_1.IncyclistCapability.HeartRate);
+            }
+            if (((_b = sensor.features) === null || _b === void 0 ? void 0 : _b.cadence) && !this.hasCapability(types_1.IncyclistCapability.Cadence)) {
+                this.capabilities.push(types_1.IncyclistCapability.Cadence);
+            }
+            if (((_c = sensor.features) === null || _c === void 0 ? void 0 : _c.power) && !this.hasCapability(types_1.IncyclistCapability.Power)) {
+                this.capabilities.push(types_1.IncyclistCapability.Power);
+            }
+            const after = this.capabilities.join(',');
+            if (before !== after) {
+                this.logEvent({ message: 'device capabilities updated', name: this.getSettings().name, interface: this.getSettings().interface, capabilities: this.capabilities });
+                this.emit('device-info', this.getSettings(), { capabilities: this.capabilities });
+            }
+        });
     }
     sendUpdate(request_1) {
         return __awaiter(this, arguments, void 0, function* (request, enforced = false) {
@@ -211,7 +216,7 @@ class BleFmAdapter extends adapter_1.default {
             try {
                 const update = this.getCyclingMode().sendBikeUpdate(request);
                 this.logEvent({ message: 'send bike update requested', profile: this.getProfile(), update, request });
-                const device = this.device;
+                const device = this.getSensor();
                 if (update.slope !== undefined) {
                     yield device.setSlope(update.slope);
                 }

package/lib/ble/fm/comms.d.ts

@@ -1,6 +1,6 @@
 import { BleProtocol, BleWriteProps, IBlePeripheralConnector } from "../types";
 import { IndoorBikeData, IndoorBikeFeatures } from "./types";
-import { BleComms } from "../base/sensor";
+import { BleComms } from "../base/comms";
 import { LegacyProfile } from "../../antv2/types";
 export default class BleFitnessMachineDevice extends BleComms {
     static protocol: BleProtocol;

package/lib/ble/fm/comms.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const consts_1 = require("../consts");
-const sensor_1 = require("../base/sensor");
+const comms_1 = require("../base/comms");
 const utils_1 = require("../utils");
 const bit = (nr) => (1 << nr);
 const IndoorBikeDataFlag = {
@@ -66,7 +66,7 @@ const TargetSettingFeatureFlag = {
     SpinDownControlSupported: bit(15),
     TargetedCadenceConfigurationSupported: bit(16)
 };
-class BleFitnessMachineDevice extends sensor_1.BleComms {
+class BleFitnessMachineDevice extends comms_1.BleComms {
     constructor(props) {
         super(props);
         this.features = undefined;
@@ -92,7 +92,7 @@ class BleFitnessMachineDevice extends sensor_1.BleComms {
     subscribeWriteResponse(cuuid) {
         return __awaiter(this, void 0, void 0, function* () {
             this.logEvent({ message: 'subscribe to CP response', characteristics: cuuid });
-            const connector = this.getPeripheral();
+            const connector = this.ble.peripheralCache.getConnector(this.peripheral);
             const isAlreadySubscribed = connector.isSubscribed(cuuid);
             if (!isAlreadySubscribed) {
                 connector.removeAllListeners(cuuid);

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

@@ -34,7 +34,7 @@ export default class BleFitnessMachineDevice extends TBleSensor {
     protected parseHrm(_data: Uint8Array): IndoorBikeData;
     protected parseIndoorBikeData(_data: Uint8Array): IndoorBikeData;
     protected parseFitnessMachineStatus(_data: Uint8Array): IndoorBikeData;
-    protected getFitnessMachineFeatures(): Promise<IndoorBikeFeatures | undefined>;
+    getFitnessMachineFeatures(): Promise<IndoorBikeFeatures | undefined>;
     protected writeFtmsMessage(requestedOpCode: any, data: any, props?: BleWriteProps): Promise<number>;
     setTargetInclination(inclination: number): Promise<boolean>;
     setIndoorBikeSimulation(windSpeed: number, gradient: number, crr: number, cw: number): Promise<boolean>;

package/lib/ble/fm/sensor.js

@@ -100,8 +100,6 @@ class BleFitnessMachineDevice extends sensor_1.TBleSensor {
             this.logEvent({ message: 'setTargetPower', power, skip: (this.data.targetPower !== undefined && this.data.targetPower === power) });
             if (this.data.targetPower !== undefined && this.data.targetPower === power)
                 return true;
-            if (!this.hasControl)
-                return;
             const hasControl = yield this.requestControl();
             if (!hasControl) {
                 this.logEvent({ message: 'setTargetPower failed', reason: 'control is disabled' });
@@ -111,15 +109,15 @@ class BleFitnessMachineDevice extends sensor_1.TBleSensor {
             data.writeUInt8(5, 0);
             data.writeInt16LE(Math.round(power), 1);
             const res = yield this.writeFtmsMessage(5, data);
+            if (res === 5) {
+                this.hasControl = false;
+            }
             return (res === 1);
         });
     }
     setSlope(slope) {
         return __awaiter(this, void 0, void 0, function* () {
             this.logEvent({ message: 'setSlope', slope });
-            const hasControl = yield this.requestControl();
-            if (!hasControl)
-                return;
             const { windSpeed, crr, cw } = this;
             return yield this.setIndoorBikeSimulation(windSpeed, slope, crr, cw);
         });
@@ -331,6 +329,9 @@ class BleFitnessMachineDevice extends sensor_1.TBleSensor {
             data.writeUInt8(Math.round(crr * 10000), 5);
             data.writeUInt8(Math.round(cw * 100), 6);
             const res = yield this.writeFtmsMessage(17, data);
+            if (res === 5) {
+                this.hasControl = false;
+            }
             return (res === 1);
         });
     }

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

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

package/lib/ble/hr/comm.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const sensor_1 = require("../base/sensor");
+const comms_1 = require("../base/comms");
 const consts_1 = require("../consts");
 const utils_1 = require("../utils");
-class BleHrmDevice extends sensor_1.BleComms {
+class BleHrmDevice extends comms_1.BleComms {
     constructor(props) {
         super(props);
         this.heartrate = undefined;

package/lib/ble/index.js

@@ -30,6 +30,7 @@ Object.defineProperty(exports, "BleInterface", { enumerable: true, get: function
 const factories_1 = require("./factories");
 Object.defineProperty(exports, "BleInterfaceFactory", { enumerable: true, get: function () { return factories_1.BleMultiTransportInterfaceFactory; } });
 Object.defineProperty(exports, "BleAdapterFactory", { enumerable: true, get: function () { return factories_1.BleAdapterFactory; } });
+const csc_1 = require("./csc");
 ['ble', 'wifi'].forEach(i => {
     const af = factories_1.BleAdapterFactory.getInstance(i);
     af.register('hr', hr_1.BleHrmAdapter, hr_1.BleHrmComms);
@@ -37,6 +38,7 @@ Object.defineProperty(exports, "BleAdapterFactory", { enumerable: true, get: fun
     af.register('fm', fm_1.BleFmAdapter, fm_1.BleFmComms);
     af.register('wahoo', wahoo_1.BleWahooAdapter, wahoo_1.BleWahooComms);
     af.register('tacx', tacx_1.BleTacxAdapter, tacx_1.BleTacxComms);
+    af.register('csc', csc_1.BleCSCAdapter, csc_1.BleCyclingSpeedCadenceDevice);
 });
 factories_1.BleMultiTransportInterfaceFactory.register('ble', interface_1.BleInterfaceFactory);
 __exportStar(require("./utils"), exports);

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

@@ -9,5 +9,5 @@ export default class BleTacxAdapter extends BleFmAdapter {
     updateSensor(peripheral: IBlePeripheral): void;
     getProfile(): LegacyProfile;
     protected initControl(props?: BleStartProperties): Promise<void>;
-    protected checkCapabilities(): void;
+    protected checkCapabilities(): Promise<void>;
 }