incyclist-devices 2.2.10-beta.0 → 2.3.0-beta.10

package/lib/ble/fm/adapter.js

@@ -16,33 +16,31 @@ const gd_eventlog_1 = require("gd-eventlog");
 const power_meter_1 = __importDefault(require("../../modes/power-meter"));
 const antble_smarttrainer_1 = __importDefault(require("../../modes/antble-smarttrainer"));
 const antble_erg_1 = __importDefault(require("../../modes/antble-erg"));
-const comms_1 = __importDefault(require("./comms"));
+const sensor_1 = __importDefault(require("./sensor"));
 const adapter_1 = __importDefault(require("../base/adapter"));
 const consts_1 = require("./consts");
-const utils_1 = require("../../utils/utils");
 const types_1 = require("../../types");
+const utils_1 = require("../../utils/utils");
 class BleFmAdapter extends adapter_1.default {
     constructor(settings, props) {
         super(settings, props);
         this.distanceInternal = 0;
+        this.requestControlRetryDelay = 1000;
         this.logger = new gd_eventlog_1.EventLogger('BLE-FM');
-        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
         ];
     }
+    updateSensor(peripheral) {
+        this.device = new sensor_1.default(peripheral, { logger: this.logger });
+    }
     isSame(device) {
         if (!(device instanceof BleFmAdapter))
             return false;
         return this.isEqual(device.settings);
     }
-    getName() {
-        return `${this.device.name}`;
-    }
     isControllable() {
         return true;
     }
