incyclist-devices 2.1.0 → 2.1.1

package/lib/antv2/hr copy/adapter.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const adapter_1 = __importDefault(require("../base/adapter"));
+const types_1 = require("../../types");
+class AntHrAdapter extends adapter_1.default {
+    constructor(settings, props) {
+        super(settings, props);
+        this.capabilities = [types_1.IncyclistCapability.HeartRate];
+    }
+    getDisplayName() {
+        const { ComputedHeartRate } = this.deviceData;
+        const hrmStr = ComputedHeartRate ? ` (${ComputedHeartRate})` : '';
+        return `${this.getUniqueName()}${hrmStr}`;
+    }
+    mapToAdapterData(deviceData) {
+        if (deviceData.ComputedHeartRate) {
+            this.data.heartrate = deviceData.ComputedHeartRate;
+            this.data.timestamp = Date.now();
+        }
+    }
+    hasData() {
+        return this.deviceData.ComputedHeartRate !== undefined && this.deviceData.ComputedHeartRate !== null;
+    }
+}
+AntHrAdapter.INCYCLIST_PROFILE_NAME = 'Heartrate Monitor';
+AntHrAdapter.ANT_PROFILE_NAME = 'HR';
+exports.default = AntHrAdapter;

package/lib/antv2/hr copy/index.d.ts

@@ -0,0 +1,2 @@
+import AntHrAdapter from './adapter';
+export default AntHrAdapter;

package/lib/antv2/hr copy/index.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const adapter_1 = __importDefault(require("./adapter"));
+exports.default = adapter_1.default;

package/lib/antv2/index.d.ts

@@ -1,7 +1,8 @@
 import AntPwrAdapter from "./pwr";
 import AntFEAdapter from "./fe";
 import AntHrAdapter from "./hr";
-import AntAdapterFactory from "./adapter-factory";
-import AntInterface, { AntInterfaceProps } from "./ant-interface";
-import { AntDeviceSettings, AntScanProps } from "./types";
-export { AntAdapterFactory, AntFEAdapter, AntHrAdapter, AntPwrAdapter, AntDeviceSettings, AntScanProps, AntInterface, AntInterfaceProps };
+import AntAdapterFactory from "./factories/adapter-factory";
+import AntInterface from "./base/ant-interface";
+import { AntInterfaceProps } from "./types";
+export { AntDeviceSettings, AntDeviceProperties, AntScanProps } from "./types";
+export { AntAdapterFactory, AntFEAdapter, AntHrAdapter, AntPwrAdapter, AntInterface, AntInterfaceProps };

package/lib/antv2/index.js

@@ -10,11 +10,13 @@ const fe_1 = __importDefault(require("./fe"));
 exports.AntFEAdapter = fe_1.default;
 const hr_1 = __importDefault(require("./hr"));
 exports.AntHrAdapter = hr_1.default;
-const adapter_factory_1 = __importDefault(require("./adapter-factory"));
+const cad_1 = __importDefault(require("./cad"));
+const adapter_factory_1 = __importDefault(require("./factories/adapter-factory"));
 exports.AntAdapterFactory = adapter_factory_1.default;
-const ant_interface_1 = __importDefault(require("./ant-interface"));
+const ant_interface_1 = __importDefault(require("./base/ant-interface"));
 exports.AntInterface = ant_interface_1.default;
 const af = adapter_factory_1.default.getInstance();
 af.register('PWR', 'Power Meter', pwr_1.default);
 af.register('HR', 'Heartrate Monitor', hr_1.default);
 af.register('FE', 'Smart Trainer', fe_1.default);
+af.register('CAD', 'Cadence Sensor', cad_1.default);

package/lib/antv2/pwr/adapter.d.ts

@@ -1,37 +1,13 @@
-import { BicyclePowerSensorState, ISensor, Profile } from "incyclist-ant-plus";
-import AntAdapter from "../adapter";
-import ICyclingMode, { CyclingMode, IncyclistBikeData } from '../../modes/types';
+import { BicyclePowerSensorState, Profile } from "incyclist-ant-plus";
+import AntAdapter from "../base/adapter";
 import { AntDeviceProperties, AntDeviceSettings, LegacyProfile } from "../types";
