@robdobsn/raftjs 1.1.1

package/examples/dashboard/src/SystemTypeMarty/RICCommsStats.ts

@@ -0,0 +1,170 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// RICJS
+// Communications Library
+//
+// Rob Dobson & Chris Greening 2020-2022
+// (C) 2020-2022
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+export default class RICCommsStats {
+
+  _msgSmartServos = 0;
+  _msgIMU = 0;
+  _msgPowerStatus = 0;
+  _msgAddOnPub = 0;
+  _msgRobotStatus = 0;
+
+  _msgSmartServosPS = 0;
+  _msgIMUPS = 0;
+  _msgPowerStatusPS = 0;
+  _msgAddOnPubPS = 0;
+  _msgRobotStatusPS = 0;
+
+  _msgSmartServosCountInWindow = 0;
+  _msgIMUCountInWindow = 0;
+  _msgPowerStatusCountInWindow = 0;
+  _msgAddOnPubCountInWindow = 0;
+  _msgRobotStatusCountInWindow = 0;
+
+  _msgSmartServosLastCalcMs = 0;
+  _msgIMULastCalcMs = 0;
+  _msgPowerStatusLastCalcMs = 0;
+  _msgAddOnPubLastCalcMs = 0;
+  _msgRobotStatusLastCalcMs = 0;
+
+  _msgOtherTopic = 0;
+
+  _rosSerialRxRate = 0;
+  _rosSerialRxTotalBytes = 0;
+  _rosSerialRxTotalTimeMs = 0;
+
+  clear() {
+    this._msgSmartServos = 0;
+    this._msgIMU = 0;
+    this._msgPowerStatus = 0;
+    this._msgAddOnPub = 0;
+    this._msgRobotStatus = 0;
+    this._msgSmartServosPS = 0;
+    this._msgIMUPS = 0;
+    this._msgPowerStatusPS = 0;
+    this._msgAddOnPubPS = 0;
+    this._msgRobotStatusPS = 0;
+    this._msgSmartServosCountInWindow = 0;
+    this._msgIMUCountInWindow = 0;
+    this._msgPowerStatusCountInWindow = 0;
+    this._msgAddOnPubCountInWindow = 0;
+    this._msgRobotStatusCountInWindow = 0;
+    this._msgSmartServosLastCalcMs = Date.now();
+    this._msgIMULastCalcMs = Date.now();
+    this._msgPowerStatusLastCalcMs = Date.now();
+    this._msgAddOnPubLastCalcMs = Date.now();
+    this._msgRobotStatusLastCalcMs = Date.now();
+    this._rosSerialRxRate = 0;
+    this._rosSerialRxTotalBytes = 0;
+    this._rosSerialRxTotalTimeMs = 0;
+  }
+
+  getSmartServosRate(): number {
+    if (this._msgSmartServosLastCalcMs + 1000 < Date.now()) {
+      this._msgSmartServosPS =
+        (1000.0 * this._msgSmartServosCountInWindow) /
+        (Date.now() - this._msgSmartServosLastCalcMs);
+      this._msgSmartServosLastCalcMs = Date.now();
+      this._msgSmartServosCountInWindow = 0;
+    }
+    return this._msgSmartServosPS;
+  }
+
+  getIMURate(): number {
+    if (this._msgIMULastCalcMs + 1000 < Date.now()) {
+      this._msgIMUPS =
+        (1000.0 * this._msgIMUCountInWindow) /
+        (Date.now() - this._msgIMULastCalcMs);
+      this._msgIMULastCalcMs = Date.now();
+      this._msgIMUCountInWindow = 0;
+    }
+    return this._msgIMUPS;
+  }
+
+  getPowerStatusRate(): number {
+    if (this._msgPowerStatusLastCalcMs + 1000 < Date.now()) {
+      this._msgPowerStatusPS =
+        (1000.0 * this._msgPowerStatusCountInWindow) /
+        (Date.now() - this._msgPowerStatusLastCalcMs);
+      this._msgPowerStatusLastCalcMs = Date.now();
+      this._msgPowerStatusCountInWindow = 0;
+    }
+    return this._msgPowerStatusPS;
+  }
+
+  getAddOnPubRate(): number {
+    if (this._msgAddOnPubLastCalcMs + 1000 < Date.now()) {
+      this._msgAddOnPubPS =
+        (1000.0 * this._msgAddOnPubCountInWindow) /
+        (Date.now() - this._msgAddOnPubLastCalcMs);
+      this._msgAddOnPubLastCalcMs = Date.now();
+      this._msgAddOnPubCountInWindow = 0;
+    }
+    return this._msgAddOnPubPS;
+  }
+
+  getRobotStatusRate(): number {
+    if (this._msgRobotStatusLastCalcMs + 1000 < Date.now()) {
+      this._msgRobotStatusPS =
+        (1000.0 * this._msgRobotStatusCountInWindow) /
+        (Date.now() - this._msgRobotStatusLastCalcMs);
+      this._msgRobotStatusLastCalcMs = Date.now();
+      this._msgRobotStatusCountInWindow = 0;
+    }
+    return this._msgRobotStatusPS;
+  }
+
+  getROSSerialRate(): number {
+    if (this._rosSerialRxTotalTimeMs > 0) {
+      return (
+        (1000.0 * this._rosSerialRxTotalBytes) / this._rosSerialRxTotalTimeMs
+      );
+    }
+    return 0;
+  }
+
+  recordSmartServos(): void {
+    this._msgSmartServos++;
+    this._msgSmartServosCountInWindow++;
+  }
+
+  recordIMU(): void {
+    this._msgIMU++;
+    this._msgIMUCountInWindow++;
+    // Don't call msgRx() as double counting msgs with smartServos
+  }
+
+  recordPowerStatus(): void {
+    this._msgPowerStatus++;
+    this._msgPowerStatusCountInWindow++;
+  }
+
+  recordAddOnPub(): void {
+    this._msgAddOnPub++;
+    this._msgAddOnPubCountInWindow++;
+  }
+
+  recordRobotStatus(): void {
+    this._msgRobotStatus++;
+    this._msgRobotStatusCountInWindow++;
+  }
+
+  recordOtherTopic(): void {
+    this._msgOtherTopic++;
+  }
+
+  updateROSSerialRxRate(frameLen: number, timeMs: number): void {
+    if ((frameLen != 0) && (timeMs != 0)) {
+      this._rosSerialRxRate = (1000*frameLen) / timeMs;
+      this._rosSerialRxTotalTimeMs += timeMs;
+      this._rosSerialRxTotalBytes += frameLen;
+    }
+  }
+}

