incyclist-devices 1.4.100 → 1.5.0

package/lib/ble/wahoo-kickr.js

@@ -1,496 +1,496 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        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.WahooAdvancedFmAdapter = void 0;
-const ble_interface_1 = __importDefault(require("./ble-interface"));
-const ble_1 = require("./ble");
-const Device_1 = require("../Device");
-const gd_eventlog_1 = require("gd-eventlog");
-const fm_1 = __importStar(require("./fm"));
-const consts_1 = require("./consts");
-const WAHOO_ADVANCED_FTMS = 'a026ee0b';
-const cwABike = {
-    race: 0.35,
-    triathlon: 0.29,
-    mountain: 0.57
-};
-const cRR = 0.0036;
-const ErgWriteDelay = 2000;
-class WahooAdvancedFitnessMachineDevice extends fm_1.default {
-    constructor(props) {
-        super(props);
-        this.prevCrankData = undefined;
-        this.currentCrankData = undefined;
-        this.timeOffset = 0;
-        this.tsPrevWrite = undefined;
-        this.prevSlope = undefined;
-        this.isRequestControlBusy = false;
-        this.weight = Device_1.DEFAULT_BIKE_WEIGHT + Device_1.DEFAULT_USER_WEIGHT;
-        this.data = {};
-        this.wahooCP = consts_1.WAHOO_ADVANCED_TRAINER_CP;
-    }
-    isMatching(characteristics) {
-        if (!characteristics)
-            return false;
-        const hasWahooCP = characteristics.find(c => (0, ble_1.matches)(c, consts_1.WAHOO_ADVANCED_TRAINER_CP)) !== undefined;
-        const hasFTMS = characteristics.find(c => (0, ble_1.matches)(c, consts_1.FTMS_CP)) !== undefined;
-        return hasWahooCP && !hasFTMS;
-    }
-    init() {
-        const _super = Object.create(null, {
-            initDevice: { get: () => super.initDevice }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield this.subscribeWriteResponse(this.wahooCP);
-                try {
-                    if (this.wahooCP !== consts_1.WAHOO_ADVANCED_TRAINER_CP_FULL.toLowerCase())
-                        yield this.subscribeWriteResponse(consts_1.WAHOO_ADVANCED_TRAINER_CP_FULL.toLowerCase());
-                }
-                catch (err) {
-                }
-                yield _super.initDevice.call(this);
-                return true;
-            }
-            catch (err) {
-                this.logEvent({ message: 'error', fn: 'WahooAdvancedFitnessMachineDevice.init()', error: err.message || err, stack: err.stack });
-                return false;
-            }
-        });
-    }
-    setCharacteristicUUIDs(uuids) {
-        this.logEvent({ message: 'set uuids', uuids });
-        uuids.forEach(c => {
-            if ((0, ble_1.matches)(c, consts_1.WAHOO_ADVANCED_TRAINER_CP))
-                this.wahooCP = c;
-        });
-    }
-    getProfile() {
-        return 'Wahoo Smart Trainer';
-    }
-    getServiceUUids() {
-        return WahooAdvancedFitnessMachineDevice.services;
-    }
-    isBike() {
-        return true;
-    }
-    isPower() {
-        return true;
-    }
-    isHrm() {
-        return this.hasService('180d');
-    }
-    parseCrankData(crankData) {
-        if (!this.prevCrankData)
-            this.prevCrankData = { revolutions: 0, time: 0, cntUpdateMissing: -1 };
-        const c = this.currentCrankData = crankData;
-        const p = this.prevCrankData;
-        let rpm = this.data.cadence;
-        let hasUpdate = c.time !== p.time;
-        if (hasUpdate) {
-            let time = c.time - p.time;
-            let revs = c.revolutions - p.revolutions;
-            if (c.time < p.time) {
-                time += 0x10000;
-                this.timeOffset += 0x10000;
-            }
-            if (c.revolutions < p.revolutions)
-                revs += 0x10000;
-            rpm = 1024 * 60 * revs / time;
-        }
-        else {
-            if (p.cntUpdateMissing < 0 || p.cntUpdateMissing > 2) {
-                rpm = 0;
-            }
-        }
-        const cntUpdateMissing = p.cntUpdateMissing;
-        this.prevCrankData = this.currentCrankData;
-        if (hasUpdate)
-            this.prevCrankData.cntUpdateMissing = 0;
-        else
-            this.prevCrankData.cntUpdateMissing = cntUpdateMissing + 1;
-        return { rpm, time: this.timeOffset + c.time };
-    }
-    parsePower(_data) {
-        const data = Buffer.from(_data);
-        try {
-            let offset = 4;
-            const flags = data.readUInt16LE(0);
-            this.data.instantaneousPower = data.readUInt16LE(2);
-            if (flags & 0x1)
-                data.readUInt8(offset++);
-            if (flags & 0x4) {
-                data.readUInt16LE(offset);
-                offset += 2;
-            }
-            if (flags & 0x20) {
-                const crankData = {
-                    revolutions: data.readUInt16LE(offset),
-                    time: data.readUInt16LE(offset + 2)
-                };
-                const { rpm, time } = this.parseCrankData(crankData);
-                this.data.cadence = rpm;
-                this.data.time = time;
-                offset += 4;
-            }
-        }
-        catch (err) {
-        }
-        const { instantaneousPower, cadence, time } = this.data;
-        return { instantaneousPower, cadence, time, raw: data.toString('hex') };
-    }
-    onData(characteristic, data) {
-        const hasData = super.onData(characteristic, data);
-        if (!hasData)
-            return false;
-        const uuid = characteristic.toLowerCase();
-        let res = undefined;
-        switch (uuid) {
-            case '2a63':
-                res = this.parsePower(data);
-                break;
-            case '2ad2':
-                res = this.parseIndoorBikeData(data);
-                break;
-            case '2a37':
-                res = this.parseHrm(data);
-                break;
-            case '2ada':
-                res = this.parseFitnessMachineStatus(data);
-                break;
-            default:
-                this.logEvent({ message: 'data', uuid, data: data.toString('hex') });
-                break;
-        }
-        if (res) {
-            this.emit('data', res);
-            return false;
-        }
-        return true;
-    }
-    writeWahooFtmsMessage(requestedOpCode, data, props) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const opcode = Buffer.alloc(1);
-                opcode.writeUInt8(requestedOpCode, 0);
-                const message = Buffer.concat([opcode, data]);
-                this.logEvent({ message: 'wahoo cp:write', data: message.toString('hex') });
-                const res = yield this.write(this.wahooCP, message, props);
-                const responseData = Buffer.from(res);
-                const result = responseData.readUInt8(0);
-                return result === 1;
-            }
-            catch (err) {
-                this.logEvent({ message: 'wahoo cp:write failed', opCode: requestedOpCode, reason: err.message });
-                return false;
-            }
-        });
-    }
-    requestControl() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.hasControl)
-                return true;
-            this.logEvent({ message: 'requestControl' });
-            if (this.isRequestControlBusy)
-                return false;
-            this.isRequestControlBusy = true;
-            try {
-                const data = Buffer.alloc(2);
-                data.writeUInt8(0xEE, 0);
-                data.writeUInt8(0xFC, 1);
-                const res = yield this.writeWahooFtmsMessage(32, data, { timeout: 10000 });
-                if (res === true) {
-                    this.hasControl = true;
-                }
-                else {
-                    this.logEvent({ message: 'requestControl failed' });
-                }
-            }
-            catch (err) {
-                this.logEvent({ message: 'error', fn: 'requestControl()', error: err.message || err, stack: err.stack });
-            }
-            this.isRequestControlBusy = false;
-            return this.hasControl;
-        });
-    }
-    setPowerAdjusting() {
-        this.tsPrevWrite = Date.now();
-    }
-    isPowerAdjusting() {
-        if (this.tsPrevWrite === undefined)
-            return false;
-        if (this.tsPrevWrite < Date.now() - ErgWriteDelay) {
-            this.tsPrevWrite = undefined;
-            return false;
-        }
-        return true;
-    }
-    setErgMode(power) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'setErgMode', power });
-            try {
-                if (this.isPowerAdjusting())
-                    return false;
-                const data = Buffer.alloc(2);
-                data.writeInt16LE(Math.round(power), 0);
-                const res = yield this.writeWahooFtmsMessage(66, data);
-                if (res === true) {
-                    this.setPowerAdjusting();
-                    this.data.targetPower = power;
-                    this.isSimMode = false;
-                    this.simModeSettings = undefined;
-                }
-                return res;
-            }
-            catch (err) {
-                this.logEvent({ message: 'error', fn: 'setErgMode', error: err.message || err, stack: err.stack });
-                return false;
-            }
-        });
-    }
-    setSimMode(weight, crr, cw) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'setSimMode', weight, crr, cw });
-            try {
-                if (this.isSimMode && this.simModeSettings) {
-                    if (weight === this.simModeSettings.weight &&
-                        crr === this.simModeSettings.crr &&
-                        cw === this.simModeSettings.cw)
-                        return true;
-                }
-                const hasControl = yield this.requestControl();
-                if (!hasControl) {
-                    this.logEvent({ message: 'setSimMode failed', reason: 'control is disabled' });
-                    return false;
-                }
-                this.weight = weight;
-                this.crr = crr;
-                this.cw = cw;
-                const data = Buffer.alloc(6);
-                data.writeInt16LE(Math.round(weight * 100), 0);
-                data.writeInt16LE(Math.round(crr * 10000), 2);
-                data.writeInt16LE(Math.round(cw * 1000), 4);
-                const res = yield this.writeWahooFtmsMessage(67, data);
-                this.isSimMode = true;
-                this.simModeSettings = { weight, crr, cw };
-                return res;
-            }
-            catch (err) {
-                this.logEvent({ message: 'error', fn: 'setSimMode', error: err.message || err, stack: err.stack });
-                return false;
-            }
-        });
-    }
-    setSimCRR(crr) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'setSimCRR', crr });
-            try {
-                const data = Buffer.alloc(2);
-                data.writeInt16LE(Math.round(crr * 10000), 0);
-                const res = yield this.writeWahooFtmsMessage(68, data);
-                return res;
-            }
-            catch (err) {
-                this.logEvent({ message: 'error', fn: 'setSimCRR', error: err.message || err, stack: err.stack });
-                return false;
-            }
-        });
-    }
-    setSimWindResistance(cw) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'setSimWindResistance', cw });
-            try {
-                const data = Buffer.alloc(2);
-                data.writeInt16LE(Math.round(cw * 1000), 0);
-                const res = yield this.writeWahooFtmsMessage(69, data);
-                return res;
-            }
-            catch (err) {
-                this.logEvent({ message: 'error', fn: 'setSimWindResistance', error: err.message || err, stack: err.stack });
-                return false;
-            }
-        });
-    }
-    setSimGrade(slope) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'setSimGrade', slope });
-            try {
-                let s = slope;
-                if (s < -100)
-                    s = -100;
-                if (s > 100)
-                    s = 100;
-                const slopeVal = Math.min(Math.round((1 + s / 100) * 65535 / 2.0), 65535);
-                const data = Buffer.alloc(2);
-                data.writeUInt16LE(slopeVal, 0);
-                const res = yield this.writeWahooFtmsMessage(70, data);
-                return res;
-            }
-            catch (err) {
-                this.logEvent({ message: 'error', fn: 'setSimGrade', error: err.message || err, stack: err.stack });
-                return false;
-            }
-        });
-    }
-    setSimWindSpeed(v) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'setSimWindSpeed', v });
-            try {
-                const value = (Math.max(-32.767, Math.min(32.767, v)) + 32.767) * 1000;
-                const data = Buffer.alloc(2);
-                data.writeInt16LE(Math.round(value), 0);
-                const res = yield this.writeWahooFtmsMessage(71, data);
-                return res;
-            }
-            catch (err) {
-                this.logEvent({ message: 'error', fn: 'setSimWindSpeed', error: err.message || err, stack: err.stack });
-                return false;
-            }
-        });
-    }
-    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;
-            const hasControl = yield this.requestControl();
-            if (!hasControl) {
-                this.logEvent({ message: 'setTargetPower failed', reason: 'control is disabled' });
-                return false;
-            }
-            return yield this.setErgMode(power);
-        });
-    }
-    setSlope(slope) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'setSlope', slope });
-            if (this.prevSlope !== undefined && slope === this.prevSlope)
-                return;
-            try {
-                if (!this.isSimMode) {
-                    const { weight, crr, cw } = this;
-                    const hasSimMode = yield this.setSimMode(weight, crr, cw);
-                    if (!hasSimMode)
-                        throw new Error('Sim Mode not enabled');
-                }
-                const res = yield this.setSimGrade(slope);
-                this.logEvent({ message: 'setSlope result', res });
-                this.prevSlope = slope;
-                return res;
-            }
-            catch (err) {
-                this.logEvent({ message: 'setSlope failed', reason: err.message || err });
-                this.prevSlope = undefined;
-                return false;
-            }
-        });
-    }
-    reset() {
-        this.data = {};
-        this.isSimMode = undefined;
-        this.simModeSettings = undefined;
-    }
-}
-exports.default = WahooAdvancedFitnessMachineDevice;
-WahooAdvancedFitnessMachineDevice.services = [consts_1.CSP];
-WahooAdvancedFitnessMachineDevice.characteristics = ['2acc', '2ad2', '2ad6', '2ad8', '2ad9', '2ada', consts_1.WAHOO_ADVANCED_TRAINER_CP];
-WahooAdvancedFitnessMachineDevice.detectionPriority = 5;
-ble_interface_1.default.register('WahooAdvancedFitnessMachineDevice', 'wahoo-fm', WahooAdvancedFitnessMachineDevice, WahooAdvancedFitnessMachineDevice.services);
-class WahooAdvancedFmAdapter extends fm_1.FmAdapter {
-    constructor(device, protocol) {
-        super(device, protocol);
-        this.device = device;
-        this.ble = protocol.ble;
-        this.cyclingMode = this.getDefaultCyclingMode();
-        this.logger = new gd_eventlog_1.EventLogger('BLE-WahooFM');
-        if (this.device)
-            this.device.setLogger(this.logger);
-    }
-    isSame(device) {
-        if (!(device instanceof WahooAdvancedFmAdapter))
-            return false;
-        const adapter = device;
-        return (adapter.getName() === this.getName() && adapter.getProfile() === this.getProfile());
-    }
-    getProfile() {
-        return 'Wahoo Smart Trainer';
-    }
-    start(props) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'wahoo: start requested', profile: this.getProfile(), props, isScanning: this.ble.isScanning() });
-            try {
-                this.logger.logEvent({ message: 'wahoo: stop previous scan', isScanning: this.ble.isScanning() });
-                if (this.ble.isScanning())
-                    yield this.ble.stopScan();
-                this.logger.logEvent({ message: 'wahoo trying device connect' });
-                const bleDevice = yield this.ble.connectDevice(this.device);
-                this.logger.logEvent({ message: 'wahoo device connected', connected: (bleDevice !== null && bleDevice !== undefined) });
-                if (bleDevice) {
-                    this.device = bleDevice;
-                    const mode = this.getCyclingMode();
-                    if (mode && mode.getSetting('bikeType')) {
-                        const bikeType = mode.getSetting('bikeType').toLowerCase();
-                        this.device.setCrr(cRR);
-                        switch (bikeType) {
-                            case 'race':
-                                this.device.setCw(cwABike.race);
-                                break;
-                            case 'triathlon':
-                                this.device.setCw(cwABike.triathlon);
-                                break;
-                            case 'mountain':
-                                this.device.setCw(cwABike.mountain);
-                                break;
-                        }
-                    }
-                    const { user } = props || {};
-                    const weight = (user && user.weight ? Number(user.weight) : Device_1.DEFAULT_USER_WEIGHT) + Device_1.DEFAULT_BIKE_WEIGHT;
-                    yield this.device.setSimMode(weight, this.device.getCrr(), this.device.getCw());
-                    const startRequest = this.getCyclingMode().getBikeInitRequest();
-                    yield this.sendUpdate(startRequest);
-                    bleDevice.on('data', (data) => {
-                        this.onDeviceData(data);
-                    });
-                    return true;
-                }
-            }
-            catch (err) {
-                this.logger.logEvent({ message: 'start result: error', error: err.message, profile: this.getProfile() });
-                throw new Error(`could not start device, reason:${err.message}`);
-            }
-        });
-    }
-    pause() { this.paused = true; return Promise.resolve(true); }
-    resume() { this.paused = false; return Promise.resolve(true); }
-}
-exports.WahooAdvancedFmAdapter = WahooAdvancedFmAdapter;
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        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.WahooAdvancedFmAdapter = void 0;
+const ble_interface_1 = __importDefault(require("./ble-interface"));
+const ble_1 = require("./ble");
+const device_1 = require("../device");
+const gd_eventlog_1 = require("gd-eventlog");
+const fm_1 = __importStar(require("./fm"));
+const consts_1 = require("./consts");
+const WAHOO_ADVANCED_FTMS = 'a026ee0b';
+const cwABike = {
+    race: 0.35,
+    triathlon: 0.29,
+    mountain: 0.57
+};
+const cRR = 0.0036;
+const ErgWriteDelay = 2000;
+class WahooAdvancedFitnessMachineDevice extends fm_1.default {
+    constructor(props) {
+        super(props);
+        this.prevCrankData = undefined;
+        this.currentCrankData = undefined;
+        this.timeOffset = 0;
+        this.tsPrevWrite = undefined;
+        this.prevSlope = undefined;
+        this.isRequestControlBusy = false;
+        this.weight = device_1.DEFAULT_BIKE_WEIGHT + device_1.DEFAULT_USER_WEIGHT;
+        this.data = {};
+        this.wahooCP = consts_1.WAHOO_ADVANCED_TRAINER_CP;
+    }
+    isMatching(characteristics) {
+        if (!characteristics)
+            return false;
+        const hasWahooCP = characteristics.find(c => (0, ble_1.matches)(c, consts_1.WAHOO_ADVANCED_TRAINER_CP)) !== undefined;
+        const hasFTMS = characteristics.find(c => (0, ble_1.matches)(c, consts_1.FTMS_CP)) !== undefined;
+        return hasWahooCP && !hasFTMS;
+    }
+    init() {
+        const _super = Object.create(null, {
+            initDevice: { get: () => super.initDevice }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.subscribeWriteResponse(this.wahooCP);
+                try {
+                    if (this.wahooCP !== consts_1.WAHOO_ADVANCED_TRAINER_CP_FULL.toLowerCase())
+                        yield this.subscribeWriteResponse(consts_1.WAHOO_ADVANCED_TRAINER_CP_FULL.toLowerCase());
+                }
+                catch (err) {
+                }
+                yield _super.initDevice.call(this);
+                return true;
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', fn: 'WahooAdvancedFitnessMachineDevice.init()', error: err.message || err, stack: err.stack });
+                return false;
+            }
+        });
+    }
+    setCharacteristicUUIDs(uuids) {
+        this.logEvent({ message: 'set uuids', uuids });
+        uuids.forEach(c => {
+            if ((0, ble_1.matches)(c, consts_1.WAHOO_ADVANCED_TRAINER_CP))
+                this.wahooCP = c;
+        });
+    }
+    getProfile() {
+        return 'Wahoo Smart Trainer';
+    }
+    getServiceUUids() {
+        return WahooAdvancedFitnessMachineDevice.services;
+    }
+    isBike() {
+        return true;
+    }
+    isPower() {
+        return true;
+    }
+    isHrm() {
+        return this.hasService('180d');
+    }
+    parseCrankData(crankData) {
+        if (!this.prevCrankData)
+            this.prevCrankData = { revolutions: 0, time: 0, cntUpdateMissing: -1 };
+        const c = this.currentCrankData = crankData;
+        const p = this.prevCrankData;
+        let rpm = this.data.cadence;
+        let hasUpdate = c.time !== p.time;
+        if (hasUpdate) {
+            let time = c.time - p.time;
+            let revs = c.revolutions - p.revolutions;
+            if (c.time < p.time) {
+                time += 0x10000;
+                this.timeOffset += 0x10000;
+            }
+            if (c.revolutions < p.revolutions)
+                revs += 0x10000;
+            rpm = 1024 * 60 * revs / time;
+        }
+        else {
+            if (p.cntUpdateMissing < 0 || p.cntUpdateMissing > 2) {
+                rpm = 0;
+            }
+        }
+        const cntUpdateMissing = p.cntUpdateMissing;
+        this.prevCrankData = this.currentCrankData;
+        if (hasUpdate)
+            this.prevCrankData.cntUpdateMissing = 0;
+        else
+            this.prevCrankData.cntUpdateMissing = cntUpdateMissing + 1;
+        return { rpm, time: this.timeOffset + c.time };
+    }
+    parsePower(_data) {
+        const data = Buffer.from(_data);
+        try {
+            let offset = 4;
+            const flags = data.readUInt16LE(0);
+            this.data.instantaneousPower = data.readUInt16LE(2);
+            if (flags & 0x1)
+                data.readUInt8(offset++);
+            if (flags & 0x4) {
+                data.readUInt16LE(offset);
+                offset += 2;
+            }
+            if (flags & 0x20) {
+                const crankData = {
+                    revolutions: data.readUInt16LE(offset),
+                    time: data.readUInt16LE(offset + 2)
+                };
+                const { rpm, time } = this.parseCrankData(crankData);
+                this.data.cadence = rpm;
+                this.data.time = time;
+                offset += 4;
+            }
+        }
+        catch (err) {
+        }
+        const { instantaneousPower, cadence, time } = this.data;
+        return { instantaneousPower, cadence, time, raw: data.toString('hex') };
+    }
+    onData(characteristic, data) {
+        const hasData = super.onData(characteristic, data);
+        if (!hasData)
+            return false;
+        const uuid = characteristic.toLowerCase();
+        let res = undefined;
+        switch (uuid) {
+            case '2a63':
+                res = this.parsePower(data);
+                break;
+            case '2ad2':
+                res = this.parseIndoorBikeData(data);
+                break;
+            case '2a37':
+                res = this.parseHrm(data);
+                break;
+            case '2ada':
+                res = this.parseFitnessMachineStatus(data);
+                break;
+            default:
+                this.logEvent({ message: 'data', uuid, data: data.toString('hex') });
+                break;
+        }
+        if (res) {
+            this.emit('data', res);
+            return false;
+        }
+        return true;
+    }
+    writeWahooFtmsMessage(requestedOpCode, data, props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const opcode = Buffer.alloc(1);
+                opcode.writeUInt8(requestedOpCode, 0);
+                const message = Buffer.concat([opcode, data]);
+                this.logEvent({ message: 'wahoo cp:write', data: message.toString('hex') });
+                const res = yield this.write(this.wahooCP, message, props);
+                const responseData = Buffer.from(res);
+                const result = responseData.readUInt8(0);
+                return result === 1;
+            }
+            catch (err) {
+                this.logEvent({ message: 'wahoo cp:write failed', opCode: requestedOpCode, reason: err.message });
+                return false;
+            }
+        });
+    }
+    requestControl() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.hasControl)
+                return true;
+            this.logEvent({ message: 'requestControl' });
+            if (this.isRequestControlBusy)
+                return false;
+            this.isRequestControlBusy = true;
+            try {
+                const data = Buffer.alloc(2);
+                data.writeUInt8(0xEE, 0);
+                data.writeUInt8(0xFC, 1);
+                const res = yield this.writeWahooFtmsMessage(32, data, { timeout: 10000 });
+                if (res === true) {
+                    this.hasControl = true;
+                }
+                else {
+                    this.logEvent({ message: 'requestControl failed' });
+                }
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', fn: 'requestControl()', error: err.message || err, stack: err.stack });
+            }
+            this.isRequestControlBusy = false;
+            return this.hasControl;
+        });
+    }
+    setPowerAdjusting() {
+        this.tsPrevWrite = Date.now();
+    }
+    isPowerAdjusting() {
+        if (this.tsPrevWrite === undefined)
+            return false;
+        if (this.tsPrevWrite < Date.now() - ErgWriteDelay) {
+            this.tsPrevWrite = undefined;
+            return false;
+        }
+        return true;
+    }
+    setErgMode(power) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'setErgMode', power });
+            try {
+                if (this.isPowerAdjusting())
+                    return false;
+                const data = Buffer.alloc(2);
+                data.writeInt16LE(Math.round(power), 0);
+                const res = yield this.writeWahooFtmsMessage(66, data);
+                if (res === true) {
+                    this.setPowerAdjusting();
+                    this.data.targetPower = power;
+                    this.isSimMode = false;
+                    this.simModeSettings = undefined;
+                }
+                return res;
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', fn: 'setErgMode', error: err.message || err, stack: err.stack });
+                return false;
+            }
+        });
+    }
+    setSimMode(weight, crr, cw) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'setSimMode', weight, crr, cw });
+            try {
+                if (this.isSimMode && this.simModeSettings) {
+                    if (weight === this.simModeSettings.weight &&
+                        crr === this.simModeSettings.crr &&
+                        cw === this.simModeSettings.cw)
+                        return true;
+                }
+                const hasControl = yield this.requestControl();
+                if (!hasControl) {
+                    this.logEvent({ message: 'setSimMode failed', reason: 'control is disabled' });
+                    return false;
+                }
+                this.weight = weight;
+                this.crr = crr;
+                this.cw = cw;
+                const data = Buffer.alloc(6);
+                data.writeInt16LE(Math.round(weight * 100), 0);
+                data.writeInt16LE(Math.round(crr * 10000), 2);
+                data.writeInt16LE(Math.round(cw * 1000), 4);
+                const res = yield this.writeWahooFtmsMessage(67, data);
+                this.isSimMode = true;
+                this.simModeSettings = { weight, crr, cw };
+                return res;
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', fn: 'setSimMode', error: err.message || err, stack: err.stack });
+                return false;
+            }
+        });
+    }
+    setSimCRR(crr) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'setSimCRR', crr });
+            try {
+                const data = Buffer.alloc(2);
+                data.writeInt16LE(Math.round(crr * 10000), 0);
+                const res = yield this.writeWahooFtmsMessage(68, data);
+                return res;
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', fn: 'setSimCRR', error: err.message || err, stack: err.stack });
+                return false;
+            }
+        });
+    }
+    setSimWindResistance(cw) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'setSimWindResistance', cw });
+            try {
+                const data = Buffer.alloc(2);
+                data.writeInt16LE(Math.round(cw * 1000), 0);
+                const res = yield this.writeWahooFtmsMessage(69, data);
+                return res;
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', fn: 'setSimWindResistance', error: err.message || err, stack: err.stack });
+                return false;
+            }
+        });
+    }
+    setSimGrade(slope) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'setSimGrade', slope });
+            try {
+                let s = slope;
+                if (s < -100)
+                    s = -100;
+                if (s > 100)
+                    s = 100;
+                const slopeVal = Math.min(Math.round((1 + s / 100) * 65535 / 2.0), 65535);
+                const data = Buffer.alloc(2);
+                data.writeUInt16LE(slopeVal, 0);
+                const res = yield this.writeWahooFtmsMessage(70, data);
+                return res;
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', fn: 'setSimGrade', error: err.message || err, stack: err.stack });
+                return false;
+            }
+        });
+    }
+    setSimWindSpeed(v) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'setSimWindSpeed', v });
+            try {
+                const value = (Math.max(-32.767, Math.min(32.767, v)) + 32.767) * 1000;
+                const data = Buffer.alloc(2);
+                data.writeInt16LE(Math.round(value), 0);
+                const res = yield this.writeWahooFtmsMessage(71, data);
+                return res;
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', fn: 'setSimWindSpeed', error: err.message || err, stack: err.stack });
+                return false;
+            }
+        });
+    }
+    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;
+            const hasControl = yield this.requestControl();
+            if (!hasControl) {
+                this.logEvent({ message: 'setTargetPower failed', reason: 'control is disabled' });
+                return false;
+            }
+            return yield this.setErgMode(power);
+        });
+    }
+    setSlope(slope) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'setSlope', slope });
+            if (this.prevSlope !== undefined && slope === this.prevSlope)
+                return;
+            try {
+                if (!this.isSimMode) {
+                    const { weight, crr, cw } = this;
+                    const hasSimMode = yield this.setSimMode(weight, crr, cw);
+                    if (!hasSimMode)
+                        throw new Error('Sim Mode not enabled');
+                }
+                const res = yield this.setSimGrade(slope);
+                this.logEvent({ message: 'setSlope result', res });
+                this.prevSlope = slope;
+                return res;
+            }
+            catch (err) {
+                this.logEvent({ message: 'setSlope failed', reason: err.message || err });
+                this.prevSlope = undefined;
+                return false;
+            }
+        });
+    }
+    reset() {
+        this.data = {};
+        this.isSimMode = undefined;
+        this.simModeSettings = undefined;
+    }
+}
+exports.default = WahooAdvancedFitnessMachineDevice;
+WahooAdvancedFitnessMachineDevice.services = [consts_1.CSP];
+WahooAdvancedFitnessMachineDevice.characteristics = ['2acc', '2ad2', '2ad6', '2ad8', '2ad9', '2ada', consts_1.WAHOO_ADVANCED_TRAINER_CP];
+WahooAdvancedFitnessMachineDevice.detectionPriority = 5;
+ble_interface_1.default.register('WahooAdvancedFitnessMachineDevice', 'wahoo-fm', WahooAdvancedFitnessMachineDevice, WahooAdvancedFitnessMachineDevice.services);
+class WahooAdvancedFmAdapter extends fm_1.FmAdapter {
+    constructor(device, protocol) {
+        super(device, protocol);
+        this.device = device;
+        this.ble = protocol.ble;
+        this.cyclingMode = this.getDefaultCyclingMode();
+        this.logger = new gd_eventlog_1.EventLogger('BLE-WahooFM');
+        if (this.device)
+            this.device.setLogger(this.logger);
+    }
+    isSame(device) {
+        if (!(device instanceof WahooAdvancedFmAdapter))
+            return false;
+        const adapter = device;
+        return (adapter.getName() === this.getName() && adapter.getProfile() === this.getProfile());
+    }
+    getProfile() {
+        return 'Wahoo Smart Trainer';
+    }
+    start(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'wahoo: start requested', profile: this.getProfile(), props, isScanning: this.ble.isScanning() });
+            try {
+                this.logger.logEvent({ message: 'wahoo: stop previous scan', isScanning: this.ble.isScanning() });
+                if (this.ble.isScanning())
+                    yield this.ble.stopScan();
+                this.logger.logEvent({ message: 'wahoo trying device connect' });
+                const bleDevice = yield this.ble.connectDevice(this.device);
+                this.logger.logEvent({ message: 'wahoo device connected', connected: (bleDevice !== null && bleDevice !== undefined) });
+                if (bleDevice) {
+                    this.device = bleDevice;
+                    const mode = this.getCyclingMode();
+                    if (mode && mode.getSetting('bikeType')) {
+                        const bikeType = mode.getSetting('bikeType').toLowerCase();
+                        this.device.setCrr(cRR);
+                        switch (bikeType) {
+                            case 'race':
+                                this.device.setCw(cwABike.race);
+                                break;
+                            case 'triathlon':
+                                this.device.setCw(cwABike.triathlon);
+                                break;
+                            case 'mountain':
+                                this.device.setCw(cwABike.mountain);
+                                break;
+                        }
+                    }
+                    const { user } = props || {};
+                    const weight = (user && user.weight ? Number(user.weight) : device_1.DEFAULT_USER_WEIGHT) + device_1.DEFAULT_BIKE_WEIGHT;
+                    yield this.device.setSimMode(weight, this.device.getCrr(), this.device.getCw());
+                    const startRequest = this.getCyclingMode().getBikeInitRequest();
+                    yield this.sendUpdate(startRequest);
+                    bleDevice.on('data', (data) => {
+                        this.onDeviceData(data);
+                    });
+                    return true;
+                }
+            }
+            catch (err) {
+                this.logger.logEvent({ message: 'start result: error', error: err.message, profile: this.getProfile() });
+                throw new Error(`could not start device, reason:${err.message}`);
+            }
+        });
+    }
+    pause() { this.paused = true; return Promise.resolve(true); }
+    resume() { this.paused = false; return Promise.resolve(true); }
+}
+exports.WahooAdvancedFmAdapter = WahooAdvancedFmAdapter;