@robdobsn/raftjs 1.8.5 → 1.10.7

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

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, '|');
+  }
+}