incyclist-devices 2.2.9 → 2.3.0

package/lib/ble/fm/sensor.js

@@ -0,0 +1,384 @@
+"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 });
+const consts_1 = require("../consts");
+const sensor_1 = require("../base/sensor");
+const utils_1 = require("../utils");
+const consts_2 = require("./consts");
+class BleFitnessMachineDevice extends sensor_1.TBleSensor {
+    constructor(peripheral, props) {
+        super(peripheral, props);
+        this._features = undefined;
+        this.hasControl = false;
+        this.isCheckingControl = false;
+        this.isCPSubscribed = false;
+        this.crr = 0.0033;
+        this.cw = 0.6;
+        this.windSpeed = 0;
+        this.wheelSize = 2100;
+        this.reset();
+    }
+    get features() {
+        return this._features;
+    }
+    reset() {
+        this.data = {};
+    }
+    getRequiredCharacteristics() {
+        return [consts_1.INDOOR_BIKE_DATA, '2a37', consts_1.FTMS_STATUS];
+    }
+    onData(characteristic, data) {
+        try {
+            const hasData = super.onData(characteristic, data);
+            if (!hasData)
+                return false;
+            const uuid = (0, utils_1.beautifyUUID)(characteristic).toLowerCase();
+            let res = undefined;
+            switch (uuid) {
+                case consts_1.INDOOR_BIKE_DATA:
+                    res = this.parseIndoorBikeData(data);
+                    break;
+                case '2a37':
+                    res = this.parseHrm(data);
+                    break;
+                case consts_1.FTMS_STATUS:
+                    res = this.parseFitnessMachineStatus(data);
+                    break;
+                case '2a63':
+                case '2a5b':
+                case '347b0011-7635-408b-8918-8ff3949ce592':
+                    break;
+                default:
+                    break;
+            }
+            if (res) {
+                this.emit('data', res);
+                return false;
+            }
+            return true;
+        }
+        catch (err) {
+            this.logEvent({ message: 'Error', fn: 'onData', error: err.message, stack: err.stack });
+            return false;
+        }
+    }
+    setCrr(crr) { this.crr = crr; }
+    getCrr() { return this.crr; }
+    setCw(cw) { this.cw = cw; }
+    getCw() { return this.cw; }
+    setWindSpeed(windSpeed) { this.windSpeed = windSpeed; }
+    getWindSpeed() { return this.windSpeed; }
+    requestControl() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.hasControl)
+                return true;
+            this.logEvent({ message: 'requestControl' });
+            this.isCheckingControl = true;
+            const data = Buffer.alloc(1);
+            data.writeUInt8(0, 0);
+            const res = yield this.writeFtmsMessage(0, data, { timeout: 5000 });
+            if (res === 1) {
+                this.hasControl = true;
+            }
+            else {
+                this.logEvent({ message: 'requestControl failed', reason: res });
+            }
+            this.isCheckingControl = false;
+            return this.hasControl;
+        });
+    }
+    setTargetPower(power) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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' });
+                return true;
+            }
+            const data = Buffer.alloc(3);
+            data.writeUInt8(5, 0);
+            data.writeInt16LE(Math.round(power), 1);
+            const res = yield this.writeFtmsMessage(5, data);
+            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);
+        });
+    }
+    parseHrm(_data) {
+        const data = Buffer.from(_data);
+        try {
+            const flags = data.readUInt8(0);
+            if (flags % 1 === 0) {
+                this.data.heartrate = data.readUInt8(1);
+            }
+            else {
+                this.data.heartrate = data.readUInt16LE(1);
+            }
+        }
+        catch (err) {
+            this.logEvent({ message: 'error', fn: 'parseHrm()', error: err.message | err, stack: err.stack });
+        }
+        return Object.assign(Object.assign({}, this.data), { raw: `2a37:${data.toString('hex')}` });
+    }
+    parseIndoorBikeData(_data) {
+        const data = Buffer.from(_data);
+        try {
+            const flags = data.readUInt16LE(0);
+            let offset = 2;
+            if ((flags & consts_2.IndoorBikeDataFlag.MoreData) === 0) {
+                this.data.speed = data.readUInt16LE(offset) / 100;
+                offset += 2;
+            }
+            if (flags & consts_2.IndoorBikeDataFlag.AverageSpeedPresent) {
+                this.data.averageSpeed = data.readUInt16LE(offset) / 100;
+                offset += 2;
+            }
+            if (flags & consts_2.IndoorBikeDataFlag.InstantaneousCadence) {
+                this.data.cadence = data.readUInt16LE(offset) / 2;
+                offset += 2;
+            }
+            if (flags & consts_2.IndoorBikeDataFlag.AverageCadencePresent) {
+                this.data.averageCadence = data.readUInt16LE(offset) / 2;
+                offset += 2;
+            }
+            if (flags & consts_2.IndoorBikeDataFlag.TotalDistancePresent) {
+                const dvLow = data.readUInt8(offset);
+                offset += 1;
+                const dvHigh = data.readUInt16LE(offset);
+                offset += 2;
+                this.data.totalDistance = (dvHigh << 8) + dvLow;
+            }
+            if (flags & consts_2.IndoorBikeDataFlag.ResistanceLevelPresent) {
+                this.data.resistanceLevel = data.readInt16LE(offset);
+                offset += 2;
+            }
+            if (flags & consts_2.IndoorBikeDataFlag.InstantaneousPowerPresent) {
+                this.data.instantaneousPower = data.readInt16LE(offset);
+                offset += 2;
+            }
+            if (flags & consts_2.IndoorBikeDataFlag.AveragePowerPresent) {
+                this.data.averagePower = data.readInt16LE(offset);
+                offset += 2;
+            }
+            if (flags & consts_2.IndoorBikeDataFlag.ExpendedEnergyPresent) {
+                this.data.totalEnergy = data.readUInt16LE(offset);
+                offset += 2;
+                this.data.energyPerHour = data.readUInt16LE(offset);
+                offset += 2;
+                this.data.energyPerMinute = data.readUInt8(offset);
+                offset += 1;
+            }
+            if (flags & consts_2.IndoorBikeDataFlag.HeartRatePresent) {
+                this.data.heartrate = data.readUInt8(offset);
+                offset += 1;
+            }
+            if (flags & consts_2.IndoorBikeDataFlag.MetabolicEquivalentPresent) {
+                this.data.metabolicEquivalent = data.readUInt8(offset) / 10;
+                offset += 2;
+            }
+            if (flags & consts_2.IndoorBikeDataFlag.ElapsedTimePresent) {
+                this.data.time = data.readUInt16LE(offset);
+                offset += 2;
+            }
+            if (flags & consts_2.IndoorBikeDataFlag.RemainingTimePresent) {
+                this.data.remainingTime = data.readUInt16LE(offset);
+            }
+        }
+        catch (err) {
+            this.logEvent({ message: 'error', fn: 'parseIndoorBikeData()', error: err.message | err, stack: err.stack });
+        }
+        return Object.assign(Object.assign({}, this.data), { raw: `2ad2:${data.toString('hex')}` });
+    }
+    parseFitnessMachineStatus(_data) {
+        const data = Buffer.from(_data);
+        try {
+            const OpCode = data.readUInt8(0);
+            switch (OpCode) {
+                case 8:
+                    this.data.targetPower = data.readInt16LE(1);
+                    break;
+                case 6:
+                    this.data.targetInclination = data.readInt16LE(1) / 10;
+                    break;
+                case 4:
+                    this.data.status = "STARTED";
+                    break;
+                case 3:
+                case 2:
+                    this.data.status = "STOPPED";
+                    break;
+                case 20:
+                    {
+                        const spinDownStatus = data.readUInt8(1);
+                        switch (spinDownStatus) {
+                            case 1:
+                                this.data.status = "SPIN DOWN REQUESTED";
+                                break;
+                            case 2:
+                                this.data.status = "SPIN DOWN SUCCESS";
+                                break;
+                            case 3:
+                                this.data.status = "SPIN DOWN ERROR";
+                                break;
+                            case 4:
+                                this.data.status = "STOP PEDALING";
+                                break;
+                            default: break;
+                        }
+                    }
+            }
+        }
+        catch (err) {
+            this.logEvent({ message: 'error', fn: 'parseFitnessMachineStatus()', error: err.message | err, stack: err.stack });
+        }
+        return Object.assign(Object.assign({}, this.data), { raw: `2ada:${data.toString('hex')}` });
+    }
+    getFitnessMachineFeatures() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._features)
+                return this._features;
+            try {
+                const data = yield this.read('2acc');
+                const buffer = data ? Buffer.from(data) : undefined;
+                if (buffer) {
+                    const fitnessMachine = buffer.readUInt32LE(0);
+                    const targetSettings = buffer.readUInt32LE(4);
+                    const power = (fitnessMachine & consts_2.FitnessMachineFeatureFlag.PowerMeasurementSupported) !== 0;
+                    const heartrate = (fitnessMachine & consts_2.FitnessMachineFeatureFlag.HeartRateMeasurementSupported) !== 0;
+                    const cadence = (fitnessMachine & consts_2.FitnessMachineFeatureFlag.CadenceSupported) !== 0;
+                    const setSlope = (targetSettings & consts_2.TargetSettingFeatureFlag.IndoorBikeSimulationParametersSupported) !== 0
+                        || (targetSettings & consts_2.TargetSettingFeatureFlag.InclinationTargetSettingSupported) !== 0;
+                    const setPower = (targetSettings & consts_2.TargetSettingFeatureFlag.PowerTargetSettingSupported) !== 0;
+                    this._features = { fitnessMachine, targetSettings, power, heartrate, cadence, setPower, setSlope };
+                    this.logEvent({ message: 'supported Features: ', fatures: this._features, power, heartrate, cadence });
+                }
+            }
+            catch (err) {
+                this.logEvent({ message: 'could not read FitnessMachineFeatures', error: err.message, stack: err.stack });
+                return undefined;
+            }
+        });
+    }
+    writeFtmsMessage(requestedOpCode, data, props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.logEvent({ message: 'fmts:write', data: data.toString('hex') });
+                const res = yield this.write(consts_1.FTMS_CP, data, props);
+                const responseData = Buffer.from(res);
+                const opCode = responseData.readUInt8(0);
+                const request = responseData.readUInt8(1);
+                const result = responseData.readUInt8(2);
+                if (opCode !== 128 || request !== requestedOpCode)
+                    throw new Error('Illegal response ');
+                this.logEvent({ message: 'fmts:write result', res, result });
+                return result;
+            }
+            catch (err) {
+                this.logEvent({ message: 'fmts:write failed', opCode: requestedOpCode, reason: err.message });
+                return 4;
+            }
+        });
+    }
+    setTargetInclination(inclination) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.data.targetInclination !== undefined && this.data.targetInclination === inclination)
+                return true;
+            if (!this.hasControl)
+                return;
+            const hasControl = yield this.requestControl();
+            if (!hasControl) {
+                this.logEvent({ message: 'setTargetInclination failed', reason: 'control is disabled' });
+                return false;
+            }
+            const data = Buffer.alloc(3);
+            data.writeUInt8(3, 0);
+            data.writeInt16LE(Math.round(inclination * 10), 1);
+            const res = yield this.writeFtmsMessage(3, data);
+            return (res === 1);
+        });
+    }
+    setIndoorBikeSimulation(windSpeed, gradient, crr, cw) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hasControl = yield this.requestControl();
+            if (!hasControl) {
+                this.logEvent({ message: 'setIndoorBikeSimulation failed', reason: 'control is disabled' });
+                return false;
+            }
+            const data = Buffer.alloc(7);
+            data.writeUInt8(17, 0);
+            data.writeInt16LE(Math.round(windSpeed * 1000), 1);
+            data.writeInt16LE(Math.round(gradient * 100), 3);
+            data.writeUInt8(Math.round(crr * 10000), 5);
+            data.writeUInt8(Math.round(cw * 100), 6);
+            const res = yield this.writeFtmsMessage(17, data);
+            return (res === 1);
+        });
+    }
+    startRequest() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hasControl = yield this.requestControl();
+            if (!hasControl) {
+                this.logEvent({ message: 'startRequest failed', reason: 'control is disabled' });
+                return false;
+            }
+            const data = Buffer.alloc(1);
+            data.writeUInt8(7, 0);
+            const res = yield this.writeFtmsMessage(7, data);
+            return (res === 1);
+        });
+    }
+    stopRequest() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hasControl = yield this.requestControl();
+            if (!hasControl) {
+                this.logEvent({ message: 'stopRequest failed', reason: 'control is disabled' });
+                return false;
+            }
+            const data = Buffer.alloc(2);
+            data.writeUInt8(8, 0);
+            data.writeUInt8(1, 1);
+            const res = yield this.writeFtmsMessage(8, data);
+            return (res === 1);
+        });
+    }
+    PauseRequest() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hasControl = yield this.requestControl();
+            if (!hasControl) {
+                this.logEvent({ message: 'PauseRequest failed', reason: 'control is disabled' });
+                return false;
+            }
+            const data = Buffer.alloc(2);
+            data.writeUInt8(8, 0);
+            data.writeUInt8(2, 1);
+            const res = yield this.writeFtmsMessage(8, data);
+            return (res === 1);
+        });
+    }
+}
+BleFitnessMachineDevice.profile = 'Smart Trainer';
+BleFitnessMachineDevice.protocol = 'fm';
+BleFitnessMachineDevice.services = [consts_1.FTMS];
+BleFitnessMachineDevice.characteristics = ['2acc', consts_1.INDOOR_BIKE_DATA, '2ad6', '2ad8', consts_1.FTMS_CP, consts_1.FTMS_STATUS];
+BleFitnessMachineDevice.detectionPriority = 100;
+exports.default = BleFitnessMachineDevice;

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

