incyclist-devices 1.4.45 → 1.4.48

package/lib/Device.d.ts

@@ -28,6 +28,7 @@ export interface DeviceAdapter extends Device {
     isBike(): boolean;
     isPower(): boolean;
     isHrm(): boolean;
+    isSame(device: DeviceAdapter): boolean;
     getID(): string;
     getDisplayName(): string;
     getName(): string;
@@ -58,6 +59,7 @@ export default class IncyclistDevice implements DeviceAdapter {
     isBike(): boolean;
     isPower(): boolean;
     isHrm(): boolean;
+    isSame(device: DeviceAdapter): boolean;
     getID(): string;
     getDisplayName(): string;
     getName(): string;

package/lib/Device.js

@@ -13,6 +13,7 @@ class IncyclistDevice {
     isBike() { throw new Error('not implemented'); }
     isPower() { throw new Error('not implemented'); }
     isHrm() { throw new Error('not implemented'); }
+    isSame(device) { throw new Error('not implemented'); }
     getID() { throw new Error('not implemented'); }
     getDisplayName() { return this.getName(); }
     getName() { throw new Error('not implemented'); }

package/lib/ant/AntAdapter.d.ts

@@ -18,6 +18,7 @@ export default class AntAdapter extends DeviceAdapter {
     lastUpdate?: number;
     updateFrequency: number;
     constructor(protocol: any);
+    isSame(device: DeviceAdapter): boolean;
     setSensor(sensor: any): void;
     getID(): string;
     setIgnoreHrm(ignore: any): void;

package/lib/ant/AntAdapter.js

@@ -22,6 +22,12 @@ class AntAdapter extends Device_1.default {
         this.data = {};
         this.updateFrequency = exports.DEFAULT_UPDATE_FREQUENCY;
     }
+    isSame(device) {
+        if (!(device instanceof AntAdapter))
+            return false;
+        const adapter = device;
+        return (adapter.getName() === this.getName() && adapter.getProfile() === this.getProfile());
+    }
     setSensor(sensor) {
         this.sensor = sensor;
     }

package/lib/ble/ble-device.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 import { EventLogger } from "gd-eventlog";
 import { BleInterfaceClass, BleDeviceClass, BlePeripheral, BleDeviceProps, ConnectProps, BleDeviceInfo } from "./ble";
+import BlePeripheralConnector from "./ble-peripheral";
 interface BleDeviceConstructProps extends BleDeviceProps {
     log?: boolean;
     logger?: EventLogger;
@@ -16,23 +17,24 @@ export declare abstract class BleDevice extends BleDeviceClass {
     state?: string;
     logger?: EventLogger;
     deviceInfo: BleDeviceInfo;
-    isSubscribed: boolean;
+    isInitialized: boolean;
+    subscribedCharacteristics: string[];
     constructor(props?: BleDeviceConstructProps);
     logEvent(event: any): void;
     setInterface(ble: BleInterfaceClass): void;
-    private cleanupListeners;
-    private onDisconnect;
+    cleanupListeners(): void;
+    onDisconnect(): void;
     waitForConnectFinished(timeout: any): Promise<unknown>;
     hasService(serviceUuid: any): boolean;
     init(): Promise<boolean>;
+    connectPeripheral(peripheral: BlePeripheral): Promise<void>;
+    subscribeAll(conn?: BlePeripheralConnector): Promise<void>;
     connect(props?: ConnectProps): Promise<boolean>;
     disconnect(): Promise<boolean>;
     abstract getProfile(): string;
     abstract onData(characteristic: string, data: Buffer): void;
-    subscribeAll(device?: this): Promise<void>;
-    subscribe(characteristicUuid: string): Promise<boolean>;
-    write(characteristicUuid: string, data: Buffer, withoutResponse: boolean): Promise<boolean>;
-    read(characteristicUuid: string): Promise<Buffer>;
+    write(characteristicUuid: string, data: Buffer, withoutResponse?: boolean): Promise<boolean>;
+    read(characteristicUuid: string): Promise<Uint8Array>;
     getDeviceInfo(): Promise<BleDeviceInfo>;
 }
 export {};

package/lib/ble/ble-device.js

@@ -24,7 +24,8 @@ class BleDevice extends ble_1.BleDeviceClass {
         this.services = props.services;
         this.ble = props.ble;
         this.characteristics = [];
-        this.isSubscribed = false;
+        this.subscribedCharacteristics = [];
+        this.isInitialized = false;
         if (props.peripheral) {
             const { id, address, advertisement, state } = props.peripheral;
             this.peripheral = props.peripheral;
@@ -57,14 +58,14 @@ class BleDevice extends ble_1.BleDeviceClass {
             this.characteristics = [];
         }
         else {
+            const connector = this.ble.getConnector(this.peripheral);
             this.characteristics.forEach(c => {
-                c.unsubscribe();
-                c.removeAllListeners('data');
+                connector.removeAllListeners((0, ble_1.uuid)(c.uuid));
             });
-            this.isSubscribed = false;
         }
     }
     onDisconnect() {
+        this.logEvent({ message: 'device disconnected', address: this.address, profile: this.getProfile() });
         this.state = "disconnected";
         if (!this.connectState.isDisconnecting) {
             this.peripheral.state = 'disconnected';
@@ -98,82 +99,78 @@ class BleDevice extends ble_1.BleDeviceClass {
         return this.services && this.services.find(s => s === serviceUuid || (0, ble_1.uuid)(serviceUuid)) !== undefined;
     }
     init() {
-        return this.getDeviceInfo().then(() => true);
+        if (this.isInitialized)
+            return Promise.resolve(true);
+        return this.getDeviceInfo().then(() => {
+            this.emit('deviceInfo', this.deviceInfo);
+            this.isInitialized = true;
+            return true;
+        });
+    }
+    connectPeripheral(peripheral) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.connectState.isConnecting = true;
+            try {
+                const connector = this.ble.getConnector(peripheral);
+                yield connector.connect();
+                yield connector.initialize();
+                yield this.subscribeAll(connector);
+                this.connectState.isConnected = true;
+                this.state = "connected";
+                this.emit('connected');
+                yield this.init();
+            }
+            catch (err) {
+                this.logEvent({ message: 'Error', fn: 'connectPeripheral()', error: err.message, stack: err.stack });
+            }
+            this.connectState.isConnecting = false;
+        });
+    }
+    subscribeAll(conn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const connector = conn || this.ble.getConnector(this.peripheral);
+                const subscribed = yield connector.subscribeAll((uuid, data) => { this.onData(uuid, data); });
+                subscribed.forEach(c => this.subscribedCharacteristics.push(c));
+            }
+            catch (err) {
+                this.logEvent({ message: 'Error', fn: 'subscribeAll()', error: err.message, stack: err.stack });
+            }
+        });
     }
     connect(props) {
         return __awaiter(this, void 0, void 0, function* () {
-            const connectPeripheral = (peripheral) => __awaiter(this, void 0, void 0, function* () {
-                this.connectState.isConnecting = true;
-                const connected = this.ble.findConnected(peripheral);
-                if (peripheral.state !== 'connected') {
-                    this.isSubscribed = false;
-                    try {
-                        yield peripheral.connectAsync();
-                    }
-                    catch (err) {
-                        this.logEvent({ message: 'cannot connect', error: err.message || err });
-                    }
-                }
-                try {
-                    if (!this.characteristics)
-                        this.characteristics = [];
-                    if (!connected) {
-                        if (!this.characteristics || this.characteristics.length === 0) {
-                            this.logEvent({ message: 'connect: discover characteristics start' });
-                            const res = yield peripheral.discoverSomeServicesAndCharacteristicsAsync([], []);
-                            const { characteristics } = res;
-                            this.logEvent({ message: 'connect: discover characteristics result',
-                                result: characteristics.map(c => ({ uuid: (0, ble_1.uuid)(c.uuid), properties: c.properties.join(','), service: (0, ble_1.uuid)(c._serviceUuid) }))
-                            });
-                            this.characteristics = characteristics;
-                        }
-                        else {
-                        }
-                    }
-                    else {
-                        this.characteristics = connected.characteristics;
-                    }
-                    let device;
-                    if (!connected) {
-                        this.ble.addConnectedDevice(this);
-                        device = this;
-                    }
-                    else {
-                        device = connected;
-                    }
-                    this.peripheral.once('disconnect', () => { this.onDisconnect(); });
-                    yield this.subscribeAll(device);
-                    this.connectState.isConnecting = false;
-                    this.connectState.isConnected = true;
-                    this.state = "connected";
-                    this.emit('connected');
-                    this.init().then((isInitialized) => {
-                        if (isInitialized)
-                            this.emit('deviceInfo', this.deviceInfo);
-                    });
-                }
-                catch (err) {
-                    this.logEvent({ message: 'cannot connect', error: err.message || err });
-                    this.connectState.isConnecting = false;
-                    this.connectState.isConnected = false;
-                }
-            });
             try {
+                this.logEvent({ message: 'connect', address: this.peripheral ? this.peripheral.address : this.address, state: this.connectState });
                 if (this.connectState.isConnecting) {
                     yield this.waitForConnectFinished(CONNECT_WAIT_TIMEOUT);
                 }
                 if (this.connectState.isConnected) {
-                    if (!this.isSubscribed) {
+                    try {
                         yield this.subscribeAll();
+                        yield this.init();
+                    }
+                    catch (err) {
+                        this.logEvent({ message: 'cannot reconnect', error: err.message || err });
+                        return false;
                     }
                     return true;
                 }
                 this.connectState.isConnecting = true;
+                if (!this.peripheral) {
+                    const { id, name, address } = this;
+                    try {
+                        this.peripheral = this.ble.findPeripheral({ id, name, address });
+                    }
+                    catch (err) {
+                        console.log('~~~ error', err);
+                    }
+                }
                 if (this.peripheral) {
                     const { id, address, advertisement } = this.peripheral;
                     const name = advertisement === null || advertisement === void 0 ? void 0 : advertisement.localName;
                     this.logEvent({ message: 'connect requested', mode: 'peripheral', device: { id, name, address: address } });
-                    yield connectPeripheral(this.peripheral);
+                    yield this.connectPeripheral(this.peripheral);
                     this.logEvent({ message: 'connect result: success', mode: 'peripheral', device: { id, name, address } });
                     return true;
                 }
@@ -189,7 +186,7 @@ class BleDevice extends ble_1.BleDeviceClass {
                             const devices = yield this.ble.scan({ requested: this });
                             if (devices && devices.length > 0) {
                                 this.peripheral = devices[0].peripheral;
-                                yield connectPeripheral(this.peripheral);
+                                yield this.connectPeripheral(this.peripheral);
                                 this.logEvent({ message: 'connect result: success', mode: 'device', device: { id, name, address } });
                                 return true;
                             }
@@ -238,64 +235,28 @@ class BleDevice extends ble_1.BleDeviceClass {
             }
         });
     }
-    subscribeAll(device = this) {
+    write(characteristicUuid, data, withoutResponse = false) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.isSubscribed)
-                return;
-            const cnt = this.characteristics.length;
-            for (let i = 0; i < cnt; i++) {
-                try {
-                    const c = this.characteristics[i];
-                    const isNotify = c.properties.find(p => p === 'notify');
-                    if (isNotify) {
-                        c.on('data', (data, _isNotification) => {
-                            this.onData((0, ble_1.uuid)(c.uuid), data);
-                        });
-                        if (!device.isSubscribed) {
-                            this.logEvent({ message: 'subscribe', device: this.name, address: this.address, service: c._serviceUuid, characteristic: c.uuid });
-                            try {
-                                yield this.subscribe(c.uuid);
-                            }
-                            catch (err) {
-                                this.logEvent({ message: 'cannot subscribe', device: this.name, address: this.address, service: c._serviceUuid, characteristic: c.uuid, error: err.message || err });
-                            }
-                        }
-                    }
-                }
-                catch (err) {
-                    console.log('~~~ error', err);
-                }
-            }
-            this.isSubscribed = true;
-        });
-    }
-    subscribe(characteristicUuid) {
-        return new Promise((resolve, reject) => {
-            const characteristic = this.characteristics.find(c => c.uuid === characteristicUuid || (0, ble_1.uuid)(c.uuid) === characteristicUuid);
-            if (!characteristic) {
-                reject(new Error('Characteristic not found'));
-                return;
+            if (this.subscribedCharacteristics.find(c => c === characteristicUuid) === undefined) {
+                const connector = this.ble.getConnector(this.peripheral);
+                connector.on(characteristicUuid, (uuid, data) => {
+                    this.onData(uuid, data);
+                });
+                yield connector.subscribe(characteristicUuid);
+                this.subscribedCharacteristics.push(characteristicUuid);
             }
-            characteristic.subscribe((err) => {
-                if (err)
-                    reject(err);
-                else
-                    resolve(true);
-            });
-        });
-    }
-    write(characteristicUuid, data, withoutResponse) {
-        return new Promise((resolve, reject) => {
-            const characteristic = this.characteristics.find(c => c.uuid === characteristicUuid || (0, ble_1.uuid)(c.uuid) === characteristicUuid);
-            if (!characteristic) {
-                reject(new Error('Characteristic not found'));
-                return;
-            }
-            characteristic.write(data, withoutResponse, (err) => {
-                if (err)
-                    reject(err);
-                else
-                    resolve(true);
+            return new Promise((resolve, reject) => {
+                const characteristic = this.characteristics.find(c => c.uuid === characteristicUuid || (0, ble_1.uuid)(c.uuid) === characteristicUuid);
+                if (!characteristic) {
+                    reject(new Error('Characteristic not found'));
+                    return;
+                }
+                characteristic.write(data, withoutResponse, (err) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve(true);
+                });
             });
         });
     }
@@ -322,7 +283,8 @@ class BleDevice extends ble_1.BleDeviceClass {
             const readValue = (c) => __awaiter(this, void 0, void 0, function* () {
                 try {
                     const b = yield this.read(c);
-                    return b ? b.toString() : undefined;
+                    const buffer = b ? Buffer.from(b) : undefined;
+                    return buffer ? buffer.toString() : undefined;
                 }
                 catch (_a) {
                     return undefined;

package/lib/ble/ble-erg-mode.d.ts

@@ -0,0 +1,24 @@
+import CyclingMode, { CyclingModeProperty, IncyclistBikeData, UpdateRequest } from "../CyclingMode";
+import PowerBasedCyclingModeBase from "../modes/power-base";
+import { FmAdapter } from "./fm";
+export declare type ERGEvent = {
+    rpmUpdated?: boolean;
+    gearUpdated?: boolean;
+    starting?: boolean;
+    tsStart?: number;
+};
+export default class ERGCyclingMode extends PowerBasedCyclingModeBase implements CyclingMode {
+    prevRequest: UpdateRequest;
+    hasBikeUpdate: boolean;
+    chain: number[];
+    cassette: number[];
+    event: ERGEvent;
+    constructor(adapter: FmAdapter, props?: any);
+    getName(): string;
+    getDescription(): string;
+    getProperties(): CyclingModeProperty[];
+    getProperty(name: string): CyclingModeProperty;
+    getBikeInitRequest(): UpdateRequest;
+    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
+    updateData(bikeData: IncyclistBikeData): any;
+}

package/lib/ble/ble-erg-mode.js

@@ -0,0 +1,148 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const CyclingMode_1 = require("../CyclingMode");
+const power_base_1 = __importDefault(require("../modes/power-base"));
+const config = {
+    name: "ERG",
+    description: "Calculates speed based on power and slope. Power targets are set by workout or remain stable throughout the workout",
+    properties: [
+        { key: 'bikeType', name: 'Bike Type', description: '', type: CyclingMode_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain', 'Triathlon'], default: 'Race' },
+        { key: 'startPower', name: 'Starting Power', description: 'Initial power in Watts at start of training', type: CyclingMode_1.CyclingModeProperyType.Integer, default: 50, min: 25, max: 800 },
+    ]
+};
+class ERGCyclingMode extends power_base_1.default {
+    constructor(adapter, props) {
+        super(adapter, props);
+        this.hasBikeUpdate = false;
+        this.event = {};
+        this.initLogger('ERGMode');
+    }
+    getName() {
+        return config.name;
+    }
+    getDescription() {
+        return config.description;
+    }
+    getProperties() {
+        return config.properties;
+    }
+    getProperty(name) {
+        return config.properties.find(p => p.name === name);
+    }
+    getBikeInitRequest() {
+        const startPower = this.getSetting('startPower');
+        return { targetPower: startPower };
+    }
+    sendBikeUpdate(request) {
+        const getData = () => {
+            if (!this.data)
+                return {};
+            const { pedalRpm, slope, power, speed } = this.data;
+            return { pedalRpm, slope, power, speed };
+        };
+        this.logger.logEvent({ message: "processing update request", request, prev: this.prevRequest, data: getData(), event: this.event });
+        let newRequest = {};
+        try {
+            if (!request || request.reset || Object.keys(request).length === 0) {
+                this.prevRequest = {};
+                return request || {};
+            }
+            const prevData = this.data || {};
+            if (request.targetPower !== undefined) {
+                delete request.slope;
+                delete request.refresh;
+            }
+            if (this.event.starting && request.targetPower === undefined) {
+                newRequest.targetPower = this.getSetting('startPower');
+                if (this.event.tsStart && Date.now() - this.event.tsStart > 5000) {
+                    delete this.event.starting;
+                    delete this.event.tsStart;
+                }
+            }
+            if (request.refresh) {
+                delete request.refresh;
+                newRequest.targetPower = this.prevRequest.targetPower;
+            }
+            if (request.slope !== undefined) {
+                if (!this.data)
+                    this.data = {};
+                this.data.slope = request.slope;
+            }
+            if (request.maxPower !== undefined && request.minPower !== undefined && request.maxPower === request.minPower) {
+                request.targetPower = request.maxPower;
+            }
+            if (request.targetPower !== undefined) {
+                newRequest.targetPower = request.targetPower;
+            }
+            delete request.slope;
+            if (request.maxPower !== undefined) {
+                if (newRequest.targetPower !== undefined && newRequest.targetPower > request.maxPower) {
+                    newRequest.targetPower = request.maxPower;
+                }
+                newRequest.maxPower = request.maxPower;
+            }
+            if (request.minPower !== undefined) {
+                if (newRequest.targetPower !== undefined && newRequest.targetPower < request.minPower) {
+                    newRequest.targetPower = request.minPower;
+                }
+                newRequest.minPower = request.minPower;
+            }
+            if (newRequest.targetPower !== undefined && prevData.power !== undefined && newRequest.targetPower === prevData.power) {
+                delete newRequest.targetPower;
+            }
+            this.prevRequest = JSON.parse(JSON.stringify(request));
+        }
+        catch (err) {
+            this.logger.logEvent({ message: "error", fn: 'sendBikeUpdate()', error: err.message || err, stack: err.stack });
+        }
+        return newRequest;
+    }
+    updateData(bikeData) {
+        const prevData = JSON.parse(JSON.stringify(this.data || {}));
+        const prevSpeed = prevData.speed;
+        const prevRequest = this.prevRequest || {};
+        const data = this.data || {};
+        const bikeType = this.getSetting('bikeType').toLowerCase();
+        delete this.event.rpmUpdated;
+        if (prevData === {} || prevData.speed === undefined || prevData.speed === 0) {
+            this.event.starting = true;
+            this.event.tsStart = Date.now();
+        }
+        try {
+            const rpm = bikeData.pedalRpm || 0;
+            let power = bikeData.power || 0;
+            const slope = (prevData.slope !== undefined ? prevData.slope : prevRequest.slope || 0);
+            const distanceInternal = prevData.distanceInternal || 0;
+            if (!bikeData.pedalRpm || bikeData.isPedalling === false) {
+                power = 0;
+            }
+            const m = this.getWeight();
+            const t = this.getTimeSinceLastUpdate();
+            const { speed, distance } = this.calculateSpeedAndDistance(power, slope, m, t, { bikeType });
+            data.speed = parseFloat(speed.toFixed(1));
+            data.power = Math.round(power);
+            data.distanceInternal = Math.round(distanceInternal + distance);
+            data.slope = slope;
+            data.pedalRpm = rpm;
+            if (data.time !== undefined && !(this.event.starting && !bikeData.pedalRpm))
+                data.time += t;
+            else
+                data.time = 0;
+            data.heartrate = bikeData.heartrate;
+            data.isPedalling = bikeData.isPedalling;
+            if (rpm && rpm !== prevData.pedalRpm) {
+                this.event.rpmUpdated = true;
+            }
+        }
+        catch (err) {
+            this.logger.logEvent({ message: 'error', fn: 'updateData()', error: err.message || err });
+        }
+        this.logger.logEvent({ message: "updateData result", data, bikeData, prevRequest, prevSpeed });
+        this.data = data;
+        return data;
+    }
+}
+exports.default = ERGCyclingMode;

package/lib/ble/ble-interface.d.ts

@@ -65,6 +65,12 @@ export default class BleInterface extends BleInterfaceClass {
     getServicesFromDevice(device: BleDeviceClass): string[];
     waitForConnectFinished(timeout: any): Promise<unknown>;
     addPeripheralToCache(peripheral: any, props?: {}): void;
+    getConnector(peripheral: BlePeripheral): any;
+    findPeripheral(peripheral: BlePeripheral | {
+        id?: string;
+        address?: string;
+        name?: string;
+    }): BlePeripheral;
     getCharacteristics(peripheral: any): Promise<any>;
     getDeviceClasses(peripheral: any, props?: {
         deviceTypes?: (typeof BleDeviceClass)[];
@@ -77,6 +83,13 @@ export default class BleInterface extends BleInterfaceClass {
     stopScan(): Promise<boolean>;
     isScanning(): boolean;
     addConnectedDevice(device: BleDeviceClass): void;
+    addDeviceToCache(device: BleDeviceClass, isConnected: boolean): void;
     findConnected(device: BleDeviceClass | BlePeripheral): BleDeviceClass;
+    findDeviceInCache(device: {
+        id?: string;
+        address?: string;
+        name?: string;
+        profile: string;
+    }): BleDeviceClass;
     removeConnectedDevice(device: BleDeviceClass): void;
 }