incyclist-devices 1.1.0 → 1.3.25

package/lib/ant/anthrm/anthrm.js

@@ -1,523 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const hrm_js_1 = require("../../hrm.js");
-const { EventLogger } = require('gd-eventlog');
-var Ant = undefined;
-let Logger = new EventLogger('Ant+Hrm', 'Incyclist');
-var stick = undefined;
-var sensor = undefined;
-const MAX_SPAN_NO_DATA = 5000;
-class AntHrmSensor extends hrm_js_1.default {
-    static setAnt(antClass) {
-        Ant = antClass;
-    }
-    static getClassName() {
-        return "Ant+Hrm";
-    }
-    constructor(opts) {
-        super(opts);
-        this.logger = new EventLogger('Ant+Hrm');
-        this.manufacturer = undefined;
-        this.deviceID = undefined;
-        this.prevHrmTime = undefined;
-        this.bike = undefined;
-        this.mode = "idle";
-        this.shareStick = false;
-        this.stick = undefined;
-        this.scanMode = false;
-        this.isScanning = false;
-        this.isAttached = false;
-        if (opts !== undefined) {
-            this.bike = opts.bike;
-            this.processor = opts.processor;
-        }
-        if (this.bike !== undefined) {
-            this.bike.hrm = this;
-        }
-        if (opts.mode === "scan") {
-            this.scanMode = true;
-        }
-        else {
-            if (opts.deviceID !== undefined) {
-                this.deviceID = opts.deviceID;
-            }
-            else {
-                this.deviceID = 0;
-            }
-        }
-        if (this.stick === undefined) {
-            if (opts.stick === undefined) {
-                this.stick = new Ant.GarminStick3();
-            }
-            else {
-                this.stick = opts.stick;
-                this.shareStick = true;
-            }
-            return;
-        }
-    }
-    static getStick() {
-        Logger.log('checking GarminStick2');
-        let stick2 = new Ant.GarminStick2();
-        if (stick2.is_present() && stick2.open()) {
-            this.logEvent({ message: 'found GarminStick2' });
-            return stick2;
-        }
-        Logger.log('checking GarminStick3');
-        let stick3 = new Ant.GarminStick3();
-        if (stick3.is_present() && stick3.open()) {
-            this.logEvent({ message: 'found GarminStick3' });
-            return stick3;
-        }
-        this.logEvent({ message: 'no stick found' });
-        return undefined;
-    }
-    static scan(scanId, callbacks, timeout, scanOpts) {
-        Logger.log("scanning for devices...");
-        AntHrmSensor.isScanning = true;
-        let stick = undefined;
-        if (scanOpts !== undefined && scanOpts.ant !== undefined)
-            stick = scanOpts.ant.stick;
-        var hrm = undefined;
-        if (stick === undefined) {
-            stick = this.getStick();
-            if (stick !== undefined) {
-                stick.createdForHrmScan = true;
-                if (scanOpts === undefined)
-                    scanOpts = {};
-                if (scanOpts.ant === undefined)
-                    scanOpts.ant = {};
-                scanOpts.ant.stick = stick;
-            }
-        }
-        if (stick === undefined) {
-            if (callbacks !== undefined && callbacks.end !== undefined) {
-                callbacks.end(scanId);
-            }
-            return;
-        }
-        stick.hrmScanId = scanId;
-        if (stick.createdForHrmScan) {
-            stick.on('startup', function () {
-                if (hrm !== undefined)
-                    hrm.startScanning(callbacks, timeout);
-            });
-            if (stick.is_present()) {
-                if (!stick.open()) {
-                    Logger.log('Stick could not be opened!');
-                    if (callbacks !== undefined && callbacks.end !== undefined) {
-                        callbacks.end(stick.hrmScanId);
-                    }
-                    return;
-                }
-                else {
-                    hrm = new AntHrmSensor({ stick: stick });
-                    hrm.isFirstScanner = (stick.cntScanners === undefined);
-                }
-            }
-            else {
-                Logger.log('Stick not found');
-                if (callbacks !== undefined && callbacks.end !== undefined) {
-                    callbacks.end(stick.hrmScanId);
-                }
-                return;
-            }
-        }
-        else {
-            if (!stick.opened) {
-                if (callbacks !== undefined && callbacks.end !== undefined) {
-                    callbacks.end(stick.hrmScanId);
-                }
-                return;
-            }
-            hrm = new AntHrmSensor({ stick: stick, mode: "scan" });
-            hrm.isFirstScanner = (stick.cntScanners === undefined);
-            hrm.startScanning(callbacks, timeout);
-        }
-        if (stick.cntScanners === undefined)
-            stick.cntScanners = 1;
-        else
-            stick.cntScanners++;
-    }
-    static log(str, args) {
-        Logger.log(str, ...args);
-    }
-    static logEvent(event, level) {
-        Logger.logEvent(event, level);
-    }
-    startScanning(callbacks, timeout) {
-        let self = this;
-        let stick = this.stick;
-        this.initScanner(callbacks);
-        this.stick.hrmScanningInterval = setInterval(() => {
-            if (self.stick.startHrmScan === undefined) {
-                if (self.isFirstScanner || self.stick.scannerAttached) {
-                    this.logger.log('starting scanner...');
-                    self.stick.startHrmScan = Date.now();
-                    try {
-                        self.scanner.scan();
-                        self.stick.antScanners = [];
-                    }
-                    catch (e) {
-                        this.logger.logEvent({ message: "Error", fn: 'startScanning->setInterval', error: e });
-                    }
-                }
-            }
-            if (stick.startHrmScan !== undefined) {
-                let ts = Date.now();
-                if (ts - stick.startHrmScan < timeout) {
-                    return;
-                }
-                else {
-                    let cb = callbacks === undefined ? undefined : callbacks.end;
-                    self.stopScanning(cb);
-                }
-            }
-            return;
-        }, 100);
-    }
-    initScanner(callbacks, obj) {
-        var self = obj;
-        if (obj === undefined)
-            self = this;
-        try {
-            if (self.scanner !== undefined) {
-                if (self.isFirstScanner) {
-                    self.scanner.detach(0);
-                    setTimeout(self.initScanner, 500, callbacks, self);
-                }
-                else {
-                    self.scanner.removeAllListeners();
-                    self.scanner = undefined;
-                }
-            }
-            self.scanner = new Ant.HeartRateScanner(self.stick);
-            self.scanner.on('hbData', (data) => {
-                if (self.stick.anthrm === undefined) {
-                    self.stick.anthrm = [];
-                }
-                if (data.DeviceID === undefined)
-                    return;
-                var foundHrm = false;
-                for (var i = 0; i < self.stick.anthrm.length; i++) {
-                    if (self.stick.anthrm[i] === data.DeviceID) {
-                        foundHrm = true;
-                    }
-                }
-                if (!foundHrm) {
-                    self.stick.anthrm.push(data.DeviceID);
-                    if (callbacks !== undefined && callbacks.found !== undefined) {
-                        this.logger.logEvent({ message: "adding device ", deviceID: data.DeviceID });
-                        var name = "ANT+Hrm";
-                        if (data.ManId !== undefined) {
-                            switch (data.ManId) {
-                                case 1:
-                                    name = "Garmin";
-                                    break;
-                                case 16:
-                                    name = "Timex";
-                                    break;
-                                case 23:
-                                    name = "Suunto";
-                                    break;
-                                case 52:
-                                    name = "Seiko";
-                                    break;
-                                case 53:
-                                    name = "Seiko";
-                                    break;
-                                case 70:
-                                    name = "Sigma";
-                                    break;
-                                case 123:
-                                    name = "Polar";
-                                    break;
-                                case 287:
-                                    name = "VDO";
-                                    break;
-                                case 32:
-                                    name = "Wahoo";
-                                    break;
-                                case 86:
-                                    name = "Elite";
-                                    break;
-                                case 89:
-                                    name = "Tacx";
-                                    break;
-                                default:
-                                    name = 'Other:' + data.ManId;
-                            }
-                        }
-                        callbacks.found(AntHrmSensor, { profile: "hrm", name: name + " " + data.DeviceID, type: "ANT+Hrm", deviceID: data.DeviceID, options: { stick: self.stick, deviceID: data.DeviceID } });
-                    }
-                }
-            });
-            self.scanner.on('attached', () => {
-                this.logger.log('scanner attached');
-                self.isScanning = true;
-                self.stick.cntHrmScanners = 1;
-                if (self.isFirstScanner) {
-                    self.stick.scannerAttached = true;
-                    for (var i in self.stick.antScanners) {
-                        self.stick.antScanners[i].scan();
-                    }
-                }
-            });
-            self.scanner.on('detached', () => {
-                this.logger.log('scanner detached');
-                self.isScanning = false;
-                AntHrmSensor.isScanning = false;
-                if (self.isFirstScanner) {
-                    self.stick.scannerAttached = undefined;
-                }
-                self.stick.cntHrmScanners = undefined;
-                self.scanner.removeAllListeners();
-                self.scanner = undefined;
-            });
-        }
-        catch (error) {
-            this.logger.logEvent({ message: "Error ", fn: 'initScanner()', error });
-        }
-    }
-    stopScanning(callback) {
-        let self = this;
-        if (self.scanner === undefined) {
-            if (self.stick.startHrmScan !== undefined) {
-                this.logger.log("scan stopped");
-                if (self.stick.hrmScanningInterval !== undefined)
-                    clearInterval(self.stick.hrmScanningInterval);
-                self.stick.startHrmScan = undefined;
-                self.stick.hrmScanningInterval = undefined;
-                if (callback !== undefined) {
-                    callback(self.stick.hrmScanId);
-                }
-            }
-            return;
-        }
-        this.logger.log("stopping scan ...");
-        try {
-            if (self.isFirstScanner) {
-                self.logger.log("detaching channel " + self.scanner.channel + " ...");
-                self.scanner.detach(0);
-            }
-            else {
-                self.scanner.removeAllListeners();
-                self.scanner = undefined;
-            }
-            if (self.stick.hrmScanningInterval !== undefined)
-                clearInterval(self.stick.hrmScanningInterval);
-            self.stick.startHrmScan = undefined;
-            self.stick.hrmScanningInterval = undefined;
-            self.stopScanningStart = Date.now();
-            self.stopScanningIv = setInterval(function () {
-                let duration = Date.now() - self.stopScanningStart;
-                if (duration > 2000 || self.scanner === undefined) {
-                    self.logger.log("scan stopped");
-                    if (callback !== undefined) {
-                        callback(self.stick.hrmScanId);
-                    }
-                    clearInterval(self.stopScanningIv);
-                    self.stopScanningIv = undefined;
-                }
-            }, 100);
-        }
-        catch (error) {
-            self.logger.logEvent({ messsage: 'Error', fn: 'stopScanning()', error });
-        }
-    }
-    connect(callback) {
-        let self = this;
-        if (self.stick !== undefined) {
-            self.channel = self.stick.inUse === undefined ? 0 : self.stick.inUse;
-            self.stick.inUse = self.channel + 1;
-        }
-        this.logger.logEvent({ message: "connect()", scanMode: this.scanMode, stick: this.stick === undefined ? '' : `${this.stick.idVendor}-${this.stick.idProduct}`, channel: self.channel });
-        let cb = callback || function (str) { };
-        if (this.scanMode) {
-            return;
-        }
-        if (this.stick === undefined) {
-            try {
-                this.stick = new Ant.GarminStick3();
-                if (this.stick.is_present()) {
-                    this.initSensor();
-                    this.stick.open();
-                }
-                else {
-                    this.logger.log("connect():no stick found");
-                    cb(503, { message: "no stick found" });
-                    return;
-                }
-            }
-            catch (error) {
-                this.logger.logEvent({ message: "Error ", fn: 'connect()', error });
-            }
-        }
-        else {
-            if (self.scanner !== undefined) {
-                self.logger.log('scan still ongoing. Stopping...');
-                self.stopScanning(() => { self.initSensor(); });
-            }
-            else if (self.channel !== 0) {
-                setTimeout(() => { self.initSensor(); }, 2000);
-            }
-            else
-                return self.initSensor();
-        }
-        return cb(200, {});
-    }
-    waitforDetached() {
-        let self = this;
-        this.logger.log("Waiting for scanners to be detached ... ");
-        if (self.stick.cntHrmScanners !== undefined) {
-            return;
-        }
-        else {
-            clearInterval(self.waitStopScanIv);
-            self.waitStopScanIv = undefined;
-            self.initSensor();
-        }
-    }
-    initSensor() {
-        let self = this;
-        this.logger.logEvent({ message: 'initSensor', devideID: this.deviceID, channel: this.channel });
-        try {
-            if (self.stick.cntHrmScanners !== undefined) {
-                self.waitStopScanIv = setInterval(function () { self.waitforDetached(); }, 1000);
-                return;
-            }
-            if (self.stick === undefined) {
-                self.stick = new Ant.GarminStick3();
-                self.stick.on('startup', onStickStartup);
-                self.stick.on('shutdown', onStickShutdown);
-            }
-            self.sensor = new Ant.HeartRateSensor(self.stick);
-            self.stick.hrmSensor = this;
-            if (self.channel === undefined) {
-                self.channel = self.stick.inUse === undefined ? 0 : self.stick.inUse;
-                self.stick.inUse = self.channel + 1;
-            }
-            self.sensor.on('hbData', function (data) { self.onHrmSensorData(data); });
-            self.sensor.on('attached', () => { self.onSensorAttached(); });
-            self.sensor.on('detached', function () { self.onSensorDetached(); });
-            self.sensor.deviceID = this.deviceID;
-            self.sensor.attach(self.channel, self.deviceID);
-        }
-        catch (error) {
-            self.ogger.logEvent({ message: "Error: ", fn: 'initSensor()', error });
-        }
-        return;
-    }
-    getData(callback) {
-        let cb = callback || function (str) { };
-        this.logger.logEvent({ message: "getData():" });
-        if (this.data === undefined || this.data.heartrate === undefined)
-            cb(404, {});
-        else
-            cb(200, this.data);
-    }
-    disconnect() {
-        this.logger.log("disconnect()");
-        try {
-            this.sensor.detach(this.sensor.channel);
-        }
-        catch (error) {
-            this.logger.logEvent({ message: "error ", fn: 'disconnect()', error });
-        }
-    }
-    onHrmSensorData(data) {
-        let self = this;
-        try {
-            let hrm = data.ComputedHeartRate;
-            if (data.ComputedHeartRate !== undefined && data.BeatTime !== undefined) {
-                let prevBeatTime = self.beatTime;
-                let prevHrmTime = self.prevHrmTime;
-                if (prevBeatTime === undefined || data.BeatTime !== prevBeatTime) {
-                    if (hrm === 0)
-                        hrm = undefined;
-                    self.beatTime = data.BeatTime;
-                    self.prevHrmTime = Date.now();
-                    self.data.heartrate = hrm;
-                    if (self.bike !== undefined && self.bike.data !== undefined)
-                        self.bike.data.heartrate = hrm;
-                    if (self.processor !== undefined) {
-                        try {
-                            self.processor.update({ heartrate: hrm });
-                        }
-                        catch (error) {
-                            self.logger.logEvent({ message: 'Error', fn: 'onHrmSensorData()', error });
-                        }
-                    }
-                    if (hrm !== undefined) {
-                        self.logger.logEvent({ message: "hrm data", hrm });
-                        if (!self.timeoutCheck) {
-                            self.timeoutCheck = setInterval(1000, function () { self.checkTimeout(); });
-                        }
-                    }
-                }
-                else {
-                    if (prevHrmTime !== undefined) {
-                        let ts = Date.now();
-                        let duration = ts - prevHrmTime;
-                        if (duration > MAX_SPAN_NO_DATA) {
-                            self.logger.log("no new hrm data received");
-                            self.bike.data.heartrate = undefined;
-                            self.prevHrmTime = undefined;
-                        }
-                    }
-                }
-            }
-        }
-        catch (error) {
-            this.logger.logEvent({ message: 'Error', fn: 'onHrmSensorData()', data, error });
-        }
-    }
-    checkTimeout() {
-        if (this.prevHrmTime === undefined)
-            return;
-        let ts = Date.now();
-        if (ts - this.prevHrmTime > MAX_SPAN_NO_DATA) {
-            this.logger.log("no data received");
-            this.prevHrmTime = undefined;
-            this.bike.data.heartrate = undefined;
-        }
-    }
-    onSensorAttached() {
-        if (!this.isAttached)
-            this.logger.logEvent({ message: "sensor attached", channel: this.channel });
-        this.isAttached = true;
-    }
-    onSensorDetached() {
-        if (this.isAttached)
-            this.logger.log("sensor detached");
-        this.isAttached = false;
-        this.sensor.removeAllListeners();
-        if (this.stick.bikeSensor === undefined) {
-            this.stick.close();
-        }
-    }
-}
-exports.default = AntHrmSensor;
-function onStickStartup() {
-    try {
-        if (stick.link !== undefined) {
-            let stickinfo = {
-                idProduct: stick.idProduct,
-                idVendor: stick.idVendor,
-                maxChannels: stick.maxChannels,
-                usedChannels: stick.usedChannels
-            };
-            Logger.log("ANT Stick: connected to stick:" + JSON.stringify(stickinfo));
-            Logger.log("ANT Stick: scanning for HRM Sensor ...");
-        }
-        sensor.scan();
-    }
-    catch (error) {
-        Logger.logEvent({ message: 'Error', error });
-    }
-}
-function onStickShutdown() {
-    if (stick.link !== undefined) {
-        Logger.log("ANT Stick: stick is correctly closed. ");
-    }
-}

