@robdobsn/raftjs 1.7.8 → 1.10.7

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

@@ -0,0 +1,70 @@
+import { RICHWElem } from "./RICHWElem";
+
+/**
+ * RICAddOn
+ * 
+ * @description
+ * Information about an add-on
+ * 
+ * @field name: string - Name of add-on
+ * @field SN: string - Serial number
+ * @field poll: string - polling type ("status")
+ * @field pollRd: string - hex data most recently read
+ * @field pollHz: number - rate of polling
+ */
+export type RICAddOn = {
+  name: string;
+  SN: string;
+  poll: string;
+  pollRd: number;
+  pollHz: number;
+};
+
+export class RICConfiguredAddOns {
+  req = '';
+  rslt = 'ok';
+  addons: Array<RICAddOn> = [];
+}
+
+/**
+ * AddOnElemAndConfig
+ * 
+ * @description
+ * Carrier of information about an add-on combining
+ * the add-on element and the add-on configuration
+ * 
+ * @field addOnConfig: RICAddOn - Add-on configuration
+ * @field hwElemRec: RICHWElem - Add-on element
+ * @field elemIdx: number - Index of the add-on element
+ */
+export class AddOnElemAndConfig {
+  constructor(
+    addOnConfig: RICAddOn | null,
+    hwElemRec: RICHWElem | null,
+    elemIdx: number,
+  ) {
+    this.isConfigured = addOnConfig !== null;
+    this.isConnected = hwElemRec !== null;
+    if (addOnConfig != null) {
+      this.SN = addOnConfig.SN;
+      this.name = addOnConfig.name;
+    } else if (hwElemRec != null) {
+      this.SN = hwElemRec.SN;
+      this.name = hwElemRec.name;
+    }
+    this.addOnConfig = addOnConfig;
+    this.hwElemRec = hwElemRec;
+    this.id = elemIdx.toString();
+  }
+
+  // Fields from config (stored in RIC NVS using addon REST API)
+  addOnConfig: RICAddOn | null = null;
+  // Fields from HWElem (from hwstatus command)
+  hwElemRec: RICHWElem | null = null;
+  // Fields allocated when combining records
+  name = '';
+  SN = '';
+  id = '0';
+  isConnected = false;
+  isConfigured = false;
+}

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

@@ -0,0 +1,33 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// RICJS
+// Communications Library
+//
+// Rob Dobson & Chris Greening 2020-2022
+// (C) 2020-2022
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+import { RaftReportMsg } from '../../../../src/RaftTypes';
+import { ROSSerialAddOnStatus } from './RICROSSerial';
+
+export default abstract class RICAddOnBase {
+  _name = '';
+  _typeName = '';
+  _whoAmI = "";
+  _whoAmITypeCode = "";
+  _isStatic = false;
+  _initCmd: string | null = null;
+  constructor(name: string, typeName: string, whoAmI: string, whoAmITypeCode: string) {
+    this._name = name;
+    this._typeName = typeName;
+    this._whoAmI = whoAmI;
+    this._whoAmITypeCode = whoAmITypeCode;
+  }
+  abstract processInit(_dataReceived: RaftReportMsg): void;
+  abstract processPublishedData(
+    addOnID: number,
+    statusByte: number,
+    rawData: Uint8Array,
+  ): ROSSerialAddOnStatus;
+}

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

