incyclist-devices 1.5.38 → 2.0.0

package/lib/serial/kettler/ergo-racer/mock.js

@@ -0,0 +1,216 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KettlerRacerMockBinding = exports.KettlerRacerSimulator = exports.KettlerRacerMockImpl = exports.KettlerRacerMock = void 0;
+const binding_mock_1 = require("@serialport/binding-mock");
+const __1 = require("../..");
+const utils_1 = require("../../../utils/utils");
+const user_1 = require("../../../types/user");
+const CRLF = '\r\n';
+function pad(num, size) {
+    let str = Math.round(num).toString();
+    while (str.length < size)
+        str = "0" + str;
+    return str;
+}
+exports.KettlerRacerMock = {
+    reset() {
+        KettlerRacerMockImpl.getInstance().reset();
+    },
+    createPort(path, options = {}) {
+        return KettlerRacerMockImpl.getInstance().createPort(path, options);
+    },
+    list() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return KettlerRacerMockImpl.getInstance().list();
+        });
+    },
+    open(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return KettlerRacerMockImpl.getInstance().open(options);
+        });
+    }
+};
+class KettlerRacerMockImpl {
+    static getInstance() {
+        if (!KettlerRacerMockImpl._instance)
+            KettlerRacerMockImpl._instance = new KettlerRacerMockImpl();
+        return KettlerRacerMockImpl._instance;
+    }
+    static reset() {
+        KettlerRacerMockImpl._instance = undefined;
+        __1.SerialPortProvider._instance = undefined;
+        __1.SerialInterface._instances = [];
+    }
+    constructor() {
+        this.simulators = new Map();
+        this.ports = [];
+    }
+    setSimulator(path, simulator) {
+        this.simulators.set(path, simulator);
+    }
+    getSimulator(path) {
+        return this.simulators.get(path);
+    }
+    reset() {
+        binding_mock_1.MockBinding.reset();
+    }
+    createPort(path, options = {}) {
+        return binding_mock_1.MockBinding.createPort(path, options);
+    }
+    list() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return binding_mock_1.MockBinding.list();
+        });
+    }
+    open(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const port = yield binding_mock_1.MockBinding.open(options);
+            return new KettlerRacerMockBinding(port);
+        });
+    }
+}
+exports.KettlerRacerMockImpl = KettlerRacerMockImpl;
+class KettlerRacerSimulator {
+    constructor() {
+        this.identifier = 'SDFB3129';
+        this.version = '131';
+        this.bikeType = 'SDJB';
+        this.ifVersion = 'E5';
+        this.power = 0;
+        this.requestedPower = 0;
+        this.person = { weight: 75, length: 180, age: 30, sex: user_1.Gender.MALE };
+        this.cadence = 0;
+        this.distance = 0;
+        this.speed = 0;
+        this.heartrate = 0;
+        this.time = 4;
+        this.energy = 0;
+    }
+}
+exports.KettlerRacerSimulator = KettlerRacerSimulator;
+class KettlerRacerMockBinding extends binding_mock_1.MockPortBinding {
+    constructor(parent) {
+        super(parent.port, parent.openOptions);
+        this.simulator = KettlerRacerMockImpl.getInstance().getSimulator(this.getPath());
+        if (!this.simulator) {
+            this.simulator = new KettlerRacerSimulator();
+            KettlerRacerMockImpl.getInstance().setSimulator(this.getPath(), this.simulator);
+        }
+        this.initHandlers();
+    }
+    getPath() {
+        return this.port.info.path;
+    }
+    initHandlers() {
+        this.handlers = new Map();
+        this.handlers.set('CP', this.onSetComputerMode.bind(this));
+        this.handlers.set('CM', this.onSetClientMode.bind(this));
+        this.handlers.set('RS', this.onReset.bind(this));
+        this.handlers.set('ID', this.onGetIdentifier.bind(this));
+        this.handlers.set('VE', this.onGetVersion.bind(this));
+        this.handlers.set('KI', this.onGetKettlerInfo.bind(this));
+        this.handlers.set('PW', this.onSetPower.bind(this));
+        this.handlers.set('ST', this.onGetStatus.bind(this));
+    }
+    write(buffer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!Buffer.isBuffer(buffer)) {
+                throw new TypeError('"buffer" is not a Buffer');
+            }
+            if (!this.isOpen || !this.port) {
+                throw new Error('Port is not open');
+            }
+            if (this.writeOperation) {
+                throw new Error('Overlapping writes are not supported and should be queued by the serialport object');
+            }
+            this.writeOperation = (() => __awaiter(this, void 0, void 0, function* () {
+                yield (0, utils_1.resolveNextTick)();
+                if (!this.isOpen || !this.port) {
+                    throw new Error('Write canceled');
+                }
+                setTimeout(() => { this.processData(buffer); }, 5);
+                this.writeOperation = null;
+            }))();
+            return this.writeOperation;
+        });
+    }
+    processData(buffer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = buffer.toString();
+            const lines = data.split(CRLF);
+            lines.forEach(line => {
+                let payload;
+                let cmd = line.substring(0, 2);
+                if (cmd === 'ES') {
+                    cmd = line.substring(0, 3);
+                    payload = line.substring(3);
+                }
+                else {
+                    payload = line.substring(2);
+                }
+                if (!cmd || cmd.length === 0)
+                    return;
+                const handler = this.handlers.get(cmd);
+                if (handler) {
+                    handler(payload);
+                }
+                else {
+                    this, this.emitData('ERROR' + CRLF);
+                }
+            });
+        });
+    }
+    onSetComputerMode(_payload) {
+        this.sendResponse('ACK');
+    }
+    onSetClientMode(_payload) {
+        this.sendResponse('ACK');
+    }
+    onReset(_payload) {
+        this.sendResponse('ACK');
+    }
+    onGetIdentifier(_payload) {
+        this.sendResponse(this.simulator.identifier);
+    }
+    onGetVersion(_payload) {
+        this.sendResponse(this.simulator.version);
+    }
+    onGetKettlerInfo(_payload) {
+        const { bikeType, ifVersion } = this.simulator;
+        this.sendResponse(`${bikeType}\t${ifVersion}`);
+    }
+    onSetPower(payload) {
+        this.simulator.requestedPower = Number(payload);
+        setTimeout(() => { this.simulator.power = this.simulator.requestedPower; }, 1000);
+        this.onGetStatus();
+    }
+    onGetStatus() {
+        const { heartrate, cadence, speed, distance, power, energy, time, requestedPower } = this.simulator;
+        const mins = time % 60;
+        const secs = time - mins * 60;
+        const data = [];
+        data.push(pad(heartrate, 3));
+        data.push(pad(cadence, 3));
+        data.push(pad(speed * 10, 3));
+        data.push(pad(distance, 3));
+        data.push(pad(power, 3));
+        data.push(pad(energy, 3));
+        data.push(pad(mins, 2) + ':' + pad(secs, 2));
+        data.push(pad(requestedPower, 3));
+        const response = data.join('\t');
+        this.sendResponse(response);
+    }
+    sendResponse(msg) {
+        this.emitData(msg + CRLF);
+    }
+}
+exports.KettlerRacerMockBinding = KettlerRacerMockBinding;

