incyclist-devices 2.3.0-beta.19 → 2.3.0-beta.20

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;
+}

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/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/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/comms.d.ts

@@ -1,7 +1,7 @@
 import { LegacyProfile } from "../../antv2/types";
 import { CrankData } from "../cp";
 import { IndoorBikeData } from "../fm";
-import BleFitnessMachineDevice from "../fm/sensor";
+import BleFitnessMachineDevice from "../fm/comms";
 import { BleProtocol, IBlePeripheralConnector } from "../types";
 import { BleFeBikeData } from "./types";
 export default class TacxAdvancedFitnessMachineDevice extends BleFitnessMachineDevice {

package/lib/ble/tacx/comms.js

@@ -13,7 +13,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const consts_1 = require("../consts");
-const sensor_1 = __importDefault(require("../fm/sensor"));
+const comms_1 = __importDefault(require("../fm/comms"));
 const utils_1 = require("../utils");
 var ANTMessages;
 (function (ANTMessages) {
@@ -37,7 +37,7 @@ const PROFILE_ID = 'Tacx SmartTrainer';
 const SYNC_BYTE = 0xA4;
 const DEFAULT_CHANNEL = 5;
 const ACKNOWLEDGED_DATA = 0x4F;
-class TacxAdvancedFitnessMachineDevice extends sensor_1.default {
+class TacxAdvancedFitnessMachineDevice extends comms_1.default {
     constructor(props) {
         super(props);
         this.prevCrankData = undefined;

package/lib/ble/tacx/sensor.js

@@ -43,7 +43,7 @@ class TacxAdvancedFitnessMachineDevice extends sensor_1.default {
         }
         this.messageCnt++;
         try {
-            const uuid = characteristic.toLocaleLowerCase();
+            const uuid = (0, utils_1.beautifyUUID)(characteristic).toLowerCase();
             let res = undefined;
             if (uuid && (0, utils_1.matches)(uuid, this.tacxRx)) {
                 res = this.parseFECMessage(data);

package/lib/ble/types.d.ts

@@ -1,7 +1,7 @@
 import EventEmitter from "events";
 import { EventLogger } from "gd-eventlog";
 import { DeviceProperties, DeviceSettings, DeviceStartProperties, IncyclistInterface, IncyclistScanProps, InterfaceProps } from "../types";
-export type BleProtocol = 'hr' | 'fm' | 'cp' | 'tacx' | 'wahoo' | 'elite';
+export type BleProtocol = 'hr' | 'fm' | 'cp' | 'tacx' | 'wahoo' | 'elite' | 'csc';
 export type BleInterfaceState = 'unknown' | 'resetting' | 'unsupported' | 'unauthorized' | 'poweredOff' | 'poweredOn';
 export interface BleBinding extends EventEmitter {
     startScanning(serviceUUIDs?: string[], allowDuplicates?: boolean, callback?: (error?: Error) => void): void;

package/lib/ble/utils.d.ts

@@ -19,4 +19,5 @@ export declare const beautifyUUID: (str: string, withX?: boolean) => string;
 export declare const fullUUID: (str: string) => string;
 export declare const propertyVal: (properties: BleProperty[]) => number;
 export declare const propertyFromVal: (val: number) => BleProperty[];
+export declare const bit: (nr: any) => number;
 export {};