incyclist-devices 1.5.38 → 2.0.0

package/lib/ble/types.d.ts

@@ -0,0 +1,128 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import EventEmitter from "events";
+import { EventLogger } from "gd-eventlog";
+import { DeviceProperties, DeviceSettings, DeviceStartProperties, IncyclistScanProps } from "../types/device";
+import { InterfaceProps } from "../types/interface";
+export type BleProtocol = 'hr' | 'fm' | 'cp' | 'tacx' | 'wahoo' | 'elite';
+export type BleInterfaceState = 'unknown' | 'resetting' | 'unsupported' | 'unauthorized' | 'poweredOff' | 'poweredOn';
+export interface BleBinding extends EventEmitter {
+    startScanning(serviceUUIDs?: string[], allowDuplicates?: boolean, callback?: (error?: Error) => void): void;
+    stopScanning(callback?: () => void): void;
+    _bindings: any;
+    state: BleInterfaceState;
+    on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+}
+export interface BleScanProps extends IncyclistScanProps {
+    protocol?: BleProtocol;
+    protocols?: BleProtocol[];
+    isBackgroundScan?: boolean;
+}
+export interface BleDeviceConstructProps extends BleDeviceProps {
+    log?: boolean;
+    logger?: EventLogger;
+    peripheral?: BlePeripheral;
+}
+export interface BleDeviceSettings extends DeviceSettings {
+    id?: string;
+    protocol: BleProtocol;
+    profile?: string;
+    address?: string;
+    name?: string;
+}
+export interface BleDetectedDevice extends BleDeviceSettings {
+    peripheral: BlePeripheral;
+}
+export interface BleDeviceProperties extends DeviceProperties {
+    wheelDiameter?: number;
+    gearRatio?: number;
+}
+export interface BleStartProperties extends DeviceStartProperties {
+    wheelDiameter?: number;
+    gearRatio?: number;
+    restart?: boolean;
+    scanOnly?: boolean;
+}
+export interface BleInterfaceProps extends InterfaceProps {
+    binding?: BleBinding;
+    timeout?: number;
+    reconnect?: boolean;
+}
+export type BleService = {
+    uuid: string;
+};
+export type DiscoverResult = {
+    services: BleService[];
+    characteristics: BleCharacteristic[];
+};
+export interface BlePeripheral extends EventEmitter, BlePeripheralIdentifier {
+    services: [];
+    advertisement: any;
+    state: string;
+    connectAsync(): Promise<void>;
+    disconnect(cb: (err?: Error) => void): Promise<void>;
+    discoverSomeServicesAndCharacteristicsAsync(serviceUUIDs: string[], characteristicUUIDs: string[]): Promise<DiscoverResult>;
+}
+export interface IBlePeripheralConnector {
+    connect(): Promise<void>;
+    reconnect(): Promise<void>;
+    initialize(enforce: boolean): Promise<void>;
+    isSubscribed(characteristicUuid: string): boolean;
+    subscribeAll(callback: (characteristicUuid: string, data: any) => void): Promise<string[]>;
+    subscribe(characteristicUuid: string, timeout?: number): Promise<boolean>;
+    onDisconnect(): void;
+    onData(characteristicUuid: string, data: any): void;
+    on(characteristicUuid: string, callback: (characteristicUuid: string, data: any) => void): void;
+    off(characteristicUuid: string, callback: (characteristicUuid: string, data: any) => void): void;
+    removeAllListeners(characteristicUuid: string): void;
+    getState(): string;
+    getCharachteristics(): BleCharacteristic[];
+    getServices(): string[];
+    getPeripheral(): BlePeripheral;
+}
+export interface BleCharacteristic extends EventEmitter {
+    uuid: string;
+    properties: string[];
+    _serviceUuid?: string;
+    name?: string;
+    subscribe(callback: (err: Error | undefined) => void): void;
+    unsubscribe(callback: (err: Error | undefined) => void): void;
+    read(callback: (err: Error | undefined, data: Buffer) => void): void;
+    write(data: Buffer, withoutResponse: boolean, callback?: (err: Error | undefined) => void): void;
+}
+export type BleDeviceProps = {
+    id?: string;
+    address?: string;
+    name?: string;
+    services?: string[];
+    peripheral?: BlePeripheral;
+};
+export type BleCommsConnectProps = {
+    timeout?: number;
+    reconnect?: boolean;
+};
+export interface BleWriteProps {
+    withoutResponse?: boolean;
+    timeout?: number;
+}
+export interface BlePeripheralIdentifier {
+    id?: string;
+    address?: string;
+    name?: string;
+}
+export interface BlePeripheralDescription extends BlePeripheralIdentifier {
+    profile: string;
+}
+export interface ConnectState {
+    isConnecting: boolean;
+    isConnected: boolean;
+    isDisconnecting: boolean;
+}
+export type BleDeviceInfo = {
+    manufacturer?: string;
+    hwRevision?: string;
+    swRevision?: string;
+    fwRevision?: string;
+    model?: string;
+    serialNo?: string;
+};