package/lib/{kettler/ergo-racer/ERGCyclingMode.d.ts → serial/kettler/ergo-racer/modes/erg.d.ts}

@@ -1,7 +1,7 @@
-import CyclingMode, { CyclingModeProperty, IncyclistBikeData, UpdateRequest } from '../../cycling-mode';
-import KettlerAdapter from "./adapter";
-import PowerBasedCyclingModeBase from '../../modes/power-base';
-export declare type ERGEvent = {
+import CyclingMode, { CyclingModeProperty, IncyclistBikeData, UpdateRequest } from '../../../../modes/cycling-mode';
+import KettlerAdapter from "../adapter";
+import PowerBasedCyclingModeBase from '../../../../modes/power-base';
+export type ERGEvent = {
     rpmUpdated?: boolean;
     gearUpdated?: boolean;
     starting?: boolean;

package/lib/{kettler/ergo-racer/ERGCyclingMode.js → serial/kettler/ergo-racer/modes/erg.js}

@@ -3,8 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const cycling_mode_1 = require("../../cycling-mode");
-const power_base_1 = __importDefault(require("../../modes/power-base"));
+const cycling_mode_1 = require("../../../../modes/cycling-mode");
+const power_base_1 = __importDefault(require("../../../../modes/power-base"));
 const MIN_SPEED = 10;
 const config = {
     name: "ERG",

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

@@ -0,0 +1,60 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import EventEmitter from "events";
+import { BindingInterface } from "@serialport/bindings-interface";
+import { SerialPortStream } from '@serialport/stream';
+import { SerialDeviceSettings } from './adapter';
+import { EventLogger } from "gd-eventlog";
+import { IncyclistScanProps } from "../types/device";
+import { IncyclistInterface, InterfaceProps } from "../types/interface";
+export declare const SerialInterfaceType: {
+    SERIAL: string;
+    TCPIP: string;
+};
+export interface SerialInterfaceProps extends InterfaceProps {
+    ifaceName: string;
+    binding?: BindingInterface;
+}
+export type PortMapping = {
+    path: string;
+    port: SerialPortStream;
+};
+export interface SerialScannerProps extends IncyclistScanProps {
+    port?: string;
+    protocol: string;
+}
+export declare class SinglePathScanner {
+    path: string;
+    serial: SerialInterface;
+    result: SerialDeviceSettings;
+    isScanning: boolean;
+    props: SerialScannerProps;
+    logger: EventLogger;
+    constructor(path: string, serial: SerialInterface, props: SerialScannerProps);
+    onStopRequest(resolve: any): Promise<void>;
+    scan(): Promise<SerialDeviceSettings | undefined>;
+}
+export default class SerialInterface extends EventEmitter implements IncyclistInterface {
+    ifaceName: string;
+    binding: BindingInterface;
+    ports: PortMapping[];
+    isScanning: boolean;
+    isStopScanRequested: boolean;
+    scanEvents: EventEmitter;
+    logger: EventLogger;
+    toScan: NodeJS.Timeout;
+    connected: boolean;
+    static _instances: SerialInterface[];
+    static getInstance(props: SerialInterfaceProps): SerialInterface;
+    static _add(instance: SerialInterface): void;
+    constructor(props: SerialInterfaceProps);
+    setBinding(binding: BindingInterface): void;
+    getName(): string;
+    isConnected(): boolean;
+    connect(): Promise<boolean>;
+    disconnect(): Promise<boolean>;
+    openPort(path: string): Promise<SerialPortStream | null>;
+    closePort(path: string): Promise<Boolean>;
+    scan(props: SerialScannerProps): Promise<SerialDeviceSettings[]>;
+    stopScan(): Promise<boolean>;
+}

package/lib/serial/serial-interface.js

@@ -0,0 +1,309 @@
+"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.SinglePathScanner = exports.SerialInterfaceType = void 0;
+const events_1 = __importDefault(require("events"));
+const serialport_1 = __importDefault(require("./serialport"));
+const gd_eventlog_1 = require("gd-eventlog");
+const utils_1 = require("../utils/utils");
+const adapters_1 = __importDefault(require("../adapters"));
+const DEFAULT_SCAN_TIMEOUT = 10000;
+exports.SerialInterfaceType = {
+    SERIAL: 'serial',
+    TCPIP: 'tcpip'
+};
+class SinglePathScanner {
+    constructor(path, serial, props) {
+        this.path = path;
+        this.serial = serial;
+        this.result = undefined;
+        this.isScanning = false;
+        this.props = props;
+        this.logger = props.logger || new gd_eventlog_1.EventLogger('SerialScanner');
+    }
+    onStopRequest(resolve) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'stopping scan', path: this.path });
+            yield this.serial.closePort(this.path);
+            this.isScanning = false;
+            resolve(this.result);
+        });
+    }
+    scan() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('~~~ start SERIAL Scan', this.isScanning);
+            if (this.isScanning)
+                return;
+            this.isScanning = true;
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                this.logger.logEvent({ message: 'starting scan', path: this.path });
+                this.serial.scanEvents.on('timeout', () => this.onStopRequest(resolve));
+                this.serial.scanEvents.on('stop', () => this.onStopRequest(resolve));
+                let found = false;
+                while (!found && this.isScanning) {
+                    try {
+                        console.log('~~~ adapter check attempt');
+                        const { protocol } = this.props;
+                        let host, port;
+                        if (this.serial.getName() === exports.SerialInterfaceType.TCPIP) {
+                            [host, port] = this.path.split(':');
+                        }
+                        else {
+                            port = this.path;
+                        }
+                        const adapterSettings = { interface: this.serial.getName(), host, port, protocol };
+                        const adapter = adapters_1.default.create(adapterSettings);
+                        found = yield adapter.check();
+                        if (found) {
+                            const name = adapter.getName();
+                            resolve(Object.assign(Object.assign({}, adapterSettings), { name }));
+                        }
+                        yield (0, utils_1.sleep)(100);
+                    }
+                    catch (err) {
+                        console.log('~~~ERROR', err);
+                        this.logger.logEvent({ message: 'error', fn: 'scan()', error: err.message || err, stack: err.stack });
+                        yield (0, utils_1.sleep)(100);
+                    }
+                }
+            }));
+        });
+    }
+}
+exports.SinglePathScanner = SinglePathScanner;
+class SerialInterface extends events_1.default {
+    static getInstance(props) {
+        const { ifaceName, binding, logger } = props;
+        let instance = SerialInterface._instances.find(i => i.ifaceName === ifaceName);
+        if (!instance) {
+            if (binding)
+                instance = new SerialInterface(props);
+            else {
+                instance = new SerialInterface({ ifaceName, binding: serialport_1.default.getInstance().getBinding(ifaceName), logger });
+                if (instance)
+                    SerialInterface._instances.push(instance);
+            }
+        }
+        return instance;
+    }
+    static _add(instance) {
+        let existingIdx = SerialInterface._instances.findIndex(i => i.ifaceName === instance.ifaceName);
+        if (existingIdx !== -1)
+            SerialInterface._instances[existingIdx] = instance;
+        else
+            SerialInterface._instances.push(instance);
+    }
+    constructor(props) {
+        super();
+        const { ifaceName, binding } = props;
+        this.ifaceName = ifaceName;
+        this.binding = undefined;
+        this.ports = [];
+        this.isScanning = false;
+        this.isStopScanRequested = false;
+        this.scanEvents = new events_1.default();
+        this.logger = props.logger || new gd_eventlog_1.EventLogger(`Serial:${ifaceName}`);
+        this.connected = false;
+        this.logger.logEvent({ message: 'new serial interface', ifaceName });
+        if (binding) {
+            this.setBinding(binding);
+        }
+        SerialInterface._add(this);
+    }
+    setBinding(binding) {
+        this.binding = binding;
+        serialport_1.default.getInstance().setBinding(this.ifaceName, binding);
+    }
+    getName() {
+        return this.ifaceName;
+    }
+    isConnected() {
+        return this.connected;
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const binding = serialport_1.default.getInstance().getBinding(this.ifaceName);
+            if (!binding || !this.binding) {
+                this.connected = false;
+                return false;
+            }
+            try {
+                const SerialPort = this.binding;
+                const res = yield SerialPort.list();
+                this.connected = true;
+                return true;
+            }
+            catch (err) {
+                this.connected = false;
+                return false;
+            }
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.connected = false;
+            return true;
+        });
+    }
+    openPort(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('~~~ SerialPort.openPort', this.ifaceName, path);
+            this.logger.logEvent({ message: 'opening port', path });
+            const port = serialport_1.default.getInstance().getSerialPort(this.ifaceName, { path });
+            if (!port) {
+                return null;
+            }
+            const existing = this.ports.findIndex(p => p.path === path);
+            if (existing !== -1) {
+                const port = this.ports[existing].port;
+                if (port.isOpen)
+                    return port;
+                else {
+                    this.ports.splice(existing, 1);
+                }
+            }
+            return new Promise((resolve) => {
+                port.once('error', (err) => {
+                    this.logger.logEvent({ message: 'error', path, error: err || err.message });
+                    port.removeAllListeners();
+                    resolve(null);
+                });
+                port.once('open', () => {
+                    this.logger.logEvent({ message: 'port opened', path });
+                    port.removeAllListeners();
+                    this.ports.push({ path, port });
+                    resolve(port);
+                });
+                port.open();
+            });
+        });
+    }
+    closePort(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('~~~ SerialPort.closePort', this.ifaceName, path);
+            const existing = this.ports.findIndex(p => p.path === path);
+            if (existing === -1)
+                return true;
+            const port = this.ports[existing].port;
+            if (!port.isOpen)
+                return true;
+            port.on('error', () => { });
+            port.flush();
+            yield port.drain();
+            return new Promise(resolve => {
+                port.close(err => {
+                    if (!err) {
+                        this.ports.splice(existing, 1);
+                        port.removeAllListeners();
+                        resolve(true);
+                    }
+                    resolve(false);
+                });
+            });
+        });
+    }
+    scan(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('~~serial scan', this.isScanning, this.isConnected());
+            if (this.isScanning)
+                return [];
+            if (!this.isConnected())
+                yield this.connect();
+            const binding = serialport_1.default.getInstance().getBinding(this.ifaceName);
+            if (!binding || !this.binding)
+                return [];
+            const { port, timeout = DEFAULT_SCAN_TIMEOUT } = props;
+            let paths;
+            const detected = [];
+            let timeOutExpired = false;
+            let toExpiresAt = Date.now() + timeout;
+            if (timeout) {
+                this.toScan = setTimeout(() => {
+                    timeOutExpired = true;
+                    this.scanEvents.emit('timeout');
+                }, timeout);
+            }
+            this.logger.logEvent({ message: 'checking for ports ' });
+            this.isScanning = true;
+            do {
+                try {
+                    if (this.getName() === 'tcpip') {
+                        const _binding = binding;
+                        paths = (yield _binding.list(port)) || [];
+                    }
+                    else {
+                        paths = (yield binding.list()) || [];
+                    }
+                }
+                catch (err) {
+                    console.log('~~~ERROR', err);
+                }
+                if (!paths || paths.length === 0) {
+                    this.logger.logEvent({ message: 'scanning: no ports detected', interface: this.ifaceName, paths: paths.map(p => p.path), timeout });
+                    yield (0, utils_1.sleep)(1000);
+                }
+                if (Date.now() > toExpiresAt)
+                    timeOutExpired = true;
+            } while (this.isScanning && !timeOutExpired && paths.length === 0);
+            if (paths.length === 0) {
+                this.logger.logEvent({ message: 'nothing to scan ' });
+                if (this.toScan) {
+                    clearTimeout(this.toScan);
+                    this.toScan = null;
+                }
+                return [];
+            }
+            this.logger.logEvent({ message: 'scanning on ', paths: paths.map(p => p.path), timeout });
+            const scanners = paths.map(p => new SinglePathScanner(p.path, this, Object.assign(Object.assign({}, props), { logger: this.logger })));
+            try {
+                yield Promise.all(scanners.map(s => s.scan()
+                    .then(device => {
+                    if (device) {
+                        detected.push(device);
+                        this.emit('device', device);
+                    }
+                })
+                    .catch()));
+            }
+            catch (err) {
+                this.logger.logEvent({ message: 'error', fn: 'scan()', error: err.message || err, stack: err.stack });
+            }
+            if (this.toScan) {
+                clearTimeout(this.toScan);
+                this.toScan = null;
+            }
+            this.isScanning = false;
+            this.logger.logEvent({ message: 'scan finished on', interface: this.ifaceName, paths: paths.map(p => p.path), devices: detected.map(d => {
+                    const res = Object.assign({}, d);
+                    res.interface = this.ifaceName;
+                    return res;
+                }) });
+            return detected;
+        });
+    }
+    stopScan() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isScanning)
+                return true;
+            if (this.toScan) {
+                clearTimeout(this.toScan);
+                this.toScan = null;
+            }
+            this.scanEvents.emit('stop');
+            return true;
+        });
+    }
+}
+exports.default = SerialInterface;
+SerialInterface._instances = [];