-import { ControllableDevice } from "../../base/adpater";
-type PowerSensorData = {
-    speed: number;
-    slope: number;
-    power: number;
-    cadence: number;
-    distance: number;
-    timestamp: number;
-};
-export declare class AntPwrControl extends ControllableDevice<AntDeviceProperties> {
-    getSupportedCyclingModes(): Array<typeof CyclingMode>;
-    getDefaultCyclingMode(): ICyclingMode;
-    sendInitCommands(): Promise<boolean>;
-}
-export default class AntPwrAdapter extends AntAdapter<AntPwrControl, BicyclePowerSensorState, PowerSensorData> {
-    static INCYCLIST_PROFILE_NAME: LegacyProfile;
-    static ANT_PROFILE_NAME: Profile;
-    protected distanceInternal?: number;
+import { ControllerConfig, IncyclistBikeData } from "../../types";
+export default class AntPwrAdapter extends AntAdapter<BicyclePowerSensorState> {
+    protected static INCYCLIST_PROFILE_NAME: LegacyProfile;
+    protected static ANT_PROFILE_NAME: Profile;
+    protected static controllers: ControllerConfig;
     constructor(settings: AntDeviceSettings, props?: AntDeviceProperties);
-    createSensor(settings: AntDeviceSettings): ISensor;
-    getName(): string;
-    getUniqueName(): string;
-    getDisplayName(): string;
-    getLogData(data: any, excludeList: any): any;
-    onDeviceData(deviceData: any): void;
-    canSendUpdate(): boolean;
-    sendUpdate(request: any): void;
-    mapData(deviceData: any): IncyclistBikeData;
-    transformData(bikeData: IncyclistBikeData): PowerSensorData;
+    mapData(deviceData: BicyclePowerSensorState): IncyclistBikeData;
+    transformData(bikeData: IncyclistBikeData): void;
     hasData(): boolean;
-    start(props?: any): Promise<any>;
 }
-export {};

package/lib/antv2/pwr/adapter.js

@@ -1,177 +1,56 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AntPwrControl = void 0;
-const adapter_1 = __importDefault(require("../adapter"));
-const utils_1 = require("../utils");
-const gd_eventlog_1 = require("gd-eventlog");
+const adapter_1 = __importDefault(require("../base/adapter"));
 const power_meter_1 = __importDefault(require("../../modes/power-meter"));
-const sensor_factory_1 = __importDefault(require("../sensor-factory"));
-const capabilities_1 = require("../../types/capabilities");
-const adpater_1 = require("../../base/adpater");
-class AntPwrControl extends adpater_1.ControllableDevice {
-    getSupportedCyclingModes() {
-        return [power_meter_1.default];
-    }
-    getDefaultCyclingMode() {
-        return new power_meter_1.default(this.adapter);
-    }
-    sendInitCommands() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return false;
-        });
-    }
-}
-exports.AntPwrControl = AntPwrControl;
+const types_1 = require("../../types");
 class AntPwrAdapter extends adapter_1.default {
     constructor(settings, props) {
-        if (settings.protocol && settings.profile !== AntPwrAdapter.INCYCLIST_PROFILE_NAME)
-            throw new Error('Incorrect Profile');
-        if (!settings.protocol && settings.profile !== AntPwrAdapter.ANT_PROFILE_NAME)
-            throw new Error('Incorrect Profile');
         super(settings, props);
-        this.setControl(new AntPwrControl(this, props));
-        this.deviceData = {
-            DeviceID: this.sensor.getDeviceID()
-        };
-        this.logger = new gd_eventlog_1.EventLogger('Ant+PWR');
         this.capabilities = [
-            capabilities_1.IncyclistCapability.Power, capabilities_1.IncyclistCapability.Cadence, capabilities_1.IncyclistCapability.Speed
+            types_1.IncyclistCapability.Power, types_1.IncyclistCapability.Cadence, types_1.IncyclistCapability.Speed
         ];
     }
-    createSensor(settings) {
-        return sensor_factory_1.default.create(AntPwrAdapter.ANT_PROFILE_NAME, Number(settings.deviceID));
-    }
-    getName() {
-        if (this.settings.name)
-            return this.settings.name;
-        const deviceID = this.sensor.getDeviceID();
-        return `Ant+PWR ${deviceID}`;
-    }
-    getUniqueName() {
-        if (this.settings.name)
-            return this.settings.name;
-        const { DeviceID, ManId } = this.deviceData;
-        const brand = (0, utils_1.getBrand)(ManId);
-        if (brand)
-            return `${brand} PWR ${DeviceID}`;
-        else
-            return `${this.getName()}`;
-    }
-    getDisplayName() {
-        const { Power } = this.deviceData;
-        const pwrStr = Power ? ` (${Power})` : '';
-        return `${this.getUniqueName()}${pwrStr}`;
-    }
-    getLogData(data, excludeList) {
-        const logData = JSON.parse(JSON.stringify(data));
-        excludeList.forEach((key) => {
-            delete logData[key];
-        });
-        return logData;
-    }
-    onDeviceData(deviceData) {
-        this.dataMsgCount++;
-        this.lastDataTS = Date.now();
-        super.onDeviceData(deviceData);
-        if (!this.started)
-            return;
-        if (!this.ivDataTimeout)
-            this.startDataTimeoutCheck();
-        try {
-            if (!this.canSendUpdate())
-                return;
-            const logData = this.getLogData(deviceData, ['PairedDevices', 'RawData']);
-            this.logger.logEvent({ message: 'onDeviceData', data: logData });
-            let incyclistData = this.mapData(deviceData);
-            incyclistData = this.getCyclingMode().updateData(incyclistData);
-            const data = this.transformData(incyclistData);
-            this.emitData(data);
-        }
-        catch (err) {
-        }
-    }
-    canSendUpdate() {
-        if (!this.hasDataListeners() || this.paused)
-            return false;
-        return super.canSendUpdate();
-    }
-    sendUpdate(request) {
-        if (this.isPaused())
-            return;
-        this.getCyclingMode().sendBikeUpdate(request);
-    }
     mapData(deviceData) {
         const data = {
             isPedalling: false,
             power: 0,
             pedalRpm: 0,
-            speed: 0,
-            heartrate: 0,
-            distanceInternal: 0,
-            slope: undefined,
-            time: undefined
+            speed: 0
         };
-        data.slope = (deviceData.Slope !== undefined ? deviceData.Slope : data.slope);
         data.power = (deviceData.Power !== undefined ? deviceData.Power : data.power);
         data.pedalRpm = (deviceData.Cadence !== undefined ? deviceData.Cadence : data.pedalRpm);
         data.time = (deviceData.TimeStamp !== undefined ? deviceData.TimeStamp : data.time);
-        data.isPedalling = data.pedalRpm > 0;
+        if (deviceData.CalculatedPower !== undefined && deviceData.Power === undefined)
+            data.power = deviceData.CalculatedPower;
+        if (deviceData.CalculatedCadence !== undefined && deviceData.Cadence === undefined)
+            data.pedalRpm = deviceData.CalculatedCadence;
+        data.isPedalling = data.pedalRpm > 0 || data.power > 0;
         return data;
     }
     transformData(bikeData) {
-        if (bikeData === undefined)
-            return;
-        let distance = 0;
-        if (this.distanceInternal !== undefined && bikeData.distanceInternal !== undefined) {
-            distance = bikeData.distanceInternal - this.distanceInternal;
-        }
-        if (bikeData.distanceInternal !== undefined)
-            this.distanceInternal = bikeData.distanceInternal;
         const data = {
-            speed: bikeData.speed,
-            slope: bikeData.slope,
             power: bikeData.power,
             cadence: bikeData.pedalRpm,
-            distance,
             timestamp: Date.now()
         };
-        return data;
+        if (bikeData.time)
+            data.deviceTime = bikeData.time;
+        this.data = data;
     }
     hasData() {
-        const { Power, Cadence, TimeStamp } = this.deviceData;
-        const hasData = (Power !== undefined && Power !== null) || (Cadence !== undefined && Cadence !== null) || (TimeStamp !== undefined && TimeStamp !== null);
+        const { Power, CalculatedPower, CalculatedCadence, Cadence } = this.deviceData;
+        const has = v => (v !== undefined && v !== null);
+        const hasData = has(Power) || has(CalculatedPower) || has(Cadence) || has(CalculatedCadence);
         return hasData;
     }
-    start(props) {
-        const _super = Object.create(null, {
-            start: { get: () => super.start }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const wasPaused = this.paused;
-            const wasStopped = this.stopped;
-            if (wasPaused)
-                this.resume();
-            if (wasStopped)
-                this.stopped = false;
-            if (this.started && !wasPaused && !wasStopped) {
-                return true;
-            }
-            return yield _super.start.call(this, props);
-        });
-    }
 }
 AntPwrAdapter.INCYCLIST_PROFILE_NAME = 'Power Meter';
 AntPwrAdapter.ANT_PROFILE_NAME = 'PWR';
