incyclist-devices 2.2.10-beta.0 → 2.3.0

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

@@ -1,7 +1,7 @@
-import BleCyclingPowerDevice from './comm';
+import BleCyclingPowerDevice from './sensor';
 import BleAdapter from '../base/adapter';
 import { PowerData } from './types';
-import { BleDeviceSettings } from '../types';
+import { BleDeviceSettings, IBlePeripheral } from '../types';
 import { DeviceProperties, IncyclistBikeData, IncyclistAdapterData, ControllerConfig, IAdapter } from '../../types';
 import { LegacyProfile } from '../../antv2/types';
 import { UpdateRequest } from '../../modes/types';
@@ -11,8 +11,8 @@ export default class PwrAdapter extends BleAdapter<PowerData, BleCyclingPowerDev
     distanceInternal: number;
     constructor(settings: BleDeviceSettings, props?: DeviceProperties);
     isSame(device: IAdapter): boolean;
+    updateSensor(peripheral: IBlePeripheral): void;
     getProfile(): LegacyProfile;
-    getName(): string;
     getDisplayName(): string;
     mapData(deviceData: PowerData): IncyclistBikeData;
     transformData(bikeData: IncyclistBikeData): IncyclistAdapterData;

package/lib/ble/cp/adapter.js

@@ -13,7 +13,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const gd_eventlog_1 = require("gd-eventlog");
-const comm_1 = __importDefault(require("./comm"));
+const sensor_1 = __importDefault(require("./sensor"));
 const adapter_1 = __importDefault(require("../base/adapter"));
 const types_1 = require("../../types");
 const power_meter_1 = __importDefault(require("../../modes/power-meter"));
@@ -22,9 +22,7 @@ class PwrAdapter extends adapter_1.default {
         super(settings, props);
         this.distanceInternal = 0;
         this.logger = new gd_eventlog_1.EventLogger('Ble-CP');
-        const { id, address, name } = settings;
-        const logger = this.logger;
-        this.device = new comm_1.default({ id, address, name, logger });
+        this.device = new sensor_1.default(this.getPeripheral(), { logger: this.logger });
         this.capabilities = [
             types_1.IncyclistCapability.Power, types_1.IncyclistCapability.Cadence, types_1.IncyclistCapability.Speed
         ];
@@ -34,19 +32,20 @@ class PwrAdapter extends adapter_1.default {
             return false;
         return this.isEqual(device.settings);
     }
+    updateSensor(peripheral) {
+        this.device = new sensor_1.default(peripheral, { logger: this.logger });
+    }
     getProfile() {
         return 'Power Meter';
     }
-    getName() {
-        return `${this.device.name}`;
-    }
     getDisplayName() {
-        const { name } = this.device;
+        const name = this.getName();
         const { instantaneousPower: power } = this.deviceData;
         const powerStr = power ? ` (${power})` : '';
         return `${name}${powerStr}`;
     }
     mapData(deviceData) {
+        var _a, _b, _c;
         const data = {
             isPedalling: false,
             power: 0,
@@ -57,9 +56,9 @@ class PwrAdapter extends adapter_1.default {
             slope: undefined,
             time: undefined
         };
-        data.power = (deviceData.instantaneousPower !== undefined ? deviceData.instantaneousPower : data.power);
-        data.pedalRpm = (deviceData.rpm !== undefined ? deviceData.rpm : data.pedalRpm);
-        data.time = (deviceData.time !== undefined ? deviceData.time : data.time);
+        data.power = (_a = deviceData === null || deviceData === void 0 ? void 0 : deviceData.instantaneousPower) !== null && _a !== void 0 ? _a : data.power;
+        data.pedalRpm = (_b = deviceData === null || deviceData === void 0 ? void 0 : deviceData.rpm) !== null && _b !== void 0 ? _b : data.pedalRpm;
+        data.time = (_c = deviceData === null || deviceData === void 0 ? void 0 : deviceData.time) !== null && _c !== void 0 ? _c : data.time;
         data.isPedalling = data.pedalRpm > 0 || (data.pedalRpm === undefined && data.power > 0);
         return data;
     }
@@ -93,10 +92,10 @@ class PwrAdapter extends adapter_1.default {
             try {
                 if (this.isPaused() || this.isStopped())
                     return;
-                return yield this.getCyclingMode().sendBikeUpdate(request);
+                return this.getCyclingMode().sendBikeUpdate(request);
             }
             catch (err) {
-                this.logEvent({ message: 'Error', fn: 'sendUpdate', error: err.message });
+                this.logEvent({ message: 'Error', fn: 'BleCP:sendUpdate', error: err.message });
             }
         });
     }

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