package/lib/simulator/Simulator.d.ts

@@ -1,18 +1,18 @@
-import DeviceProtocolBase, { DeviceSettings, DeviceProtocol } from '../protocol';
-import DeviceAdapter from '../device';
+import DeviceAdapter, { ControllableDevice } from '../base/adpater';
 import { EventLogger } from 'gd-eventlog';
-import CyclingMode, { IncyclistBikeData } from '../cycling-mode';
-interface SimulatorSettings extends DeviceSettings {
+import CyclingMode, { IncyclistBikeData } from '../modes/cycling-mode';
+import { DeviceProperties, DeviceSettings } from '../types/device';
+interface SimulatorProperties extends DeviceProperties {
     isBot?: boolean;
     settings?: any;
+    activity?: any;
 }
-export declare class Simulator extends DeviceAdapter {
+export declare class Simulator extends ControllableDevice {
     static NAME: string;
     logger: EventLogger;
     speed: number;
     power: number;
     cadence: number;
-    paused: boolean;
     time: number;
     iv: any;
     started: boolean;
@@ -30,21 +30,18 @@ export declare class Simulator extends DeviceAdapter {
     bikeSettings: {
         weight?: number;
     };
-    constructor(protocol?: DeviceProtocol, props?: SimulatorSettings);
-    isBike(): boolean;
-    isHrm(): boolean;
-    isPower(): boolean;
+    constructor(settings: DeviceSettings, props?: SimulatorProperties);
+    isEqual(settings: DeviceSettings): boolean;
     isSame(device: DeviceAdapter): boolean;
     getID(): string;
     getName(): string;
-    getPort(): string;
-    getWeight(): number;
+    getUniqueName(): string;
     setIgnoreHrm(ignore: any): void;
     getSupportedCyclingModes(): Array<any>;
     getDefaultCyclingMode(): CyclingMode;
     getCyclingMode(): CyclingMode;
     setCyclingMode(mode: CyclingMode | string, settings?: any): void;
-    start(props?: any): Promise<unknown>;
+    start(props?: SimulatorProperties): Promise<boolean>;
     stop(): Promise<boolean>;
     pause(): Promise<boolean>;
     resume(): Promise<boolean>;
@@ -52,18 +49,8 @@ export declare class Simulator extends DeviceAdapter {
     faster(): void;
     slower(): void;
     update(): void;
+    canSendUpdate(): boolean;
     calculateDistance(speedKps: any, timeS: any): number;
-    sendUpdate(request: any): import("../cycling-mode").UpdateRequest;
-}
-export default class SimulatorProtocol extends DeviceProtocolBase {
-    static NAME: string;
-    constructor();
-    add(settings: SimulatorSettings): any;
-    getName(): string;
-    getInterfaces(): string[];
-    isBike(): boolean;
-    isHrm(): boolean;
-    isPower(): boolean;
-    getDevices(): import("../protocol").Device[];
+    sendUpdate(request: any): import("../modes/cycling-mode").UpdateRequest;
 }
 export {};