@@ -70,6 +68,7 @@ class BleFmAdapter extends adapter_1.default {
         return new power_meter_1.default(this);
     }
     mapData(deviceData) {
+        var _a, _b, _c;
         const data = {
             isPedalling: false,
             power: 0,
@@ -80,9 +79,9 @@ class BleFmAdapter extends adapter_1.default {
             slope: undefined,
             time: undefined
         };
-        data.power = (deviceData.instantaneousPower !== undefined ? deviceData.instantaneousPower : data.power);
-        data.pedalRpm = (deviceData.cadence !== undefined ? deviceData.cadence : data.pedalRpm);
-        data.time = (deviceData.time !== undefined ? deviceData.time : data.time);
+        data.power = (_a = deviceData === null || deviceData === void 0 ? void 0 : deviceData.instantaneousPower) !== null && _a !== void 0 ? _a : data.power;
+        data.pedalRpm = (_b = deviceData === null || deviceData === void 0 ? void 0 : deviceData.cadence) !== null && _b !== void 0 ? _b : data.pedalRpm;
+        data.time = (_c = deviceData === null || deviceData === void 0 ? void 0 : deviceData.time) !== null && _c !== void 0 ? _c : data.time;
         data.isPedalling = data.pedalRpm > 0 || (data.pedalRpm === undefined && data.power > 0);
         data.heartrate = deviceData.heartrate || data.heartrate;
         return data;
@@ -107,107 +106,100 @@ class BleFmAdapter extends adapter_1.default {
         };
         return data;
     }
-    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.logEvent(Object.assign(Object.assign({ message: 'starting device' }, this.getSettings()), { protocol: this.getProtocolName(), props, isStarted: this.started, isConnected: this.getComms().isConnected() }));
-            const { restart = wasPaused } = props;
-            if (!restart && this.ble.isScanning() && !this.getComms().isConnected()) {
-            }
-            let scanOnly = props.scanOnly;
-            if (this.ble.isScanning() && this.getComms().isConnected()) {
-                scanOnly = true;
-            }
-            else {
-                const { timeout = 20000 } = props || {};
-                if (!this.connectPromise)
-                    this.connectPromise = this.connect();
-                const res = yield Promise.race([
-                    this.connectPromise.then((connected) => {
-                        return { connected, reason: connected ? null : 'could not connect' };
-                    }),
-                    (0, utils_1.sleep)(timeout).then(() => ({ connected: false, reason: 'timeout' }))
-                ]);
-                this.connectPromise = undefined;
-                const connected = res.connected;
-                if (!connected) {
-                    throw new Error(`could not start device, reason:${res.reason}`);
-                }
+    checkResume() {
+        const wasPaused = this.paused;
+        const wasStopped = this.stopped;
+        if (wasPaused)
+            this.resume();
+        this.stopped = false;
+        if (this.started && !wasPaused && !wasStopped)
+            return [wasPaused, true];
+        return [wasPaused, false];
+    }
+    initControl(_startProps) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isStarting())
+                return;
+            this.setConstants();
+            yield this.establishControl();
+            this.setConstants();
+            yield this.sendInitialRequest();
+        });
+    }
+    setConstants() {
+        const mode = this.getCyclingMode();
+        const sensor = this.getComms();
+        if (mode === null || mode === void 0 ? void 0 : mode.getSetting('bikeType')) {
+            const bikeType = mode.getSetting('bikeType').toLowerCase();
+            sensor.setCrr(consts_1.cRR);
+            switch (bikeType) {
+                case 'race':
+                    sensor.setCw(consts_1.cwABike.race);
+                    break;
+                case 'triathlon':
+                    sensor.setCw(consts_1.cwABike.triathlon);
+                    break;
+                case 'mountain':
+                    sensor.setCw(consts_1.cwABike.mountain);
+                    break;
             }
-            try {
-                const comms = this.device;
-                if (comms) {
-                    if (!scanOnly) {
-                        const mode = this.getCyclingMode();
-                        if (mode && mode.getSetting('bikeType')) {
-                            const bikeType = mode.getSetting('bikeType').toLowerCase();
-                            comms.setCrr(consts_1.cRR);
-                            switch (bikeType) {
-                                case 'race':
-                                    comms.setCw(consts_1.cwABike.race);
-                                    break;
-                                case 'triathlon':
-                                    comms.setCw(consts_1.cwABike.triathlon);
-                                    break;
-                                case 'mountain':
-                                    comms.setCw(consts_1.cwABike.mountain);
-                                    break;
-                            }
+        }
+    }
+    establishControl() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isStarting())
+                return false;
+            let hasControl = false;
+            let tryCnt = 0;
+            const sensor = this.getComms();
+            return new Promise((resolve) => {
+                this.startTask.notifyOnStop(() => {
+                    resolve(false);
+                });
+                const waitUntilControl = () => __awaiter(this, void 0, void 0, function* () {
+                    while (!hasControl && this.isStarting()) {
+                        if (tryCnt++ === 0) {
+                            this.logEvent({ message: 'requesting control', device: this.getName(), interface: this.getInterface() });
                         }
-                        let hasControl = yield comms.requestControl();
-                        if (!hasControl) {
-                            let retry = 1;
-                            while (!hasControl && retry < 3) {
-                                yield (0, utils_1.sleep)(1000);
-                                hasControl = yield comms.requestControl();
-                                retry++;
-                            }
+                        hasControl = yield sensor.requestControl();
+                        if (hasControl) {
+                            this.logEvent({ message: 'control granted', device: this.getName(), interface: this.getInterface() });
+                            resolve(this.isStarting());
+                        }
+                        else {
+                            yield (0, utils_1.sleep)(this.requestControlRetryDelay);
                         }
-                        if (!hasControl)
-                            throw new Error('could not establish control');
-                        const startRequest = this.getCyclingMode().getBikeInitRequest();
-                        yield this.sendUpdate(startRequest, true);
-                    }
-                    if (!this.started && !wasPaused) {
-                        comms.on('data', (data) => {
-                            this.onDeviceData(data);
-                        });
-                        comms.on('disconnected', this.emit);
-                    }
-                    const before = this.capabilities.join(',');
-                    if (comms.features.heartrate && !this.hasCapability(types_1.IncyclistCapability.HeartRate)) {
-                        this.capabilities.push(types_1.IncyclistCapability.HeartRate);
-                    }
-                    if (comms.features.cadence && !this.hasCapability(types_1.IncyclistCapability.Cadence)) {
-                        this.capabilities.push(types_1.IncyclistCapability.Cadence);
-                    }
-                    if (comms.features.power && !this.hasCapability(types_1.IncyclistCapability.Power)) {
-                        this.capabilities.push(types_1.IncyclistCapability.Power);
-                    }
-                    const after = this.capabilities.join(',');
-                    if (before !== after) {
-                        this.emit('device-info', this.getSettings(), { capabilities: this.capabilities });
                     }
-                    this.resetData();
-                    this.stopped = false;
-                    this.started = true;
-                    this.resume();
-                    return true;
-                }
-            }
-            catch (err) {
-                this.logEvent({ message: 'start result: error', error: err.message, profile: this.getProfile() });
-                throw new Error(`could not start device, reason:${err.message}`);
-            }
+                });
+                waitUntilControl();
+            });
         });
     }
