@robotical/webapp-types 3.14.23 → 3.14.25

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

@@ -8,6 +8,7 @@ import { MartyWifiManager } from "./MartyWifiManager";
 import MartyAddonsManager from "./MartyAddonsManager";
 import CalibrationManager from "./CalibrationManager";
 import { RICNotificationsManager } from "./notifications-manager/RICNotificationsManager";
+import PublishedDataAnalyser from "./PublishedDataAnalyser";
 export declare class Marty extends RAFT implements RICInterface {
     id: string;
     type: RaftTypeE;
@@ -17,6 +18,7 @@ export declare class Marty extends RAFT implements RICInterface {
     addonsManager: MartyAddonsManager;
     calibrationManager: CalibrationManager;
     ricNotificationManager: RICNotificationsManager;
+    publishedDataAnalyser: PublishedDataAnalyser;
     _ledLcdColours: RICLedLcdColours;
     private rssiValues;
     private MAX_RSSI_VALUES_N;

package/dist-types/src/application/RAFTs/Marty/Marty.js

@@ -58,6 +58,7 @@ import CalibrationManager from "./CalibrationManager";
 import Logger from "../../../services/logger/Logger";
 import { AppSentMessage } from "../../../types/communication-between-apps/wrapper-communication";
 import { RICNotificationsManager } from "./notifications-manager/RICNotificationsManager";
+import PublishedDataAnalyser from "./PublishedDataAnalyser";
 var SHOW_LOGS = true;
 var TAG = "Marty";
 var Marty = /** @class */ (function (_super) {
@@ -77,6 +78,8 @@ var Marty = /** @class */ (function (_super) {
         // Calibration Manager
         _this.calibrationManager = new CalibrationManager(_this);
         _this.ricNotificationManager = new RICNotificationsManager(_this);
+        // Published data analyser  
+        _this.publishedDataAnalyser = new PublishedDataAnalyser(_this);
         // Colours to use for LED patterns
         _this._ledLcdColours = [
             { led: "#202000", lcd: "#FFFF00" },

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

@@ -0,0 +1,58 @@
+/// <reference types="node" />
+import EventEmitter from "events";
+import RAFT from "../RAFT";
+import type { RICStateInfo } from "@robotical/roboticaljs";
+import { type ColourSensorValues } from "./published-data-helpers";
+interface MartyState {
+    colourSensed: "blue" | "green" | "red" | "yellow" | "purple" | "unclear" | "air";
+    lightSense: "none" | "high" | "mid" | "low";
+    objectSense: "none" | "near";
+    noiseSense: "none" | "detected";
+}
+declare class PublishedDataAnalyser extends EventEmitter {
+    private marty;
+    martyState: MartyState;
+    private pubSub;
+    lightSenseDetection: LightSenseDetection;
+    colourSensedDetection: ColourSensedDetection;
+    objectSenseDetection: ObjectSenseDetection;
+    noiseSenseDetection: NoiseSenseDetection;
+    eventsMap: {
+        colourSensed: Record<MartyState["colourSensed"], string>;
+        lightSense: Record<MartyState["lightSense"], string>;
+        objectSense: Record<MartyState["objectSense"], string>;
+        noiseSense: Record<MartyState["noiseSense"], string>;
+    };
+    connectedSensors: {
+        colourSensor: boolean;
+        lightSensor: boolean;
+        objectSensor: boolean;
+        noiseSensor: boolean;
+    };
+    constructor(marty: RAFT);
+    subscribeToPublishedData(): void;
+    unsubscribeFromPublishedData(): void;
+    analyse(data: RICStateInfo): void;
+    setColourSensed(colour: MartyState["colourSensed"]): void;
+    setLightSense(lightSense: MartyState["lightSense"]): void;
+    setObjectSense(objectSense: MartyState["objectSense"]): void;
+    setNoiseSense(noiseSense: MartyState["noiseSense"]): void;
+}
+declare class ColourSensedDetection {
+    private thresholds;
+    detectColourSensed({ r, g, b, clear, air }: ColourSensorValues, analyser: PublishedDataAnalyser): void;
+}
+declare class LightSenseDetection {
+    private lowLightThreshold;
+    private midLightThreshold;
+    private highLightThreshold;
+    detectLightSense(lightSenseValues: [number, number, number], analyser: PublishedDataAnalyser): void;
+}
+declare class ObjectSenseDetection {
+    detectObjectSense(objectSenseValue: boolean, analyser: PublishedDataAnalyser): void;
+}
+declare class NoiseSenseDetection {
+    private noiseThreshold;
+    detectNoiseSense(noiseSenseValue: number, analyser: PublishedDataAnalyser): void;
+}
+export default PublishedDataAnalyser;

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

@@ -0,0 +1,204 @@
+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 __());
+    };
+})();
+import EventEmitter from "events";
+import { createRaftPubSubscriptionHelper } from "../raft-subscription-helpers";
+import { getColourSensor, getLightSensor, getObjectSensor, getNoiseSensor, getRGBFromColourSensorVals, getHueChroma, getLightSenseValues, getObjectIsTouchingFromVals, getNoiseSenseValue, } from "./published-data-helpers";
+var PublishedDataAnalyser = /** @class */ (function (_super) {
+    __extends(PublishedDataAnalyser, _super);
+    function PublishedDataAnalyser(marty) {
+        var _this = _super.call(this) || this;
+        _this.marty = marty;
+        _this.lightSenseDetection = new LightSenseDetection();
+        _this.colourSensedDetection = new ColourSensedDetection();
+        _this.objectSenseDetection = new ObjectSenseDetection();
+        _this.noiseSenseDetection = new NoiseSenseDetection();
+        _this.eventsMap = {
+            colourSensed: {
+                blue: "blue",
+                green: "green",
+                red: "red",
+                yellow: "yellow",
+                purple: "purple",
+                unclear: "unclear",
+                air: "air",
+            },
+            lightSense: {
+                high: "highLightSense",
+                mid: "midLightSense",
+                low: "lowLightSense",
+                none: "noLightSense",
+            },
+            objectSense: {
+                none: "noObjectSense",
+                near: "objectNear",
+            },
+            noiseSense: {
+                none: "noNoiseSense",
+                detected: "noiseDetected",
+            },
+        };
+        _this.connectedSensors = {
+            colourSensor: false,
+            lightSensor: false,
+            objectSensor: false,
+            noiseSensor: false,
+        };
+        _this.marty = marty;
+        _this.martyState = {
+            colourSensed: "unclear",
+            lightSense: "none",
+            objectSense: "none",
+            noiseSense: "none",
+        };
+        _this.pubSub = null;
+        _this.subscribeToPublishedData();
+        return _this;
+    }
+    PublishedDataAnalyser.prototype.subscribeToPublishedData = function () {
+        var _this = this;
+        this.pubSub = createRaftPubSubscriptionHelper(this.marty, this.marty.id);
+        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 colourSensor = getColourSensor(data);
+        var lightSensor = getLightSensor(data);
+        var objectSensor = getObjectSensor(data);
+        var noiseSensor = getNoiseSensor(data);
+        colourSensor &&
+            this.colourSensedDetection.detectColourSensed(getRGBFromColourSensorVals(colourSensor), this);
+        (objectSensor || colourSensor) &&
+            this.objectSenseDetection.detectObjectSense(getObjectIsTouchingFromVals(objectSensor, colourSensor), this);
+        lightSensor &&
+            this.lightSenseDetection.detectLightSense(getLightSenseValues(lightSensor), this);
+        noiseSensor &&
+            this.noiseSenseDetection.detectNoiseSense(getNoiseSenseValue(noiseSensor), this);
+        this.connectedSensors.colourSensor = !!colourSensor;
+        this.connectedSensors.lightSensor = !!lightSensor;
+        this.connectedSensors.objectSensor = !!objectSensor || !!colourSensor;
+        this.connectedSensors.noiseSensor = !!noiseSensor;
+    };
+    PublishedDataAnalyser.prototype.setColourSensed = function (colour) {
+        this.martyState.colourSensed = colour;
+        this.emit(this.eventsMap.colourSensed[colour]);
+    };
+    PublishedDataAnalyser.prototype.setLightSense = function (lightSense) {
+        this.martyState.lightSense = lightSense;
+        this.emit(this.eventsMap.lightSense[lightSense]);
+    };
+    PublishedDataAnalyser.prototype.setObjectSense = function (objectSense) {
+        this.martyState.objectSense = objectSense;
+        this.emit(this.eventsMap.objectSense[objectSense]);
+    };
+    PublishedDataAnalyser.prototype.setNoiseSense = function (noiseSense) {
+        this.martyState.noiseSense = noiseSense;
+        this.emit(this.eventsMap.noiseSense[noiseSense]);
+    };
+    return PublishedDataAnalyser;
+}(EventEmitter));
+var ColourSensedDetection = /** @class */ (function () {
+    function ColourSensedDetection() {
+        this.thresholds = [
+            { hue: [0, 10], chroma: [50, 200], clear: [40, 150], name: "red" },
+            { hue: [20, 50], chroma: [40, 300], clear: [100, 255], name: "yellow" },
+            { hue: [85, 160], chroma: [5, 100], clear: [25, 150], name: "green" },
+            { hue: [180, 220], chroma: [40, 230], clear: [55, 255], name: "blue" },
+            { hue: [200, 320], chroma: [0, 40], clear: [25, 150], name: "purple" },
+            { hue: [345, 361], chroma: [50, 200], clear: [40, 150], name: "red" },
+        ];
+    }
+    ColourSensedDetection.prototype.detectColourSensed = function (_a, analyser) {
+        var r = _a.r, g = _a.g, b = _a.b, clear = _a.clear, air = _a.air;
+        if (air) {
+            return analyser.setColourSensed("air");
+        }
+        else {
+            var _b = getHueChroma(r, g, b), hue = _b[0], chroma = _b[1];
+            for (var _i = 0, _c = this.thresholds; _i < _c.length; _i++) {
+                var colour = _c[_i];
+                if (colour.hue[0] <= hue &&
+                    hue <= colour.hue[1] &&
+                    colour.chroma[0] <= chroma &&
+                    chroma <= colour.chroma[1] &&
+                    colour.clear[0] <= clear &&
+                    clear <= colour.clear[1]) {
+                    return analyser.setColourSensed(colour.name);
+                }
+            }
+            return analyser.setColourSensed("unclear");
+        }
+    };
+    return ColourSensedDetection;
+}());
+var LightSenseDetection = /** @class */ (function () {
+    function LightSenseDetection() {
+        this.lowLightThreshold = 30;
+        this.midLightThreshold = 250;
+        this.highLightThreshold = 500;
+    }
+    LightSenseDetection.prototype.detectLightSense = function (lightSenseValues, analyser) {
+        var lightSenseValue1 = lightSenseValues[0], lightSenseValue2 = lightSenseValues[1], lightSenseValue3 = lightSenseValues[2];
+        var avgLightSense = (lightSenseValue1 + lightSenseValue2 + lightSenseValue3) / 3;
+        if (avgLightSense >= this.highLightThreshold) {
+            analyser.setLightSense("high");
+        }
+        else if (avgLightSense >= this.midLightThreshold) {
+            analyser.setLightSense("mid");
+        }
+        else if (avgLightSense >= this.lowLightThreshold) {
+            analyser.setLightSense("low");
+        }
+        else {
+            analyser.setLightSense("none");
+        }
+    };
+    return LightSenseDetection;
+}());
+var ObjectSenseDetection = /** @class */ (function () {
+    function ObjectSenseDetection() {
+    }
+    ObjectSenseDetection.prototype.detectObjectSense = function (objectSenseValue, analyser) {
+        if (objectSenseValue) {
+            analyser.setObjectSense("near");
+        }
+        else {
+            analyser.setObjectSense("none");
+        }
+    };
+    return ObjectSenseDetection;
+}());
+var NoiseSenseDetection = /** @class */ (function () {
+    function NoiseSenseDetection() {
+        this.noiseThreshold = 300;
+    }
+    NoiseSenseDetection.prototype.detectNoiseSense = function (noiseSenseValue, analyser) {
+        if (noiseSenseValue > this.noiseThreshold) {
+            analyser.setNoiseSense("detected");
+        }
+        else {
+            analyser.setNoiseSense("none");
+        }
+    };
+    return NoiseSenseDetection;
+}());
+export default PublishedDataAnalyser;

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

@@ -0,0 +1,17 @@
+import type { RICStateInfo, ROSSerialAddOnStatus } from "@robotical/roboticaljs";
+export type ColourSensorValues = {
+    r: number;
+    g: number;
+    b: number;
+    clear: number;
+    air: boolean;
+};
+export declare const getColourSensor: (stateInfo: RICStateInfo) => ROSSerialAddOnStatus | null;
+export declare const getRGBFromColourSensorVals: (status: ROSSerialAddOnStatus) => ColourSensorValues;
+export declare const getHueChroma: (r: number, g: number, b: number) => [number, number];
+export declare const getLightSensor: (stateInfo: RICStateInfo) => ROSSerialAddOnStatus | null;
+export declare const getLightSenseValues: (status: ROSSerialAddOnStatus | null) => [number, number, number];
+export declare const getObjectSensor: (stateInfo: RICStateInfo) => ROSSerialAddOnStatus | null;
+export declare const getObjectIsTouchingFromVals: (obstacleStatus: ROSSerialAddOnStatus | null, colourStatus: ROSSerialAddOnStatus | null) => boolean;
+export declare const getNoiseSensor: (stateInfo: RICStateInfo) => ROSSerialAddOnStatus | null;
+export declare const getNoiseSenseValue: (status: ROSSerialAddOnStatus | null) => number;

package/dist-types/src/application/RAFTs/Marty/published-data-helpers.js

@@ -0,0 +1,122 @@
+import { RIC_WHOAMI_TYPE_CODE_ADDON_COLOUR, RIC_WHOAMI_TYPE_CODE_ADDON_IRFOOT, RIC_WHOAMI_TYPE_CODE_ADDON_LIGHT, RIC_WHOAMI_TYPE_CODE_ADDON_NOISE, } from "@robotical/ricjs-robotical-addons/dist/RICRoboticalAddOns";
+/* COLOUR SENSOR HELPERS */
+export var getColourSensor = function (stateInfo) {
+    if (!stateInfo.addOnInfo || !stateInfo.addOnInfo.addons)
+        return null;
+    var colourSensor = stateInfo.addOnInfo.addons.find(function (addon) { return addon.whoAmI === RIC_WHOAMI_TYPE_CODE_ADDON_COLOUR; });
+    return colourSensor || null;
+};
+export var getRGBFromColourSensorVals = function (status) {
+    if (!status || !status.vals)
+        return { r: 0, g: 0, b: 0, clear: 0, air: false };
+    var BLUE_KEY_WORD = "Blue";
+    var GREEN_KEY_WORD = "Green";
+    var RED_KEY_WORD = "Red";
+    var CLEAR_KEY_WORD = "Clear";
+    var AIR_KEY_WORD = "Air";
+    var r = 0, g = 0, b = 0, clear = 0;
+    var air = false;
+    for (var key in status.vals) {
+        if (key.includes(RED_KEY_WORD)) {
+            r = status.vals[key];
+        }
+        else if (key.includes(GREEN_KEY_WORD)) {
+            g = status.vals[key];
+        }
+        else if (key.includes(BLUE_KEY_WORD)) {
+            b = status.vals[key];
+        }
+        else if (key.includes(CLEAR_KEY_WORD)) {
+            clear = status.vals[key];
+        }
+        else if (key.includes(AIR_KEY_WORD)) {
+            air = Boolean(status.vals[key]);
+        }
+    }
+    return { r: r, g: g, b: b, clear: clear, air: air };
+};
+export var getHueChroma = function (r, g, b) {
+    var maxVal = Math.max(r, g, b);
+    var minVal = Math.min(r, g, b);
+    var chroma = maxVal - minVal;
+    var hue = 0;
+    if (chroma === 0)
+        return [0, 0]; // avoid NaN when r=g=b
+    if (r > g && r > b) {
+        hue = (((g - b) / chroma) % 6) * 60;
+    }
+    else if (g > b) {
+        hue = ((b - r) / chroma + 2) * 60;
+    }
+    else {
+        hue = ((r - g) / chroma + 4) * 60;
+    }
+    if (hue < 0)
+        hue += 360;
+    return [hue, chroma];
+};
+/* END OF COLOUR SENSOR HELPERS */
+/* LIGHT SENSOR HELPERS */
+export var getLightSensor = function (stateInfo) {
+    if (!stateInfo.addOnInfo || !stateInfo.addOnInfo.addons)
+        return null;
+    var lightSensor = stateInfo.addOnInfo.addons.find(function (addon) { return addon.whoAmI === RIC_WHOAMI_TYPE_CODE_ADDON_LIGHT; });
+    return lightSensor || null;
+};
+export var getLightSenseValues = function (status) {
+    if (!status || !status.vals)
+        return [0, 0, 0];
+    var readings = [];
+    for (var key in status.vals) {
+        readings.push(status.vals[key]);
+    }
+    return readings;
+};
+/* END OF LIGHT SENSOR HELPERS */
+/* OBJECT SENSOR HELPERS */
+export var getObjectSensor = function (stateInfo) {
+    if (!stateInfo.addOnInfo || !stateInfo.addOnInfo.addons)
+        return null;
+    var objectSensor = stateInfo.addOnInfo.addons.find(function (addon) { return addon.whoAmI === RIC_WHOAMI_TYPE_CODE_ADDON_IRFOOT; });
+    return objectSensor || null;
+};
+export var getObjectIsTouchingFromVals = function (obstacleStatus, colourStatus) {
+    // if either the ir from the ir or the colour sensors indicate touching, return true
+    var isTouching = false;
+    var TOUCHING_KEY_WORD = "Touch";
+    if (obstacleStatus && obstacleStatus.vals) {
+        for (var key in obstacleStatus.vals) {
+            if (key.endsWith(TOUCHING_KEY_WORD)) {
+                isTouching = isTouching || Boolean(obstacleStatus.vals[key]);
+            }
+        }
+    }
+    if (colourStatus && colourStatus.vals) {
+        for (var key in colourStatus.vals) {
+            if (key.endsWith(TOUCHING_KEY_WORD)) {
+                isTouching = isTouching || Boolean(colourStatus.vals[key]);
+            }
+        }
+    }
+    return isTouching;
+};
+/* END OF OBJECT SENSOR HELPERS */
+/* NOISE SENSOR HELPERS */
+export var getNoiseSensor = function (stateInfo) {
+    if (!stateInfo.addOnInfo || !stateInfo.addOnInfo.addons)
+        return null;
+    var noiseSensor = stateInfo.addOnInfo.addons.find(function (addon) { return addon.whoAmI === RIC_WHOAMI_TYPE_CODE_ADDON_NOISE; });
+    return noiseSensor || null;
+};
+export var getNoiseSenseValue = function (status) {
+    if (!status || !status.vals)
+        return 0;
+    var NOISE_KEY_WORD = "HighestSinceLastReading";
+    for (var key in status.vals) {
+        if (key.includes(NOISE_KEY_WORD)) {
+            return status.vals[key];
+        }
+    }
+    return 0;
+};
+/* END OF NOISE SENSOR HELPERS */ 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robotical/webapp-types",
-  "version": "3.14.23",
+  "version": "3.14.25",
   "description": "Type definitions for the Application Manager",
   "main": "dist/application-manager.d.ts",
   "types": "dist/application-manager.d.ts",