incyclist-devices 1.5.38 → 2.0.0

package/lib/ble/hr/types.js

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

package/lib/ble/index.d.ts

@@ -0,0 +1,9 @@
+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 };

package/lib/ble/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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;
+const hr_1 = require("./hr");
+Object.defineProperty(exports, "BleHrmAdapter", { enumerable: true, get: function () { return hr_1.BleHrmAdapter; } });
+const cp_1 = require("./cp");
+Object.defineProperty(exports, "BlePwrAdapter", { enumerable: true, get: function () { return cp_1.BlePwrAdapter; } });
+const fm_1 = require("./fm");
+Object.defineProperty(exports, "BleFmAdapter", { enumerable: true, get: function () { return fm_1.BleFmAdapter; } });
+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);

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

@@ -0,0 +1,43 @@
+import BleAdapter from "./base/adapter";
+import BlePeripheralConnector from "./ble-peripheral";
+import { BleCharacteristic, BlePeripheral } from "./types";
+export interface PeripheralState {
+    isLoading: boolean;
+    isConfigured: boolean;
+    isInterrupted: boolean;
+}
+export interface PeripheralCacheItem {
+    address: string;
+    name?: string;
+    id?: string;
+    ts: number;
+    peripheral: BlePeripheral;
+    state?: PeripheralState;
+    characteristics?: BleCharacteristic[];
+    connector?: BlePeripheralConnector;
+}
+export default class BlePeripheralCache {
+    peripherals: PeripheralCacheItem[];
+    findAdapter(adapter: BleAdapter): PeripheralCacheItem;
+    getConnector(peripheral: BlePeripheral): BlePeripheralConnector;
+    getPeripheral(query: {
+        id?: string;
+        address?: string;
+        name?: string;
+    }): BlePeripheral;
+    handleStopScan(): void;
+    find(query: {
+        name?: string;
+        id?: string;
+        address?: string;
+        peripheral?: BlePeripheral;
+    }): PeripheralCacheItem;
+    filter(services: string[]): PeripheralCacheItem[];
+    protected _findIndex(query: {
+        name?: string;
+        id?: string;
+        address?: string;
+    }): number;
+    add(item: PeripheralCacheItem): PeripheralCacheItem;
+    remove(query: PeripheralCacheItem | BlePeripheral): void;
+}

package/lib/ble/peripheral-cache.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ble_peripheral_1 = __importDefault(require("./ble-peripheral"));
+class BlePeripheralCache {
+    constructor() {
+        this.peripherals = [];
+    }
+    findAdapter(adapter) {
+        return this.find(adapter.getSettings());
+    }
+    getConnector(peripheral) {
+        const info = this.find({ address: peripheral.address });
+        if (!info) {
+            const item = this.add({ address: peripheral.address, ts: Date.now(), peripheral });
+            return item.connector;
+        }
+        return info.connector;
+    }
+    getPeripheral(query) {
+        const info = this.find(query);
+        return info ? info.peripheral : undefined;
+    }
+    handleStopScan() {
+        const ongoing = this.peripherals.filter(i => i.state && i.state.isLoading);
+        if (ongoing)
+            ongoing.forEach(i => { i.state.isInterrupted = true; });
+    }
+    find(query) {
+        const { peripheral } = query;
+        const { name, address, id } = peripheral ? peripheral : query;
+        if (!name && !address && !id)
+            throw new Error('illegal query, one of <id>,<name>,<address> needs to be provided');
+        if (address)
+            return this.peripherals.find(i => i.address === address);
+        else if (name)
+            return this.peripherals.find(i => i.name === name);
+        else if (id)
+            return this.peripherals.find(i => i.id === id);
+    }
+    filter(services) {
+        if (services.length === 0) {
+            return this.peripherals;
+        }
+        return this.peripherals.filter(i => {
+            const announced = i.peripheral.services.map(s => s.uuid);
+            const requested = services;
+            return (announced.find(s => requested.includes(s)));
+        });
+    }
+    _findIndex(query) {
+        const { name, address, id } = query;
+        if (!name && !address && !id)
+            throw new Error('illegal query, one of <id>,<name>,<address> needs to be provided');
+        if (address)
+            return this.peripherals.findIndex(i => i.address === address);
+        else if (name)
+            return this.peripherals.findIndex(i => i.name === name);
+        else if (id)
+            return this.peripherals.findIndex(i => i.id === id);
+    }
+    add(item) {
+        const { address, name, id } = item;
+        const { ts, peripheral, state, characteristics } = item;
+        const cachedItem = this.find({ address, name, id });
+        if (cachedItem) {
+            cachedItem.ts = ts;
+            cachedItem.peripheral = peripheral;
+            if (state)
+                cachedItem.state = state;
+            if (characteristics) {
+                cachedItem.characteristics = characteristics;
+            }
+            if (!cachedItem.connector) {
+                cachedItem.connector = item.connector || new ble_peripheral_1.default(cachedItem.peripheral);
+            }
+            return cachedItem;
+        }
+        else {
+            const newItem = Object.assign({}, item);
+            if (newItem.peripheral && !newItem.connector)
+                newItem.connector = new ble_peripheral_1.default(item.peripheral);
+            this.peripherals.push(newItem);
+            return newItem;
+        }
+    }
+    remove(query) {
+        const item = query;
+        const isCacheItem = item.peripheral !== undefined;
+        let cachedItemIdx;
+        if (isCacheItem) {
+            const { address, name, id } = item;
+            cachedItemIdx = this._findIndex({ address, name, id });
+        }
+        else {
+            const peripheral = query;
+            const { address } = peripheral;
+            cachedItemIdx = this._findIndex({ address });
+        }
+        if (cachedItemIdx == -1)
+            return;
+        this.peripherals.splice(cachedItemIdx);
+    }
+}
+exports.default = BlePeripheralCache;

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

