@robotical/webapp-types 0.6.58

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

@@ -0,0 +1,223 @@
+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 RAFT from "../RAFT";
+import { RaftTypeE } from "../../../types/raft";
+import { RaftConnEvent, RaftPublishEvent } from "@robotical/raftjs";
+import { RaftInfoEvents } from "../../../types/events/raft-info";
+import PublishedDataAnalyser, { setButtonThresholdsUtil } from "./PublishedDataAnalyser";
+var Cog = /** @class */ (function (_super) {
+    __extends(Cog, _super);
+    function Cog(id) {
+        var _this = _super.call(this, id) || this;
+        _this.id = id;
+        _this.type = RaftTypeE.COG;
+        // Colours to use for LED patterns
+        _this._ledLcdColours = [
+            { led: "#202000", lcd: "#FFFF00" },
+            { led: "#880000", lcd: "#FF0000" },
+            { led: "#000040", lcd: "#0080FF" },
+            { led: "#004000", lcd: "#00FF00" },
+        ];
+        // RAFT State Info
+        _this.raftStateInfo = null;
+        _this.publishedDataAnalyser = new PublishedDataAnalyser(_this);
+        return _this;
+    }
+    Object.defineProperty(Cog.prototype, "ledLcdColours", {
+        get: function () {
+            return this._ledLcdColours;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+    * Gets the RSSI of the RAFT
+    */
+    Cog.prototype.getRSSI = function () {
+        // RSSI is not published by the COG yet
+        var possibleValues = [126, 127];
+        return possibleValues[Math.floor(Math.random() * possibleValues.length)];
+    };
+    /**
+     * Helper function to calculate battery strength based on voltage
+     */
+    Cog.prototype.calculateBatteryStrength = function (voltage) {
+        if (voltage >= 2.7) {
+            return 100;
+        }
+        else if (voltage >= 2.3) {
+            return ((voltage - 2.3) / 0.4) * 80 + 20;
+        }
+        else if (voltage >= 2.0) {
+            return ((voltage - 2.0) / 0.3) * 20;
+        }
+        else {
+            return 0;
+        }
+    };
+    /**
+     * Gets the battery strength of the RAFT
+     */
+    Cog.prototype.getBatteryStrength = function () {
+        /* check if usb is connected */
+        if (!this.raftStateInfo)
+            return 0.1;
+        if (this.raftStateInfo.power.usb === 'yes')
+            return 0; // 0 indicates USB is connected
+        /* if usb is not connected, check battery voltage */
+        var battV = this.raftStateInfo.power.battV;
+        if (!isNaN(+battV)) {
+            return Math.round(this.calculateBatteryStrength(+battV));
+        }
+        return 0;
+    };
+    /**
+   * This methods handles RAFT events coming from the RICConnector of the wrapper
+   */
+    Cog.prototype.handleRaftEvent = function (eventType, eventEnum, eventName, eventData) {
+        _super.prototype.handleRaftEvent.call(this, eventType, eventEnum, eventName, eventData);
+        switch (eventType) {
+            case "conn":
+                this.connEventHandler(eventEnum, eventName, eventData);
+                break;
+            case "pub":
+                this.pubEventHandler(eventEnum, eventName, eventData);
+                break;
+            case "raftinfo":
+                this.raftInfoEventHandler(eventEnum, eventName, eventData);
+                break;
+            default:
+                break;
+        }
+    };
+    /**
+     * Conn Event Handler
+     */
+    Cog.prototype.connEventHandler = function (eventEnum, eventName, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (eventEnum) {
+                    case RaftConnEvent.CONN_VERIFIED_CORRECT:
+                        // set up cog thresholds 
+                        setButtonThresholdsUtil(this);
+                        break;
+                    case RaftConnEvent.CONN_DISCONNECTED:
+                        // this.publishedDataAnalyser.unsubscribeFromPublishedData();
+                        break;
+                    default:
+                        break;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * Pub Event Handler
+     */
+    Cog.prototype.pubEventHandler = function (eventEnum, eventName, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (eventEnum) {
+                    case RaftPublishEvent.PUBLISH_EVENT_DATA:
+                        break;
+                    default:
+                        break;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * Highlights the COG by flashing the LED and playing a tune
+     */
+    Cog.prototype.highlight = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.sendRestMessage('led/ring/color/#ff8585')];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.sendRestMessage('audio/rtttl/NoteASharp:d=4,o=6,b=600:a#')];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 100); })];
+                    case 3:
+                        _a.sent();
+                        return [4 /*yield*/, this.sendRestMessage('led/ring/color/#000000')];
+                    case 4:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Raft Info Event Handler
+     */
+    Cog.prototype.raftInfoEventHandler = function (eventEnum, eventName, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (eventEnum) {
+                    case RaftInfoEvents.STATE_INFO:
+                        this.raftStateInfo = data.stateInfo;
+                        break;
+                    default:
+                        break;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    return Cog;
+}(RAFT));
+export { Cog };
+export default Cog;

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

@@ -0,0 +1,120 @@
+/// <reference types="node" />
+import RAFT from "../RAFT";
+import EventEmitter from "events";
+import Cog from "./Cog";
+import { SimplifiedCogStateInfo } from "@robotical/roboticaljs/dist/SystemTypeCog/CogTypes";
+interface CogState {
+    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 extends EventEmitter {
+    private cog;
+    cogState: CogState;
+    private pubSub;
+    rotationDetection: RotationDetection;
+    shakeDetector: ShakeDetector;
+    buttonClickDetection: ButtonClickDetection;
+    tiltDetection: TiltDetection;
+    objectSenseDetection: ObjectSenseDetection;
+    lightSenseDetection: LightSenseDetection;
+    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;
+    constructor(cog: RAFT);
+    subscribeToPublishedData(): void;
+    unsubscribeFromPublishedData(): void;
+    analyse(data: SimplifiedCogStateInfo): 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;
+}
+declare class RotationDetection {
+    private dataBuffer;
+    private bufferSize;
+    private DELAY_FOR_ROTATION;
+    private ROTATION_THRESHOLD;
+    private rotationDetected;
+    private lastRotationDetectionTime;
+    private rotationTimer;
+    constructor();
+    addToBuffer(data: number): void;
+    detectRotation(gz: number, isMoving: boolean | undefined, analyser: PublishedDataAnalyser): void;
+    calculateMetric(): number;
+}
+declare class ShakeDetector {
+    private thresholdAccelerationMove;
+    private thresholdAcceleration;
+    private thresholdShakeNumber;
+    private interval;
+    private maxShakeDuration;
+    private coolOffPeriod;
+    private lastTime;
+    private lastTimeShakeDetected;
+    private sensorBundles;
+    private gravityVector;
+    private lastVector;
+    private shakeInProgress;
+    private moveInProgress;
+    constructor();
+    detectShake(xAcc: number, yAcc: number, zAcc: number, timestamp: number, analyser: PublishedDataAnalyser): boolean;
+    performCheck(analyser: PublishedDataAnalyser): void;
+    updateAxis(index: number, acceleration: number, matrix: number[][], adjustment?: number): void;
+}
+export declare class ButtonClickDetection {
+    clickThreshold: number;
+    releaseThreshold: number;
+    lastTime: number;
+    buttonClicked: boolean;
+    constructor();
+    detectButtonClick(buttonValue: number, analyser: PublishedDataAnalyser, cogVersion: string): void;
+}
+declare class ObjectSenseDetection {
+    private objectSensed0Threshold;
+    private objectSensed1Threshold;
+    private objectSensed2Threshold;
+    constructor();
+    detectObjectSense(objectSenseValue: number[], analyser: PublishedDataAnalyser): void;
+}
+declare class LightSenseDetection {
+    private lowLightThreshold;
+    private midLightThreshold;
+    private highLightThreshold;
+    constructor();
+    detectLightSense(lightSenseValue: number, analyser: PublishedDataAnalyser): void;
+}
+export declare const setButtonThresholdsUtil: (connectedCog: Cog) => Promise<void>;
+export default PublishedDataAnalyser;