@robotical/webapp-types 0.6.58

package/dist-types/src/application/RAFTs/Cog/PublishedDataAnalyser.js

@@ -0,0 +1,533 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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 __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { raftPubSubscriptionHelper } from "../raft-subscription-helpers";
+import { isVersionGreater_errorCatching } from "../../../utils/helpers/compare-version";
+import EventEmitter from "events";
+import Logger from "../../../services/logger/Logger";
+var SHOW_LOGS = true;
+var TAG = "PublishedDataAnalyser";
+var PublishedDataAnalyser = /** @class */ (function (_super) {
+    __extends(PublishedDataAnalyser, _super);
+    function PublishedDataAnalyser(cog) {
+        var _this = _super.call(this) || this;
+        _this.cog = cog;
+        _this.rotationDetection = new RotationDetection();
+        _this.shakeDetector = new ShakeDetector();
+        _this.buttonClickDetection = new ButtonClickDetection();
+        _this.tiltDetection = new TiltDetection();
+        _this.objectSenseDetection = new ObjectSenseDetection();
+        _this.lightSenseDetection = new LightSenseDetection();
+        _this.eventsMap = {
+            tilt: {
+                forward: "tiltForward",
+                backward: "tiltBackward",
+                left: "tiltLeft",
+                right: "tiltRight",
+                none: "noTilt"
+            },
+            movementType: {
+                shake: "shake",
+                move: "move",
+                none: "noMovement"
+            },
+            rotation: {
+                clockwise: "rotationClockwise",
+                counterClockwise: "rotationCounterClockwise",
+                none: "noRotation"
+            },
+            buttonClick: {
+                click: "buttonClick",
+                release: "buttonRelease",
+                none: "noButtonClick"
+            },
+            objectSense: {
+                left: "objectSenseLeft",
+                right: "objectSenseRight",
+                none: "noObjectSense"
+            },
+            lightSense: {
+                high: "highLightSense",
+                mid: "midLightSense",
+                low: "lowLightSense",
+                none: "noLightSense"
+            },
+        };
+        _this.TiltDetection = TiltDetection;
+        _this.cog = cog;
+        _this.cogState = {
+            tilt: "none",
+            movementType: "none",
+            rotation: "none",
+            buttonClick: "none",
+            objectSense: "none",
+            lightSense: "none",
+        };
+        _this.pubSub = null;
+        _this.subscribeToPublishedData();
+        return _this;
+    }
+    PublishedDataAnalyser.prototype.subscribeToPublishedData = function () {
+        var _this = this;
+        this.pubSub = raftPubSubscriptionHelper(this.cog);
+        this.pubSub.subscribe(function (data) {
+            _this.analyse(data.stateInfo);
+        });
+    };
+    PublishedDataAnalyser.prototype.unsubscribeFromPublishedData = function () {
+        var _a;
+        (_a = this.pubSub) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+    };
+    PublishedDataAnalyser.prototype.analyse = function (data) {
+        if (!data)
+            return;
+        var accelData = data.accelerometer;
+        var gyroData = data.gyroscope;
+        var lightData = data.light;
+        var isMoving;
+        if (accelData)
+            isMoving = this.shakeDetector.detectShake(accelData.ax, accelData.ay, accelData.az, Date.now(), this);
+        accelData && this.tiltDetection.detectTilt(accelData.ax, accelData.ay, accelData.az, isMoving, this, this.cog.getRaftVersion());
+        gyroData && this.rotationDetection.detectRotation(gyroData.gz, isMoving, this);
+        lightData && this.buttonClickDetection.detectButtonClick(lightData.ir2, this, this.cog.getRaftVersion());
+        lightData && this.objectSenseDetection.detectObjectSense([lightData.ir0, lightData.ir1], this);
+        lightData && this.lightSenseDetection.detectLightSense(lightData.amb0, this);
+    };
+    PublishedDataAnalyser.prototype.setTilt = function (tilt) {
+        this.cogState.tilt = tilt;
+        this.emit(this.eventsMap.tilt[tilt]);
+    };
+    PublishedDataAnalyser.prototype.setMovementType = function (movementType) {
+        this.cogState.movementType = movementType;
+        this.emit(this.eventsMap.movementType[movementType]);
+    };
+    PublishedDataAnalyser.prototype.setRotation = function (rotation) {
+        this.cogState.rotation = rotation;
+        this.emit(this.eventsMap.rotation[rotation]);
+    };
+    PublishedDataAnalyser.prototype.setButtonClick = function (buttonClick) {
+        this.cogState.buttonClick = buttonClick;
+        this.emit(this.eventsMap.buttonClick[buttonClick]);
+    };
+    PublishedDataAnalyser.prototype.setObjectSense = function (objectSense) {
+        this.cogState.objectSense = objectSense;
+        this.emit(this.eventsMap.objectSense[objectSense]);
+    };
+    PublishedDataAnalyser.prototype.setLightSense = function (lightSense) {
+        this.cogState.lightSense = lightSense;
+        this.emit(this.eventsMap.lightSense[lightSense]);
+    };
+    return PublishedDataAnalyser;
+}(EventEmitter));
+var TiltDetection = /** @class */ (function () {
+    function TiltDetection() {
+    }
+    TiltDetection.prototype.distance = function (a, b) { return Math.sqrt((Math.pow(a, 2) + Math.pow(b, 2))); };
+    TiltDetection.rotateAccelData = function (x, y, z, degrees) {
+        // Convert degrees to radians
+        var radians = degrees * (Math.PI / 180);
+        // First rotate by 180 degrees about y axis
+        var rotatedX = 0 - x;
+        var rotatedY = y;
+        var rotatedZ = 0 - z;
+        var initialRotatedX = rotatedX;
+        // Calculate cosine and sine of the rotation angle
+        var cosTheta = Math.cos(radians);
+        var sinTheta = Math.sin(radians);
+        // Rotate around the z-axis
+        rotatedX = initialRotatedX * cosTheta - rotatedY * sinTheta;
+        rotatedY = initialRotatedX * sinTheta + rotatedY * cosTheta;
+        rotatedZ = rotatedZ; // z remains unchanged as the rotation is around the z-axis
+        return { x: rotatedX, y: rotatedY, z: rotatedZ };
+    };
+    TiltDetection.prototype.detectTilt = function (ax, ay, az, isMoving, analyser, cogVersion) {
+        if (isMoving === void 0) { isMoving = false; }
+        if (isMoving)
+            return;
+        var tiltCorrectionForOlderCog = 30;
+        var tiltCorrectionForNewerCog = -90;
+        var correctionCutOffVersion = "1.2.0";
+        var tiltCorrection = tiltCorrectionForOlderCog;
+        if (isVersionGreater_errorCatching(cogVersion, correctionCutOffVersion)) {
+            tiltCorrection = tiltCorrectionForNewerCog;
+        }
+        var _a = TiltDetection.rotateAccelData(ax, ay, az * -1, tiltCorrection), x = _a.x, y = _a.y, z = _a.z;
+        var pitch = Math.atan2(x, this.distance(y, z));
+        var roll = Math.atan2(y, this.distance(x, z));
+        var yaw = Math.atan2(z, this.distance(x, y));
+        // no tilt example values: pitch: 0.00, roll: 0.00, yaw: 1.50
+        // tilt left example values: pitch: 0.00, roll: -1.00, yaw: 0.50
+        // tilt right example values: pitch: 0.00, roll: 1.00, yaw: 0.50
+        // tilt forward example values: pitch: -1.00, roll: 0.00, yaw: 0.50
+        // tilt backward example values: pitch: 1.00, roll: 0.00, yaw: 0.50
+        var forwardBackwardThreshold = 20 * (Math.PI / 180); // threshold for forward and backward tilt
+        var leftRightThreshold = 20 * (Math.PI / 180); // threshold for left and right tilt
+        var upDownThreshold = 0.5; // threshold for up and down tilt
+        var tiltDirection = "none";
+        if (pitch < -forwardBackwardThreshold) { // && Math.abs(yaw) < upDownThreshold) {
+            tiltDirection = "forward";
+        }
+        if (pitch > forwardBackwardThreshold) { // && Math.abs(yaw) < upDownThreshold) {
+            tiltDirection = "backward";
+        }
+        if (roll < -leftRightThreshold) { // && Math.abs(yaw) < upDownThreshold) {
+            tiltDirection = "left";
+        }
+        if (roll > leftRightThreshold) { // && Math.abs(yaw) < upDownThreshold) {
+            tiltDirection = "right";
+        }
+        analyser.setTilt(tiltDirection);
+    };
+    return TiltDetection;
+}());
+var RotationDetection = /** @class */ (function () {
+    function RotationDetection() {
+        this.dataBuffer = [];
+        this.bufferSize = 20; // buffer size for rotation detection
+        this.DELAY_FOR_ROTATION = 500; // delay between rotation detection
+        this.ROTATION_THRESHOLD = 8; // threshold for rotation detection
+        this.rotationDetected = false;
+        this.lastRotationDetectionTime = 0;
+        this.rotationTimer = null;
+    }
+    RotationDetection.prototype.addToBuffer = function (data) {
+        this.dataBuffer.push(data);
+        if (this.dataBuffer.length > this.bufferSize) {
+            this.dataBuffer.shift();
+        }
+    };
+    RotationDetection.prototype.detectRotation = function (gz, isMoving, analyser) {
+        if (isMoving === void 0) { isMoving = false; }
+        var currentTime = Date.now();
+        this.addToBuffer(gz);
+        if (this.dataBuffer.length < this.bufferSize) {
+            return; // Wait until buffer is full
+        }
+        if (currentTime - this.lastRotationDetectionTime < this.DELAY_FOR_ROTATION || isMoving) {
+            // Ensure there is a minimum time between detections
+            return;
+        }
+        var metric = this.calculateMetric();
+        // Check if the magnitude of the rate of change is above the threshold
+        if (metric > this.ROTATION_THRESHOLD || metric < -this.ROTATION_THRESHOLD) {
+            this.lastRotationDetectionTime = currentTime;
+            this.dataBuffer = [];
+            console.log("Rotation detected. Rotation: ", metric > this.ROTATION_THRESHOLD ? "clockwise" : "counter-clockwise");
+            if (metric > this.ROTATION_THRESHOLD) {
+                // console.log("Clockwise rotation detected:", metric);
+                analyser.setRotation("clockwise");
+            }
+            else if (metric < -this.ROTATION_THRESHOLD) {
+                // console.log("Counter-clockwise rotation detected:", metric);
+                analyser.setRotation("counterClockwise");
+            }
+        }
+        else {
+            analyser.setRotation("none");
+        }
+    };
+    RotationDetection.prototype.calculateMetric = function () {
+        //let gzArray = [];
+        var sum = 0;
+        for (var i = 0; i < this.dataBuffer.length; i++) {
+            //sum += this.dataBuffer[i].LSM6DS.gz;
+            sum += this.dataBuffer[i];
+            //gzArray.push(this.dataBuffer[i]);
+        }
+        //console.log("gz buffer (" + gzArray.length + " elements avg. " + (sum / this.dataBuffer.length) + "): " + gzArray);
+        //console.log(this.dataBuffer);
+        return sum / this.dataBuffer.length;
+    };
+    return RotationDetection;
+}());
+var ShakeDetector = /** @class */ (function () {
+    function ShakeDetector() {
+        this.thresholdAccelerationMove = 0.3;
+        this.thresholdAcceleration = 1; // how much acceleration is needed to consider shaking
+        this.thresholdShakeNumber = 1; // how many shakes are needed
+        this.interval = 400; // how much time between shakes
+        this.maxShakeDuration = 1500; // Maximum duration between first and last shakes in a sequence
+        this.coolOffPeriod = 1500; // how much time to wait before detecting another shake
+        this.lastTime = 0;
+        this.lastTimeShakeDetected = 0;
+        this.sensorBundles = [];
+        this.gravityVector = [0, 0, 0];
+        this.lastVector = [0, 0, 0];
+        this.shakeInProgress = false;
+        this.moveInProgress = false;
+    }
+    ShakeDetector.prototype.detectShake = function (xAcc, yAcc, zAcc, timestamp, analyser) {
+        this.thresholdAcceleration = this.thresholdAcceleration;
+        this.thresholdAccelerationMove = this.thresholdAccelerationMove;
+        this.thresholdShakeNumber = this.thresholdShakeNumber;
+        this.interval = this.interval;
+        this.maxShakeDuration = this.maxShakeDuration;
+        this.coolOffPeriod = this.coolOffPeriod;
+        var magAcc = Math.sqrt(xAcc * xAcc + yAcc * yAcc + zAcc * zAcc);
+        if (magAcc > 0.9 && magAcc < 1.1) {
+            // device is stationary-ish, log direction of acc values to get a rough reading on where down is
+            this.gravityVector = [xAcc, yAcc, zAcc];
+            if (this.moveInProgress) {
+                // console.log("move detected");
+                // analyser.setMovementType("move");
+            }
+            else {
+                // console.log("no move detected");
+                analyser.setMovementType("none");
+            }
+            this.moveInProgress = false;
+            this.shakeInProgress = false;
+            this.sensorBundles = [];
+            return this.shakeInProgress;
+        }
+        else {
+            //console.log("move in progrss. prev state: ", this.moveInProgress);
+            // potentially threshold this with thresholeAccelerationMove if we want it to be less trigger happy
+            this.moveInProgress = true;
+            // this assumes that the orientation of the device doesn't change during the movement, so it's not ideal
+            var x = xAcc - this.gravityVector[0];
+            var y = yAcc - this.gravityVector[1];
+            var z = zAcc - this.gravityVector[2];
+            var mag = Math.sqrt(x * x + y * y + z * z);
+            if (mag > this.thresholdAcceleration || this.shakeInProgress) {
+                this.shakeInProgress = true;
+                var diffThresh = this.thresholdAcceleration;
+                if (mag > this.thresholdAcceleration) {
+                    // console.log('large magnitude movement ', x, y, z, this.gravityVector);
+                    // check if the acc vector is significantly changed from the previous large value
+                    if (!this.sensorBundles.length || Math.sqrt(Math.pow(this.lastVector[0] - x, 2) + Math.pow(this.lastVector[1] - y, 2) + Math.pow(this.lastVector[2] - z, 2)) > this.thresholdAcceleration) {
+                        this.sensorBundles.push({ x: x, y: y, z: z, timestamp: timestamp });
+                        //console.log(this.sensorBundles);
+                        this.lastVector = [x, y, z];
+                        // todo - call performCheck() to do a more detailed analysis of the readings? Might need some tweaks
+                        if (this.sensorBundles.length > this.thresholdShakeNumber) {
+                            // console.log("Shake detected!");
+                            this.sensorBundles = [];
+                            this.shakeInProgress = true;
+                            analyser.setMovementType("shake");
+                        }
+                    }
+                    // this.noMoveCallback();
+                }
+                else {
+                    if (!this.sensorBundles.length || (timestamp - this.sensorBundles[this.sensorBundles.length - 1].timestamp) > this.interval) {
+                        this.shakeInProgress = false;
+                        this.sensorBundles = [];
+                        // console.log("resetting shake detector. Move detected");
+                        // fire move detector
+                        analyser.setMovementType("none");
+                    }
+                }
+            }
+            return this.shakeInProgress;
+            /*
+            if (this.sensorBundles.length === 0 || timestamp - this.lastTime > this.interval) {
+                // Check if we should reset based on time since last recorded shake
+                if (this.sensorBundles.length > 0 && (timestamp - this.sensorBundles[0].timestamp) > this.maxShakeDuration) {
+                    this.sensorBundles = []; // Reset the sensor data if the shakes are too far apart
+                }
+                this.sensorBundles.push({ xAcc, yAcc, zAcc, timestamp });
+                this.lastTime = timestamp;
+                this.performCheck();
+            }
+            */
+        }
+    };
+    ShakeDetector.prototype.performCheck = function (analyser) {
+        var _this = this;
+        var matrix = [
+            [0, 0],
+            [0, 0],
+            [0, 0] // Z axis positive and negative
+        ];
+        for (var _i = 0, _a = this.sensorBundles; _i < _a.length; _i++) {
+            var bundle = _a[_i];
+            this.updateAxis(0, bundle.x, matrix);
+            this.updateAxis(1, bundle.y, matrix);
+            this.updateAxis(2, bundle.z, matrix, -1);
+        }
+        // check if any of the negatives and the positives are greater than the threshold
+        var negativesTotal = matrix.reduce(function (acc, axis) { return acc + axis[1]; }, 0);
+        var positivesTotal = matrix.reduce(function (acc, axis) { return acc + axis[0]; }, 0);
+        if (matrix.some(function (axis) { return axis[0] >= _this.thresholdShakeNumber && axis[1] >= _this.thresholdShakeNumber; })) {
+            // if (positivesTotal >= this.thresholdShakeNumber && negativesTotal >= this.thresholdShakeNumber) {
+            if (Date.now() - this.lastTimeShakeDetected < this.coolOffPeriod) {
+                return;
+            }
+            this.lastTimeShakeDetected = Date.now();
+            // console.log("Shake detected!", JSON.stringify(matrix));
+            analyser.setMovementType("shake");
+            this.sensorBundles = [];
+        }
+    };
+    ShakeDetector.prototype.updateAxis = function (index, acceleration, matrix, adjustment) {
+        if (adjustment === void 0) { adjustment = 0; }
+        var accelerationAdjusted = acceleration + adjustment;
+        if (accelerationAdjusted > this.thresholdAcceleration) {
+            matrix[index][0]++;
+            // console.log(JSON.stringify(matrix));
+        }
+        else if (accelerationAdjusted < -this.thresholdAcceleration) {
+            matrix[index][1]++;
+            // console.log(JSON.stringify(matrix));
+        }
+    };
+    return ShakeDetector;
+}());
+var ButtonClickDetection = /** @class */ (function () {
+    function ButtonClickDetection() {
+        /*
+        When the threshold is exceeded, the button is clicked, but we want to send the event when the button is released
+        so that the event is triggered only once.
+        */
+        this.clickThreshold = 1600;
+        this.releaseThreshold = 1590;
+        this.lastTime = 0;
+        this.buttonClicked = false;
+    }
+    ButtonClickDetection.prototype.detectButtonClick = function (buttonValue, analyser, cogVersion) {
+        var currentTime = Date.now();
+        if (buttonValue > this.clickThreshold && !this.buttonClicked) {
+            // console.log("Button clicked", buttonValue);
+            this.buttonClicked = true;
+            this.lastTime = currentTime;
+            Logger.info(SHOW_LOGS, TAG, "Button clicked");
+            analyser.setButtonClick("click");
+        }
+        else if (buttonValue < this.releaseThreshold && this.buttonClicked) {
+            // console.log("Button released", buttonValue);
+            this.buttonClicked = false;
+            Logger.info(SHOW_LOGS, TAG, "Button released");
+            analyser.setButtonClick("release");
+        }
+        // } else {
+        //     this.buttonClicked = false;
+        //     this.buttonReleaseCallback();
+        // }
+    };
+    return ButtonClickDetection;
+}());
+export { ButtonClickDetection };
+var ObjectSenseDetection = /** @class */ (function () {
+    function ObjectSenseDetection() {
+        this.objectSensed0Threshold = 2500; // left of the arrow
+        this.objectSensed1Threshold = 2500; // right of the arrow
+        this.objectSensed2Threshold = 1500; // button
+    }
+    ObjectSenseDetection.prototype.detectObjectSense = function (objectSenseValue, analyser) {
+        if (objectSenseValue[0] > this.objectSensed0Threshold) {
+            analyser.setObjectSense("left");
+        }
+        else if (objectSenseValue[1] > this.objectSensed1Threshold) {
+            analyser.setObjectSense("right");
+        }
+        else {
+            analyser.setObjectSense("none");
+        }
+    };
+    return ObjectSenseDetection;
+}());
+var LightSenseDetection = /** @class */ (function () {
+    function LightSenseDetection() {
+        this.lowLightThreshold = 5;
+        this.midLightThreshold = 250;
+        this.highLightThreshold = 450;
+    }
+    LightSenseDetection.prototype.detectLightSense = function (lightSenseValue, analyser) {
+        if (lightSenseValue > this.highLightThreshold) {
+            analyser.setLightSense("high");
+        }
+        else if (lightSenseValue > this.midLightThreshold) {
+            analyser.setLightSense("mid");
+        }
+        else if (lightSenseValue > this.lowLightThreshold) {
+            analyser.setLightSense("low");
+        }
+        else {
+            analyser.setLightSense("none");
+        }
+    };
+    return LightSenseDetection;
+}());
+export var setButtonThresholdsUtil = function (connectedCog) { return __awaiter(void 0, void 0, void 0, function () {
+    var lightResponse, irMin, irMax, buttonClickDetection, error_1;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                Logger.info(SHOW_LOGS, TAG, "Setting button thresholds");
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, 3, , 4]);
+                return [4 /*yield*/, connectedCog.sendRestMessage('light')];
+            case 2:
+                lightResponse = _a.sent();
+                if (lightResponse && lightResponse.rslt === "ok" && lightResponse.light.irMax4) {
+                    irMin = lightResponse.light.irMin4;
+                    irMax = lightResponse.light.irMax4;
+                    Logger.info(SHOW_LOGS, TAG, "Got button thresholds: irMin: ".concat(irMin, ", irMax: ").concat(irMax));
+                    buttonClickDetection = connectedCog.publishedDataAnalyser.buttonClickDetection;
+                    buttonClickDetection.clickThreshold = irMin + (irMax - irMin) / 2;
+                    buttonClickDetection.releaseThreshold = buttonClickDetection.clickThreshold - 10;
+                    Logger.info(SHOW_LOGS, TAG, "Set button thresholds: clickThreshold: ".concat(buttonClickDetection.clickThreshold, ", releaseThreshold: ").concat(buttonClickDetection.releaseThreshold));
+                }
+                else {
+                    Logger.warn(SHOW_LOGS, TAG, "Couldn't get button thresholds, probably older fw version");
+                }
+                return [3 /*break*/, 4];
+            case 3:
+                error_1 = _a.sent();
+                Logger.warn(SHOW_LOGS, TAG, "Couldn't get button thresholds, probably older fw version");
+                return [3 /*break*/, 4];
+            case 4: return [2 /*return*/];
+        }
+    });
+}); };
+export default PublishedDataAnalyser;