package/lib/simulator/Simulator.unit.tests.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/simulator/Simulator.unit.tests.js

@@ -1,79 +0,0 @@
-"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 });
-const Simulator_1 = require("./Simulator");
-if (process.env.DEBUG === undefined)
-    console.log = jest.fn();
-describe('Simulator', () => {
-    describe('Constructor', () => {
-        test('empty constructor', () => {
-            let s = new Simulator_1.Simulator();
-            expect(s).toMatchObject({ speed: 0, power: 0, cadence: 90, slope: 0 });
-            expect(s).toMatchObject({ detected: false, selected: false });
-            expect(s.started).toBe(false);
-            expect(s.paused).toBeUndefined();
-            expect(s.time).toBeUndefined();
-            expect(s.iv).toBeUndefined();
-            expect(s.getProtocolName()).toBe(Simulator_1.default.NAME);
-        });
-    });
-    test('getName', () => {
-        let s = new Simulator_1.Simulator();
-        expect(s.getName()).toBe(Simulator_1.Simulator.NAME);
-    });
-    test('getPort', () => {
-        let s = new Simulator_1.Simulator();
-        expect(s.getPort()).toBe('local');
-    });
-    describe('start', () => {
-        let s;
-        beforeEach(() => {
-            s = new Simulator_1.Simulator();
-        });
-        afterEach(() => {
-            s.stop();
-        });
-        test('promise: normal start', () => __awaiter(void 0, void 0, void 0, function* () {
-            const res = yield s.start();
-            expect(res.error).toBeUndefined();
-            expect(s.iv).toBeDefined();
-            expect(s.started).toBe(true);
-            expect(s.paused).toBe(true);
-        }));
-        test('promise: repetative start', () => __awaiter(void 0, void 0, void 0, function* () {
-            yield s.start();
-            const iv = s.iv;
-            const res = s.start();
-            expect(res.error).toBeUndefined();
-            expect(s.iv).toEqual(iv);
-            expect(s.started).toBe(true);
-            expect(s.paused).toBe(true);
-        }));
-        test('callback: normal start', () => {
-            s.start(res => {
-                expect(res.error).toBeUndefined();
-                expect(s.iv).toBeDefined();
-                expect(s.started).toBe(true);
-                expect(s.paused).toBe(true);
-            });
-        });
-        test('callback: repetative start', () => __awaiter(void 0, void 0, void 0, function* () {
-            yield s.start();
-            const iv = s.iv;
-            s.start(res => {
-                expect(res.error).toBeUndefined();
-                expect(s.iv).toEqual(iv);
-                expect(s.started).toBe(true);
-                expect(s.paused).toBe(true);
-            });
-        }));
-    });
-});