@@ -0,0 +1,10 @@
+import { BleFmAdapter } from '../fm';
+import BleAdapter from '../base/adapter';
+import { DeviceProperties } from '../../types/device';
+import { BleDeviceSettings, BleStartProperties } from '../types';
+export default class BleTacxFEAdapter extends BleFmAdapter {
+    constructor(settings: BleDeviceSettings, props?: DeviceProperties);
+    isSame(device: BleAdapter): boolean;
+    getProfile(): string;
+    start(props?: BleStartProperties): Promise<any>;
+}

package/lib/ble/tacx/adapter.js

@@ -0,0 +1,99 @@
+"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 });
+const gd_eventlog_1 = require("gd-eventlog");
+const fm_1 = require("../fm");
+const comms_1 = __importDefault(require("./comms"));
+const adpater_1 = require("../../base/adpater");
+const capabilities_1 = require("../../types/capabilities");
+class BleTacxFEAdapter extends fm_1.BleFmAdapter {
+    constructor(settings, props) {
+        super(settings, props);
+        this.logger = new gd_eventlog_1.EventLogger('BLE-FEC-Tacx');
+        const { id, address, name } = settings;
+        const logger = this.logger;
+        const ble = this.ble;
+        this.device = new comms_1.default({ id, address, name, ble, logger });
+        this.capabilities = [
+            capabilities_1.IncyclistCapability.Power, capabilities_1.IncyclistCapability.Speed, capabilities_1.IncyclistCapability.Cadence,
+            capabilities_1.IncyclistCapability.Control
+        ];
+    }
+    isSame(device) {
+        if (!(device instanceof BleTacxFEAdapter))
+            return false;
+        return this.isEqual(device.settings);
+    }
+    getProfile() {
+        return 'Smart Trainer';
+    }
+    start(props = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.started)
+                return true;
+            if (this.ble.isScanning()) {
+                this.logger.logEvent({ message: 'stop previous scan', isScanning: this.ble.isScanning() });
+                yield this.ble.stopScan();
+            }
+            const connected = yield this.connect();
+            if (!connected)
+                throw new Error(`could not start device, reason:could not connect`);
+            this.logger.logEvent({ message: 'start requested', protocol: this.getProtocolName(), props });
+            try {
+                const comms = this.device;
+                if (comms) {
+                    this.device = comms;
+                    const mode = this.getCyclingMode();
+                    if (mode && mode.getSetting('bikeType')) {
+                        const bikeType = mode.getSetting('bikeType').toLowerCase();
+                        comms.setCrr(fm_1.cRR);
+                        switch (bikeType) {
+                            case 'race':
+                                comms.setCw(fm_1.cwABike.race);
+                                break;
+                            case 'triathlon':
+                                comms.setCw(fm_1.cwABike.triathlon);
+                                break;
+                            case 'mountain':
+                                comms.setCw(fm_1.cwABike.mountain);
+                                break;
+                        }
+                    }
+                    const { user, wheelDiameter, gearRatio, bikeWeight = adpater_1.DEFAULT_BIKE_WEIGHT } = props || {};
+                    const userWeight = (user && user.weight ? user.weight : adpater_1.DEFAULT_USER_WEIGHT);
+                    comms.sendTrackResistance(0.0);
+                    comms.sendUserConfiguration(userWeight, bikeWeight, wheelDiameter, gearRatio);
+                    const startRequest = this.getCyclingMode().getBikeInitRequest();
+                    yield this.sendUpdate(startRequest);
+                    comms.on('data', (data) => {
+                        this.onDeviceData(data);
+                    });
+                    this.resetData();
+                    this.stopped = false;
+                    this.started = true;
+                    this.paused = false;
+                    if (comms.features.heartrate && !this.hasCapability(capabilities_1.IncyclistCapability.HeartRate)) {
+                        this.capabilities.push(capabilities_1.IncyclistCapability.HeartRate);
+                    }
+                    return true;
+                }
+            }
+            catch (err) {
+                this.logger.logEvent({ message: 'start result: error', error: err.message, profile: this.getProfile() });
+                throw new Error(`could not start device, reason:${err.message}`);
+            }
+        });
+    }
+}
+exports.default = BleTacxFEAdapter;