package/dist-types/src/application/RAFTs/Marty/Marty.d.ts

@@ -0,0 +1,42 @@
+import RICInterface from "../RAFTInterface";
+import { RaftTypeE } from "../../../types/raft";
+import RAFT from "../RAFT";
+import { RaftConnEvent, RaftPublishEvent, RaftSystemInfo, RaftUpdateEvent } from "@robotical/raftjs";
+import { RaftInfoEvents } from "../../../types/events/raft-info";
+import { RICLedLcdColours, RICStateInfo } from "@robotical/roboticaljs";
+export declare class Marty extends RAFT implements RICInterface {
+    id: string;
+    type: RaftTypeE;
+    raftStateInfo: RICStateInfo | null;
+    systemInfo: RaftSystemInfo | null;
+    _ledLcdColours: RICLedLcdColours;
+    private rssiValues;
+    private MAX_RSSI_VALUES_N;
+    constructor(id: string);
+    get ledLcdColours(): RICLedLcdColours;
+    /**
+    * Gets the RSSI of the RAFT
+    */
+    getRSSI(): number;
+    /**
+     * Gets the battery strength of the RAFT
+     */
+    getBatteryStrength(): number;
+    /**
+     * Highlights Marty by flashing the LED and playing a tune
+     */
+    highlight(): Promise<void>;
+    /**
+    * This methods handles RAFT events coming from the RICConnector of the wrapper
+    */
+    handleRaftEvent(eventType: string, eventEnum: RaftConnEvent | RaftUpdateEvent | RaftPublishEvent | RaftInfoEvents, eventName: string, eventData: any): void;
+    /**
+     * Pub Event Handler
+     */
+    pubEventHandler(eventEnum: RaftPublishEvent, eventName: string, data: any): Promise<void>;
+    /**
+     * Raft Info Event Handler
+     */
+    raftInfoEventHandler(eventEnum: RaftInfoEvents, eventName: string, data: any): Promise<void>;
+}
+export default Marty;