incyclist-devices 2.2.9 → 2.3.0

package/lib/ble/types.d.ts

@@ -1,6 +1,6 @@
 import EventEmitter from "events";
 import { EventLogger } from "gd-eventlog";
-import { DeviceProperties, DeviceSettings, DeviceStartProperties, IncyclistScanProps, InterfaceProps } from "../types";
+import { DeviceProperties, DeviceSettings, DeviceStartProperties, IncyclistInterface, IncyclistScanProps, InterfaceProps } from "../types";
 export type BleProtocol = 'hr' | 'fm' | 'cp' | 'tacx' | 'wahoo' | 'elite';
 export type BleInterfaceState = 'unknown' | 'resetting' | 'unsupported' | 'unauthorized' | 'poweredOff' | 'poweredOn';
 export interface BleBinding extends EventEmitter {
@@ -13,15 +13,46 @@ export interface BleBinding extends EventEmitter {
     state: BleInterfaceState;
     on(eventName: string | symbol, listener: (...args: any[]) => void): this;
 }
+export interface BleRawPeripheral extends EventEmitter {
+    id?: string;
+    address?: string;
+    name?: string;
+    services: [];
+    advertisement: any;
+    state: string;
+    connectAsync(): Promise<void>;
+    disconnectAsync(): Promise<void>;
+    disconnect(cb: (err?: Error) => void): Promise<void>;
+    discoverSomeServicesAndCharacteristicsAsync(serviceUUIDs: string[], characteristicUUIDs: string[]): Promise<DiscoverResult>;
+    discoverServicesAsync?(serviceUUIDs: string[]): Promise<BleService[]>;
+}
+export interface PeripheralAnnouncement {
+    name: string;
+    serviceUUIDs: string[];
+    transport: string;
+}
+export interface BlePeripheralAnnouncement extends PeripheralAnnouncement {
+    advertisement: any;
+    peripheral: BleRawPeripheral;
+}
+export interface BlePeripheralInfo {
+    id: string;
+    uuid: string;
+    address: string;
+    addressType: string;
+    advertisement: any;
+    rssi: number;
+    serviceUUIDs: string[];
+    stats: string;
+}
 export interface BleScanProps extends IncyclistScanProps {
     protocol?: BleProtocol;
     protocols?: BleProtocol[];
     isBackgroundScan?: boolean;
 }
-export interface BleDeviceConstructProps extends BleDeviceProps {
+export interface BleDeviceConstructProps extends BlePeripheralAnnouncement {
     log?: boolean;
     logger?: EventLogger;
-    peripheral?: BlePeripheral;
 }
 export interface BleDeviceSettings extends DeviceSettings {
     id?: string;
@@ -30,9 +61,6 @@ export interface BleDeviceSettings extends DeviceSettings {
     address?: string;
     name?: string;
 }
-export interface BleDetectedDevice extends BleDeviceSettings {
-    peripheral: BlePeripheral;
-}
 export interface BleDeviceProperties extends DeviceProperties {
     wheelDiameter?: number;
     gearRatio?: number;
@@ -48,54 +76,26 @@ export interface BleInterfaceProps extends InterfaceProps {
     timeout?: number;
     reconnect?: boolean;
 }
-export type BleService = {
-    uuid: string;
-};
 export type DiscoverResult = {
     services: BleService[];
-    characteristics: BleCharacteristic[];
+    characteristics: BleRawCharacteristic[];
 };
-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<boolean>;
-    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 {
+export type BleProperty = 'notify' | 'read' | 'write';
+export interface BleCharacteristic {
     uuid: string;
-    properties: string[];
-    _serviceUuid?: string;
+    properties: BleProperty[];
     name?: string;
+    _serviceUuid?: string;
+}
+export interface BleRawCharacteristic extends BleCharacteristic, EventEmitter {
     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 BleService = {
+    uuid: string;
+    characteristics?: BleCharacteristic[];
 };
 export type BleCommsConnectProps = {
     timeout?: number;
@@ -105,14 +105,6 @@ 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;
@@ -126,3 +118,40 @@ export type BleDeviceInfo = {
     model?: string;
     serialNo?: string;
 };
+export interface IBleInterface<T extends PeripheralAnnouncement> extends IncyclistInterface {
+    pauseLogging(debugOnly?: boolean): void;
+    resumeLogging(): any;
+    isLoggingPaused(): boolean;
+    logEvent(event: any): any;
+    logError(err: Error, fn: string, args?: any): any;
+    createPeripheral(announcement: T): IBlePeripheral;
+    createPeripheralFromSettings(settings: DeviceSettings): IBlePeripheral;
+    createDeviceSetting(announcement: T): DeviceSettings;
+    waitForPeripheral(settings: DeviceSettings): Promise<IBlePeripheral>;
+    pauseDiscovery?(): Promise<void>;
+    resumeDiscovery?(): Promise<void>;
+}
+export interface IBlePeripheral {
+    services: BleService[];
+    connect(): Promise<boolean>;
+    disconnect(): Promise<boolean>;
+    isConnected(): boolean;
+    isConnecting(): boolean;
+    onDisconnect(callback: () => void): void;
+    discoverServices(): Promise<string[]>;
+    discoverCharacteristics(serviceUUID: string): Promise<BleCharacteristic[]>;
+    subscribe(characteristicUUID: string, callback: (characteristicUuid: string, data: Buffer) => void): Promise<boolean>;
+    unsubscribe(characteristicUUID: string): Promise<boolean>;
+    subscribeAll?(callback: (characteristicUuid: string, data: Buffer) => void): Promise<boolean>;
+    subscribeSelected(characteristics: string[], callback: (characteristicUuid: string, data: Buffer) => void): Promise<boolean>;
+    read(characteristicUUID: string): Promise<Buffer>;
+    write(characteristicUUID: string, data: Buffer, options?: BleWriteProps): Promise<Buffer>;
+}
+export interface IBleSensor extends EventEmitter {
+    startSensor(): Promise<boolean>;
+    stopSensor(): Promise<boolean>;
+    reset(): void;
+    isConnected(): boolean;
+    read(characteristicUUID: string): Promise<Buffer>;
+    write(characteristicUUID: string, data: Buffer, options?: BleWriteProps): Promise<Buffer>;
+}

package/lib/ble/utils.d.ts

@@ -1,5 +1,5 @@
 import { LegacyProfile } from "../antv2/types";
-import { BleCharacteristic, BlePeripheral, BleProtocol } from "./types";
+import { BleCharacteristic, BleProperty, BleProtocol, BleRawPeripheral } from "./types";
 type MappingRecord = {
     profile: LegacyProfile;
     protocol: BleProtocol;
@@ -7,11 +7,16 @@ type MappingRecord = {
 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): {
+export declare function getPeripheralInfo(p: BleRawPeripheral): {
     id: string;
     name: any;
     address: string;
     services: any;
 };
 export declare function getCharachteristicsInfo(c: BleCharacteristic): string;
+export declare const parseUUID: (str: string) => string;
+export declare const beautifyUUID: (str: string, withX?: boolean) => string;
+export declare const fullUUID: (str: string) => string;
+export declare const propertyVal: (properties: BleProperty[]) => number;
+export declare const propertyFromVal: (val: number) => BleProperty[];
 export {};

package/lib/ble/utils.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.propertyFromVal = exports.propertyVal = exports.fullUUID = exports.beautifyUUID = exports.parseUUID = void 0;
 exports.mapLegacyProfile = mapLegacyProfile;
 exports.uuid = uuid;
 exports.matches = matches;
@@ -29,15 +30,7 @@ function uuid(s) {
     }
 }
 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;
+    return (0, exports.parseUUID)(uuid1) === (0, exports.parseUUID)(uuid2);
 }
 function getPeripheralInfo(p) {
     const { id, name, address, advertisement, services } = p;
@@ -54,3 +47,85 @@ function getCharachteristicsInfo(c) {
     const serviceStr = _serviceUuid ? `${_serviceUuid}:` : '';
     return `${serviceStr}${uuid}${nameStr} ${properties}`;
 }
+const parseUUID = (str) => {
+    const uuid = str.toUpperCase();
+    if (str.startsWith('0x')) {
+        const hex = uuid.slice(2);
+        if (hex.length === 4) {
+            return `0000${hex}00001000800000805F9B34FB`;
+        }
+        if (hex.length === 8) {
+            return `${hex}00001000800000805F9B34FB`;
+        }
+    }
+    else if (uuid.length === 4) {
+        return `0000${uuid}00001000800000805F9B34FB`;
+    }
+    else if (uuid.length === 8) {
+        return `${uuid}00001000800000805F9B34FB`;
+    }
+    else if (uuid.length === 32) {
+        return uuid;
+    }
+    else if (uuid.length === 36) {
+        return uuid.replace(/-/g, '');
+    }
+    throw new Error(`Invalid UUID: ${uuid}`);
+};
+exports.parseUUID = parseUUID;
+const beautifyUUID = (str, withX = false) => {
+    const uuid = (0, exports.parseUUID)(str);
+    const parts = [
+        uuid.substring(0, 8),
+        uuid.substring(8, 12),
+        uuid.substring(12, 16),
+        uuid.substring(16, 20),
+        uuid.substring(20),
+    ];
+    if (uuid.substring(8) === '00001000800000805F9B34FB') {
+        let short;
+        if (parts[0].startsWith('0000')) {
+            short = parts[0].substring(4);
+        }
+        else {
+            short = parts[0];
+        }
+        return withX ? `0x${short}` : short;
+    }
+    return parts.join('-');
+};
+exports.beautifyUUID = beautifyUUID;
+const fullUUID = (str) => {
+    const uuid = (0, exports.parseUUID)(str);
+    const parts = [
+        uuid.substring(0, 8),
+        uuid.substring(8, 12),
+        uuid.substring(12, 16),
+        uuid.substring(16, 20),
+        uuid.substring(20),
+    ];
+    return parts.join('-');
+};
+exports.fullUUID = fullUUID;
+const propertyVal = (properties) => {
+    let res = 0;
+    if (properties.includes('read'))
+        res |= 0x01;
+    if (properties.includes('write'))
+        res |= 0x02;
+    if (properties.includes('notify'))
+        res |= 0x04;
+    return res;
+};
+exports.propertyVal = propertyVal;
+const propertyFromVal = (val) => {
+    const res = [];
+    if (val & 0x01)
+        res.push('read');
+    if (val & 0x02)
+        res.push('write');
+    if (val & 0x04)
+        res.push('notify');
+    return res;
+};
+exports.propertyFromVal = propertyFromVal;

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

@@ -1,5 +1,5 @@
 import { BleFmAdapter } from '../fm';
-import { BleDeviceProperties, BleDeviceSettings, BleStartProperties } from '../types';
+import { BleDeviceProperties, BleDeviceSettings, IBlePeripheral } from '../types';
 import { IAdapter } from '../../types';
 import { LegacyProfile } from '../../antv2/types';
 export default class BleWahooAdapter extends BleFmAdapter {
@@ -7,5 +7,5 @@ export default class BleWahooAdapter extends BleFmAdapter {
     constructor(settings: BleDeviceSettings, props?: BleDeviceProperties);
     isSame(device: IAdapter): boolean;
     getProfile(): LegacyProfile;
-    start(props?: BleStartProperties): Promise<any>;
+    updateSensor(peripheral: IBlePeripheral): void;
 }

package/lib/ble/wahoo/adapter.js

@@ -1,30 +1,17 @@
 "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 consts_1 = require("../../base/consts");
+const sensor_1 = __importDefault(require("./sensor"));
 const types_1 = require("../../types");
 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.device = new sensor_1.default(this.getPeripheral(), { logger: this.logger });
         this.capabilities = [
             types_1.IncyclistCapability.Power, types_1.IncyclistCapability.Speed, types_1.IncyclistCapability.Cadence,
             types_1.IncyclistCapability.Control
@@ -38,63 +25,8 @@ class BleWahooAdapter extends fm_1.BleFmAdapter {
     getProfile() {
         return 'Smart Trainer';
     }
-    start() {
-        return __awaiter(this, arguments, void 0, function* (props = {}) {
-            const wasPaused = this.paused;
-            const wasStopped = this.stopped;
-            if (wasPaused)
-                this.resume();
-            if (wasStopped)
-                this.stopped = false;
-            if (this.started && !wasPaused && !wasStopped)
-                return true;
-            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 = consts_1.DEFAULT_BIKE_WEIGHT } = props || {};
-                    const weight = (user && user.weight ? Number(user.weight) : consts_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);
-                    });
-                    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}`);
-            }
-        });
+    updateSensor(peripheral) {
+        this.device = new sensor_1.default(peripheral, { logger: this.logger });
     }
 }
 BleWahooAdapter.INCYCLIST_PROFILE_NAME = 'Smart Trainer';

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

@@ -1,7 +1,7 @@
 import { LegacyProfile } from "../../antv2/types";
 import { CrankData } from "../cp";
 import { IndoorBikeData } from "../fm";
-import BleFitnessMachineDevice from "../fm/comms";
+import BleFitnessMachineDevice from "../fm/sensor";
 import { BleProtocol, BleWriteProps, IBlePeripheralConnector } from "../types";
 export declare const enum OpCode {
     unlock = 32,

package/lib/ble/wahoo/comms.js

@@ -15,10 +15,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const _1 = require(".");
 const consts_1 = require("../../base/consts");
 const consts_2 = require("../consts");
-const comms_1 = __importDefault(require("../fm/comms"));
+const sensor_1 = __importDefault(require("../fm/sensor"));
 const utils_1 = require("../utils");
 const ErgWriteDelay = 2000;
-class BleWahooDevice extends comms_1.default {
+class BleWahooDevice extends sensor_1.default {
     constructor(props) {
         super(props);
         this.prevCrankData = undefined;

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

@@ -0,0 +1,16 @@
+export declare const enum OpCode {
+    unlock = 32,
+    setResistanceMode = 64,
+    setStandardMode = 65,
+    setErgMode = 66,
+    setSimMode = 67,
+    setSimCRR = 68,
+    setSimWindResistance = 69,
+    setSimGrade = 70,
+    setSimWindSpeed = 71,
+    setWheelCircumference = 72
+}
+export declare const ErgWriteDelay = 2000;
+export declare const WAHOO_ADVANCED_TRAINER_CP = "a026e005-0a7d-4ab3-97fa-f1500f9feb8b";
+export declare const WAHOO_ADVANCED_FTMS = "a026ee0b-0a7d-4ab3-97fa-f1500f9feb8b";
+export declare const WAHOO_ADVANCED_TRAINER_CP_FULL = "A026E005-0A7D-4AB3-97FA-F1500F9FEB8B";

package/lib/ble/wahoo/consts.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WAHOO_ADVANCED_TRAINER_CP_FULL = exports.WAHOO_ADVANCED_FTMS = exports.WAHOO_ADVANCED_TRAINER_CP = exports.ErgWriteDelay = void 0;
+exports.ErgWriteDelay = 2000;
+exports.WAHOO_ADVANCED_TRAINER_CP = 'a026e005-0a7d-4ab3-97fa-f1500f9feb8b';
+exports.WAHOO_ADVANCED_FTMS = 'a026ee0b-0a7d-4ab3-97fa-f1500f9feb8b';
+exports.WAHOO_ADVANCED_TRAINER_CP_FULL = 'A026E005-0A7D-4AB3-97FA-F1500F9FEB8B';

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

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

package/lib/ble/wahoo/index.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (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 sensor_1 = __importDefault(require("./sensor"));
+exports.BleWahooComms = sensor_1.default;
 const adapter_1 = __importDefault(require("./adapter"));
 exports.BleWahooAdapter = adapter_1.default;

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

@@ -0,0 +1,48 @@
+import { LegacyProfile } from "../../antv2/types";
+import { CrankData } from "../cp";
+import { IndoorBikeData } from "../fm";
+import BleFitnessMachineDevice from "../fm/sensor";
+import { BleProtocol, BleWriteProps } from "../types";
+export default class BleWahooDevice extends BleFitnessMachineDevice {
+    static readonly profile: LegacyProfile;
+    static readonly protocol: BleProtocol;
+    static readonly services: string[];
+    static readonly characteristics: string[];
+    static readonly detectionPriority = 5;
+    prevCrankData: CrankData;
+    currentCrankData: CrankData;
+    timeOffset: number;
+    tsPrevWrite: any;
+    prevSlope: any;
+    wahooCP: string;
+    isSimMode: boolean;
+    isRequestControlBusy: boolean;
+    weight: number;
+    simModeSettings: {
+        weight: number;
+        crr: number;
+        cw: number;
+    };
+    constructor(peripheral: any, props?: any);
+    isMatching(serviceUUIDs: string[]): boolean;
+    reset(): void;
+    protected getRequiredCharacteristics(): Array<string>;
+    onData(characteristic: string, data: Buffer): boolean;
+    requestControl(): Promise<boolean>;
+    setTargetPower(power: number): Promise<boolean>;
+    setSlope(slope: any): Promise<boolean>;
+    protected parseCrankData(crankData: any): {
+        rpm: number;
+        time: any;
+    };
+    protected parsePower(_data: Buffer): IndoorBikeData;
+    protected writeWahooFtmsMessage(requestedOpCode: number, data: Buffer, props?: BleWriteProps): Promise<boolean>;
+    protected setPowerAdjusting(): void;
+    protected isPowerAdjusting(): boolean;
+    setErgMode(power: number): Promise<boolean>;
+    setSimMode(weight: number, crr: number, cw: number): Promise<boolean>;
+    setSimCRR(crr: number): Promise<boolean>;
+    setSimWindResistance(cw: number): Promise<boolean>;
+    setSimGrade(slope: number): Promise<boolean>;
+    setSimWindSpeed(v: number): Promise<boolean>;
+}