package/lib/ble/types.js

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

package/lib/ble/utils.d.ts

@@ -0,0 +1,17 @@
+import { LegacyProfile } from "../antv2/types";
+import { BleCharacteristic, BlePeripheral, BleProtocol } from "./types";
+type MappingRecord = {
+    profile: LegacyProfile;
+    protocol: BleProtocol;
+};
+export declare function mapLegacyProfile(profile: string): MappingRecord;
+export declare function uuid(s: string): string;
+export declare function matches(uuid1: string, uuid2: string): boolean;
+export declare function getPeripheralInfo(p: BlePeripheral): {
+    id: string;
+    name: any;
+    address: string;
+    services: any;
+};
+export declare function getCharachteristicsInfo(c: BleCharacteristic): string;
+export {};

package/lib/ble/utils.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCharachteristicsInfo = exports.getPeripheralInfo = exports.matches = exports.uuid = exports.mapLegacyProfile = void 0;
+function mapLegacyProfile(profile) {
+    switch (profile) {
+        case 'Smart Trainer': return { profile: 'Smart Trainer', protocol: 'fm' };
+        case 'Elite Smart Trainer': return { profile: 'Smart Trainer', protocol: 'elite' };
+        case 'Heartrate Monitor': return { profile: 'Heartrate Monitor', protocol: 'hr' };
+        case 'Power Meter': return { profile: 'Power Meter', protocol: 'cp' };
+        case 'Tacx Smart Trainer': return { profile: 'Smart Trainer', protocol: 'tacx' };
+        case 'Wahoo Smart Trainer': return { profile: 'Smart Trainer', protocol: 'wahoo' };
+    }
+}
+exports.mapLegacyProfile = mapLegacyProfile;
+function uuid(s) {
+    if (s) {
+        if (s.includes('-')) {
+            const parts = s.split('-');
+            const uuidNo = parseInt('0x' + parts[0]);
+            return uuidNo.toString(16).toLowerCase();
+        }
+        return s;
+    }
+}
+exports.uuid = uuid;
+function matches(uuid1, uuid2) {
+    const ul1 = uuid1.toLowerCase();
+    const ul2 = uuid2.toLowerCase();
+    if (uuid(ul1) === uuid(ul2))
+        return true;
+    if (ul1.length < ul2.length && ul2.startsWith(ul1))
+        return true;
+    if (ul1.length > ul2.length && ul1.startsWith(ul2))
+        return true;
+    return false;
+}
+exports.matches = matches;
+function getPeripheralInfo(p) {
+    const { id, name, address, advertisement, services } = p;
+    if (advertisement) {
+        return { id, name: advertisement.localName, address, services: advertisement.serviceUuids };
+    }
+    else {
+        return { id, name, address, services };
+    }
+}
+exports.getPeripheralInfo = getPeripheralInfo;
+function getCharachteristicsInfo(c) {
+    const { uuid, properties, name, _serviceUuid } = c;
+    const nameStr = name ? ` (${name})` : '';
+    const serviceStr = _serviceUuid ? `${_serviceUuid}:` : '';
+    return `${serviceStr}${uuid}${nameStr} ${properties}`;
+}
+exports.getCharachteristicsInfo = getCharachteristicsInfo;

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

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

package/lib/ble/wahoo/adapter.js