@@ -1,5 +1,5 @@
 import { CrankData, PowerData } from './types';
-import { BleComms } from '../base/comms';
+import { BleComms } from '../base/sensor';
 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 comms_1 = require("../base/comms");
-class BleCyclingPowerDevice extends comms_1.BleComms {
+const sensor_1 = require("../base/sensor");
+class BleCyclingPowerDevice extends sensor_1.BleComms {
     constructor() {
         super(...arguments);
         this.instantaneousPower = undefined;

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

@@ -1,4 +1,4 @@
 import { PowerData, CrankData } from './types';
 import BlePwrAdapter from './adapter';
-import BlePwrComms from './comm';
+import BlePwrComms from './sensor';
 export { PowerData, CrankData, BlePwrAdapter, BlePwrComms };

package/lib/ble/cp/index.js

@@ -6,5 +6,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BlePwrComms = exports.BlePwrAdapter = void 0;
 const adapter_1 = __importDefault(require("./adapter"));
 exports.BlePwrAdapter = adapter_1.default;
-const comm_1 = __importDefault(require("./comm"));
-exports.BlePwrComms = comm_1.default;
+const sensor_1 = __importDefault(require("./sensor"));
+exports.BlePwrComms = sensor_1.default;

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

@@ -0,0 +1,27 @@
+import { CrankData, PowerData } from './types';
+import { LegacyProfile } from '../../antv2/types';
+import { BleProtocol } from '../types';
+import { TBleSensor } from '../base/sensor';
+export default class BleCyclingPowerDevice extends TBleSensor {
+    static readonly profile: LegacyProfile;
+    static readonly protocol: BleProtocol;
+    static readonly services: string[];
+    static readonly characteristics: string[];
+    static readonly detectionPriority = 1;
+    instantaneousPower: number;
+    balance: number;
+    accTorque: number;
+    rpm: number;
+    timeOffset: number;
+    time: number;
+    currentCrankData: CrankData;
+    prevCrankData: CrankData;
+    parseCrankData(crankData: any): {
+        rpm: number;
+        time: any;
+    };
+    parsePower(_data: Uint8Array): PowerData;
+    protected getRequiredCharacteristics(): Array<string>;
+    onData(characteristic: string, data: Buffer): boolean;
+    reset(): void;
+}

package/lib/ble/cp/sensor.js

@@ -0,0 +1,107 @@
+"use strict";
+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.TBleSensor {
+    constructor() {
+        super(...arguments);
+        this.instantaneousPower = undefined;
+        this.balance = undefined;
+        this.accTorque = undefined;
+        this.rpm = undefined;
+        this.timeOffset = 0;
+        this.time = undefined;
+        this.currentCrankData = undefined;
+        this.prevCrankData = undefined;
+    }
+    parseCrankData(crankData) {
+        if (!this.prevCrankData)
+            this.prevCrankData = { revolutions: 0, time: 0, cntUpdateMissing: -1 };
+        const c = this.currentCrankData = crankData;
+        const p = this.prevCrankData;
+        let rpm = this.rpm;
+        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 };
+    }
+    parsePower(_data) {
+        const data = Buffer.from(_data);
+        try {
+            let offset = 4;
+            const flags = data.readUInt16LE(0);
+            this.instantaneousPower = data.readUInt16LE(2);
+            if (flags & 0x1)
+                this.balance = data.readUInt8(offset++);
+            if (flags & 0x4) {
+                this.accTorque = data.readUInt16LE(offset);
+                offset += 2;
+            }
+            if (flags & 0x10) {
+                offset += 6;
+            }
+            if (flags & 0x20) {
+                const crankData = {
+                    revolutions: data.readUInt16LE(offset),
+                    time: data.readUInt16LE(offset + 2)
+                };
+                const { rpm, time } = this.parseCrankData(crankData);
+                this.rpm = rpm;
+                this.time = time;
+            }
+        }
+        catch (err) {
+        }
+        const { instantaneousPower, balance, accTorque, rpm, time } = this;
+        return { instantaneousPower, balance, accTorque, rpm, time, raw: `2a63:${data.toString('hex')}` };
+    }
+    getRequiredCharacteristics() {
+        return [consts_1.CSP_MEASUREMENT];
+    }
+    onData(characteristic, data) {
+        const hasData = super.onData(characteristic, data);
+        if (!hasData)
+            return false;
+        if ((0, utils_1.matches)(characteristic, consts_1.CSP_MEASUREMENT)) {
+            const res = this.parsePower(data);
+            this.emit('data', res);
+            return false;
+        }
+        return true;
+    }
+    reset() {
+        this.instantaneousPower = undefined;
+        this.balance = undefined;
+        this.accTorque = undefined;
+        this.rpm = undefined;
+        this.timeOffset = 0;
+        this.time = undefined;
+        this.currentCrankData = undefined;
+        this.prevCrankData = undefined;
+    }
+}
+BleCyclingPowerDevice.profile = 'Power Meter';
+BleCyclingPowerDevice.protocol = 'cp';
+BleCyclingPowerDevice.services = [consts_1.CSP];
+BleCyclingPowerDevice.characteristics = [consts_1.CSP_MEASUREMENT, consts_1.CSP_FEATURE, '2a5d', '2a3c'];
+BleCyclingPowerDevice.detectionPriority = 1;
+exports.default = BleCyclingPowerDevice;

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

@@ -1,5 +1,5 @@
 import { LegacyProfile } from "../../antv2/types";
-import { BleComms } from "../base/comms";
+import { BleComms } from "../base/sensor";
 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 comms_1 = require("../base/comms");
+const sensor_1 = require("../base/sensor");
 const consts_1 = require("../consts");
 const utils_1 = require("../utils");
-class BleEliteDevice extends comms_1.BleComms {
+class BleEliteDevice extends sensor_1.BleComms {
     constructor(props) {
         super(props);
         this.instantaneousPower = undefined;

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

@@ -0,0 +1,32 @@
+import BleAdapter from "../base/adapter";
+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> {
+    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>;
+    removeInstance(query: {
+        settings?: BleDeviceSettings;
+        adapter?: BleAdapter<BleDeviceData, T>;
+    }): void;
+    find(settings?: BleDeviceSettings): BleAdapter<BleDeviceData, T>;
+    register(protocol: BleProtocol, Adapter: typeof BleAdapter<BleDeviceData, T>, Sensor: typeof TBleSensor): void;
+    getAllInstances(): Array<BleAdapter<BleDeviceData, T>>;
+    getAllSupportedSensors(): (typeof TBleSensor)[];
+    getAllSupportedAdapters(): Array<(typeof BleAdapter<BleDeviceData, T>)>;
+    getServices(info: BleAdapterInfo<T>): string[];
+    getAllSupportedServices(): string[];
+}

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

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BleAdapterFactory = void 0;
+const utils_1 = require("../utils");
+class BleAdapterFactory {
+    static getInstance(transport) {
+        if (!BleAdapterFactory._instances[transport])
+            BleAdapterFactory._instances[transport] = new BleAdapterFactory(transport);
+        return BleAdapterFactory._instances[transport];
+    }
+    constructor(transport) {
+        this.transport = transport;
+        this.implementations = [];
+        this.instances = [];
+    }
+    getAdapterInfo(protocol) {
+        return this.implementations.find(a => a.protocol === protocol);
+    }
+    getAll() {
+        return this.implementations;
+    }
+    createInstance(settings, props) {
+        let { profile, protocol } = settings;
+        const adapterSettings = Object.assign({}, settings);
+        if (profile) {
+            try {
+                const mapping = (0, utils_1.mapLegacyProfile)(profile);
+                protocol = adapterSettings.protocol = mapping.protocol;
+                delete adapterSettings.profile;
+            }
+            catch (_a) {
+                delete settings.profile;
+            }
+        }
+        const existing = this.find(adapterSettings);
+        if (existing) {
+            existing.setProperties(props);
+            return existing;
+        }
+        const info = this.getAdapterInfo(protocol);
+        if (!(info === null || info === void 0 ? void 0 : info.Adapter))
+            return;
+        const AdapterClass = info.Adapter;
+        const adapter = new AdapterClass(adapterSettings, props);
+        this.instances.push(adapter);
+        return adapter;
+    }
+    removeInstance(query) {
+        let idx = -1;
+        if (query.settings) {
+            idx = this.instances.findIndex(a => a.isEqual(query.settings));
+        }
+        else if (query.adapter) {
+            idx = this.instances.findIndex(a => a.isEqual(query.adapter.getSettings()));
+        }
+        if (idx !== -1)
+            this.instances.splice(idx);
+    }
+    find(settings) {
+        return this.instances.find(a => a.isEqual(settings));
+    }
+    register(protocol, Adapter, Sensor) {
+        const info = { protocol, Adapter, Sensor };
+        const existing = this.implementations.findIndex(a => a.protocol === protocol);
+        if (existing !== -1)
+            this.implementations[existing] = info;
+        else
+            this.implementations.push(info);
+    }
+    getAllInstances() {
+        return this.instances;
+    }
+    getAllSupportedSensors() {
+        const supported = this.getAll();
+        return supported.map(info => info.Sensor);
+    }
+    getAllSupportedAdapters() {
+        const supported = this.getAll();
+        return supported.map(info => info.Adapter);
+    }
+    getServices(info) {
+        const Sensor = info.Sensor;
+        if (!Sensor)
+            return [];
+        const sensor = new Sensor(null, {});
+        return sensor.getServiceUUids().map(utils_1.fullUUID);
+    }
+    getAllSupportedServices() {
+        const supported = this.getAll();
+        const res = [];
+        if (supported && supported.length > 0) {
+            supported.forEach(info => {
+                const services = this.getServices(info);
+                services.forEach(s => {
+                    if (!res.includes(s))
+                        res.push(s);
+                });
+            });
+        }
+        return res;
+    }
+}
+exports.BleAdapterFactory = BleAdapterFactory;
+BleAdapterFactory._instances = {};

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

@@ -0,0 +1,2 @@
+export * from './adapter-factory';
+export * from './interface-factory';

package/lib/ble/factories/index.js

@@ -0,0 +1,18 @@
+"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-factory"), exports);
+__exportStar(require("./interface-factory"), exports);

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

@@ -0,0 +1,7 @@
+import { InterfaceFactory } from "../base/types";
+import { IBleInterface } from "../types";
+export declare class BleMultiTransportInterfaceFactory {
+    static readonly registered: Record<string, typeof InterfaceFactory>;
+    static register(transport: string, Class: typeof InterfaceFactory): void;
+    static createInstance(transport: string): IBleInterface<any>;
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BleMultiTransportInterfaceFactory = void 0;
+class BleMultiTransportInterfaceFactory {
+    static register(transport, Class) {
+        this.registered[transport] = Class;
+    }
+    static createInstance(transport) {
+        var _a;
+        if (this.registered[transport]) {
+            const Class = this.registered[transport];
+            const iface = (_a = new Class()) === null || _a === void 0 ? void 0 : _a.getInterface();
+            return iface;
+        }
+    }
+}
+exports.BleMultiTransportInterfaceFactory = BleMultiTransportInterfaceFactory;
+BleMultiTransportInterfaceFactory.registered = {};

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

@@ -1,8 +1,8 @@
-import BleFitnessMachineDevice from './comms';
+import BleFitnessMachineDevice from './sensor';
 import BleAdapter from '../base/adapter';
 import ICyclingMode, { CyclingMode } from '../../modes/types';
 import { IndoorBikeData } from './types';
-import { BleDeviceProperties, BleDeviceSettings, BleStartProperties } from '../types';
+import { BleDeviceProperties, BleDeviceSettings, BleStartProperties, IBlePeripheral } from '../types';
 import { IAdapter, IncyclistAdapterData, IncyclistBikeData } from '../../types';
 import { LegacyProfile } from '../../antv2/types';
 export default class BleFmAdapter extends BleAdapter<IndoorBikeData, BleFitnessMachineDevice> {
@@ -10,14 +10,19 @@ export default class BleFmAdapter extends BleAdapter<IndoorBikeData, BleFitnessM
     distanceInternal: number;
     connectPromise: Promise<boolean>;
     constructor(settings: BleDeviceSettings, props?: BleDeviceProperties);
+    updateSensor(peripheral: IBlePeripheral): void;
     isSame(device: IAdapter): boolean;
-    getName(): string;
     isControllable(): boolean;
     getSupportedCyclingModes(): Array<typeof CyclingMode>;
     getDefaultCyclingMode(): ICyclingMode;
     mapData(deviceData: IndoorBikeData): IncyclistBikeData;
     transformData(bikeData: IncyclistBikeData): IncyclistAdapterData;
-    start(props?: BleStartProperties): Promise<any>;
+    protected checkResume(): boolean[];
+    protected initControl(_startProps?: BleStartProperties): Promise<void>;
+    protected setConstants(): void;
+    protected establishControl(): Promise<boolean>;
+    protected sendInitialRequest(): Promise<void>;
+    protected checkCapabilities(): void;
     sendUpdate(request: any, enforced?: boolean): Promise<void>;
     sendInitCommands(): Promise<boolean>;
 }