package/examples/dashboard/src/SystemTypeMarty/RICHWElem.ts

@@ -0,0 +1,123 @@
+/**
+ * RICHWElem
+ * 
+ * @description
+ * Information about a hardware element
+ * 
+ * @field name: string - element name
+ * @field type: string - element type
+ * @field busName: string - name of bus (e.g. I2C) attached to
+ * @field addr: string - address of element on the bus
+ * @field addrValid: number - 1 if address is valid
+ * @field IDNo: string - unique identifier of element
+ * @field whoAmI: string - name of element type
+ * @field whoAmITypeCode: string - number of element type
+ * @field SN: string - Serial number
+ * @field versionStr: string - Version
+ * @field commsOk: number - 1 if communications OK, 0 if not, -1 if device is invalid
+ */
+export type RICHWElem = {
+  name: string;
+  type: string;
+  busName: string;
+  addr: string;
+  addrValid: number;
+  IDNo: string;
+  whoAmI: string;
+  whoAmITypeCode: string;
+  SN: string;
+  versionStr: string;
+  commsOk: number;
+};
+
+export class RICHWElemList {
+  req = '';
+  rslt = 'ok';
+  hw: Array<RICHWElem> = [];
+}
+
+// Minimum key length version of RICHWElem
+export type RICHWElem_Min = {
+  n: string;
+  t: string;
+  I: string;
+  w: string;
+  W: string;
+  S: string;
+  v: string;
+  c: number;
+};
+
+export class RICHWElemList_Min {
+  // Members
+  req = '';
+  rslt = 'ok';
+  hw: Array<RICHWElem_Min> = [];
+
+  // Method to convert to RICHWElemList
+  static expand(hwMin: RICHWElemList_Min): RICHWElemList {
+    const hwList = new RICHWElemList();
+    for (const hwElem of hwMin.hw) {
+      hwList.hw.push({
+        name: hwElem.n,
+        type: hwElem.t,
+        busName: '',
+        addr: '',
+        addrValid: 0,
+        IDNo: hwElem.I,
+        whoAmI: hwElem.w,
+        whoAmITypeCode: hwElem.W,
+        SN: hwElem.S,
+        versionStr: hwElem.v,
+        commsOk: hwElem.c,
+      });
+    }
+    return hwList;
+  }
+}
+
+// Single encoded string version of RICHWElem
+export type RICHWElem_Str = {
+  a: string;
+};
+
+export type RICHWElemList_Name = {
+  rslt: string;
+  hw: Array<string>;
+};
+
+// RICHWElemList containing coded strings for each HWElem field
+export class RICHWElemList_Str {
+  req = '';
+  rslt = 'ok';
+  hw: Array<RICHWElem_Str> = [];
+
+  // Method to convert to RICHWElemList
+  static expand(hwStr: RICHWElemList_Str): RICHWElemList {
+    const hwList = new RICHWElemList();
+    for (const hwElem of hwStr.hw) {
+      if (hwElem.a) {
+        const hwElemStr = hwElem.a.split('|');
+        hwList.hw.push({
+          name: RICHWElemList_Str.unesc(hwElemStr[0]),
+          type: RICHWElemList_Str.unesc(hwElemStr[1]),
+          busName: "",
+          addr: "",
+          addrValid: 0,
+          IDNo: RICHWElemList_Str.unesc(hwElemStr[2]),
+          whoAmI: RICHWElemList_Str.unesc(hwElemStr[3]),
+          whoAmITypeCode: RICHWElemList_Str.unesc(hwElemStr[4]),
+          SN: RICHWElemList_Str.unesc(hwElemStr[5]),
+          versionStr: RICHWElemList_Str.unesc(hwElemStr[6]),
+          commsOk: Number(hwElemStr[7]),
+        });
+      }
+    }
+    return hwList;
+  }
+
+  // Method to unescape a pipe character
+  static unesc(s: string): string {
+    return s.replace(/\/x7c/g, '|');
+  }
+}

