incyclist-devices 1.4.39 → 1.4.40

package/lib/DeviceSupport.d.ts

@@ -11,6 +11,7 @@ import { CyclingModeProperyType } from './CyclingMode';
 import BleInterface from './ble/ble-interface';
 import BleHrmDevice from './ble/hrm';
 import BleCyclingPowerDevice from './ble/pwr';
+import BleFitnessMachineDevice from './ble/fm';
 declare const Protocols: {
     SimulatorProtocol: typeof SimulatorProtocol;
     DaumClassicProtocol: typeof DaumClassicProtocol;
@@ -18,4 +19,4 @@ declare const Protocols: {
     KettlerRacerProtocol: typeof KettlerRacerProtocol;
     BleProtocol: typeof BleProtocol;
 };
-export { DeviceProtocolBase, DeviceProtocol, DeviceRegistry, INTERFACE, DeviceAdapter as Device, Protocols, AntScanner, BleProtocol, CyclingModeProperyType, BleInterface, BleHrmDevice, BleCyclingPowerDevice };
+export { DeviceProtocolBase, DeviceProtocol, DeviceRegistry, INTERFACE, DeviceAdapter as Device, Protocols, AntScanner, BleProtocol, CyclingModeProperyType, BleInterface, BleHrmDevice, BleCyclingPowerDevice, BleFitnessMachineDevice };

package/lib/DeviceSupport.js

@@ -33,6 +33,8 @@ const hrm_1 = __importDefault(require("./ble/hrm"));
 exports.BleHrmDevice = hrm_1.default;
 const pwr_1 = __importDefault(require("./ble/pwr"));
 exports.BleCyclingPowerDevice = pwr_1.default;
+const fm_1 = __importDefault(require("./ble/fm"));
+exports.BleFitnessMachineDevice = fm_1.default;
 const Protocols = {
     SimulatorProtocol: Simulator_1.default,
     DaumClassicProtocol: DaumClassicProtocol_1.default,

package/lib/ble/ble-device.js

@@ -105,7 +105,7 @@ class BleDevice extends ble_1.BleDeviceClass {
                     this.cleanupListeners();
                     if (!connected) {
                         this.logEvent({ message: 'connect: discover characteristics start' });
-                        const res = yield peripheral.discoverSomeServicesAndCharacteristicsAsync(this.services || [], []);
+                        const res = yield peripheral.discoverSomeServicesAndCharacteristicsAsync([], []);
                         const { characteristics } = res;
                         this.logEvent({ message: 'connect: discover characteristics result',
                             result: characteristics.map(c => ({ uuid: ble_1.uuid(c.uuid), properties: c.properties.join(','), service: ble_1.uuid(c._serviceUuid) }))

package/lib/ble/fm.d.ts

@@ -0,0 +1,78 @@
+/// <reference types="node" />
+import { BleDevice } from './ble-device';
+import BleInterface from './ble-interface';
+import BleProtocol from './incyclist-protocol';
+import { BleDeviceClass } from './ble';
+import DeviceAdapter, { DeviceData } from '../Device';
+import { DeviceProtocol } from '../DeviceProtocol';
+import { EventLogger } from 'gd-eventlog';
+import CyclingMode from '../CyclingMode';
+import { IncyclistBikeData } from '../CyclingMode';
+declare type PowerData = {
+    instantaneousPower?: number;
+    balance?: number;
+    accTorque?: number;
+    time: number;
+    rpm: number;
+    raw?: string;
+};
+declare type IndoorBikeData = {
+    speed?: number;
+    averageSpeed?: number;
+    cadence?: number;
+    averageCadence?: number;
+    totalDistance?: number;
+    resistanceLevel?: number;
+    instantaneousPower?: number;
+    averagePower?: number;
+    expendedEnergy?: number;
+    heartrate?: number;
+    metabolicEquivalent?: number;
+    time?: number;
+    remainingTime?: number;
+    raw?: string;
+};
+export default class BleFitnessMachineDevice extends BleDevice {
+    static services: string[];
+    static characteristics: string[];
+    data: IndoorBikeData;
+    constructor(props?: any);
+    getProfile(): string;
+    getServiceUUids(): string[];
+    parseIndoorBikeData(_data: Uint8Array): IndoorBikeData;
+    onData(characteristic: string, data: Buffer): void;
+    write(characteristic: any, data: any): Promise<boolean>;
+    read(characteristic: any): Promise<Buffer>;
+    reset(): void;
+}
+export declare class FmAdapter extends DeviceAdapter {
+    device: BleFitnessMachineDevice;
+    ignore: boolean;
+    ble: BleInterface;
+    protocol: DeviceProtocol;
+    paused: boolean;
+    logger: EventLogger;
+    mode: CyclingMode;
+    distanceInternal: number;
+    prevDataTS: number;
+    constructor(device: BleDeviceClass, protocol: BleProtocol);
+    isBike(): boolean;
+    isHrm(): boolean;
+    isPower(): boolean;
+    getProfile(): string;
+    getName(): string;
+    getDisplayName(): string;
+    getCyclingMode(): CyclingMode;
+    getDefaultCyclingMode(): CyclingMode;
+    getPort(): string;
+    setIgnoreBike(ignore: any): void;
+    setIgnorePower(ignore: any): void;
+    onDeviceData(deviceData: PowerData): void;
+    mapData(deviceData: IndoorBikeData): IncyclistBikeData;
+    transformData(bikeData: IncyclistBikeData): DeviceData;
+    start(props?: any): Promise<any>;
+    stop(): Promise<boolean>;
+    pause(): Promise<boolean>;
+    resume(): Promise<boolean>;
+}
+export {};

package/lib/ble/fm.js

@@ -0,0 +1,248 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const 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 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)
+};
+class BleFitnessMachineDevice extends ble_device_1.BleDevice {
+    constructor(props) {
+        super(props);
+        this.data = {};
+    }
+    getProfile() {
+        return 'Smart Trainer';
+    }
+    getServiceUUids() {
+        return BleFitnessMachineDevice.services;
+    }
+    parseIndoorBikeData(_data) {
+        const data = Buffer.from(_data);
+        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);
+            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);
+            offset += 2;
+        }
+        if (flags & IndoorBikeDataFlag.TotalDistancePresent) {
+            this.data.totalDistance = data.readUInt16LE(offset);
+            offset += 2;
+        }
+        if (flags & IndoorBikeDataFlag.ResistanceLevelPresent) {
+            this.data.resistanceLevel = data.readUInt16LE(offset);
+            offset += 2;
+        }
+        if (flags & IndoorBikeDataFlag.InstantaneousPowerPresent) {
+            this.data.instantaneousPower = data.readUInt16LE(offset);
+            offset += 2;
+        }
+        if (flags & IndoorBikeDataFlag.AveragePowerPresent) {
+            this.data.averagePower = data.readUInt16LE(offset);
+            offset += 2;
+        }
+        if (flags & IndoorBikeDataFlag.ExpendedEnergyPresent) {
+            this.data.expendedEnergy = data.readUInt16LE(offset);
+            offset += 2;
+        }
+        if (flags & IndoorBikeDataFlag.HeartRatePresent) {
+            this.data.heartrate = data.readUInt16LE(offset);
+            offset += 2;
+        }
+        if (flags & IndoorBikeDataFlag.MetabolicEquivalentPresent) {
+            this.data.metabolicEquivalent = data.readUInt16LE(offset);
+            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;
+        }
+        return Object.assign(Object.assign({}, this.data), { raw: data.toString('hex') });
+    }
+    onData(characteristic, data) {
+        console.log(characteristic.toLocaleLowerCase(), data);
+        if (characteristic.toLocaleLowerCase() === '2ad2') {
+            const res = this.parseIndoorBikeData(data);
+            this.emit('data', res);
+        }
+    }
+    write(characteristic, data) {
+        console.log('write', characteristic, data);
+        return Promise.resolve(true);
+    }
+    read(characteristic) {
+        console.log('read', characteristic);
+        return Promise.resolve(Buffer.from([]));
+    }
+    reset() {
+        this.data = {};
+    }
+}
+exports.default = BleFitnessMachineDevice;
+BleFitnessMachineDevice.services = ['1826'];
+BleFitnessMachineDevice.characteristics = ['2acc', '2ad2', '2ad6', '2ad8', '2ad9', '2ada'];
+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.mode = this.getDefaultCyclingMode();
+        this.logger = new gd_eventlog_1.EventLogger('BLE-FM');
+    }
+    isBike() { return true; }
+    isHrm() { return false; }
+    isPower() { return true; }
+    getProfile() {
+        return 'Power Meter';
+    }
+    getName() {
+        return `${this.device.name}`;
+    }
+    getDisplayName() {
+        return this.getName();
+    }
+    getCyclingMode() {
+        if (!this.mode)
+            this.mode = this.getDefaultCyclingMode();
+        return this.mode;
+    }
+    getDefaultCyclingMode() {
+        return new power_meter_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: 'start requested', profile: this.getProfile(), props });
+            try {
+                const bleDevice = yield this.ble.connectDevice(this.device);
+                if (bleDevice) {
+                    this.device = bleDevice;
+                    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();
+        });
+    }
+    pause() { this.paused = true; return Promise.resolve(true); }
+    resume() { this.paused = false; return Promise.resolve(true); }
+}
+exports.FmAdapter = FmAdapter;