@@ -0,0 +1,95 @@
+"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 BleWahooAdapter extends fm_1.BleFmAdapter {
+    constructor(settings, props) {
+        super(settings, props);
+        this.logger = new gd_eventlog_1.EventLogger('BLE-WahooFM');
+        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 BleWahooAdapter))
+            return false;
+        return this.isEqual(device.settings);
+    }
+    getProfile() {
+        return 'Smart Trainer';
+    }
+    start(props = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'start requested', protocol: this.getProtocolName(), props });
+            try {
+                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`);
+                const comms = this.device;
+                if (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, bikeWeight = adpater_1.DEFAULT_BIKE_WEIGHT } = props || {};
+                    const weight = (user && user.weight ? Number(user.weight) : adpater_1.DEFAULT_USER_WEIGHT) + bikeWeight;
+                    yield comms.setSimMode(weight, comms.getCrr(), comms.getCw());
+                    const startRequest = this.getCyclingMode().getBikeInitRequest();
+                    yield this.sendUpdate(startRequest);
+                    comms.on('data', (data) => {
+                        this.onDeviceData(data);
+                    });
+                    if (comms.features.heartrate && !this.hasCapability(capabilities_1.IncyclistCapability.HeartRate)) {
+                        this.capabilities.push(capabilities_1.IncyclistCapability.HeartRate);
+                    }
+                    this.resetData();
+                    this.stopped = false;
+                    this.started = true;
+                    this.paused = false;
+                    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 = BleWahooAdapter;

package/lib/ble/{wahoo-kickr.d.ts → wahoo/comms.d.ts}

@@ -1,8 +1,9 @@
 /// <reference types="node" />
-import BleProtocol from './incyclist-protocol';
-import { BleDeviceClass, BleWriteProps } from './ble';
-import DeviceAdapter from '../device';
-import BleFitnessMachineDevice, { FmAdapter } from './fm';
+import { LegacyProfile } from "../../antv2/types";
+import { CrankData } from "../cp";
+import { IndoorBikeData } from "../fm";
+import BleFitnessMachineDevice from "../fm/comms";
+import { BleProtocol, BleWriteProps, IBlePeripheralConnector } from "../types";
 export declare const enum OpCode {
     unlock = 32,
     setResistanceMode = 64,
@@ -15,31 +16,8 @@ export declare const enum OpCode {
     setSimWindSpeed = 71,
     setWheelCircumference = 72
 }
-declare type IndoorBikeData = {
-    speed?: number;
-    averageSpeed?: number;
-    cadence?: number;
-    averageCadence?: number;
-    totalDistance?: number;
-    resistanceLevel?: number;
-    instantaneousPower?: number;
-    averagePower?: number;
-    expendedEnergy?: number;
-    heartrate?: number;
-    metabolicEquivalent?: number;
-    time?: number;
-    remainingTime?: number;
-    raw?: string;
-    targetPower?: number;
-    targetInclination?: number;
-    status?: string;
-};
-declare type CrankData = {
-    revolutions?: number;
-    time?: number;
-    cntUpdateMissing?: number;
-};
-export default class WahooAdvancedFitnessMachineDevice extends BleFitnessMachineDevice {
+export default class BleWahooDevice extends BleFitnessMachineDevice {
+    static protocol: BleProtocol;
     static services: string[];
     static characteristics: string[];
     static detectionPriority: number;
@@ -58,20 +36,19 @@ export default class WahooAdvancedFitnessMachineDevice extends BleFitnessMachine
         cw: number;
     };
     constructor(props?: any);
-    isMatching(characteristics: string[]): boolean;
+    static isMatching(characteristics: string[]): boolean;
     init(): Promise<boolean>;
     setCharacteristicUUIDs(uuids: string[]): void;
-    getProfile(): string;
+    getProfile(): LegacyProfile;
+    getProtocol(): BleProtocol;
     getServiceUUids(): string[];
-    isBike(): boolean;
-    isPower(): boolean;
-    isHrm(): boolean;
     parseCrankData(crankData: any): {
         rpm: number;
         time: any;
     };
     parsePower(_data: Buffer): IndoorBikeData;
     onData(characteristic: string, data: Buffer): boolean;
+    subscribeAll(conn?: IBlePeripheralConnector): Promise<void>;
     writeWahooFtmsMessage(requestedOpCode: number, data: Buffer, props?: BleWriteProps): Promise<boolean>;
     requestControl(): Promise<boolean>;
     setPowerAdjusting(): void;
@@ -86,13 +63,3 @@ export default class WahooAdvancedFitnessMachineDevice extends BleFitnessMachine
     setSlope(slope: any): Promise<boolean>;
     reset(): void;
 }
-export declare class WahooAdvancedFmAdapter extends FmAdapter {
-    device: WahooAdvancedFitnessMachineDevice;
-    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/{wahoo-kickr.js → wahoo/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,22 +12,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WahooAdvancedFmAdapter = 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 WAHOO_ADVANCED_FTMS = 'a026ee0b';
-const cwABike = {
-    race: 0.35,
-    triathlon: 0.29,
-    mountain: 0.57
-};
-const cRR = 0.0036;
+const _1 = require(".");
+const adpater_1 = require("../../base/adpater");
+const consts_1 = require("../consts");
+const comms_1 = __importDefault(require("../fm/comms"));
+const utils_1 = require("../utils");
 const ErgWriteDelay = 2000;
-class WahooAdvancedFitnessMachineDevice extends fm_1.default {
+class BleWahooDevice extends comms_1.default {
     constructor(props) {
         super(props);
         this.prevCrankData = undefined;
@@ -55,15 +27,15 @@ class WahooAdvancedFitnessMachineDevice extends fm_1.default {
         this.tsPrevWrite = undefined;
         this.prevSlope = undefined;
         this.isRequestControlBusy = false;
-        this.weight = device_1.DEFAULT_BIKE_WEIGHT + device_1.DEFAULT_USER_WEIGHT;
+        this.weight = adpater_1.DEFAULT_BIKE_WEIGHT + adpater_1.DEFAULT_USER_WEIGHT;
         this.data = {};
         this.wahooCP = consts_1.WAHOO_ADVANCED_TRAINER_CP;
     }
-    isMatching(characteristics) {
+    static isMatching(characteristics) {
         if (!characteristics)
             return false;
-        const hasWahooCP = characteristics.find(c => (0, ble_1.matches)(c, consts_1.WAHOO_ADVANCED_TRAINER_CP)) !== undefined;
-        const hasFTMS = characteristics.find(c => (0, ble_1.matches)(c, consts_1.FTMS_CP)) !== undefined;
+        const hasWahooCP = characteristics.find(c => (0, utils_1.matches)(c, consts_1.WAHOO_ADVANCED_TRAINER_CP)) !== undefined;
+        const hasFTMS = characteristics.find(c => (0, utils_1.matches)(c, consts_1.FTMS_CP)) !== undefined;
         return hasWahooCP && !hasFTMS;
     }
     init() {
@@ -79,8 +51,7 @@ class WahooAdvancedFitnessMachineDevice extends fm_1.default {
                 }
                 catch (err) {
                 }
-                yield _super.initDevice.call(this);
-                return true;
+                return yield _super.initDevice.call(this);
             }
             catch (err) {
                 this.logEvent({ message: 'error', fn: 'WahooAdvancedFitnessMachineDevice.init()', error: err.message || err, stack: err.stack });
@@ -91,24 +62,18 @@ class WahooAdvancedFitnessMachineDevice extends fm_1.default {
     setCharacteristicUUIDs(uuids) {
         this.logEvent({ message: 'set uuids', uuids });
         uuids.forEach(c => {
-            if ((0, ble_1.matches)(c, consts_1.WAHOO_ADVANCED_TRAINER_CP))
+            if ((0, utils_1.matches)(c, consts_1.WAHOO_ADVANCED_TRAINER_CP))
                 this.wahooCP = c;
         });
     }
     getProfile() {
-        return 'Wahoo Smart Trainer';
-    }
-    getServiceUUids() {
-        return WahooAdvancedFitnessMachineDevice.services;
-    }
-    isBike() {
-        return true;
+        return 'Smart Trainer';
     }
-    isPower() {
-        return true;
+    getProtocol() {
+        return _1.BleWahooComms.protocol;
     }
-    isHrm() {
-        return this.hasService('180d');
+    getServiceUUids() {
+        return BleWahooDevice.services;
     }
     parseCrankData(crankData) {
         if (!this.prevCrankData)
@@ -178,16 +143,16 @@ class WahooAdvancedFitnessMachineDevice extends fm_1.default {
         const uuid = characteristic.toLowerCase();
         let res = undefined;
         switch (uuid) {
-            case '2a63':
+            case consts_1.CSP_MEASUREMENT:
                 res = this.parsePower(data);
                 break;
-            case '2ad2':
+            case consts_1.INDOOR_BIKE_DATA:
                 res = this.parseIndoorBikeData(data);
                 break;
-            case '2a37':
+            case consts_1.HR_MEASUREMENT:
                 res = this.parseHrm(data);
                 break;
-            case '2ada':
+            case consts_1.FTMS_STATUS:
                 res = this.parseFitnessMachineStatus(data);
                 break;
             default:
@@ -200,6 +165,9 @@ class WahooAdvancedFitnessMachineDevice extends fm_1.default {
         }
         return true;
     }
+    subscribeAll(conn) {
+        return this.subscribeMultiple([consts_1.CSP_MEASUREMENT, consts_1.INDOOR_BIKE_DATA, consts_1.HR_MEASUREMENT, consts_1.FTMS_STATUS, this.wahooCP], conn);
+    }
     writeWahooFtmsMessage(requestedOpCode, data, props) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
@@ -423,76 +391,8 @@ class WahooAdvancedFitnessMachineDevice extends fm_1.default {
         this.simModeSettings = undefined;
     }
 }
-exports.default = WahooAdvancedFitnessMachineDevice;
-WahooAdvancedFitnessMachineDevice.services = [consts_1.CSP];
-WahooAdvancedFitnessMachineDevice.characteristics = ['2acc', '2ad2', '2ad6', '2ad8', '2ad9', '2ada', consts_1.WAHOO_ADVANCED_TRAINER_CP];
-WahooAdvancedFitnessMachineDevice.detectionPriority = 5;
-ble_interface_1.default.register('WahooAdvancedFitnessMachineDevice', 'wahoo-fm', WahooAdvancedFitnessMachineDevice, WahooAdvancedFitnessMachineDevice.services);
-class WahooAdvancedFmAdapter 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-WahooFM');
-        if (this.device)
-            this.device.setLogger(this.logger);
-    }
-    isSame(device) {
-        if (!(device instanceof WahooAdvancedFmAdapter))
-            return false;
-        const adapter = device;
-        return (adapter.getName() === this.getName() && adapter.getProfile() === this.getProfile());
-    }
-    getProfile() {
-        return 'Wahoo Smart Trainer';
-    }
-    start(props) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'wahoo: start requested', profile: this.getProfile(), props, isScanning: this.ble.isScanning() });
-            try {
-                this.logger.logEvent({ message: 'wahoo: stop previous scan', isScanning: this.ble.isScanning() });
-                if (this.ble.isScanning())
-                    yield this.ble.stopScan();
-                this.logger.logEvent({ message: 'wahoo trying device connect' });
-                const bleDevice = yield this.ble.connectDevice(this.device);
-                this.logger.logEvent({ message: 'wahoo device connected', connected: (bleDevice !== null && bleDevice !== undefined) });
-                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 } = props || {};
-                    const weight = (user && user.weight ? Number(user.weight) : device_1.DEFAULT_USER_WEIGHT) + device_1.DEFAULT_BIKE_WEIGHT;
-                    yield this.device.setSimMode(weight, this.device.getCrr(), this.device.getCw());
-                    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.WahooAdvancedFmAdapter = WahooAdvancedFmAdapter;
+exports.default = BleWahooDevice;
+BleWahooDevice.protocol = 'wahoo';
+BleWahooDevice.services = [consts_1.CSP];
+BleWahooDevice.characteristics = ['2acc', '2ad2', '2ad6', '2ad8', '2ad9', '2ada', consts_1.WAHOO_ADVANCED_TRAINER_CP];
+BleWahooDevice.detectionPriority = 5;

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

@@ -0,0 +1,4 @@
+import BleWahooComms from "./comms";
+import BleWahooAdapter from "./adapter";
+import { IndoorBikeData as WahooIndoorBikeData } from "./types";
+export { WahooIndoorBikeData, BleWahooAdapter, BleWahooComms };

package/lib/ble/wahoo/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.BleWahooComms = exports.BleWahooAdapter = void 0;
+const comms_1 = __importDefault(require("./comms"));
+exports.BleWahooComms = comms_1.default;
+const adapter_1 = __importDefault(require("./adapter"));
+exports.BleWahooAdapter = adapter_1.default;

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

@@ -0,0 +1,19 @@
+export type IndoorBikeData = {
+    speed?: number;
+    averageSpeed?: number;
+    cadence?: number;
+    averageCadence?: number;
+    totalDistance?: number;
+    resistanceLevel?: number;
+    instantaneousPower?: number;
+    averagePower?: number;
+    expendedEnergy?: number;
+    heartrate?: number;
+    metabolicEquivalent?: number;
+    time?: number;
+    remainingTime?: number;
+    raw?: string;
+    targetPower?: number;
+    targetInclination?: number;
+    status?: string;
+};

package/lib/ble/wahoo/types.js

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