package/examples/dashboard/src/SystemTypeMarty/RICLEDPatternChecker.ts

@@ -0,0 +1,207 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// RICJS
+// Communications Library
+//
+// Rob Dobson & Chris Greening 2020-2022
+// (C) 2020-2022
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+import { RaftConnEvent, RaftConnEventFn } from '../../../../src/RaftConnEvents';
+import RaftLog from '../../../../src/RaftLog';
+import RaftMsgHandler from '../../../../src/RaftMsgHandler';
+import { RaftOKFail } from '../../../../src/RaftTypes';
+import { RICLEDPatternCheckerColour, RICLedLcdColours } from './RICTypes';
+
+export default class RICLEDPatternChecker {
+
+  // LED pattern refresh
+  private _ledPatternTimeoutMs = 10000;
+  private _ledPatternRefreshTimer: ReturnType<typeof setTimeout> | null = null;
+
+  // Verification of correct device
+  private _ledColours: Array<string> = new Array<string>();
+  private _lcdColours: Array<string> = new Array<string>();
+  private _bleVerifActive = false;
+
+  // Message handler, etc
+  private _msgHandler: RaftMsgHandler | null = null;
+  private _onConnEvent: RaftConnEventFn | null = null;
+  private _isConnectedFn: () => boolean = () => false;
+
+  /**
+   * Start checking correct RIC using LED pattern
+   *
+   *  @param {RICLedLcdColours} ricLedLcdColours - available colours
+   *  @param {RaftMsgHandler} msgHandler - message handler
+   *  @param {RaftConnEventFn} onConnEvent - connection event handler
+   *  @param {() => boolean} isConnectedFn - function to check if connected
+   *  @return boolean - true if started ok
+   *
+   */
+  async checkCorrectRICStart(ricLedLcdColours: RICLedLcdColours, 
+          msgHandler: RaftMsgHandler, 
+          onConnEvent: RaftConnEventFn,
+          isConnectedFn: () => boolean): Promise<boolean> {
+
+    // Store the onConnEvent, etc
+    this._msgHandler = msgHandler;
+    this._onConnEvent = onConnEvent;
+    this._isConnectedFn = isConnectedFn;
+
+    // Set colour pattern checker colours
+    const randomColours = this.setupColours(ricLedLcdColours);
+
+    // Start timer to repeat checking LED pattern
+    RaftLog.debug(`checkCorrectRICStart: starting LED pattern checker`);
+    if (!await this._checkCorrectRICRefreshLEDs()) {
+      return false;
+    }
+
+    // Event
+    onConnEvent(RaftConnEvent.CONN_VERIFYING_CORRECT, randomColours);
+
+    // Start timer to repeat sending of LED pattern
+    // This is because RIC's LED pattern override times out after a while
+    // so has to be refreshed periodically
+    this._ledPatternRefreshTimer = setInterval(async () => {
+      RaftLog.verbose(`checkCorrectRICStart: loop`);
+      if (!this._checkCorrectRICRefreshLEDs()) {
+        RaftLog.debug('checkCorrectRICStart no longer active - clearing timer');
+        this._clearLedPatternRefreshTimer();
+      }
+    }, this._ledPatternTimeoutMs / 2.1);
+    return true;
+  }
+
+  /**
+   *  Stop checking correct RIC
+   *  @param {boolean} confirmCorrectRIC - true if user confirmed correct RIC
+   *  @return void
+   *
+   */
+  async checkCorrectRICStop(confirmCorrectRIC: boolean): Promise<boolean> {
+
+    // Stop refreshing LED pattern on RIC
+    this._clearLedPatternRefreshTimer();
+
+    // Stop the LED pattern checker if connected
+    if (this._isConnectedFn()) {
+      await this.clearRICColors();
+    }
+
+    // Check correct
+    if (!confirmCorrectRIC) {
+      // Event
+      if (this._onConnEvent)
+        this._onConnEvent(RaftConnEvent.CONN_REJECTED);
+      // Indicate as rejected if we're not connected or if user didn't confirm
+      return false;
+    }
+    // Event
+    if (this._onConnEvent)
+      this._onConnEvent(RaftConnEvent.CONN_VERIFIED_CORRECT);
+    return true;
+  }
+
+  /**
+   * Refresh LED pattern on RIC
+   *
+   *  @return boolean - true if checking still active
+   *
+   */
+  async _checkCorrectRICRefreshLEDs(): Promise<boolean> {
+    // Check LED pattern is active
+    if (!this.isActive()) {
+      return false;
+    }
+
+    // Check connected
+    RaftLog.debug(`_verificationRepeat getting isConnected`);
+    if (!this._isConnectedFn()) {
+      console.warn('_verificationRepeat not connected');
+      return false;
+    }
+
+    // Repeat the LED pattern (RIC times out the LED override after ~10 seconds)
+    RaftLog.debug(`_verificationRepeat setting pattern`);
+    return await this.setRICColors();
+  }
+
+  _clearLedPatternRefreshTimer(): void {
+    if (this._ledPatternRefreshTimer) {
+      clearInterval(this._ledPatternRefreshTimer);
+      this._ledPatternRefreshTimer = null;
+    }
+  }
+
+  isActive(): boolean {
+    return this._bleVerifActive;
+  }
+
+  clear(): void {
+    this._bleVerifActive = false;
+  }
+
+  setupColours(availableColors: RICLEDPatternCheckerColour[]): string[] {
+
+    // Check length of available colours
+    if (availableColors.length == 0) {
+      RaftLog.warn('start no available colours');
+    }
+
+    // Random colour selection
+    const LED_1 =
+      availableColors[Math.floor(Math.random() * availableColors.length)];
+    const LED_2 =
+      availableColors[Math.floor(Math.random() * availableColors.length)];
+    const LED_3 =
+      availableColors[Math.floor(Math.random() * availableColors.length)];
+
+    // LED and LCD colours are different to attempt to be visually similar
+    this._ledColours = [LED_1.led, LED_2.led, LED_3.led];
+    this._lcdColours = [LED_1.lcd, LED_2.lcd, LED_3.lcd];
+
+    // Set the colours to display on LEDs
+    this._bleVerifActive = true;
+
+    // Return LCD colours to display
+    return this._lcdColours;
+  }
+
+  async setRICColors(): Promise<boolean> {
+    // Set bonding colours
+    let colourSetStr = '';
+    for (let i = 0; i < this._ledColours.length; i++) {
+      if (i != 0) {
+        colourSetStr += '&';
+      }
+      let colr = this._ledColours[i];
+      if (colr.startsWith('#')) colr = colr.slice(1);
+      colourSetStr += `c${i}=${colr}`;
+    }
+    try {
+      RaftLog.debug('setRICColors setting colours');
+      if (this._msgHandler) {
+        await this._msgHandler.sendRICRESTURL<RaftOKFail>(`indicator/set?${colourSetStr}&ms=${this._ledPatternTimeoutMs}`);
+      }
+    } catch (error) {
+      RaftLog.debug(`setRICColors failed to send ${error}`);
+      return false;
+    }
+    return true;
+  }
+
+  async clearRICColors(): Promise<void> {
+    // Clear the LED colours
+    RaftLog.debug('clearRICColors');
+    try {
+      if (this._msgHandler) {
+        await this._msgHandler.sendRICRESTURL<RaftOKFail>(`indicator/resume`);
+      }
+    } catch (error) {
+      RaftLog.debug(`clearRICColors failed to send ${error}`);
+    }
+  }
+}