@@ -1,7 +1,7 @@
 import BleAdapter from '../base/adapter';
-import BleHrmDevice from './comm';
+import BleHrmDevice from './sensor';
 import { IncyclistAdapterData, IAdapter, DeviceProperties } from '../../types';
-import { BleDeviceSettings } from '../types';
+import { BleDeviceSettings, IBlePeripheral } from '../types';
 import { HrmData } from './types';
 import { LegacyProfile } from '../../antv2/types';
 export default class HrmAdapter extends BleAdapter<HrmData, BleHrmDevice> {
@@ -9,7 +9,7 @@ export default class HrmAdapter extends BleAdapter<HrmData, BleHrmDevice> {
     ignore: boolean;
     constructor(settings: BleDeviceSettings, props?: DeviceProperties);
     isSame(device: IAdapter): boolean;
-    getName(): string;
+    updateSensor(peripheral: IBlePeripheral): void;
     getDisplayName(): string;
     mapData(deviceData: HrmData): IncyclistAdapterData;
 }

package/lib/ble/hr/adapter.js

@@ -5,17 +5,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const gd_eventlog_1 = require("gd-eventlog");
 const adapter_1 = __importDefault(require("../base/adapter"));
-const comm_1 = __importDefault(require("./comm"));
+const sensor_1 = __importDefault(require("./sensor"));
 const types_1 = require("../../types");
 class HrmAdapter extends adapter_1.default {
     constructor(settings, props) {
         super(settings, props);
         this.ignore = false;
         this.logger = new gd_eventlog_1.EventLogger('Ble-HR');
-        const { id, address, name } = settings;
-        const logger = this.logger;
-        const ble = this.ble;
-        this.device = new comm_1.default({ id, address, name, ble, logger });
+        this.device = new sensor_1.default(this.getPeripheral(), { logger: this.logger });
         this.capabilities = [
             types_1.IncyclistCapability.HeartRate
         ];
@@ -25,11 +22,11 @@ class HrmAdapter extends adapter_1.default {
             return false;
         return this.isEqual(device.settings);
     }
-    getName() {
-        return `${this.device.name}`;
+    updateSensor(peripheral) {
+        this.device = new sensor_1.default(peripheral, { logger: this.logger });
     }
     getDisplayName() {
-        const { name } = this.device;
+        const name = this.getName();
         const { heartrate: hrm } = this.deviceData;
         const hrmStr = hrm ? ` (${hrm})` : '';
         return `${name}${hrmStr}`;

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

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

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

@@ -1,4 +1,4 @@
 import { HrmData } from './types';
 import BleHrmAdapter from './adapter';
-import BleHrmComms from './comm';
+import BleHrmComms from './sensor';
 export { HrmData, BleHrmAdapter, BleHrmComms };

package/lib/ble/hr/index.js

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

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

@@ -0,0 +1,17 @@
+import { LegacyProfile } from '../../antv2/types';
+import { TBleSensor } from '../base/sensor';
+import { BleProtocol } from '../types';
+import { HrmData } from './types';
+export default class BleHrmDevice extends TBleSensor {
+    static readonly profile: LegacyProfile;
+    static readonly protocol: BleProtocol;
+    static readonly services: string[];
+    static readonly characteristics: string[];
+    static readonly detectionPriority = 1;
+    protected heartrate: number;
+    protected rr: number;
+    parseHrm(_data: Uint8Array): HrmData;
+    reset(): void;
+    protected getRequiredCharacteristics(): Array<string>;
+    onData(characteristic: string, data: Buffer): boolean;
+}

package/lib/ble/hr/sensor.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sensor_1 = require("../base/sensor");
+const consts_1 = require("../consts");
+const utils_1 = require("../utils");
+class BleHrmDevice extends sensor_1.TBleSensor {
+    parseHrm(_data) {
+        const data = Buffer.from(_data);
+        try {
+            const flags = data.readUInt8(0);
+            let offset = 2;
+            if (flags % 1 === 0) {
+                this.heartrate = data.readUInt8(1);
+            }
+            else {
+                this.heartrate = data.readUInt16LE(1);
+                offset = 3;
+            }
+            if (flags % 0xF) {
+                this.rr = (data.readUInt16LE(offset)) / 1024;
+            }
+        }
+        catch (err) {
+        }
+        const { heartrate, rr } = this;
+        return { heartrate, rr, raw: data.toString('hex') };
+    }
+    reset() {
+        delete this.heartrate;
+        delete this.rr;
+    }
+    getRequiredCharacteristics() {
+        return [consts_1.HR_MEASUREMENT];
+    }
+    onData(characteristic, data) {
+        const hasData = super.onData(characteristic, data);
+        if (!hasData)
+            return;
+        if ((0, utils_1.matches)(characteristic, consts_1.HR_MEASUREMENT)) {
+            const res = this.parseHrm(data);
+            this.emit('data', res);
+            return false;
+        }
+        return true;
+    }
+}
+BleHrmDevice.profile = 'Heartrate Monitor';
+BleHrmDevice.protocol = 'hr';
+BleHrmDevice.services = ['180d'];
+BleHrmDevice.characteristics = [consts_1.HR_MEASUREMENT, '2a38', '2a39', '2a3c'];
+BleHrmDevice.detectionPriority = 1;
+exports.default = BleHrmDevice;

package/lib/ble/index.d.ts

@@ -1,9 +1,10 @@
-import BleInterface from './ble-interface';
-import BleAdapterFactory from './adapter-factory';
 import { BleHrmAdapter } from './hr';
 import { BlePwrAdapter } from './cp';
 import { BleFmAdapter } from './fm';
 import { BleWahooAdapter } from './wahoo';
 import { BleTacxAdapter } from './tacx';
 import { BleDeviceSettings, BleInterfaceProps } from './types';
-export { BleAdapterFactory, BleInterface, BleInterfaceProps, BleDeviceSettings, BleHrmAdapter, BlePwrAdapter, BleFmAdapter, BleWahooAdapter, BleTacxAdapter };
+import { BleInterface } from '../ble/base/interface';
+import { BleMultiTransportInterfaceFactory, BleAdapterFactory } from './factories';
+export * from './utils';
+export { BleAdapterFactory, BleMultiTransportInterfaceFactory as BleInterfaceFactory, BleInterface, BleInterfaceProps, BleDeviceSettings, BleHrmAdapter, BlePwrAdapter, BleFmAdapter, BleWahooAdapter, BleTacxAdapter };

package/lib/ble/index.js

@@ -1,13 +1,20 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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 });
-exports.BleTacxAdapter = exports.BleWahooAdapter = exports.BleFmAdapter = exports.BlePwrAdapter = exports.BleHrmAdapter = exports.BleInterface = exports.BleAdapterFactory = void 0;
-const ble_interface_1 = __importDefault(require("./ble-interface"));
-exports.BleInterface = ble_interface_1.default;
-const adapter_factory_1 = __importDefault(require("./adapter-factory"));
-exports.BleAdapterFactory = adapter_factory_1.default;
+exports.BleTacxAdapter = exports.BleWahooAdapter = exports.BleFmAdapter = exports.BlePwrAdapter = exports.BleHrmAdapter = exports.BleInterface = exports.BleInterfaceFactory = exports.BleAdapterFactory = void 0;
 const hr_1 = require("./hr");
 Object.defineProperty(exports, "BleHrmAdapter", { enumerable: true, get: function () { return hr_1.BleHrmAdapter; } });
 const cp_1 = require("./cp");
@@ -18,9 +25,18 @@ const wahoo_1 = require("./wahoo");
 Object.defineProperty(exports, "BleWahooAdapter", { enumerable: true, get: function () { return wahoo_1.BleWahooAdapter; } });
 const tacx_1 = require("./tacx");
 Object.defineProperty(exports, "BleTacxAdapter", { enumerable: true, get: function () { return tacx_1.BleTacxAdapter; } });
-const af = adapter_factory_1.default.getInstance();
-af.register('hr', hr_1.BleHrmAdapter, hr_1.BleHrmComms);
-af.register('cp', cp_1.BlePwrAdapter, cp_1.BlePwrComms);
-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);
+const interface_1 = require("../ble/base/interface");
+Object.defineProperty(exports, "BleInterface", { enumerable: true, get: function () { return interface_1.BleInterface; } });
+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; } });
+['ble', 'wifi'].forEach(i => {
+    const af = factories_1.BleAdapterFactory.getInstance(i);
+    af.register('hr', hr_1.BleHrmAdapter, hr_1.BleHrmComms);
+    af.register('cp', cp_1.BlePwrAdapter, cp_1.BlePwrComms);
+    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);
+});
+factories_1.BleMultiTransportInterfaceFactory.register('ble', interface_1.BleInterfaceFactory);
+__exportStar(require("./utils"), exports);

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

@@ -1,11 +1,13 @@
 import { BleFmAdapter } from '../fm';
-import { BleDeviceSettings, BleStartProperties } from '../types';
+import { BleDeviceSettings, BleStartProperties, IBlePeripheral } from '../types';
 import { DeviceProperties, IAdapter } from '../../types';
 import { LegacyProfile } from '../../antv2/types';
 export default class BleTacxAdapter extends BleFmAdapter {
     protected static INCYCLIST_PROFILE_NAME: LegacyProfile;
     constructor(settings: BleDeviceSettings, props?: DeviceProperties);
     isSame(device: IAdapter): boolean;
+    updateSensor(peripheral: IBlePeripheral): void;
     getProfile(): LegacyProfile;
-    start(props?: BleStartProperties): Promise<any>;
+    protected initControl(props?: BleStartProperties): Promise<void>;
+    protected checkCapabilities(): void;
 }