@robotical/webapp-types 1.0.6 → 1.0.8

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

@@ -51,7 +51,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 import RAFT from "../RAFT";
 import { RaftTypeE } from "../../../types/raft";
-import { RaftConnEvent, RaftPublishEvent } from "@robdobsn/raftjs";
+import { deviceAttrGetLatestFormatted, RaftConnEvent, RaftPublishEvent } from "@robdobsn/raftjs";
 import { RaftInfoEvents } from "../../../types/events/raft-info";
 import PublishedDataAnalyser from "./PublishedDataAnalyser";
 var Cog = /** @class */ (function (_super) {
@@ -91,8 +91,23 @@ var Cog = /** @class */ (function (_super) {
      * Gets the battery strength of the RAFT
      */
     Cog.prototype.getBatteryStrength = function () {
-        var _a;
-        return ((_a = this.raftStateInfo) === null || _a === void 0 ? void 0 : _a.Power.battV) ? Math.round(this.raftStateInfo.Power.battV * 100) : 0;
+        var _a, _b, _c, _d;
+        /* check if usb is connected */
+        var usbAttr = (_b = (_a = this.raftStateInfo) === null || _a === void 0 ? void 0 : _a.deviceManager.getDeviceState('RoboCogPowerV1_00')) === null || _b === void 0 ? void 0 : _b.deviceAttributes['USB'];
+        if (!usbAttr)
+            return 0.1;
+        var usb = deviceAttrGetLatestFormatted(usbAttr);
+        if (usb === 'yes')
+            return 0; // 0 indicates USB is connected
+        /* if usb is not connected, check battery voltage */
+        var battVAttr = (_d = (_c = this.raftStateInfo) === null || _c === void 0 ? void 0 : _c.deviceManager.getDeviceState('RoboCogPowerV1_00')) === null || _d === void 0 ? void 0 : _d.deviceAttributes['battV'];
+        if (!battVAttr)
+            return 0.1;
+        var battV = deviceAttrGetLatestFormatted(battVAttr);
+        if (!isNaN(+battV)) {
+            return Math.round(+battV * 100);
+        }
+        return 0;
     };
     /**
    * This methods handles RAFT events coming from the RICConnector of the wrapper
@@ -121,7 +136,7 @@ var Cog = /** @class */ (function (_super) {
             return __generator(this, function (_a) {
                 switch (eventEnum) {
                     case RaftConnEvent.CONN_DISCONNECTED:
-                        this.publishedDataAnalyser.unsubscribeFromPublishedData();
+                        // this.publishedDataAnalyser.unsubscribeFromPublishedData();
                         break;
                     default:
                         break;

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

@@ -1,28 +1,60 @@
+/// <reference types="node" />
 import { CogStateInfo } from "@robotical/roboticaljs";
 import RAFT from "../RAFT";
+import PublishedDataGetter from "./PublishedDataGetter";
+import EventEmitter from "events";
 interface CogState {
-    tilt: boolean | "forward" | "backward" | "left" | "right";
-    movementType: boolean | "shake" | "move";
-    rotation: boolean | "clockwise" | "counter-clockwise";
-    buttonClick: boolean;
-    objectSense: boolean | "left" | "right";
-    lightSense: boolean | "left" | "right";
-    irMessage: boolean | "left" | "right";
+    tilt: "none" | "forward" | "backward" | "left" | "right";
+    movementType: "none" | "shake" | "move";
+    rotation: "none" | "clockwise" | "counterClockwise";
+    buttonClick: "none" | "click" | "release";
+    objectSense: "none" | "left" | "right";
+    lightSense: "none" | "high" | "mid" | "low";
 }
-declare class PublishedDataAnalyser {
+declare class PublishedDataAnalyser extends EventEmitter {
     private cog;
     cogState: CogState;
     private pubSub;
+    eventsMap: {
+        tilt: {
+            [key in CogState["tilt"]]: string;
+        };
+        movementType: {
+            [key in CogState["movementType"]]: string;
+        };
+        rotation: {
+            [key in CogState["rotation"]]: string;
+        };
+        buttonClick: {
+            [key in CogState["buttonClick"]]: string;
+        };
+        objectSense: {
+            [key in CogState["objectSense"]]: string;
+        };
+        lightSense: {
+            [key in CogState["lightSense"]]: string;
+        };
+    };
+    TiltDetection: typeof TiltDetection;
+    PublishedDataGetter: typeof PublishedDataGetter;
     constructor(cog: RAFT);
     subscribeToPublishedData(): void;
     unsubscribeFromPublishedData(): void;
     analyse(data: CogStateInfo): void;
-    detectTilt(data: CogStateInfo, isMoving: boolean): void;
-    detectMovement(data: CogStateInfo): boolean;
-    detectRotation(data: CogStateInfo, isMoving: boolean): void;
-    detectButtonClick(data: CogStateInfo): void;
-    detectObjectSense(data: CogStateInfo): void;
-    detectLightSense(data: CogStateInfo): void;
-    detectIRMessage(data: CogStateInfo): void;
+    setTilt(tilt: CogState["tilt"]): void;
+    setMovementType(movementType: CogState["movementType"]): void;
+    setRotation(rotation: CogState["rotation"]): void;
+    setButtonClick(buttonClick: CogState["buttonClick"]): void;
+    setObjectSense(objectSense: CogState["objectSense"]): void;
+    setLightSense(lightSense: CogState["lightSense"]): void;
+}
+declare class TiltDetection {
+    distance(a: number, b: number): number;
+    static rotateAccelData(x: number, y: number, z: number, degrees: number): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    detectTilt(ax: number, ay: number, az: number, isMoving: boolean | undefined, analyser: PublishedDataAnalyser, cogVersion: string): void;
 }
 export default PublishedDataAnalyser;

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

@@ -1,20 +1,76 @@
+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 { raftPubSubscriptionHelper } from "../raft-subscription-helpers";
 import { isVersionGreater_errorCatching } from "../../../utils/helpers/compare-version";
-var PublishedDataAnalyser = /** @class */ (function () {
+import PublishedDataGetter from "./PublishedDataGetter";
+import EventEmitter from "events";
+var PublishedDataAnalyser = /** @class */ (function (_super) {
+    __extends(PublishedDataAnalyser, _super);
     function PublishedDataAnalyser(cog) {
-        this.cog = cog;
-        this.cog = cog;
-        this.cogState = {
-            tilt: false,
-            movementType: false,
-            rotation: false,
-            buttonClick: false,
-            objectSense: false,
-            lightSense: false,
-            irMessage: false
+        var _this = _super.call(this) || this;
+        _this.cog = cog;
+        _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.PublishedDataGetter = PublishedDataGetter;
+        _this.cog = cog;
+        _this.cogState = {
+            tilt: "none",
+            movementType: "none",
+            rotation: "none",
+            buttonClick: "none",
+            objectSense: "none",
+            lightSense: "none",
         };
-        this.pubSub = null;
-        this.subscribeToPublishedData();
+        _this.pubSub = null;
+        _this.subscribeToPublishedData();
+        return _this;
     }
     PublishedDataAnalyser.prototype.subscribeToPublishedData = function () {
         var _this = this;
@@ -28,40 +84,47 @@ var PublishedDataAnalyser = /** @class */ (function () {
         (_a = this.pubSub) === null || _a === void 0 ? void 0 : _a.unsubscribe();
     };
     PublishedDataAnalyser.prototype.analyse = function (data) {
-        var isMoving = this.detectMovement(data);
-        this.detectTilt(data, isMoving);
-        this.detectRotation(data, isMoving);
-        this.detectButtonClick(data);
-        this.detectObjectSense(data);
-        this.detectLightSense(data);
-        this.detectIRMessage(data);
+        //@ts-ignore
+        var accelData = PublishedDataGetter.getAccelerometerData(data.deviceManager);
+        //@ts-ignore
+        var gyroData = PublishedDataGetter.getGyroscopeData(data.deviceManager);
+        //@ts-ignore
+        var lightData = PublishedDataGetter.getLightData(data.deviceManager);
+        var isMoving;
+        if (accelData)
+            isMoving = shakeDetector.detectShake(accelData.ax, accelData.ay, accelData.az, Date.now(), this);
+        accelData && tiltDetection.detectTilt(accelData.ax, accelData.ay, accelData.az, isMoving, this, this.cog.getRaftVersion());
+        gyroData && rotationDetection.detectRotation(gyroData.gz, isMoving, this);
+        lightData && buttonClickDetection.detectButtonClick(lightData.ir2, this, this.cog.getRaftVersion());
+        lightData && objectSenseDetection.detectObjectSense([lightData.ir0, lightData.ir1], this);
+        lightData && lightSenseDetection.detectLightSense(lightData.amb0, this);
     };
-    PublishedDataAnalyser.prototype.detectTilt = function (data, isMoving) {
-        tiltDetection.detectTilt(data, isMoving, this.cogState, this.cog.getRaftVersion());
+    PublishedDataAnalyser.prototype.setTilt = function (tilt) {
+        this.cogState.tilt = tilt;
+        this.emit(this.eventsMap.tilt[tilt]);
     };
-    PublishedDataAnalyser.prototype.detectMovement = function (data) {
-        return shakeDetector.detectShake(data.LSM6DS.ax, data.LSM6DS.ay, data.LSM6DS.az, Date.now(), this.cogState);
+    PublishedDataAnalyser.prototype.setMovementType = function (movementType) {
+        this.cogState.movementType = movementType;
+        this.emit(this.eventsMap.movementType[movementType]);
     };
-    PublishedDataAnalyser.prototype.detectRotation = function (data, isMoving) {
-        rotationDetection.detectRotation(data, isMoving, this.cogState);
+    PublishedDataAnalyser.prototype.setRotation = function (rotation) {
+        this.cogState.rotation = rotation;
+        this.emit(this.eventsMap.rotation[rotation]);
     };
-    PublishedDataAnalyser.prototype.detectButtonClick = function (data) {
-        buttonClickDetection.detectButtonClick(data.Light.irVals[2], this.cogState, this.cog.getRaftVersion());
+    PublishedDataAnalyser.prototype.setButtonClick = function (buttonClick) {
+        this.cogState.buttonClick = buttonClick;
+        this.emit(this.eventsMap.buttonClick[buttonClick]);
     };
-    PublishedDataAnalyser.prototype.detectObjectSense = function (data) {
-        var objectSenseValueArray = data.Light.irVals;
-        objectSenseDetection.detectObjectSense(objectSenseValueArray, this.cogState);
+    PublishedDataAnalyser.prototype.setObjectSense = function (objectSense) {
+        this.cogState.objectSense = objectSense;
+        this.emit(this.eventsMap.objectSense[objectSense]);
     };
-    PublishedDataAnalyser.prototype.detectLightSense = function (data) {
-        var lightSenseValue = data.Light.ambientVals[0];
-        lightSenseDetection.detectLightSense(lightSenseValue, this.cogState);
-    };
-    PublishedDataAnalyser.prototype.detectIRMessage = function (data) {
-        var irMessageData = data;
-        // irMessageDetection.detectIRMessage(data, this.cogState);
+    PublishedDataAnalyser.prototype.setLightSense = function (lightSense) {
+        this.cogState.lightSense = lightSense;
+        this.emit(this.eventsMap.lightSense[lightSense]);
     };
     return PublishedDataAnalyser;
-}());
+}(EventEmitter));
 var TiltDetection = /** @class */ (function () {
     function TiltDetection() {
     }
@@ -83,7 +146,7 @@ var TiltDetection = /** @class */ (function () {
         rotatedZ = rotatedZ; // z remains unchanged as the rotation is around the z-axis
         return { x: rotatedX, y: rotatedY, z: rotatedZ };
     };
-    TiltDetection.prototype.detectTilt = function (data, isMoving, cogState, cogVersion) {
+    TiltDetection.prototype.detectTilt = function (ax, ay, az, isMoving, analyser, cogVersion) {
         if (isMoving === void 0) { isMoving = false; }
         if (isMoving)
             return;
@@ -94,7 +157,7 @@ var TiltDetection = /** @class */ (function () {
         if (isVersionGreater_errorCatching(cogVersion, correctionCutOffVersion)) {
             tiltCorrection = tiltCorrectionForNewerCog;
         }
-        var _a = TiltDetection.rotateAccelData(data.LSM6DS.ax, data.LSM6DS.ay, data.LSM6DS.az, tiltCorrection), x = _a.x, y = _a.y, z = _a.z;
+        var _a = TiltDetection.rotateAccelData(ax, ay, az, 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));
@@ -106,7 +169,7 @@ var TiltDetection = /** @class */ (function () {
         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 = false;
+        var tiltDirection = "none";
         if (pitch < -forwardBackwardThreshold) { // && Math.abs(yaw) < upDownThreshold) {
             tiltDirection = "forward";
         }
@@ -119,7 +182,7 @@ var TiltDetection = /** @class */ (function () {
         if (roll > leftRightThreshold) { // && Math.abs(yaw) < upDownThreshold) {
             tiltDirection = "right";
         }
-        cogState.tilt = tiltDirection;
+        analyser.setTilt(tiltDirection);
     };
     return TiltDetection;
 }());
@@ -139,13 +202,10 @@ var RotationDetection = /** @class */ (function () {
             this.dataBuffer.shift();
         }
     };
-    RotationDetection.prototype.detectRotation = function (data, isMoving, cogState) {
+    RotationDetection.prototype.detectRotation = function (gz, isMoving, analyser) {
         if (isMoving === void 0) { isMoving = false; }
-        this.bufferSize = this.bufferSize;
-        this.DELAY_FOR_ROTATION = this.DELAY_FOR_ROTATION;
-        this.ROTATION_THRESHOLD = this.ROTATION_THRESHOLD;
         var currentTime = Date.now();
-        this.addToBuffer(data.LSM6DS.gz);
+        this.addToBuffer(gz);
         if (this.dataBuffer.length < this.bufferSize) {
             return; // Wait until buffer is full
         }
@@ -158,17 +218,18 @@ var RotationDetection = /** @class */ (function () {
         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);
-                cogState.rotation = "clockwise";
+                analyser.setRotation("clockwise");
             }
             else if (metric < -this.ROTATION_THRESHOLD) {
                 // console.log("Counter-clockwise rotation detected:", metric);
-                cogState.rotation = "counter-clockwise";
+                analyser.setRotation("counterClockwise");
             }
         }
         else {
-            cogState.rotation = false;
+            analyser.setRotation("none");
         }
     };
     RotationDetection.prototype.calculateMetric = function () {
@@ -201,7 +262,7 @@ var ShakeDetector = /** @class */ (function () {
         this.shakeInProgress = false;
         this.moveInProgress = false;
     }
-    ShakeDetector.prototype.detectShake = function (xAcc, yAcc, zAcc, timestamp, cogState) {
+    ShakeDetector.prototype.detectShake = function (xAcc, yAcc, zAcc, timestamp, analyser) {
         this.thresholdAcceleration = this.thresholdAcceleration;
         this.thresholdAccelerationMove = this.thresholdAccelerationMove;
         this.thresholdShakeNumber = this.thresholdShakeNumber;
@@ -214,11 +275,11 @@ var ShakeDetector = /** @class */ (function () {
             this.gravityVector = [xAcc, yAcc, zAcc];
             if (this.moveInProgress) {
                 // console.log("move detected");
-                cogState.movementType = "move";
+                analyser.setMovementType("move");
             }
             else {
                 // console.log("no move detected");
-                cogState.movementType = false;
+                analyser.setMovementType("none");
             }
             this.moveInProgress = false;
             this.shakeInProgress = false;
@@ -249,7 +310,7 @@ var ShakeDetector = /** @class */ (function () {
                             // console.log("Shake detected!");
                             this.sensorBundles = [];
                             this.shakeInProgress = false;
-                            cogState.movementType = "shake";
+                            analyser.setMovementType("shake");
                         }
                     }
                     // this.noMoveCallback();
@@ -260,7 +321,7 @@ var ShakeDetector = /** @class */ (function () {
                         this.sensorBundles = [];
                         // console.log("resetting shake detector. Move detected");
                         // fire move detector
-                        cogState.movementType = "move";
+                        analyser.setMovementType("move");
                     }
                 }
             }
@@ -278,7 +339,7 @@ var ShakeDetector = /** @class */ (function () {
             */
         }
     };
-    ShakeDetector.prototype.performCheck = function (cogState) {
+    ShakeDetector.prototype.performCheck = function (analyser) {
         var _this = this;
         var matrix = [
             [0, 0],
@@ -301,7 +362,7 @@ var ShakeDetector = /** @class */ (function () {
             }
             this.lastTimeShakeDetected = Date.now();
             // console.log("Shake detected!", JSON.stringify(matrix));
-            cogState.movementType = "shake";
+            analyser.setMovementType("shake");
             this.sensorBundles = [];
         }
     };
@@ -330,7 +391,7 @@ var ButtonClickDetection = /** @class */ (function () {
         this.lastTime = 0;
         this.buttonClicked = false;
     }
-    ButtonClickDetection.prototype.detectButtonClick = function (buttonValue, cogState, cogVersion) {
+    ButtonClickDetection.prototype.detectButtonClick = function (buttonValue, analyser, cogVersion) {
         var correctionCutOffVersion = "1.2.0";
         var clickThreshold = 1600;
         if (isVersionGreater_errorCatching(cogVersion, correctionCutOffVersion)) {
@@ -347,12 +408,12 @@ var ButtonClickDetection = /** @class */ (function () {
             // console.log("Button clicked", buttonValue);
             this.buttonClicked = true;
             this.lastTime = currentTime;
-            cogState.buttonClick = true;
+            analyser.setButtonClick("click");
         }
         else if (buttonValue < this.releaseThreshold && this.buttonClicked) {
             // console.log("Button released", buttonValue);
             this.buttonClicked = false;
-            cogState.buttonClick = false;
+            analyser.setButtonClick("release");
         }
         // } else {
         //     this.buttonClicked = false;
@@ -367,51 +428,40 @@ var ObjectSenseDetection = /** @class */ (function () {
         this.objectSensed1Threshold = 2500; // right of the arrow
         this.objectSensed2Threshold = 1500; // button
     }
-    ObjectSenseDetection.prototype.detectObjectSense = function (objectSenseValue, cogState) {
+    ObjectSenseDetection.prototype.detectObjectSense = function (objectSenseValue, analyser) {
         if (objectSenseValue[0] > this.objectSensed0Threshold) {
-            cogState.objectSense = "left";
+            analyser.setObjectSense("left");
         }
         else if (objectSenseValue[1] > this.objectSensed1Threshold) {
-            cogState.objectSense = "right";
+            analyser.setObjectSense("right");
         }
         else {
-            cogState.objectSense = false;
+            analyser.setObjectSense("none");
         }
     };
     return ObjectSenseDetection;
 }());
 var LightSenseDetection = /** @class */ (function () {
     function LightSenseDetection() {
-        this.lightSenseThreshold = 450;
+        this.lowLightThreshold = 5;
+        this.midLightThreshold = 250;
+        this.highLightThreshold = 450;
     }
-    LightSenseDetection.prototype.detectLightSense = function (lightSenseValue, cogState) {
-        if (lightSenseValue > this.lightSenseThreshold) {
-            cogState.lightSense = true;
-        }
-        else {
-            cogState.lightSense = false;
+    LightSenseDetection.prototype.detectLightSense = function (lightSenseValue, analyser) {
+        if (lightSenseValue > this.highLightThreshold) {
+            analyser.setLightSense("high");
         }
-    };
-    return LightSenseDetection;
-}());
-var IRMessageDetection = /** @class */ (function () {
-    function IRMessageDetection() {
-        this.irMessage0Threshold = 0;
-        this.irMessage1Threshold = 0;
-    }
-    IRMessageDetection.prototype.detectIRMessage = function (irMessageValue, cogState) {
-        // placeholder for now
-        if (irMessageValue[0] > this.irMessage0Threshold) {
-            cogState.irMessage = "left";
+        else if (lightSenseValue > this.midLightThreshold) {
+            analyser.setLightSense("mid");
         }
-        else if (irMessageValue[1] > this.irMessage1Threshold) {
-            cogState.irMessage = "right";
+        else if (lightSenseValue > this.lowLightThreshold) {
+            analyser.setLightSense("low");
         }
         else {
-            cogState.irMessage = false;
+            analyser.setLightSense("none");
         }
     };
-    return IRMessageDetection;
+    return LightSenseDetection;
 }());
 var rotationDetection = new RotationDetection();
 var shakeDetector = new ShakeDetector();
@@ -419,5 +469,4 @@ var buttonClickDetection = new ButtonClickDetection();
 var tiltDetection = new TiltDetection();
 var objectSenseDetection = new ObjectSenseDetection();
 var lightSenseDetection = new LightSenseDetection();
-var irMessageDetection = new IRMessageDetection();
 export default PublishedDataAnalyser;

package/dist-types/src/application/RAFTs/Cog/PublishedDataGetter.d.ts

@@ -0,0 +1,23 @@
+import { DeviceManager } from "@robdobsn/raftjs/dist/web/RaftDeviceManager";
+export default class PublishedDataGetter {
+    static getPowerData(deviceManager: DeviceManager): {
+        battV: number;
+        usb: "yes" | "no";
+    } | undefined;
+    static getAccelerometerData(deviceManager: DeviceManager): {
+        ax: number;
+        ay: number;
+        az: number;
+    } | undefined;
+    static getGyroscopeData(deviceManager: DeviceManager): {
+        gx: number;
+        gy: number;
+        gz: number;
+    } | undefined;
+    static getLightData(deviceManager: DeviceManager): {
+        amb0: number;
+        ir0: number;
+        ir1: number;
+        ir2: number;
+    } | undefined;
+}

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

@@ -0,0 +1,65 @@
+import { deviceAttrGetLatestFormatted } from "@robdobsn/raftjs";
+/* LIGHT ATTRIBUTES */
+var COG_LIGHT_ATTR_KEY = 'RoboCogLightV1_0';
+var AMB0_KEY = 'amb0';
+var IR0_KEY = 'ir0';
+var IR1_KEY = 'ir1';
+var IR2_KEY = 'ir2';
+/* POWER ATTRIBUTES */
+var COG_POWER_ATTR_KEY = 'RoboCogPowerV1_00';
+var BATTV_KEY = 'battV';
+var USB_KEY = 'UST';
+/* I2CA ATTRIBUTES */
+var COG_I2CA_ATTR_KEY = 'I2CA_6a';
+var AX_KEY = 'ax';
+var AY_KEY = 'ay';
+var AZ_KEY = 'az';
+var GX_KEY = 'gx';
+var GY_KEY = 'gy';
+var GZ_KEY = 'gz';
+var PublishedDataGetter = /** @class */ (function () {
+    function PublishedDataGetter() {
+    }
+    PublishedDataGetter.getPowerData = function (deviceManager) {
+        var powerAttr = deviceManager.getDeviceState(COG_POWER_ATTR_KEY);
+        var battV = deviceAttrGetLatestFormatted(powerAttr === null || powerAttr === void 0 ? void 0 : powerAttr.deviceAttributes[BATTV_KEY]);
+        var usb = deviceAttrGetLatestFormatted(powerAttr === null || powerAttr === void 0 ? void 0 : powerAttr.deviceAttributes[USB_KEY]);
+        return { battV: convertStringToNumber(battV), usb: usb };
+    };
+    PublishedDataGetter.getAccelerometerData = function (deviceManager) {
+        var i2caAttr = deviceManager.getDeviceState(COG_I2CA_ATTR_KEY);
+        if (!i2caAttr)
+            return;
+        var i2ca = i2caAttr.deviceAttributes;
+        var ax = deviceAttrGetLatestFormatted(i2ca[AX_KEY]);
+        var ay = deviceAttrGetLatestFormatted(i2ca[AY_KEY]);
+        var az = deviceAttrGetLatestFormatted(i2ca[AZ_KEY]);
+        return { ax: convertStringToNumber(ax), ay: convertStringToNumber(ay), az: convertStringToNumber(az) };
+    };
+    PublishedDataGetter.getGyroscopeData = function (deviceManager) {
+        var i2caAttr = deviceManager.getDeviceState(COG_I2CA_ATTR_KEY);
+        if (!i2caAttr)
+            return;
+        var i2ca = i2caAttr.deviceAttributes;
+        var gx = deviceAttrGetLatestFormatted(i2ca[GX_KEY]);
+        var gy = deviceAttrGetLatestFormatted(i2ca[GY_KEY]);
+        var gz = deviceAttrGetLatestFormatted(i2ca[GZ_KEY]);
+        return { gx: convertStringToNumber(gx), gy: convertStringToNumber(gy), gz: convertStringToNumber(gz) };
+    };
+    PublishedDataGetter.getLightData = function (deviceManager) {
+        var lightAttr = deviceManager.getDeviceState(COG_LIGHT_ATTR_KEY);
+        if (!lightAttr)
+            return;
+        var light = lightAttr.deviceAttributes;
+        var amb0 = deviceAttrGetLatestFormatted(light[AMB0_KEY]);
+        var ir0 = deviceAttrGetLatestFormatted(light[IR0_KEY]);
+        var ir1 = deviceAttrGetLatestFormatted(light[IR1_KEY]);
+        var ir2 = deviceAttrGetLatestFormatted(light[IR2_KEY]);
+        return { amb0: convertStringToNumber(amb0), ir0: convertStringToNumber(ir0), ir1: convertStringToNumber(ir1), ir2: convertStringToNumber(ir2) };
+    };
+    return PublishedDataGetter;
+}());
+export default PublishedDataGetter;
+var convertStringToNumber = function (str) {
+    return isNaN(+str) ? 0 : +str;
+};

package/package.json

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