incyclist-devices 1.4.97 → 1.4.100

package/lib/ble/fm.js

@@ -1,739 +1,739 @@
-"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 });
-exports.FmAdapter = void 0;
-const ble_device_1 = require("./ble-device");
-const ble_interface_1 = __importDefault(require("./ble-interface"));
-const Device_1 = __importDefault(require("../Device"));
-const gd_eventlog_1 = require("gd-eventlog");
-const power_meter_1 = __importDefault(require("../modes/power-meter"));
-const ble_st_mode_1 = __importDefault(require("./ble-st-mode"));
-const ble_erg_mode_1 = __importDefault(require("./ble-erg-mode"));
-const consts_1 = require("./consts");
-const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
-const cwABike = {
-    race: 0.35,
-    triathlon: 0.29,
-    mountain: 0.57
-};
-const cRR = 0.0036;
-const bit = (nr) => (1 << nr);
-const 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)
-};
-const 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)
-};
-const 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)
-};
-class BleFitnessMachineDevice extends ble_device_1.BleDevice {
-    constructor(props) {
-        super(props);
-        this.features = undefined;
-        this.hasControl = false;
-        this.isCheckingControl = false;
-        this.isCPSubscribed = false;
-        this.crr = 0.0033;
-        this.cw = 0.6;
-        this.windSpeed = 0;
-        this.wheelSize = 2100;
-        this.data = {};
-        this.services = BleFitnessMachineDevice.services;
-    }
-    isMatching(characteristics) {
-        if (!characteristics)
-            return false;
-        const hasStatus = characteristics.find(c => c === consts_1.FTMS_STATUS) !== undefined;
-        const hasCP = characteristics.find(c => c === consts_1.FTMS_CP) !== undefined;
-        const hasIndoorBike = characteristics.find(c => c === consts_1.INDOOR_BIKE_DATA) !== undefined;
-        return hasStatus && hasCP && hasIndoorBike;
-    }
-    subscribeWriteResponse(cuuid) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'subscribe to CP response', characteristics: cuuid });
-            const connector = this.ble.getConnector(this.peripheral);
-            const isAlreadySubscribed = connector.isSubscribed(cuuid);
-            if (!isAlreadySubscribed) {
-                connector.removeAllListeners(cuuid);
-                let prev = undefined;
-                let prevTS = undefined;
-                connector.on(cuuid, (uuid, data) => {
-                    const message = data.toString('hex');
-                    if (prevTS && prev && message === prev && Date.now() - prevTS < 500) {
-                        return;
-                    }
-                    prevTS = Date.now();
-                    prev = message;
-                    this.onData(uuid, data);
-                });
-                yield connector.subscribe(cuuid);
-            }
-        });
-    }
-    subscribeAll(conn) {
-        return new Promise(resolve => {
-            const characteristics = [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 });
-            }
-        });
-    }
-    init() {
-        const _super = Object.create(null, {
-            initDevice: { get: () => super.initDevice }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield _super.initDevice.call(this);
-                yield this.getFitnessMachineFeatures();
-                this.logEvent({ message: 'device info', deviceInfo: this.deviceInfo, features: this.features });
-            }
-            catch (err) {
-                this.logEvent({ message: 'error', fn: 'BleFitnessMachineDevice.init()', error: err.message || err, stack: err.stack });
-                return Promise.resolve(false);
-            }
-        });
-    }
-    onDisconnect() {
-        super.onDisconnect();
-        this.hasControl = false;
-    }
-    getProfile() {
-        return 'Smart Trainer';
-    }
-    getServiceUUids() {
-        return BleFitnessMachineDevice.services;
-    }
-    isBike() {
-        return this.features === undefined ||
-            ((this.features.targetSettings & TargetSettingFeatureFlag.IndoorBikeSimulationParametersSupported) !== 0);
-    }
-    isPower() {
-        if (this.hasService('1818'))
-            return true;
-        if (this.features === undefined)
-            return false;
-        const { fitnessMachine } = this.features;
-        if (fitnessMachine & FitnessMachineFeatureFlag.PowerMeasurementSupported)
-            return true;
-    }
-    isHrm() {
-        return this.hasService('180d') || (this.features && (this.features.fitnessMachine & FitnessMachineFeatureFlag.HeartRateMeasurementSupported) !== 0);
-    }
-    parseHrm(_data) {
-        const data = Buffer.from(_data);
-        try {
-            const flags = data.readUInt8(0);
-            if (flags % 1 === 0) {
-                this.data.heartrate = data.readUInt8(1);
-            }
-            else {
-                this.data.heartrate = data.readUInt16LE(1);
-            }
-        }
-        catch (err) {
-            this.logEvent({ message: 'error', fn: 'parseHrm()', error: err.message | err, stack: err.stack });
-        }
-        return Object.assign(Object.assign({}, this.data), { raw: `2a37:${data.toString('hex')}` });
-    }
-    setCrr(crr) { this.crr = crr; }
-    getCrr() { return this.crr; }
-    setCw(cw) { this.cw = cw; }
-    getCw() { return this.cw; }
-    setWindSpeed(windSpeed) { this.windSpeed = windSpeed; }
-    getWindSpeed() { return this.windSpeed; }
-    parseIndoorBikeData(_data) {
-        const data = Buffer.from(_data);
-        try {
-            const flags = data.readUInt16LE(0);
-            let offset = 2;
-            if ((flags & IndoorBikeDataFlag.MoreData) === 0) {
-                this.data.speed = data.readUInt16LE(offset) / 100;
-                offset += 2;
-            }
-            if (flags & IndoorBikeDataFlag.AverageSpeedPresent) {
-                this.data.averageSpeed = data.readUInt16LE(offset) / 100;
-                offset += 2;
-            }
-            if (flags & IndoorBikeDataFlag.InstantaneousCadence) {
-                this.data.cadence = data.readUInt16LE(offset) / 2;
-                offset += 2;
-            }
-            if (flags & IndoorBikeDataFlag.AverageCadencePresent) {
-                this.data.averageCadence = data.readUInt16LE(offset) / 2;
-                offset += 2;
-            }
-            if (flags & IndoorBikeDataFlag.TotalDistancePresent) {
-                const dvLow = data.readUInt8(offset);
-                offset += 1;
-                const dvHigh = data.readUInt16LE(offset);
-                offset += 2;
-                this.data.totalDistance = (dvHigh << 8) + dvLow;
-            }
-            if (flags & IndoorBikeDataFlag.ResistanceLevelPresent) {
-                this.data.resistanceLevel = data.readInt8(offset);
-                offset += 1;
-            }
-            if (flags & IndoorBikeDataFlag.InstantaneousPowerPresent) {
-                this.data.instantaneousPower = data.readInt16LE(offset);
-                offset += 2;
-            }
-            if (flags & IndoorBikeDataFlag.AveragePowerPresent) {
-                this.data.averagePower = data.readInt16LE(offset);
-                offset += 2;
-            }
-            if (flags & IndoorBikeDataFlag.ExpendedEnergyPresent) {
-                this.data.totalEnergy = data.readUInt16LE(offset);
-                offset += 2;
-                this.data.energyPerHour = data.readUInt16LE(offset);
-                offset += 2;
-                this.data.energyPerMinute = data.readUInt8(offset);
-                offset += 1;
-            }
-            if (flags & IndoorBikeDataFlag.HeartRatePresent) {
-                this.data.heartrate = data.readUInt8(offset);
-                offset += 1;
-            }
-            if (flags & IndoorBikeDataFlag.MetabolicEquivalentPresent) {
-                this.data.metabolicEquivalent = data.readUInt8(offset) / 10;
-                offset += 2;
-            }
-            if (flags & IndoorBikeDataFlag.ElapsedTimePresent) {
-                this.data.time = data.readUInt16LE(offset);
-                offset += 2;
-            }
-            if (flags & IndoorBikeDataFlag.RemainingTimePresent) {
-                this.data.remainingTime = data.readUInt16LE(offset);
-                offset += 2;
-            }
-        }
-        catch (err) {
-            this.logEvent({ message: 'error', fn: 'parseIndoorBikeData()', error: err.message | err, stack: err.stack });
-        }
-        return Object.assign(Object.assign({}, this.data), { raw: `2ad2:${data.toString('hex')}` });
-    }
-    parseFitnessMachineStatus(_data) {
-        const data = Buffer.from(_data);
-        try {
-            const OpCode = data.readUInt8(0);
-            switch (OpCode) {
-                case 8:
-                    this.data.targetPower = data.readInt16LE(1);
-                    break;
-                case 6:
-                    this.data.targetInclination = data.readInt16LE(1) / 10;
-                    break;
-                case 4:
-                    this.data.status = "STARTED";
-                    break;
-                case 3:
-                case 2:
-                    this.data.status = "STOPPED";
-                    break;
-                case 20:
-                    const spinDownStatus = data.readUInt8(1);
-                    switch (spinDownStatus) {
-                        case 1:
-                            this.data.status = "SPIN DOWN REQUESTED";
-                            break;
-                        case 2:
-                            this.data.status = "SPIN DOWN SUCCESS";
-                            break;
-                        case 3:
-                            this.data.status = "SPIN DOWN ERROR";
-                            break;
-                        case 4:
-                            this.data.status = "STOP PEDALING";
-                            break;
-                        default: break;
-                    }
-            }
-        }
-        catch (err) {
-            this.logEvent({ message: 'error', fn: 'parseFitnessMachineStatus()', error: err.message | err, stack: err.stack });
-        }
-        return Object.assign(Object.assign({}, this.data), { raw: `2ada:${data.toString('hex')}` });
-    }
-    getFitnessMachineFeatures() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.features)
-                return this.features;
-            try {
-                const data = yield this.read('2acc');
-                const buffer = data ? Buffer.from(data) : undefined;
-                if (buffer) {
-                    const fitnessMachine = buffer.readUInt32LE(0);
-                    const targetSettings = buffer.readUInt32LE(4);
-                    this.features = { fitnessMachine, targetSettings };
-                    this.logEvent({ message: 'supported Features: ', fatures: this.features });
-                }
-            }
-            catch (err) {
-                this.logEvent({ message: 'could not read FitnessMachineFeatures', error: err.message, stack: err.stack });
-            }
-        });
-    }
-    onData(characteristic, data) {
-        const hasData = super.onData(characteristic, data);
-        if (!hasData)
-            return false;
-        const uuid = characteristic.toLocaleLowerCase();
-        let res = undefined;
-        switch (uuid) {
-            case consts_1.INDOOR_BIKE_DATA:
-                res = this.parseIndoorBikeData(data);
-                break;
-            case '2a37':
-                res = this.parseHrm(data);
-                break;
-            case consts_1.FTMS_STATUS:
-                res = this.parseFitnessMachineStatus(data);
-                break;
-            case '2a63':
-            case '2a5b':
-            case '347b0011-7635-408b-8918-8ff3949ce592':
-                break;
-            default:
-                break;
-        }
-        if (res) {
-            this.emit('data', res);
-            return false;
-        }
-        return true;
-    }
-    writeFtmsMessage(requestedOpCode, data, props) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                this.logEvent({ message: 'fmts:write', data: data.toString('hex') });
-                const res = yield this.write(consts_1.FTMS_CP, data, props);
-                const responseData = Buffer.from(res);
-                const opCode = responseData.readUInt8(0);
-                const request = responseData.readUInt8(1);
-                const result = responseData.readUInt8(2);
-                if (opCode !== 128 || request !== requestedOpCode)
-                    throw new Error('Illegal response ');
-                this.logEvent({ message: 'fmts:write result', res, result });
-                return result;
-            }
-            catch (err) {
-                this.logEvent({ message: 'fmts:write failed', opCode: requestedOpCode, reason: err.message });
-                return 4;
-            }
-        });
-    }
-    requestControl() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let to = undefined;
-            if (this.isCheckingControl) {
-                to = setTimeout(() => { }, 3500);
-            }
-            if (this.hasControl)
-                return true;
-            this.logEvent({ message: 'requestControl' });
-            this.isCheckingControl = true;
-            const data = Buffer.alloc(1);
-            data.writeUInt8(0, 0);
-            const res = yield this.writeFtmsMessage(0, data, { timeout: 5000 });
-            if (res === 1) {
-                this.hasControl = true;
-            }
-            else {
-                this.logEvent({ message: 'requestControl failed' });
-            }
-            this.isCheckingControl = false;
-            if (to)
-                clearTimeout(to);
-            return this.hasControl;
-        });
-    }
-    setTargetPower(power) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'setTargetPower', power, skip: (this.data.targetPower !== undefined && this.data.targetPower === power) });
-            if (this.data.targetPower !== undefined && this.data.targetPower === power)
-                return true;
-            if (!this.hasControl)
-                return;
-            const hasControl = yield this.requestControl();
-            if (!hasControl) {
-                this.logEvent({ message: 'setTargetPower failed', reason: 'control is disabled' });
-                return true;
-            }
-            const data = Buffer.alloc(3);
-            data.writeUInt8(5, 0);
-            data.writeInt16LE(Math.round(power), 1);
-            const res = yield this.writeFtmsMessage(5, data);
-            return (res === 1);
-        });
-    }
-    setSlope(slope) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'setSlope', slope });
-            const hasControl = yield this.requestControl();
-            if (!hasControl)
-                return;
-            const { windSpeed, crr, cw } = this;
-            return yield this.setIndoorBikeSimulation(windSpeed, slope, crr, cw);
-        });
-    }
-    setTargetInclination(inclination) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.data.targetInclination !== undefined && this.data.targetInclination === inclination)
-                return true;
-            if (!this.hasControl)
-                return;
-            const hasControl = yield this.requestControl();
-            if (!hasControl) {
-                this.logEvent({ message: 'setTargetInclination failed', reason: 'control is disabled' });
-                return false;
-            }
-            const data = Buffer.alloc(3);
-            data.writeUInt8(3, 0);
-            data.writeInt16LE(Math.round(inclination * 10), 1);
-            const res = yield this.writeFtmsMessage(3, data);
-            return (res === 1);
-        });
-    }
-    setIndoorBikeSimulation(windSpeed, gradient, crr, cw) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const hasControl = yield this.requestControl();
-            if (!hasControl) {
-                this.logEvent({ message: 'setIndoorBikeSimulation failed', reason: 'control is disabled' });
-                return false;
-            }
-            const data = Buffer.alloc(7);
-            data.writeUInt8(17, 0);
-            data.writeInt16LE(Math.round(windSpeed * 1000), 1);
-            data.writeInt16LE(Math.round(gradient * 100), 3);
-            data.writeUInt8(Math.round(crr * 10000), 5);
-            data.writeUInt8(Math.round(cw * 100), 6);
-            const res = yield this.writeFtmsMessage(17, data);
-            return (res === 1);
-        });
-    }
-    startRequest() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const hasControl = yield this.requestControl();
-            if (!hasControl) {
-                this.logEvent({ message: 'startRequest failed', reason: 'control is disabled' });
-                return false;
-            }
-            const data = Buffer.alloc(1);
-            data.writeUInt8(7, 0);
-            const res = yield this.writeFtmsMessage(7, data);
-            return (res === 1);
-        });
-    }
-    stopRequest() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const hasControl = yield this.requestControl();
-            if (!hasControl) {
-                this.logEvent({ message: 'stopRequest failed', reason: 'control is disabled' });
-                return false;
-            }
-            const data = Buffer.alloc(2);
-            data.writeUInt8(8, 0);
-            data.writeUInt8(1, 1);
-            const res = yield this.writeFtmsMessage(8, data);
-            return (res === 1);
-        });
-    }
-    PauseRequest() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const hasControl = yield this.requestControl();
-            if (!hasControl) {
-                this.logEvent({ message: 'PauseRequest failed', reason: 'control is disabled' });
-                return false;
-            }
-            const data = Buffer.alloc(2);
-            data.writeUInt8(8, 0);
-            data.writeUInt8(2, 1);
-            const res = yield this.writeFtmsMessage(8, data);
-            return (res === 1);
-        });
-    }
-    reset() {
-        this.data = {};
-    }
-}
-exports.default = BleFitnessMachineDevice;
-BleFitnessMachineDevice.services = [consts_1.FTMS];
-BleFitnessMachineDevice.characteristics = ['2acc', consts_1.INDOOR_BIKE_DATA, '2ad6', '2ad8', consts_1.FTMS_CP, consts_1.FTMS_STATUS];
-BleFitnessMachineDevice.detectionPriority = 100;
-ble_interface_1.default.register('BleFitnessMachineDevice', 'fm', BleFitnessMachineDevice, BleFitnessMachineDevice.services);
-class FmAdapter extends Device_1.default {
-    constructor(device, protocol) {
-        super(protocol);
-        this.ignore = false;
-        this.paused = false;
-        this.distanceInternal = 0;
-        this.device = device;
-        this.ble = protocol.ble;
-        this.cyclingMode = this.getDefaultCyclingMode();
-        this.logger = new gd_eventlog_1.EventLogger('BLE-FM');
-        if (this.device)
-            this.device.setLogger(this.logger);
-    }
-    isBike() { return this.device.isBike(); }
-    isHrm() { return this.device.isHrm(); }
-    isPower() { return this.device.isPower(); }
-    isSame(device) {
-        if (!(device instanceof FmAdapter))
-            return false;
-        const adapter = device;
-        return (adapter.getName() === this.getName() && adapter.getProfile() === this.getProfile());
-    }
-    getProfile() {
-        const profile = this.device ? this.device.getProfile() : undefined;
-        return profile || 'Smart Trainer';
-    }
-    getName() {
-        return `${this.device.name}`;
-    }
-    getDisplayName() {
-        return this.getName();
-    }
-    getSupportedCyclingModes() {
-        return [ble_st_mode_1.default, ble_erg_mode_1.default, power_meter_1.default];
-    }
-    setCyclingMode(mode, settings) {
-        let selectedMode;
-        if (typeof mode === 'string') {
-            const supported = this.getSupportedCyclingModes();
-            const CyclingModeClass = supported.find(M => { const m = new M(this); return m.getName() === mode; });
-            if (CyclingModeClass) {
-                this.cyclingMode = new CyclingModeClass(this, settings);
-                return;
-            }
-            selectedMode = this.getDefaultCyclingMode();
-        }
-        else {
-            selectedMode = mode;
-        }
-        this.cyclingMode = selectedMode;
-        this.cyclingMode.setSettings(settings);
-    }
-    getCyclingMode() {
-        if (!this.cyclingMode)
-            this.cyclingMode = this.getDefaultCyclingMode();
-        return this.cyclingMode;
-    }
-    getDefaultCyclingMode() {
-        return new ble_st_mode_1.default(this);
-    }
-    getPort() {
-        return 'ble';
-    }
-    setIgnoreBike(ignore) {
-        this.ignore = ignore;
-    }
-    setIgnorePower(ignore) {
-        this.ignore = ignore;
-    }
-    onDeviceData(deviceData) {
-        if (this.prevDataTS && Date.now() - this.prevDataTS < 1000)
-            return;
-        this.prevDataTS = Date.now();
-        this.logger.logEvent({ message: 'onDeviceData', data: deviceData });
-        let incyclistData = this.mapData(deviceData);
-        incyclistData = this.getCyclingMode().updateData(incyclistData);
-        const data = this.transformData(incyclistData);
-        if (this.onDataFn && !this.ignore && !this.paused)
-            this.onDataFn(data);
-    }
-    mapData(deviceData) {
-        const data = {
-            isPedalling: false,
-            power: 0,
-            pedalRpm: undefined,
-            speed: 0,
-            heartrate: 0,
-            distanceInternal: 0,
-            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.isPedalling = data.pedalRpm > 0 || (data.pedalRpm === undefined && data.power > 0);
-        return data;
-    }
-    transformData(bikeData) {
-        if (this.ignore) {
-            return {};
-        }
-        if (bikeData === undefined)
-            return;
-        let distance = 0;
-        if (this.distanceInternal !== undefined && bikeData.distanceInternal !== undefined) {
-            distance = Math.round(bikeData.distanceInternal - this.distanceInternal);
-        }
-        if (bikeData.distanceInternal !== undefined)
-            this.distanceInternal = bikeData.distanceInternal;
-        let data = {
-            speed: bikeData.speed,
-            slope: bikeData.slope,
-            power: bikeData.power !== undefined ? Math.round(bikeData.power) : undefined,
-            cadence: bikeData.pedalRpm !== undefined ? Math.round(bikeData.pedalRpm) : undefined,
-            distance,
-            timestamp: Date.now()
-        };
-        return data;
-    }
-    start(props) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'ftms: 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;
-                        }
-                    }
-                    let hasControl = yield this.device.requestControl();
-                    if (!hasControl) {
-                        let retry = 1;
-                        while (!hasControl && retry < 3) {
-                            yield sleep(1000);
-                            hasControl = yield this.device.requestControl();
-                            retry++;
-                        }
-                    }
-                    if (!hasControl)
-                        throw new Error('could not establish control');
-                    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}`);
-            }
-        });
-    }
-    stop() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'stop requested', profile: this.getProfile() });
-            this.distanceInternal = 0;
-            this.device.reset();
-            return this.device.disconnect();
-        });
-    }
-    sendUpdate(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.paused || !this.device)
-                return;
-            const update = this.getCyclingMode().sendBikeUpdate(request);
-            this.logger.logEvent({ message: 'send bike update requested', profile: this.getProfile(), update, request });
-            if (update.slope !== undefined) {
-                yield this.device.setSlope(update.slope);
-            }
-            if (update.targetPower !== undefined) {
-                yield this.device.setTargetPower(update.targetPower);
-            }
-        });
-    }
-    pause() { this.paused = true; return Promise.resolve(true); }
-    resume() { this.paused = false; return Promise.resolve(true); }
-}
-exports.FmAdapter = FmAdapter;
+"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 });
+exports.FmAdapter = void 0;
+const ble_device_1 = require("./ble-device");
+const ble_interface_1 = __importDefault(require("./ble-interface"));
+const Device_1 = __importDefault(require("../Device"));
+const gd_eventlog_1 = require("gd-eventlog");
+const power_meter_1 = __importDefault(require("../modes/power-meter"));
+const ble_st_mode_1 = __importDefault(require("./ble-st-mode"));
+const ble_erg_mode_1 = __importDefault(require("./ble-erg-mode"));
+const consts_1 = require("./consts");
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+const cwABike = {
+    race: 0.35,
+    triathlon: 0.29,
+    mountain: 0.57
+};
+const cRR = 0.0036;
+const bit = (nr) => (1 << nr);
+const 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)
+};
+const 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)
+};
+const 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)
+};
+class BleFitnessMachineDevice extends ble_device_1.BleDevice {
+    constructor(props) {
+        super(props);
+        this.features = undefined;
+        this.hasControl = false;
+        this.isCheckingControl = false;
+        this.isCPSubscribed = false;
+        this.crr = 0.0033;
+        this.cw = 0.6;
+        this.windSpeed = 0;
+        this.wheelSize = 2100;
+        this.data = {};
+        this.services = BleFitnessMachineDevice.services;
+    }
+    isMatching(characteristics) {
+        if (!characteristics)
+            return false;
+        const hasStatus = characteristics.find(c => c === consts_1.FTMS_STATUS) !== undefined;
+        const hasCP = characteristics.find(c => c === consts_1.FTMS_CP) !== undefined;
+        const hasIndoorBike = characteristics.find(c => c === consts_1.INDOOR_BIKE_DATA) !== undefined;
+        return hasStatus && hasCP && hasIndoorBike;
+    }
+    subscribeWriteResponse(cuuid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'subscribe to CP response', characteristics: cuuid });
+            const connector = this.ble.getConnector(this.peripheral);
+            const isAlreadySubscribed = connector.isSubscribed(cuuid);
+            if (!isAlreadySubscribed) {
+                connector.removeAllListeners(cuuid);
+                let prev = undefined;
+                let prevTS = undefined;
+                connector.on(cuuid, (uuid, data) => {
+                    const message = data.toString('hex');
+                    if (prevTS && prev && message === prev && Date.now() - prevTS < 500) {
+                        return;
+                    }
+                    prevTS = Date.now();
+                    prev = message;
+                    this.onData(uuid, data);
+                });
+                yield connector.subscribe(cuuid);
+            }
+        });
+    }
+    subscribeAll(conn) {
+        return new Promise(resolve => {
+            const characteristics = [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 });
+            }
+        });
+    }
+    init() {
+        const _super = Object.create(null, {
+            initDevice: { get: () => super.initDevice }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield _super.initDevice.call(this);
+                yield this.getFitnessMachineFeatures();
+                this.logEvent({ message: 'device info', deviceInfo: this.deviceInfo, features: this.features });
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', fn: 'BleFitnessMachineDevice.init()', error: err.message || err, stack: err.stack });
+                return Promise.resolve(false);
+            }
+        });
+    }
+    onDisconnect() {
+        super.onDisconnect();
+        this.hasControl = false;
+    }
+    getProfile() {
+        return 'Smart Trainer';
+    }
+    getServiceUUids() {
+        return BleFitnessMachineDevice.services;
+    }
+    isBike() {
+        return this.features === undefined ||
+            ((this.features.targetSettings & TargetSettingFeatureFlag.IndoorBikeSimulationParametersSupported) !== 0);
+    }
+    isPower() {
+        if (this.hasService('1818'))
+            return true;
+        if (this.features === undefined)
+            return false;
+        const { fitnessMachine } = this.features;
+        if (fitnessMachine & FitnessMachineFeatureFlag.PowerMeasurementSupported)
+            return true;
+    }
+    isHrm() {
+        return this.hasService('180d') || (this.features && (this.features.fitnessMachine & FitnessMachineFeatureFlag.HeartRateMeasurementSupported) !== 0);
+    }
+    parseHrm(_data) {
+        const data = Buffer.from(_data);
+        try {
+            const flags = data.readUInt8(0);
+            if (flags % 1 === 0) {
+                this.data.heartrate = data.readUInt8(1);
+            }
+            else {
+                this.data.heartrate = data.readUInt16LE(1);
+            }
+        }
+        catch (err) {
+            this.logEvent({ message: 'error', fn: 'parseHrm()', error: err.message | err, stack: err.stack });
+        }
+        return Object.assign(Object.assign({}, this.data), { raw: `2a37:${data.toString('hex')}` });
+    }
+    setCrr(crr) { this.crr = crr; }
+    getCrr() { return this.crr; }
+    setCw(cw) { this.cw = cw; }
+    getCw() { return this.cw; }
+    setWindSpeed(windSpeed) { this.windSpeed = windSpeed; }
+    getWindSpeed() { return this.windSpeed; }
+    parseIndoorBikeData(_data) {
+        const data = Buffer.from(_data);
+        try {
+            const flags = data.readUInt16LE(0);
+            let offset = 2;
+            if ((flags & IndoorBikeDataFlag.MoreData) === 0) {
+                this.data.speed = data.readUInt16LE(offset) / 100;
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.AverageSpeedPresent) {
+                this.data.averageSpeed = data.readUInt16LE(offset) / 100;
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.InstantaneousCadence) {
+                this.data.cadence = data.readUInt16LE(offset) / 2;
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.AverageCadencePresent) {
+                this.data.averageCadence = data.readUInt16LE(offset) / 2;
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.TotalDistancePresent) {
+                const dvLow = data.readUInt8(offset);
+                offset += 1;
+                const dvHigh = data.readUInt16LE(offset);
+                offset += 2;
+                this.data.totalDistance = (dvHigh << 8) + dvLow;
+            }
+            if (flags & IndoorBikeDataFlag.ResistanceLevelPresent) {
+                this.data.resistanceLevel = data.readInt16LE(offset);
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.InstantaneousPowerPresent) {
+                this.data.instantaneousPower = data.readInt16LE(offset);
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.AveragePowerPresent) {
+                this.data.averagePower = data.readInt16LE(offset);
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.ExpendedEnergyPresent) {
+                this.data.totalEnergy = data.readUInt16LE(offset);
+                offset += 2;
+                this.data.energyPerHour = data.readUInt16LE(offset);
+                offset += 2;
+                this.data.energyPerMinute = data.readUInt8(offset);
+                offset += 1;
+            }
+            if (flags & IndoorBikeDataFlag.HeartRatePresent) {
+                this.data.heartrate = data.readUInt8(offset);
+                offset += 1;
+            }
+            if (flags & IndoorBikeDataFlag.MetabolicEquivalentPresent) {
+                this.data.metabolicEquivalent = data.readUInt8(offset) / 10;
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.ElapsedTimePresent) {
+                this.data.time = data.readUInt16LE(offset);
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.RemainingTimePresent) {
+                this.data.remainingTime = data.readUInt16LE(offset);
+                offset += 2;
+            }
+        }
+        catch (err) {
+            this.logEvent({ message: 'error', fn: 'parseIndoorBikeData()', error: err.message | err, stack: err.stack });
+        }
+        return Object.assign(Object.assign({}, this.data), { raw: `2ad2:${data.toString('hex')}` });
+    }
+    parseFitnessMachineStatus(_data) {
+        const data = Buffer.from(_data);
+        try {
+            const OpCode = data.readUInt8(0);
+            switch (OpCode) {
+                case 8:
+                    this.data.targetPower = data.readInt16LE(1);
+                    break;
+                case 6:
+                    this.data.targetInclination = data.readInt16LE(1) / 10;
+                    break;
+                case 4:
+                    this.data.status = "STARTED";
+                    break;
+                case 3:
+                case 2:
+                    this.data.status = "STOPPED";
+                    break;
+                case 20:
+                    const spinDownStatus = data.readUInt8(1);
+                    switch (spinDownStatus) {
+                        case 1:
+                            this.data.status = "SPIN DOWN REQUESTED";
+                            break;
+                        case 2:
+                            this.data.status = "SPIN DOWN SUCCESS";
+                            break;
+                        case 3:
+                            this.data.status = "SPIN DOWN ERROR";
+                            break;
+                        case 4:
+                            this.data.status = "STOP PEDALING";
+                            break;
+                        default: break;
+                    }
+            }
+        }
+        catch (err) {
+            this.logEvent({ message: 'error', fn: 'parseFitnessMachineStatus()', error: err.message | err, stack: err.stack });
+        }
+        return Object.assign(Object.assign({}, this.data), { raw: `2ada:${data.toString('hex')}` });
+    }
+    getFitnessMachineFeatures() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.features)
+                return this.features;
+            try {
+                const data = yield this.read('2acc');
+                const buffer = data ? Buffer.from(data) : undefined;
+                if (buffer) {
+                    const fitnessMachine = buffer.readUInt32LE(0);
+                    const targetSettings = buffer.readUInt32LE(4);
+                    this.features = { fitnessMachine, targetSettings };
+                    this.logEvent({ message: 'supported Features: ', fatures: this.features });
+                }
+            }
+            catch (err) {
+                this.logEvent({ message: 'could not read FitnessMachineFeatures', error: err.message, stack: err.stack });
+            }
+        });
+    }
+    onData(characteristic, data) {
+        const hasData = super.onData(characteristic, data);
+        if (!hasData)
+            return false;
+        const uuid = characteristic.toLocaleLowerCase();
+        let res = undefined;
+        switch (uuid) {
+            case consts_1.INDOOR_BIKE_DATA:
+                res = this.parseIndoorBikeData(data);
+                break;
+            case '2a37':
+                res = this.parseHrm(data);
+                break;
+            case consts_1.FTMS_STATUS:
+                res = this.parseFitnessMachineStatus(data);
+                break;
+            case '2a63':
+            case '2a5b':
+            case '347b0011-7635-408b-8918-8ff3949ce592':
+                break;
+            default:
+                break;
+        }
+        if (res) {
+            this.emit('data', res);
+            return false;
+        }
+        return true;
+    }
+    writeFtmsMessage(requestedOpCode, data, props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.logEvent({ message: 'fmts:write', data: data.toString('hex') });
+                const res = yield this.write(consts_1.FTMS_CP, data, props);
+                const responseData = Buffer.from(res);
+                const opCode = responseData.readUInt8(0);
+                const request = responseData.readUInt8(1);
+                const result = responseData.readUInt8(2);
+                if (opCode !== 128 || request !== requestedOpCode)
+                    throw new Error('Illegal response ');
+                this.logEvent({ message: 'fmts:write result', res, result });
+                return result;
+            }
+            catch (err) {
+                this.logEvent({ message: 'fmts:write failed', opCode: requestedOpCode, reason: err.message });
+                return 4;
+            }
+        });
+    }
+    requestControl() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let to = undefined;
+            if (this.isCheckingControl) {
+                to = setTimeout(() => { }, 3500);
+            }
+            if (this.hasControl)
+                return true;
+            this.logEvent({ message: 'requestControl' });
+            this.isCheckingControl = true;
+            const data = Buffer.alloc(1);
+            data.writeUInt8(0, 0);
+            const res = yield this.writeFtmsMessage(0, data, { timeout: 5000 });
+            if (res === 1) {
+                this.hasControl = true;
+            }
+            else {
+                this.logEvent({ message: 'requestControl failed' });
+            }
+            this.isCheckingControl = false;
+            if (to)
+                clearTimeout(to);
+            return this.hasControl;
+        });
+    }
+    setTargetPower(power) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'setTargetPower', power, skip: (this.data.targetPower !== undefined && this.data.targetPower === power) });
+            if (this.data.targetPower !== undefined && this.data.targetPower === power)
+                return true;
+            if (!this.hasControl)
+                return;
+            const hasControl = yield this.requestControl();
+            if (!hasControl) {
+                this.logEvent({ message: 'setTargetPower failed', reason: 'control is disabled' });
+                return true;
+            }
+            const data = Buffer.alloc(3);
+            data.writeUInt8(5, 0);
+            data.writeInt16LE(Math.round(power), 1);
+            const res = yield this.writeFtmsMessage(5, data);
+            return (res === 1);
+        });
+    }
+    setSlope(slope) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'setSlope', slope });
+            const hasControl = yield this.requestControl();
+            if (!hasControl)
+                return;
+            const { windSpeed, crr, cw } = this;
+            return yield this.setIndoorBikeSimulation(windSpeed, slope, crr, cw);
+        });
+    }
+    setTargetInclination(inclination) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.data.targetInclination !== undefined && this.data.targetInclination === inclination)
+                return true;
+            if (!this.hasControl)
+                return;
+            const hasControl = yield this.requestControl();
+            if (!hasControl) {
+                this.logEvent({ message: 'setTargetInclination failed', reason: 'control is disabled' });
+                return false;
+            }
+            const data = Buffer.alloc(3);
+            data.writeUInt8(3, 0);
+            data.writeInt16LE(Math.round(inclination * 10), 1);
+            const res = yield this.writeFtmsMessage(3, data);
+            return (res === 1);
+        });
+    }
+    setIndoorBikeSimulation(windSpeed, gradient, crr, cw) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hasControl = yield this.requestControl();
+            if (!hasControl) {
+                this.logEvent({ message: 'setIndoorBikeSimulation failed', reason: 'control is disabled' });
+                return false;
+            }
+            const data = Buffer.alloc(7);
+            data.writeUInt8(17, 0);
+            data.writeInt16LE(Math.round(windSpeed * 1000), 1);
+            data.writeInt16LE(Math.round(gradient * 100), 3);
+            data.writeUInt8(Math.round(crr * 10000), 5);
+            data.writeUInt8(Math.round(cw * 100), 6);
+            const res = yield this.writeFtmsMessage(17, data);
+            return (res === 1);
+        });
+    }
+    startRequest() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hasControl = yield this.requestControl();
+            if (!hasControl) {
+                this.logEvent({ message: 'startRequest failed', reason: 'control is disabled' });
+                return false;
+            }
+            const data = Buffer.alloc(1);
+            data.writeUInt8(7, 0);
+            const res = yield this.writeFtmsMessage(7, data);
+            return (res === 1);
+        });
+    }
+    stopRequest() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hasControl = yield this.requestControl();
+            if (!hasControl) {
+                this.logEvent({ message: 'stopRequest failed', reason: 'control is disabled' });
+                return false;
+            }
+            const data = Buffer.alloc(2);
+            data.writeUInt8(8, 0);
+            data.writeUInt8(1, 1);
+            const res = yield this.writeFtmsMessage(8, data);
+            return (res === 1);
+        });
+    }
+    PauseRequest() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hasControl = yield this.requestControl();
+            if (!hasControl) {
+                this.logEvent({ message: 'PauseRequest failed', reason: 'control is disabled' });
+                return false;
+            }
+            const data = Buffer.alloc(2);
+            data.writeUInt8(8, 0);
+            data.writeUInt8(2, 1);
+            const res = yield this.writeFtmsMessage(8, data);
+            return (res === 1);
+        });
+    }
+    reset() {
+        this.data = {};
+    }
+}
+exports.default = BleFitnessMachineDevice;
+BleFitnessMachineDevice.services = [consts_1.FTMS];
+BleFitnessMachineDevice.characteristics = ['2acc', consts_1.INDOOR_BIKE_DATA, '2ad6', '2ad8', consts_1.FTMS_CP, consts_1.FTMS_STATUS];
+BleFitnessMachineDevice.detectionPriority = 100;
+ble_interface_1.default.register('BleFitnessMachineDevice', 'fm', BleFitnessMachineDevice, BleFitnessMachineDevice.services);
+class FmAdapter extends Device_1.default {
+    constructor(device, protocol) {
+        super(protocol);
+        this.ignore = false;
+        this.paused = false;
+        this.distanceInternal = 0;
+        this.device = device;
+        this.ble = protocol.ble;
+        this.cyclingMode = this.getDefaultCyclingMode();
+        this.logger = new gd_eventlog_1.EventLogger('BLE-FM');
+        if (this.device)
+            this.device.setLogger(this.logger);
+    }
+    isBike() { return this.device.isBike(); }
+    isHrm() { return this.device.isHrm(); }
+    isPower() { return this.device.isPower(); }
+    isSame(device) {
+        if (!(device instanceof FmAdapter))
+            return false;
+        const adapter = device;
+        return (adapter.getName() === this.getName() && adapter.getProfile() === this.getProfile());
+    }
+    getProfile() {
+        const profile = this.device ? this.device.getProfile() : undefined;
+        return profile || 'Smart Trainer';
+    }
+    getName() {
+        return `${this.device.name}`;
+    }
+    getDisplayName() {
+        return this.getName();
+    }
+    getSupportedCyclingModes() {
+        return [ble_st_mode_1.default, ble_erg_mode_1.default, power_meter_1.default];
+    }
+    setCyclingMode(mode, settings) {
+        let selectedMode;
+        if (typeof mode === 'string') {
+            const supported = this.getSupportedCyclingModes();
+            const CyclingModeClass = supported.find(M => { const m = new M(this); return m.getName() === mode; });
+            if (CyclingModeClass) {
+                this.cyclingMode = new CyclingModeClass(this, settings);
+                return;
+            }
+            selectedMode = this.getDefaultCyclingMode();
+        }
+        else {
+            selectedMode = mode;
+        }
+        this.cyclingMode = selectedMode;
+        this.cyclingMode.setSettings(settings);
+    }
+    getCyclingMode() {
+        if (!this.cyclingMode)
+            this.cyclingMode = this.getDefaultCyclingMode();
+        return this.cyclingMode;
+    }
+    getDefaultCyclingMode() {
+        return new ble_st_mode_1.default(this);
+    }
+    getPort() {
+        return 'ble';
+    }
+    setIgnoreBike(ignore) {
+        this.ignore = ignore;
+    }
+    setIgnorePower(ignore) {
+        this.ignore = ignore;
+    }
+    onDeviceData(deviceData) {
+        if (this.prevDataTS && Date.now() - this.prevDataTS < 1000)
+            return;
+        this.prevDataTS = Date.now();
+        this.logger.logEvent({ message: 'onDeviceData', data: deviceData });
+        let incyclistData = this.mapData(deviceData);
+        incyclistData = this.getCyclingMode().updateData(incyclistData);
+        const data = this.transformData(incyclistData);
+        if (this.onDataFn && !this.ignore && !this.paused)
+            this.onDataFn(data);
+    }
+    mapData(deviceData) {
+        const data = {
+            isPedalling: false,
+            power: 0,
+            pedalRpm: undefined,
+            speed: 0,
+            heartrate: 0,
+            distanceInternal: 0,
+            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.isPedalling = data.pedalRpm > 0 || (data.pedalRpm === undefined && data.power > 0);
+        return data;
+    }
+    transformData(bikeData) {
+        if (this.ignore) {
+            return {};
+        }
+        if (bikeData === undefined)
+            return;
+        let distance = 0;
+        if (this.distanceInternal !== undefined && bikeData.distanceInternal !== undefined) {
+            distance = Math.round(bikeData.distanceInternal - this.distanceInternal);
+        }
+        if (bikeData.distanceInternal !== undefined)
+            this.distanceInternal = bikeData.distanceInternal;
+        let data = {
+            speed: bikeData.speed,
+            slope: bikeData.slope,
+            power: bikeData.power !== undefined ? Math.round(bikeData.power) : undefined,
+            cadence: bikeData.pedalRpm !== undefined ? Math.round(bikeData.pedalRpm) : undefined,
+            distance,
+            timestamp: Date.now()
+        };
+        return data;
+    }
+    start(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'ftms: 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;
+                        }
+                    }
+                    let hasControl = yield this.device.requestControl();
+                    if (!hasControl) {
+                        let retry = 1;
+                        while (!hasControl && retry < 3) {
+                            yield sleep(1000);
+                            hasControl = yield this.device.requestControl();
+                            retry++;
+                        }
+                    }
+                    if (!hasControl)
+                        throw new Error('could not establish control');
+                    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}`);
+            }
+        });
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'stop requested', profile: this.getProfile() });
+            this.distanceInternal = 0;
+            this.device.reset();
+            return this.device.disconnect();
+        });
+    }
+    sendUpdate(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.paused || !this.device)
+                return;
+            const update = this.getCyclingMode().sendBikeUpdate(request);
+            this.logger.logEvent({ message: 'send bike update requested', profile: this.getProfile(), update, request });
+            if (update.slope !== undefined) {
+                yield this.device.setSlope(update.slope);
+            }
+            if (update.targetPower !== undefined) {
+                yield this.device.setTargetPower(update.targetPower);
+            }
+        });
+    }
+    pause() { this.paused = true; return Promise.resolve(true); }
+    resume() { this.paused = false; return Promise.resolve(true); }
+}
+exports.FmAdapter = FmAdapter;