@@ -0,0 +1,342 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// RICJS
+// Communications Library
+//
+// Rob Dobson & Chris Greening 2020-2022
+// (C) 2020-2022
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+import RaftLog from "../../../../src/RaftLog";
+import RaftMsgHandler from "../../../../src/RaftMsgHandler";
+import { Dictionary, RaftOKFail, RaftReportMsg } from "../../../../src/RaftTypes";
+import RICAddOnBase from "./RICAddOnBase";
+import { RICHWElem } from "./RICHWElem";
+import { ROSSerialAddOnStatus } from "./RICROSSerial";
+
+export type RICAddOnCreator = (
+  name: string,
+  addOnFamily: string,
+  whoAmI: string,
+  whoAmITypeCode: string
+) => RICAddOnBase;
+
+class AddOnFactoryElem {
+  typeName: string;
+  addOnFamily: string;
+  whoAmI: string;
+  factoryFn: RICAddOnCreator;
+  constructor(
+    typeName: string,
+    addOnFamily: string,
+    whoAmI: string,
+    factoryFn: RICAddOnCreator
+  ) {
+    this.addOnFamily = addOnFamily;
+    this.typeName = typeName;
+    this.whoAmI = whoAmI;
+    this.factoryFn = factoryFn;
+  }
+}
+
+export interface RICAddOnRegistry {
+  registerHWElemType(
+    typeName: string,
+    addOnFamily: string,
+    whoAmI: string,
+    factoryFn: RICAddOnCreator
+  ): void;
+}
+
+/**
+ * RICAddOnManager
+ *
+ * @description
+ * Handles the creation and management of RIC Add-Ons
+ *
+ */
+export default class RICAddOnManager implements RICAddOnRegistry {
+
+  // Message handler, etc
+  private _msgHandler: RaftMsgHandler | null = null;
+
+  // Add-on factory map
+  private _addOnFactoryMap: Dictionary<AddOnFactoryElem> = {};
+
+  // Configured add-ons
+  private _configuredAddOns: Dictionary<RICAddOnBase> = {};
+
+  /**
+   * Setup the RIC Add-On Manager
+   */
+  setup(msgHandler: RaftMsgHandler): void {
+    this._msgHandler = msgHandler;
+  }
+
+  /**
+   * 
+   * @param typeName Register HWElem type
+   * @param addOnFamily 
+   * @param whoAmI 
+   * @param factoryFn 
+   */
+  registerHWElemType(
+    typeName: string,
+    addOnFamily: string,
+    whoAmI: string,
+    factoryFn: RICAddOnCreator
+  ): void {
+    RaftLog.debug(`registerHWElemType ${whoAmI} ${typeName}`);
+    const lookupStr = addOnFamily + "_" + whoAmI;
+    this._addOnFactoryMap[lookupStr] = new AddOnFactoryElem(
+      typeName,
+      addOnFamily,
+      whoAmI,
+      factoryFn
+    );
+  }
+
+  // Mark: Set AddOn config -----------------------------------------------------------
+
+  /**
+   *
+   * setAddOnConfig - set a specified add-on's configuration
+   * @param serialNo used to identify the add-on
+   * @param newName name to refer to add-on by
+   * @returns Promise<RaftOKFail>
+   *
+   */
+  async setAddOnConfig(serialNo: string, newName: string): Promise<RaftOKFail> {
+    try {
+      if (this._msgHandler) {
+        const msgRslt = await this._msgHandler.sendRICRESTURL<RaftOKFail>(
+          `addon/set?SN=${serialNo}&name=${newName}`,
+        );
+        return msgRslt;
+      }
+    } catch (error) {
+    }
+    return new RaftOKFail();
+  }
+
+  /**
+   * deleteAddOn - remove an addon from the addonlist on RIC
+   * @param serialNo used to identify the add-on
+   * @returns Promise<RaftOKFail>
+   */
+  async deleteAddOn(serialNo: string): Promise<RaftOKFail> {
+    try {
+      if (this._msgHandler) {
+        const msgRslt = await this._msgHandler.sendRICRESTURL<RaftOKFail>(
+          `addon/del?SN=${serialNo}`,
+        );
+        return msgRslt;
+      }
+    } catch (error) {
+    }
+    return new RaftOKFail();
+  }
+
+  // Mark: Identify AddOn -----------------------------------------------------------
+
+  /**
+   *
+   * identifyAddOn - send the 'identify' command to a specified add-on
+   * @param name used to identify the add-on
+   * @returns Promise<RaftOKFail>
+   *
+   */
+  async identifyAddOn(name: string): Promise<RaftOKFail> {
+    try {
+      if (this._msgHandler) {
+        const msgRslt = await this._msgHandler.sendRICRESTURL<RaftOKFail>(
+          `elem/${name}/json?cmd=raw&hexWr=F8`,
+        );
+        return msgRslt;
+      }
+    } catch (error) {
+    }
+    return new RaftOKFail();
+  }
+
+  /**
+   * @function getStaticAddonIds
+   * Get the ids of the add-ons that are static
+   * (their data do not get published from ricjs, eg buspixel ledeyes)
+   * @returns {Array<number>} the ids of the static add-ons
+   */
+  getStaticAddonIds(): Array<number> {
+    // at this point we will create the buspixel addon for the batch 4 ledeye,
+    // as their data is not published the same way the RSAddOn do
+    // to do so, however, we need to know if the batch 4 ledeye is connected
+    const staticAddonIds = [];
+    for (const addOnId in this._configuredAddOns) {
+      const addon = this._configuredAddOns[addOnId];
+      if (addon._isStatic) {
+        staticAddonIds.push(+addOnId);
+      }
+    }
+    return staticAddonIds;
+  }
+
+  /**
+   * @function getStaticAddons
+   * Get the add-ons that are static
+   * (their data do not get published from ricjs, eg buspixel ledeyes)
+   * @returns {Array<RICAddOnBase>} the static add-ons unprocessed
+   */
+  getStaticAddons(): Array<RICAddOnBase> {
+    const staticAddons = [];
+    for (const addOnId in this._configuredAddOns) {
+      const addon = this._configuredAddOns[addOnId];
+      if (addon._isStatic) {
+        staticAddons.push(addon);
+      }
+    }
+    return staticAddons;
+  }
+
+  /**
+   * @function getProcessedStaticAddons
+   * Get the add-ons that are static
+   * (their data do not get published from ricjs, eg buspixel ledeyes)
+   * @returns {Array<ROSSerialAddOnStatus>} the static add-ons processed
+   */
+  getProcessedStaticAddons(): Array<ROSSerialAddOnStatus> {
+    const ids = this.getStaticAddonIds();
+    const staticAddons: ROSSerialAddOnStatus[] = [];
+    ids.forEach((id) => {
+      const processedAddon = this.processPublishedData(
+        id,
+        0,
+        new Uint8Array(0)
+      );
+      if (processedAddon) {
+        staticAddons.push(processedAddon);
+      }
+    });
+    return staticAddons;
+  }
+
+  /**
+   * @function setHWElems
+   * Set the hardware elements from a list of RICHWElem
+   * @param hwElems
+   *
+   */
+  setHWElems(hwElems: Array<RICHWElem>): void {
+    this._configuredAddOns = this.configureAddOns(hwElems);
+  }
+
+  clear(): void {
+    this._configuredAddOns = {};
+  }
+
+  configureAddOns(hwElems: Array<RICHWElem>): Dictionary<RICAddOnBase> {
+    const addOnMap: Dictionary<RICAddOnBase> = {};
+    // Iterate HWElems to find addons
+    for (const hwElem of hwElems) {
+      RaftLog.debug(`configureAddOns whoAmITypeCode ${hwElem.whoAmI}`);
+
+      // Lookup the add-on
+      const lookupStr = hwElem.type + "_" + hwElem.whoAmI;
+      if (lookupStr in this._addOnFactoryMap) {
+        const addOnFactoryElem = this._addOnFactoryMap[lookupStr];
+        const whoAmILen = hwElem.whoAmITypeCode.length;
+        hwElem.whoAmITypeCode = hwElem.whoAmITypeCode.slice(
+          whoAmILen - 2,
+          whoAmILen
+        );
+        const addOn = addOnFactoryElem.factoryFn(
+          hwElem.name,
+          hwElem.type,
+          hwElem.whoAmI,
+          hwElem.whoAmITypeCode
+        );
+        if (addOn !== null) {
+          addOnMap[hwElem.IDNo.toString()] = addOn;
+        }
+      }
+    }
+    return addOnMap;
+  }
+
+  getHWElemTypeStr(
+    whoAmITypeCode: string | undefined,
+    whoAmI: string | undefined
+  ) {
+    RaftLog.debug(`getting type code for ${whoAmITypeCode}`);
+    if (whoAmITypeCode === undefined) {
+      return `Undefined whoamiTypeCode`;
+    }
+    if (whoAmITypeCode in this._addOnFactoryMap) {
+      return this._addOnFactoryMap[whoAmITypeCode].typeName;
+    }
+    return `Unknown (${whoAmI} - ${whoAmITypeCode})`;
+  }
+
+  processPublishedData(
+    addOnID: number,
+    statusByte: number,
+    rawData: Uint8Array
+  ): ROSSerialAddOnStatus | null {
+    // Lookup in map
+    const addOnIdStr = addOnID.toString();
+    if (addOnIdStr in this._configuredAddOns) {
+      const addOnHandler = this._configuredAddOns[addOnIdStr];
+      const data = addOnHandler.processPublishedData(
+        addOnID,
+        statusByte,
+        rawData
+      );
+      return data;
+    }
+    return null;
+  }
+  getIDNoFromName(name: string): string | null {
+    for (const key in this._configuredAddOns) {
+      if (key in this._configuredAddOns) {
+        if (this._configuredAddOns[key]._name == name) return key;
+      }
+    }
+    return null;
+  }
+
+  getInitCmds(): Array<string> {
+    const cmds: Array<string> = [];
+    for (const key in this._configuredAddOns) {
+      if (key in this._configuredAddOns) {
+        const initCmd = this._configuredAddOns[key]._initCmd;
+        if (initCmd) {
+          cmds.push(initCmd);
+        }
+      }
+    }
+    return cmds;
+  }
+
+  processReportMsg(reportMsgs: Array<RaftReportMsg>, timeInitStart: number) {
+    for (const reportID in reportMsgs) {
+      const report = reportMsgs[reportID];
+      //RaftLog.debug(`Report message: ${JSON.stringify(report)}`);
+      if (report.timeReceived && report.timeReceived < timeInitStart) {
+        continue;
+      }
+      if (report.elemName) {
+        let hwElemIDNoStr = "";
+        if (report.IDNo) {
+          hwElemIDNoStr = report.IDNo.toString();
+        } else if (report.elemName) {
+          const maybeIdno = this.getIDNoFromName(report.elemName);
+          if (maybeIdno) {
+            hwElemIDNoStr = maybeIdno;
+          }
+        }
+        if (hwElemIDNoStr.length > 0) {
+          this._configuredAddOns[hwElemIDNoStr].processInit(report);
+        }
+      }
+    }
+  }
+}

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;
+    }
+  }
+}