package/lib/ble/{tacx.d.ts → tacx/comms.d.ts}

@@ -1,31 +1,12 @@
 /// <reference types="node" />
-import BleProtocol from './incyclist-protocol';
-import { BleDeviceClass } from './ble';
-import DeviceAdapter from '../device';
-import BleFitnessMachineDevice, { FmAdapter, IndoorBikeData } from './fm';
-import BlePeripheralConnector from './ble-peripheral';
-interface BleFeBikeData extends IndoorBikeData {
-    EquipmentType?: 'Treadmill' | 'Elliptical' | 'StationaryBike' | 'Rower' | 'Climber' | 'NordicSkier' | 'Trainer' | 'General';
-    RealSpeed?: number;
-    VirtualSpeed?: number;
-    HeartRateSource?: 'HandContact' | 'EM' | 'ANT+';
-    State?: 'OFF' | 'READY' | 'IN_USE' | 'FINISHED';
-    EventCount?: number;
-    AccumulatedPower?: number;
-    TrainerStatus?: number;
-    TargetStatus?: 'OnTarget' | 'LowSpeed' | 'HighSpeed';
-    HwVersion?: number;
-    ManId?: number;
-    ModelNum?: number;
-    SwVersion?: number;
-    SerialNumber?: number;
-}
-declare type CrankData = {
-    revolutions?: number;
-    time?: number;
-    cntUpdateMissing?: number;
-};
+import { LegacyProfile } from "../../antv2/types";
+import { CrankData } from "../cp";
+import { IndoorBikeData } from "../fm";
+import BleFitnessMachineDevice from "../fm/comms";
+import { BleProtocol, IBlePeripheralConnector } from "../types";
+import { BleFeBikeData } from "./types";
 export default class TacxAdvancedFitnessMachineDevice extends BleFitnessMachineDevice {
+    static protocol: BleProtocol;
     static services: string[];
     static characteristics: string[];
     static PROFILE: string;
@@ -40,15 +21,13 @@ export default class TacxAdvancedFitnessMachineDevice extends BleFitnessMachineD
     tacxRx: string;
     tacxTx: string;
     constructor(props?: any);
-    isMatching(characteristics: string[]): boolean;
+    static isMatching(characteristics: string[]): boolean;
     setCharacteristicUUIDs(uuids: string[]): void;
-    subscribeAll(conn?: BlePeripheralConnector): Promise<void>;
+    subscribeAll(conn?: IBlePeripheralConnector): Promise<void>;
     init(): Promise<boolean>;
-    getProfile(): string;
+    getProfile(): LegacyProfile;
+    getProtocol(): BleProtocol;
     getServiceUUids(): string[];
-    isBike(): boolean;
-    isPower(): boolean;
-    isHrm(): boolean;
     requestControl(): Promise<boolean>;
     parseCrankData(crankData: any): {
         rpm?: undefined;
@@ -79,14 +58,3 @@ export default class TacxAdvancedFitnessMachineDevice extends BleFitnessMachineD
     setSlope(slope: any): Promise<boolean>;
     reset(): void;
 }
-export declare class TacxBleFEAdapter extends FmAdapter {
-    static PROFILE: string;
-    device: TacxAdvancedFitnessMachineDevice;
-    constructor(device: BleDeviceClass, protocol: BleProtocol);
-    isSame(device: DeviceAdapter): boolean;
-    getProfile(): string;
-    start(props?: any): Promise<any>;
-    pause(): Promise<boolean>;
-    resume(): Promise<boolean>;
-}
-export {};

package/lib/ble/{tacx.js → tacx/comms.js}

@@ -1,23 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 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) {
@@ -31,23 +12,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TacxBleFEAdapter = void 0;
-const ble_interface_1 = __importDefault(require("./ble-interface"));
-const ble_1 = require("./ble");
-const device_1 = require("../device");
-const gd_eventlog_1 = require("gd-eventlog");
-const fm_1 = __importStar(require("./fm"));
-const consts_1 = require("./consts");
-const SYNC_BYTE = 0xA4;
-const DEFAULT_CHANNEL = 5;
-const ACKNOWLEDGED_DATA = 0x4F;
-const PROFILE_ID = 'Tacx SmartTrainer';
-const cwABike = {
-    race: 0.35,
-    triathlon: 0.29,
-    mountain: 0.57
-};
-const cRR = 0.0036;
+const _1 = require(".");
+const consts_1 = require("../consts");
+const comms_1 = __importDefault(require("../fm/comms"));
+const utils_1 = require("../utils");
 var ANTMessages;
 (function (ANTMessages) {
     ANTMessages[ANTMessages["calibrationCommand"] = 1] = "calibrationCommand";
@@ -66,7 +34,11 @@ var ANTMessages;
     ANTMessages[ANTMessages["manufactererData"] = 80] = "manufactererData";
     ANTMessages[ANTMessages["productInformation"] = 81] = "productInformation";
 })(ANTMessages || (ANTMessages = {}));
-class TacxAdvancedFitnessMachineDevice extends fm_1.default {
+const PROFILE_ID = 'Tacx SmartTrainer';
+const SYNC_BYTE = 0xA4;
+const DEFAULT_CHANNEL = 5;
+const ACKNOWLEDGED_DATA = 0x4F;
+class TacxAdvancedFitnessMachineDevice extends comms_1.default {
     constructor(props) {
         super(props);
         this.prevCrankData = undefined;
@@ -79,52 +51,24 @@ class TacxAdvancedFitnessMachineDevice extends fm_1.default {
         this.tacxRx = consts_1.TACX_FE_C_RX;
         this.tacxTx = consts_1.TACX_FE_C_TX;
     }
-    isMatching(characteristics) {
+    static isMatching(characteristics) {
         if (!characteristics)
             return false;
-        const hasTacxCP = characteristics.find(c => (0, ble_1.matches)(c, consts_1.TACX_FE_C_RX)) !== undefined &&
-            characteristics.find(c => (0, ble_1.matches)(c, consts_1.TACX_FE_C_TX)) !== undefined;
+        const hasTacxCP = characteristics.find(c => (0, utils_1.matches)(c, consts_1.TACX_FE_C_RX)) !== undefined &&
+            characteristics.find(c => (0, utils_1.matches)(c, consts_1.TACX_FE_C_TX)) !== undefined;
         return hasTacxCP;
     }
     setCharacteristicUUIDs(uuids) {
         uuids.forEach(c => {
-            if ((0, ble_1.matches)(c, consts_1.TACX_FE_C_RX))
+            if ((0, utils_1.matches)(c, consts_1.TACX_FE_C_RX))
                 this.tacxRx = c;
-            if ((0, ble_1.matches)(c, consts_1.TACX_FE_C_TX))
+            if ((0, utils_1.matches)(c, consts_1.TACX_FE_C_TX))
                 this.tacxTx = c;
         });
     }
     subscribeAll(conn) {
-        return new Promise(resolve => {
-            const characteristics = [consts_1.CSC_MEASUREMENT, consts_1.CSP_MEASUREMENT, consts_1.INDOOR_BIKE_DATA, consts_1.FTMS_STATUS, consts_1.FTMS_CP];
-            const timeout = Date.now() + 5500;
-            const iv = setInterval(() => {
-                const subscriptionStatus = characteristics.map(c => this.subscribedCharacteristics.find(s => s === c) !== undefined);
-                const done = subscriptionStatus.filter(s => s === true).length === characteristics.length;
-                if (done || Date.now() > timeout) {
-                    clearInterval(iv);
-                    resolve();
-                }
-            }, 100);
-            try {
-                const connector = conn || this.ble.getConnector(this.peripheral);
-                for (let i = 0; i < characteristics.length; i++) {
-                    const c = characteristics[i];
-                    const isAlreadySubscribed = connector.isSubscribed(c);
-                    if (!isAlreadySubscribed) {
-                        connector.removeAllListeners(c);
-                        connector.on(c, (uuid, data) => {
-                            this.onData(uuid, data);
-                        });
-                        connector.subscribe(c);
-                        this.subscribedCharacteristics.push(c);
-                    }
-                }
-            }
-            catch (err) {
-                this.logEvent({ message: 'Error', fn: 'subscribeAll()', error: err.message, stack: err.stack });
-            }
-        });
+        const characteristics = [consts_1.CSC_MEASUREMENT, consts_1.CSP_MEASUREMENT, consts_1.INDOOR_BIKE_DATA, consts_1.FTMS_STATUS, consts_1.FTMS_CP, consts_1.TACX_FE_C_RX];
+        return this.subscribeMultiple(characteristics, conn);
     }
     init() {
         const _super = Object.create(null, {
@@ -132,8 +76,7 @@ class TacxAdvancedFitnessMachineDevice extends fm_1.default {
         });
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                yield _super.initDevice.call(this);
-                return true;
+                return yield _super.initDevice.call(this);
             }
             catch (err) {
                 this.logEvent({ message: 'error', fn: 'TacxAdvancedFitnessMachineDevice.init()', error: err.message || err, stack: err.stack });
@@ -142,20 +85,14 @@ class TacxAdvancedFitnessMachineDevice extends fm_1.default {
         });
     }
     getProfile() {
-        return TacxAdvancedFitnessMachineDevice.PROFILE;
+        return 'Smart Trainer';
+    }
+    getProtocol() {
+        return _1.BleTacxComms.protocol;
     }
     getServiceUUids() {
         return TacxAdvancedFitnessMachineDevice.services;
     }
-    isBike() {
-        return true;
-    }
-    isPower() {
-        return true;
-    }
-    isHrm() {
-        return this.hasService('180d');
-    }
     requestControl() {
         return __awaiter(this, void 0, void 0, function* () {
             return true;
@@ -484,7 +421,7 @@ class TacxAdvancedFitnessMachineDevice extends fm_1.default {
         try {
             const uuid = characteristic.toLocaleLowerCase();
             let res = undefined;
-            if (uuid && (0, ble_1.matches)(uuid, this.tacxRx)) {
+            if (uuid && (0, utils_1.matches)(uuid, this.tacxRx)) {
                 res = this.parseFECMessage(data);
             }
             else {
@@ -689,77 +626,8 @@ class TacxAdvancedFitnessMachineDevice extends fm_1.default {
     }
 }
 exports.default = TacxAdvancedFitnessMachineDevice;
+TacxAdvancedFitnessMachineDevice.protocol = 'tacx';
 TacxAdvancedFitnessMachineDevice.services = [consts_1.TACX_FE_C_BLE];
 TacxAdvancedFitnessMachineDevice.characteristics = ['2acc', '2ad2', '2ad6', '2ad8', '2ad9', '2ada', consts_1.TACX_FE_C_RX, consts_1.TACX_FE_C_TX];
 TacxAdvancedFitnessMachineDevice.PROFILE = PROFILE_ID;
 TacxAdvancedFitnessMachineDevice.detectionPriority = 10;
-ble_interface_1.default.register('TacxBleFEDevice', 'tacx-ble-fec', TacxAdvancedFitnessMachineDevice, TacxAdvancedFitnessMachineDevice.services);
-class TacxBleFEAdapter extends fm_1.FmAdapter {
-    constructor(device, protocol) {
-        super(device, protocol);
-        this.device = device;
-        this.ble = protocol.ble;
-        this.cyclingMode = this.getDefaultCyclingMode();
-        this.logger = new gd_eventlog_1.EventLogger('BLE-FEC-Tacx');
-        if (this.device)
-            this.device.setLogger(this.logger);
-    }
-    isSame(device) {
-        if (!(device instanceof TacxBleFEAdapter))
-            return false;
-        const adapter = device;
-        return (adapter.getName() === this.getName() && adapter.getProfile() === this.getProfile());
-    }
-    getProfile() {
-        return TacxBleFEAdapter.PROFILE;
-    }
-    start(props) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'tacx: start requested', profile: this.getProfile(), props });
-            if (this.ble.isScanning())
-                yield this.ble.stopScan();
-            try {
-                const bleDevice = yield this.ble.connectDevice(this.device);
-                bleDevice.setLogger(this.logger);
-                if (bleDevice) {
-                    this.device = bleDevice;
-                    const mode = this.getCyclingMode();
-                    if (mode && mode.getSetting('bikeType')) {
-                        const bikeType = mode.getSetting('bikeType').toLowerCase();
-                        this.device.setCrr(cRR);
-                        switch (bikeType) {
-                            case 'race':
-                                this.device.setCw(cwABike.race);
-                                break;
-                            case 'triathlon':
-                                this.device.setCw(cwABike.triathlon);
-                                break;
-                            case 'mountain':
-                                this.device.setCw(cwABike.mountain);
-                                break;
-                        }
-                    }
-                    const { user, wheelDiameter, gearRatio } = props || {};
-                    const userWeight = (user && user.weight ? user.weight : device_1.DEFAULT_USER_WEIGHT);
-                    const bikeWeight = device_1.DEFAULT_BIKE_WEIGHT;
-                    this.device.sendTrackResistance(0.0);
-                    this.device.sendUserConfiguration(userWeight, bikeWeight, wheelDiameter, gearRatio);
-                    const startRequest = this.getCyclingMode().getBikeInitRequest();
-                    yield this.sendUpdate(startRequest);
-                    bleDevice.on('data', (data) => {
-                        this.onDeviceData(data);
-                    });
-                    return true;
-                }
-            }
-            catch (err) {
-                this.logger.logEvent({ message: 'start result: error', error: err.message, profile: this.getProfile() });
-                throw new Error(`could not start device, reason:${err.message}`);
-            }
-        });
-    }
-    pause() { this.paused = true; return Promise.resolve(true); }
-    resume() { this.paused = false; return Promise.resolve(true); }
-}
-exports.TacxBleFEAdapter = TacxBleFEAdapter;
-TacxBleFEAdapter.PROFILE = PROFILE_ID;

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

@@ -0,0 +1,4 @@
+import BleTacxComms from "./comms";
+import BleTacxAdapter from "./adapter";
+import { BleFeBikeData } from "./types";
+export { BleTacxAdapter, BleTacxComms, BleFeBikeData };

package/lib/ble/tacx/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BleTacxComms = exports.BleTacxAdapter = void 0;
+const comms_1 = __importDefault(require("./comms"));
+exports.BleTacxComms = comms_1.default;
+const adapter_1 = __importDefault(require("./adapter"));
+exports.BleTacxAdapter = adapter_1.default;

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

@@ -0,0 +1,25 @@
+import { IndoorBikeData } from "../fm";
+export interface BleFeBikeData extends IndoorBikeData {
+    EquipmentType?: 'Treadmill' | 'Elliptical' | 'StationaryBike' | 'Rower' | 'Climber' | 'NordicSkier' | 'Trainer' | 'General';
+    RealSpeed?: number;
+    VirtualSpeed?: number;
+    HeartRateSource?: 'HandContact' | 'EM' | 'ANT+';
+    State?: 'OFF' | 'READY' | 'IN_USE' | 'FINISHED';
+    EventCount?: number;
+    AccumulatedPower?: number;
+    TrainerStatus?: number;
+    TargetStatus?: 'OnTarget' | 'LowSpeed' | 'HighSpeed';
+    HwVersion?: number;
+    ManId?: number;
+    ModelNum?: number;
+    SwVersion?: number;
+    SerialNumber?: number;
+}
+export type MessageInfo = {
+    message: string;
+    ts: number;
+    uuid: string;
+};
+export type MessageLog = {
+    [uuid: string]: MessageInfo;
+};

package/lib/ble/tacx/types.js

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