package/lib/ble/incyclist-protocol.js

@@ -24,9 +24,10 @@ const DeviceProtocol_1 = __importStar(require("../DeviceProtocol"));
 const DeviceRegistry_1 = __importDefault(require("../DeviceRegistry"));
 const ble_1 = require("./ble");
 const ble_interface_1 = __importDefault(require("./ble-interface"));
+const fm_1 = __importStar(require("./fm"));
 const hrm_1 = __importStar(require("./hrm"));
 const pwr_1 = __importStar(require("./pwr"));
-const supportedDeviceTypes = [hrm_1.default, pwr_1.default];
+const supportedDeviceTypes = [hrm_1.default, pwr_1.default, fm_1.default];
 class BleProtocol extends DeviceProtocol_1.default {
     constructor(binding) {
         super();
@@ -58,6 +59,10 @@ class BleProtocol extends DeviceProtocol_1.default {
             case 'hr':
             case 'heartrate monitor':
                 return new hrm_1.HrmAdapter(fromDevice ? bleDevice : new hrm_1.default(props()), this);
+            case 'fm':
+            case 'smart trainer':
+            case 'fitness machine':
+                return new fm_1.FmAdapter(fromDevice ? bleDevice : new fm_1.default(props()), this);
             case 'cp':
             case 'power meter':
                 return new pwr_1.PwrAdapter(fromDevice ? bleDevice : new pwr_1.default(props()), this);

package/package.json

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