+    sendInitialRequest() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const startRequest = this.getCyclingMode().getBikeInitRequest();
+            yield this.sendUpdate(startRequest, true);
+        });
+    }
+    checkCapabilities() {
+        var _a, _b, _c;
+        const before = this.capabilities.join(',');
+        const sensor = this.getComms();
+        if (((_a = sensor.features) === null || _a === void 0 ? void 0 : _a.heartrate) && !this.hasCapability(types_1.IncyclistCapability.HeartRate)) {
+            this.capabilities.push(types_1.IncyclistCapability.HeartRate);
+        }
+        if (((_b = sensor.features) === null || _b === void 0 ? void 0 : _b.cadence) && !this.hasCapability(types_1.IncyclistCapability.Cadence)) {
+            this.capabilities.push(types_1.IncyclistCapability.Cadence);
+        }
+        if (((_c = sensor.features) === null || _c === void 0 ? void 0 : _c.power) && !this.hasCapability(types_1.IncyclistCapability.Power)) {
+            this.capabilities.push(types_1.IncyclistCapability.Power);
+        }
+        const after = this.capabilities.join(',');
+        if (before !== after) {
+            this.logEvent({ message: 'device capabilities updated', name: this.getSettings().name, interface: this.getSettings().interface, capabilities: this.capabilities });
+            this.emit('device-info', this.getSettings(), { capabilities: this.capabilities });
+        }
+    }
     sendUpdate(request_1) {
         return __awaiter(this, arguments, void 0, function* (request, enforced = false) {
             if (!enforced && (this.paused || !this.device))
@@ -215,7 +207,7 @@ class BleFmAdapter extends adapter_1.default {
             try {
                 const update = this.getCyclingMode().sendBikeUpdate(request);
                 this.logEvent({ message: 'send bike update requested', profile: this.getProfile(), update, request });
-                const device = this.device;
+                const device = this.getComms();
                 if (update.slope !== undefined) {
                     yield device.setSlope(update.slope);
                 }

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

@@ -1,6 +1,6 @@
 import { BleProtocol, BleWriteProps, IBlePeripheralConnector } from "../types";
 import { IndoorBikeData, IndoorBikeFeatures } from "./types";
-import { BleComms } from "../base/comms";
+import { BleComms } from "../base/sensor";
 import { LegacyProfile } from "../../antv2/types";
 export default class BleFitnessMachineDevice extends BleComms {
     static protocol: BleProtocol;

package/lib/ble/fm/comms.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const consts_1 = require("../consts");
-const comms_1 = require("../base/comms");
+const sensor_1 = require("../base/sensor");
 const utils_1 = require("../utils");
 const bit = (nr) => (1 << nr);
 const IndoorBikeDataFlag = {
@@ -66,7 +66,7 @@ const TargetSettingFeatureFlag = {
     SpinDownControlSupported: bit(15),
     TargetedCadenceConfigurationSupported: bit(16)
 };
-class BleFitnessMachineDevice extends comms_1.BleComms {
+class BleFitnessMachineDevice extends sensor_1.BleComms {
     constructor(props) {
         super(props);
         this.features = undefined;
@@ -92,7 +92,7 @@ class BleFitnessMachineDevice extends comms_1.BleComms {
     subscribeWriteResponse(cuuid) {
         return __awaiter(this, void 0, void 0, function* () {
             this.logEvent({ message: 'subscribe to CP response', characteristics: cuuid });
-            const connector = this.ble.peripheralCache.getConnector(this.peripheral);
+            const connector = this.getPeripheral();
             const isAlreadySubscribed = connector.isSubscribed(cuuid);
             if (!isAlreadySubscribed) {
                 connector.removeAllListeners(cuuid);

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

@@ -4,3 +4,96 @@ export declare const cwABike: {
     mountain: number;
 };
 export declare const cRR = 0.0036;
+export declare const enum OpCode {
+    RequestControl = 0,
+    Reset = 1,
+    SetTargetSpeed = 2,
+    SetTargetInclination = 3,
+    SetTargetResistance = 4,
+    SetTargetPower = 5,
+    SetTargetHeartRate = 6,
+    StartOrResume = 7,
+    StopOrPause = 8,
+    SetIndoorBikeSimulation = 17,
+    SetWheelCircumference = 18,
+    SpinDownControl = 19,
+    SetTargetedCadence = 20,
+    ResponseCode = 128
+}
+export declare const enum FitnessMachineStatusOpCode {
+    Reset = 1,
+    FitnessMachineStoppedOrPaused = 2,
+    FitnessMachineStoppedBySafetyKey = 3,
+    FitnessMachineStartedOrResumed = 4,
+    TargetSpeedChanged = 5,
+    TargetInclineChanged = 6,
+    TargetResistanceLevelChanged = 7,
+    TargetPowerChanged = 8,
+    TargetHeartRateChanged = 9,
+    TargetExpendedEnergyChanged = 10,
+    IndoorBikeSimulationParametersChanged = 18,
+    WheelCircumferenceChanged = 19,
+    SpinDownStatus = 20,
+    TargetedCadenceChanged = 21,
+    ControlPermissionLost = 255
+}
+export declare const enum OpCodeResut {
+    Success = 1,
+    OpCodeNotSupported = 2,
+    InvalidParameter = 3,
+    OperationFailed = 4,
+    ControlNotPermitted = 5
+}
+export declare const IndoorBikeDataFlag: {
+    MoreData: number;
+    AverageSpeedPresent: number;
+    InstantaneousCadence: number;
+    AverageCadencePresent: number;
+    TotalDistancePresent: number;
+    ResistanceLevelPresent: number;
+    InstantaneousPowerPresent: number;
+    AveragePowerPresent: number;
+    ExpendedEnergyPresent: number;
+    HeartRatePresent: number;
+    MetabolicEquivalentPresent: number;
+    ElapsedTimePresent: number;
+    RemainingTimePresent: number;
+};
+export declare const FitnessMachineFeatureFlag: {
+    AverageSpeedSupported: number;
+    CadenceSupported: number;
+    TotalDistanceSupported: number;
+    InclinationSupported: number;
+    ElevationGainSupported: number;
+    PaceSupported: number;
+    StepCountSupported: number;
+    ResistanceLevelSupported: number;
+    StrideCountSupported: number;
+    ExpendedEnergySupported: number;
+    HeartRateMeasurementSupported: number;
+    MetabolicEquivalentSupported: number;
+    ElapsedTimeSupported: number;
+    RemainingTimeSupported: number;
+    PowerMeasurementSupported: number;
+    ForceOnBeltAndPowerOutputSupported: number;
+    UserDataRetentionSupported: number;
+};
+export declare const TargetSettingFeatureFlag: {
+    SpeedTargetSettingSupported: number;
+    InclinationTargetSettingSupported: number;
+    ResistanceTargetSettingSupported: number;
+    PowerTargetSettingSupported: number;
+    HeartRateTargetSettingSupported: number;
+    TargetedExpendedEnergyConfigurationSupported: number;
+    TargetedStepNumberConfigurationSupported: number;
+    TargetedStrideNumberConfigurationSupported: number;
+    TargetedDistanceConfigurationSupported: number;
+    TargetedTrainingTimeConfigurationSupported: number;
+    TargetedTimeInTwoHeartRateZonesConfigurationSupported: number;
+    TargetedTimeInThreeHeartRateZonesConfigurationSupported: number;
+    TargetedTimeInFiveHeartRateZonesConfigurationSupported: number;
+    IndoorBikeSimulationParametersSupported: number;
+    WheelCircumferenceConfigurationSupported: number;
+    SpinDownControlSupported: number;
+    TargetedCadenceConfigurationSupported: number;
+};

package/lib/ble/fm/consts.js

@@ -1,9 +1,63 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cRR = exports.cwABike = void 0;
+exports.TargetSettingFeatureFlag = exports.FitnessMachineFeatureFlag = exports.IndoorBikeDataFlag = exports.cRR = exports.cwABike = void 0;
 exports.cwABike = {
     race: 0.35,
     triathlon: 0.29,
     mountain: 0.57
 };
 exports.cRR = 0.0036;
+const bit = (nr) => (1 << nr);
+exports.IndoorBikeDataFlag = {
+    MoreData: bit(0),
+    AverageSpeedPresent: bit(1),
+    InstantaneousCadence: bit(2),
+    AverageCadencePresent: bit(3),
+    TotalDistancePresent: bit(4),
+    ResistanceLevelPresent: bit(5),
+    InstantaneousPowerPresent: bit(6),
+    AveragePowerPresent: bit(7),
+    ExpendedEnergyPresent: bit(8),
+    HeartRatePresent: bit(9),
+    MetabolicEquivalentPresent: bit(10),
+    ElapsedTimePresent: bit(11),
+    RemainingTimePresent: bit(12)
+};
+exports.FitnessMachineFeatureFlag = {
+    AverageSpeedSupported: bit(0),
+    CadenceSupported: bit(1),
+    TotalDistanceSupported: bit(2),
+    InclinationSupported: bit(3),
+    ElevationGainSupported: bit(4),
+    PaceSupported: bit(5),
+    StepCountSupported: bit(6),
+    ResistanceLevelSupported: bit(7),
+    StrideCountSupported: bit(8),
+    ExpendedEnergySupported: bit(9),
+    HeartRateMeasurementSupported: bit(10),
+    MetabolicEquivalentSupported: bit(11),
+    ElapsedTimeSupported: bit(12),
+    RemainingTimeSupported: bit(13),
+    PowerMeasurementSupported: bit(14),
+    ForceOnBeltAndPowerOutputSupported: bit(15),
+    UserDataRetentionSupported: bit(16)
+};
+exports.TargetSettingFeatureFlag = {
+    SpeedTargetSettingSupported: bit(0),
+    InclinationTargetSettingSupported: bit(1),
+    ResistanceTargetSettingSupported: bit(2),
+    PowerTargetSettingSupported: bit(3),
+    HeartRateTargetSettingSupported: bit(4),
+    TargetedExpendedEnergyConfigurationSupported: bit(5),
+    TargetedStepNumberConfigurationSupported: bit(6),
+    TargetedStrideNumberConfigurationSupported: bit(7),
+    TargetedDistanceConfigurationSupported: bit(8),
+    TargetedTrainingTimeConfigurationSupported: bit(9),
+    TargetedTimeInTwoHeartRateZonesConfigurationSupported: bit(10),
+    TargetedTimeInThreeHeartRateZonesConfigurationSupported: bit(11),
+    TargetedTimeInFiveHeartRateZonesConfigurationSupported: bit(12),
+    IndoorBikeSimulationParametersSupported: bit(13),
+    WheelCircumferenceConfigurationSupported: bit(14),
+    SpinDownControlSupported: bit(15),
+    TargetedCadenceConfigurationSupported: bit(16)
+};

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

@@ -1,4 +1,4 @@
-import BleFmComms from './comms';
+import BleFmComms from './sensor';
 import BleFmAdapter from './adapter';
 import { IndoorBikeData } from './types';
 import { cRR, cwABike } from './consts';

package/lib/ble/fm/index.js

@@ -4,8 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cwABike = exports.cRR = exports.BleFmComms = exports.BleFmAdapter = void 0;
-const comms_1 = __importDefault(require("./comms"));
-exports.BleFmComms = comms_1.default;
+const sensor_1 = __importDefault(require("./sensor"));
+exports.BleFmComms = sensor_1.default;
 const adapter_1 = __importDefault(require("./adapter"));
 exports.BleFmAdapter = adapter_1.default;
 const consts_1 = require("./consts");

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

@@ -0,0 +1,44 @@
+import { LegacyProfile } from "../../antv2/types";
+import { BleProtocol, BleWriteProps } from "../types";
+import { IndoorBikeData, IndoorBikeFeatures } from "./types";
+import { TBleSensor } from "../base/sensor";
+export default class BleFitnessMachineDevice extends TBleSensor {
+    static readonly profile: LegacyProfile;
+    static readonly protocol: BleProtocol;
+    static readonly services: string[];
+    static readonly characteristics: string[];
+    static readonly detectionPriority: number;
+    protected data: IndoorBikeData;
+    protected _features: IndoorBikeFeatures;
+    protected hasControl: boolean;
+    protected isCheckingControl: boolean;
+    protected isCPSubscribed: boolean;
+    protected crr: number;
+    protected cw: number;
+    protected windSpeed: number;
+    protected wheelSize: number;
+    constructor(peripheral: any, props?: any);
+    get features(): IndoorBikeFeatures;
+    reset(): void;
+    protected getRequiredCharacteristics(): Array<string>;
+    onData(characteristic: string, data: Buffer): boolean;
+    setCrr(crr: number): void;
+    getCrr(): number;
+    setCw(cw: number): void;
+    getCw(): number;
+    setWindSpeed(windSpeed: number): void;
+    getWindSpeed(): number;
+    requestControl(): Promise<boolean>;
+    setTargetPower(power: number): Promise<boolean>;
+    setSlope(slope: any): Promise<boolean>;
+    protected parseHrm(_data: Uint8Array): IndoorBikeData;
+    protected parseIndoorBikeData(_data: Uint8Array): IndoorBikeData;
+    protected parseFitnessMachineStatus(_data: Uint8Array): IndoorBikeData;
+    protected getFitnessMachineFeatures(): Promise<IndoorBikeFeatures | undefined>;
+    protected writeFtmsMessage(requestedOpCode: any, data: any, props?: BleWriteProps): Promise<number>;
+    setTargetInclination(inclination: number): Promise<boolean>;
+    setIndoorBikeSimulation(windSpeed: number, gradient: number, crr: number, cw: number): Promise<boolean>;
+    startRequest(): Promise<boolean>;
+    stopRequest(): Promise<boolean>;
+    PauseRequest(): Promise<boolean>;
+}