incyclist-devices 1.4.48 → 1.4.51

package/lib/ble/wahoo-kickr.js

@@ -0,0 +1,372 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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 Device_1 = require("../Device");
+const gd_eventlog_1 = require("gd-eventlog");
+const fm_1 = __importStar(require("./fm"));
+const WAHOO_ADVANCED_FTMS = 'a026e005';
+const WAHOO_ADVANCED_TRAINER_CP = 'a026e037';
+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.data = {};
+    }
+    init() {
+        const _super = Object.create(null, {
+            init: { get: () => super.init }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.logEvent({ message: 'get device info' });
+                yield _super.init.call(this);
+                this.logEvent({ message: 'device info', deviceInfo: this.deviceInfo, features: this.features });
+            }
+            catch (err) {
+                return Promise.resolve(false);
+            }
+        });
+    }
+    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) {
+        super.onData(characteristic, data);
+        const uuid = characteristic.toLocaleLowerCase();
+        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:
+                break;
+        }
+        if (res)
+            this.emit('data', res);
+    }
+    writeWahooFtmsMessage(requestedOpCode, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const opcode = Buffer.alloc(1);
+                opcode.writeUInt8(requestedOpCode, 0);
+                const message = Buffer.concat([opcode, data]);
+                const res = yield this.write(WAHOO_ADVANCED_FTMS, message);
+                const responseData = Buffer.from(res);
+                const result = responseData.readUInt8(0);
+                this.logEvent({ message: 'response', opCode: requestedOpCode, response: responseData.toString('hex') });
+                return result === 1;
+            }
+            catch (err) {
+                this.logEvent({ message: 'writeWahooFtmsMessage 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' });
+            const data = Buffer.alloc(2);
+            data.writeUInt8(0xEE, 0);
+            data.writeUInt8(0xFC, 1);
+            const res = yield this.writeWahooFtmsMessage(32, data);
+            if (res === true) {
+                this.hasControl = true;
+            }
+            else {
+                this.logEvent({ message: 'requestControl failed' });
+            }
+            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* () {
+            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;
+            }
+            return res;
+        });
+    }
+    setSimMode(weight, crr, cw) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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);
+            return res;
+        });
+    }
+    setSimCRR(crr) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = Buffer.alloc(2);
+            data.writeInt16LE(Math.round(crr * 10000), 0);
+            const res = yield this.writeWahooFtmsMessage(68, data);
+            return res;
+        });
+    }
+    setSimWindResistance(cw) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = Buffer.alloc(2);
+            data.writeInt16LE(Math.round(cw * 1000), 0);
+            const res = yield this.writeWahooFtmsMessage(69, data);
+            return res;
+        });
+    }
+    setSimGrade(slope) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const value = (Math.min(1, Math.max(-1, slope)) + 1.0) * 65535 / 2.0;
+            const data = Buffer.alloc(2);
+            data.writeInt16LE(Math.round(value), 0);
+            const res = yield this.writeWahooFtmsMessage(70, data);
+            return res;
+        });
+    }
+    setSimWindSpeed(v) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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;
+        });
+    }
+    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 });
+            const { windSpeed, crr, cw } = this;
+            return yield this.setIndoorBikeSimulation(windSpeed, slope, crr, cw);
+        });
+    }
+    reset() {
+        this.data = {};
+    }
+}
+exports.default = WahooAdvancedFitnessMachineDevice;
+WahooAdvancedFitnessMachineDevice.services = ['a026ee0b'];
+WahooAdvancedFitnessMachineDevice.characteristics = ['2acc', '2ad2', '2ad6', '2ad8', '2ad9', '2ada', WAHOO_ADVANCED_FTMS, WAHOO_ADVANCED_TRAINER_CP];
+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: '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;
+                        }
+                    }
+                    const { user } = props || {};
+                    const weight = (user && user.weight ? user.weight : Device_1.DEFAULT_USER_WEIGHT) + Device_1.DEFAULT_BIKE_WEIGHT;
+                    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;

package/lib/modes/power-base.js

@@ -37,7 +37,6 @@ class PowerBasedCyclingModeBase extends CyclingMode_1.CyclingModeBase {
         let powerToMaintainSpeed = calculations_1.default.calculatePower(m, vPrev, slope, props);
         const powerDelta = powerToMaintainSpeed - power;
         const Ekin = EkinPrev - powerDelta * t;
-        console.log('~~~~ calculateSpeedAndDistance', Ekin, powerToMaintainSpeed, power, m, vPrev, slope);
         if (Ekin > 0) {
             const v = Math.sqrt(2 * Ekin / m);
             const speed = v * 3.6;

package/lib/modes/power-meter.js

@@ -53,7 +53,7 @@ class PowerMeterCyclingMode extends power_base_1.default {
                 power = 0;
             }
             const m = this.getWeight();
-            let t = this.getTimeSinceLastUpdate();
+            const t = this.getTimeSinceLastUpdate();
             const { speed, distance } = this.calculateSpeedAndDistance(power, slope, m, t);
             data.power = Math.round(power);
             data.slope = slope;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-devices",
-  "version": "1.4.48",
+  "version": "1.4.51",
   "dependencies": {
     "@serialport/parser-byte-length": "^9.0.1",
     "@serialport/parser-delimiter": "^9.0.1",