+AntPwrAdapter.controllers = {
+    modes: [power_meter_1.default],
+    default: power_meter_1.default
+};
 exports.default = AntPwrAdapter;

package/lib/antv2/types.d.ts

@@ -1,7 +1,6 @@
 import { Profile } from 'incyclist-ant-plus';
-import IncyclistDevice from '../base/adpater';
-import { DeviceProperties, DeviceSettings, IncyclistScanProps } from '../types/device';
-import { Controllable } from '../types/adapter';
+import { IAdapter, DeviceProperties, DeviceSettings, IncyclistScanProps, InterfaceProps } from '../types';
+import AntAdapter from './base/adapter';
 export interface AntDeviceSettings extends DeviceSettings {
     deviceID?: string;
     profile: Profile | LegacyProfile;
@@ -9,7 +8,7 @@ export interface AntDeviceSettings extends DeviceSettings {
 }
 export type LegacyProfile = 'Heartrate Monitor' | 'Power Meter' | 'Smart Trainer' | 'Speed Sensor' | 'Cadence Sensor' | 'Speed + Cadence Sensor';
 export declare const isLegacyProfile: (o: unknown) => boolean;
-export type DeviceFoundCallback = (device: IncyclistDevice<Controllable<DeviceProperties>, DeviceProperties>, protocol: string) => void;
+export type DeviceFoundCallback = (device: IAdapter, protocol: string) => void;
 export type ScanFinishedCallback = (id: number) => void;
 export interface AntScanProps extends IncyclistScanProps {
     profiles?: Profile[];
@@ -21,3 +20,23 @@ export interface AntDeviceProperties extends DeviceProperties {
     startupTimeout?: number;
     automaticReconnect?: boolean;
 }
+export type BaseDeviceData = {
+    DeviceID: number;
+    ManId?: number;
+};
+export type AntAdapterInfo = {
+    antProfile: Profile;
+    incyclistProfile: LegacyProfile;
+    Adapter: typeof AntAdapter<BaseDeviceData>;
+};
+export type AdapterQuery = {
+    antProfile?: Profile;
+    incyclistProfile?: LegacyProfile;
+};
+export interface AntInterfaceProps extends InterfaceProps {
+    startupTimeout?: number;
+}
+export interface ConnectState {
+    connected: boolean;
+    connecting: boolean;
+}

package/lib/base/adpater.d.ts

@@ -1,88 +1,67 @@
 /// <reference types="node" />
 import ICyclingMode, { CyclingMode } from "../modes/types";
-import { DeviceProperties, DeviceSettings } from "../types/device";
-import { Controllable, IncyclistDeviceAdapter, OnDeviceDataCallback } from '../types/adapter';
-import { User } from "../types/user";
-import { IncyclistCapability } from "../types/capabilities";
+import { DeviceProperties, DeviceSettings, ControllerConfig, IAdapter, OnDeviceDataCallback, IncyclistCapability, IncyclistAdapterData, User } from "../types";
 import { EventLogger } from "gd-eventlog";
-import { DeviceData } from "../types/data";
 import EventEmitter from "events";
-export declare const DEFAULT_BIKE_WEIGHT = 10;
-export declare const DEFAULT_USER_WEIGHT = 75;
-export declare const DEFAULT_PROPS: DeviceProperties;
-export default class IncyclistDevice<B extends Controllable<P>, P extends DeviceProperties> extends EventEmitter implements IncyclistDeviceAdapter {
+export default class IncyclistDevice<P extends DeviceProperties> extends EventEmitter implements IAdapter {
     onDataFn: OnDeviceDataCallback;
     settings: DeviceSettings;
     lastUpdate?: number;
     updateFrequency: number;
     capabilities: IncyclistCapability[];
-    protected logger: EventLogger;
     started: boolean;
     stopped: boolean;
     paused: boolean;
-    bikeControl: B;
-    props: DeviceProperties;
-    constructor(settings: DeviceSettings, props?: DeviceProperties);
-    setControl(control: B): void;
-    connect(): Promise<boolean>;
-    close(): Promise<boolean>;
-    check(): Promise<boolean>;
+    protected props: P;
+    protected cyclingMode: ICyclingMode;
+    protected logger: EventLogger;
+    protected static controllers: ControllerConfig;
+    protected user: User;
+    protected data: IncyclistAdapterData;
+    constructor(settings: DeviceSettings, props?: P);
     getLogger(): EventLogger;
-    isControllable(): boolean;
+    logEvent(event: any): void;
+    getName(): string;
+    getID(): string;
+    getUniqueName(): string;
+    getDisplayName(): string;
+    getSettings(): DeviceSettings;
+    isSame(adapter: IAdapter): boolean;
     isEqual(settings: DeviceSettings): boolean;
-    getCapabilities(): IncyclistCapability[];
-    hasCapability(capability: IncyclistCapability): boolean;
-    addCapability(capability: IncyclistCapability): void;
-    update(): void;
+    getInterface(): string;
+    check(): Promise<boolean>;
     start(props?: DeviceProperties): Promise<boolean>;
     stop(): Promise<boolean>;
     pause(): Promise<boolean>;
     resume(): Promise<boolean>;
-    logEvent(event: any): void;
+    connect(): Promise<boolean>;
+    close(): Promise<boolean>;
+    getControllerInfo(): ControllerConfig | undefined;
+    isControllable(): boolean;
+    getCapabilities(): IncyclistCapability[];
+    hasCapability(capability: IncyclistCapability): boolean;
+    addCapability(capability: IncyclistCapability): void;
     getMaxUpdateFrequency(): number;
     setMaxUpdateFrequency(value: number): void;
-    sendUpdate(request: any): void;
-    getID(): string;
-    getDisplayName(): string;
-    getName(): string;
-    getUniqueName(): string;
-    getSettings(): DeviceSettings;
-    getInterface(): string;
-    onData(callback: OnDeviceDataCallback): void;
-    canSendUpdate(): boolean;
-    emitData(data: DeviceData): void;
-    isStopped(): boolean;
-    isStarted(): boolean;
-    isPaused(): boolean;
-    hasDataListeners(): boolean | OnDeviceDataCallback;
+    update(): void;
     setCyclingMode(mode: string | ICyclingMode, settings?: any, sendInitCommands?: boolean): void;
-    getSupportedCyclingModes(): any[];
+    getSupportedCyclingModes(): Array<typeof CyclingMode>;
     getCyclingMode(): ICyclingMode;
     getDefaultCyclingMode(): ICyclingMode;
     setBikeProps(props: P): void;
-    setUser(user: User): void;
-    getUser(): User;
-    getWeight(): number;
     sendInitCommands(): Promise<boolean>;
-}
-export declare class NonControllableDevice<P extends DeviceProperties> extends Controllable<P> {
-    isControllable(): boolean;
-    setCyclingMode(mode: string | ICyclingMode, settings?: any, sendInitCommands?: boolean): void;
-    getSupportedCyclingModes(): Array<typeof CyclingMode>;
-    getCyclingMode(): ICyclingMode;
-    getDefaultCyclingMode(): ICyclingMode;
-    setBikeProps(props: DeviceProperties): void;
+    sendUpdate(request: any): void;
     setUser(user: User): void;
-    sendInitCommands(): Promise<boolean>;
-}
-export declare class ControllableDevice<P extends DeviceProperties> extends Controllable<P> {
-    protected cyclingMode: ICyclingMode;
-    constructor(adapter: IncyclistDeviceAdapter, props?: P);
-    isControllable(): boolean;
-    getSupportedCyclingModes(): Array<typeof CyclingMode>;
-    getDefaultCyclingMode(): ICyclingMode;
-    setCyclingMode(mode: ICyclingMode | string, settings?: any): void;
-    sendInitCommands(): Promise<boolean>;
-    getCyclingMode(): ICyclingMode;
+    getUser(): User;
     getWeight(): number;
+    isUpdateWithinFrequency(): boolean;
+    canEmitData(): boolean;
+    emitData(data: IncyclistAdapterData): void;
+    isStopped(): boolean;
+    isStarted(): boolean;
+    isPaused(): boolean;
+    getData(): IncyclistAdapterData;
+    hasDataListeners(): boolean | OnDeviceDataCallback;
+    onData(callback: OnDeviceDataCallback): void;
 }
+export type IncyclistDeviceAdapter = IncyclistDevice<DeviceProperties>;