@robdobsn/raftjs 1.1.1

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

@@ -0,0 +1,371 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// RICJS
+// Communications Library
+//
+// Rob Dobson & Chris Greening 2020-2022
+// (C) 2020-2022
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+import RaftLog from "../../../../src/RaftLog";
+import RaftMsgHandler from "../../../../src/RaftMsgHandler";
+import { RaftOKFail, RaftReportMsg } from "../../../../src/RaftTypes";
+import { RICConfiguredAddOns } from "./RICAddOn";
+import RICAddOnManager from "./RICAddOnManager";
+import { RICHWElem, RICHWElemList, RICHWElemList_Str } from "./RICHWElem";
+import { RICCalibInfo } from "./RICTypes";
+
+export default class RICSystemUtils {
+
+  // Message handler
+  private _msgHandler: RaftMsgHandler;
+
+  // Add-on manager
+  private _addOnManager: RICAddOnManager;
+
+  // HWElems (connected to RIC) - excluding AddOns
+  private _hwElemsExcludingAddOns: Array<RICHWElem> = new Array<RICHWElem>();
+  private _connectedAddOns: Array<RICHWElem> = new Array<RICHWElem>();
+
+  // Calibration info
+  private _calibInfo: RICCalibInfo | null = null;
+
+  /**
+   * constructor
+   * @param raftMsgHandler
+   * @param addOnManager
+   */
+  constructor(msgHandler: RaftMsgHandler, addOnManager: RICAddOnManager) {
+    this._msgHandler = msgHandler;
+    this._addOnManager = addOnManager;
+  }
+
+  /**
+   * invalidate
+   */
+  invalidate() {
+    // Invalidate system info
+    this._hwElemsExcludingAddOns = new Array<RICHWElem>();
+    this._connectedAddOns = new Array<RICHWElem>();
+    this._addOnManager.clear();
+    this._calibInfo = null;
+    RaftLog.debug("RICSystem information invalidated");
+  }
+
+  /**
+   *  getSystemInfo - get system info
+   * @returns Promise<RICSystemInfo>
+   *
+   */
+  async retrieveInfo(): Promise<boolean> {
+    // Get HWElems (connected to RIC)
+    try {
+      await this.getHWElemList();
+    } catch (error) {
+      RaftLog.warn("retrieveInfo - failed to get HWElems " + error);
+      return false;
+    }
+
+    // Get calibration info
+    try {
+      await this.getRICCalibInfo(true);
+    } catch (error) {
+      RaftLog.warn("retrieveInfo - failed to get calib info " + error);
+      return false;
+    }
+
+    // Get HWElems (connected to RIC)
+    try {
+      await this.getHWElemList();
+    } catch (error) {
+      RaftLog.warn("retrieveInfo - failed to get HWElems " + error);
+      return false;
+    }
+    return true;
+  }
+
+  /**
+ * Get information Marty system
+ *
+ *  @return void
+ *
+ */
+  async retrieveMartySystemInfo(): Promise<boolean> {
+
+    // Retrieve system info
+    try {
+      const retrieveResult = await this.retrieveInfo();
+      return retrieveResult;
+    } catch (err) {
+      RaftLog.error(`retrieveMartySystemInfo: error ${err}`);
+    }
+    return false;
+  }
+
+  // Mark: Calibration -----------------------------------------------------------------------------------------
+
+  async calibrate(
+    cmd: string,
+    jointList: Array<string>,
+    jointNames: { [key: string]: string }
+  ) {
+    let overallResult = true;
+    if (cmd === "set") {
+      // Set calibration
+      for (const jnt of jointList) {
+        try {
+          // Set calibration on joint
+          const cmdUrl = "calibrate/set/" + jnt;
+          const rsl = await this._msgHandler.sendRICRESTURL<RaftOKFail>(
+            cmdUrl
+          );
+          // saving the calibration... (For the new servo boards it is necessary
+          // to send a "save" command after the calibration ones or any servo
+          // parameter changes in order to save any changes made into nonvolatile storage)
+          const saveCalibCmd = `elem/${jnt}/saveparams`;
+          await this._msgHandler.sendRICRESTURL<RaftOKFail>(saveCalibCmd);
+          if (rsl.rslt != "ok") overallResult = false;
+        } catch (error) {
+          console.log(`calibrate failed on joint ${jnt}`, error);
+        }
+
+        // Wait as writing to flash blocks servo access
+        // as of v0.0.113 of firmware, the pause is no longer required
+        //await new Promise(resolve => setTimeout(resolve, 3000));
+      }
+
+      // ensure all joints are enabled
+      for (const jnt in jointNames) {
+        try {
+          // enable joint
+          const cmdUrl = "servo/" + jnt + "/enable/1";
+          const rsl = await this._msgHandler.sendRICRESTURL<RaftOKFail>(
+            cmdUrl
+          );
+          if (rsl.rslt != "ok") overallResult = false;
+        } catch (error) {
+          console.log(`enable failed on joint ${jnt}`, error);
+        }
+      }
+
+      // Result
+      console.log("Set calibration flag to true");
+      const rslt = new RaftOKFail();
+      rslt.set(overallResult);
+      return rslt;
+    }
+    return false;
+  }
+
+  /**
+   *
+   * getRICCalibInfo
+   * @returns Promise<RICCalibInfo>
+   *
+   */
+  async getRICCalibInfo(forceGetFromRIC = false): Promise<RICCalibInfo> {
+    if (!forceGetFromRIC && this._calibInfo) {
+      return this._calibInfo;
+    }
+    try {
+      this._calibInfo = await this._msgHandler.sendRICRESTURL<RICCalibInfo>(
+        "calibrate"
+      );
+      RaftLog.debug("getRICCalibInfo returned " + this._calibInfo);
+      this._calibInfo.validMs = Date.now();
+      return this._calibInfo;
+    } catch (error) {
+      RaftLog.debug(`getRICCalibInfo Failed to get version ${error}`);
+      return new RICCalibInfo();
+    }
+  }
+
+  /**
+   *
+   * getHWElemList - get the list of hardware elements connected to the robot
+   *               - the result (if successful) is processed as follows:
+   *                       = if no filter is applied then all non-add-ons found are stored in
+   *                         this._hwElemsExcludingAddOns and all addons are stored in this._connectedAddOns
+   *                       = if a filter is applied and this filter is RSAddOns then this._connectedAddOns is
+   *                         updated with the new list of addons
+   *                       = in all cases the discovered list is returned
+   *
+   * @returns Promise<RICHWElemList>
+   *
+   */
+
+  async getHWElemList(filterByType?: string): Promise<Array<RICHWElem>> {
+    // Form a list of the requests to make
+    const reqList: Array<string> = [];
+    let addToNonAddOnsList = false;
+    if (!filterByType) {
+      reqList.push("SmartServo");
+      reqList.push("RSAddOn");
+      reqList.push("BusPixels");
+      reqList.push("!SmartServo,RSAddOn,BusPixels"); // not SmartServo or RSAddOn or BusPixels
+      this._hwElemsExcludingAddOns = new Array<RICHWElem>();
+      addToNonAddOnsList = true;
+    } else if (filterByType === "RSAddOn") {
+      // we treat BusPixels as an RSAddOn
+      // (batch 4 led eye add-ons have type BusPixels)
+      reqList.push("RSAddOn");
+      reqList.push("BusPixels");
+      this._connectedAddOns = new Array<RICHWElem>();
+    } else {
+      reqList.push(filterByType);
+    }
+
+    // Make the requests
+    const fullListOfElems = new Array<RICHWElem>();
+    this._connectedAddOns = [];
+    for (const reqType of reqList) {
+      try {
+        const hwElemList_Str = await this._msgHandler.sendRICRESTURL<
+          RICHWElemList_Str
+        >(`hwstatus/strstat?filterByType=${reqType}`);
+        // if the results of hwElem indicates that we are on an older fw version
+        // send the old hwstatus command and don't expand()
+        // the logic behind deciding if we are on a fw version that
+        // supports strstat is: given that hwElemList_Str.hw === object[]
+        // if we get back string[], then we know we are on an older version
+        // if hw === empty array, then we don't have any hw elems in which
+        // case we can stop at that point
+        const hwElems = hwElemList_Str.hw;
+        let hwElemList;
+        if (hwElems.length) {
+          if (typeof hwElems[0] !== "object") {
+            // we are on an older version
+            hwElemList = await this._msgHandler.sendRICRESTURL<
+              RICHWElemList
+            >(`hwstatus?filterByType=${reqType}`);
+          } else {
+            // we are on the fw version that supports strstat
+            hwElemList = RICHWElemList_Str.expand(hwElemList_Str);
+          }
+        }
+        if (hwElemList && hwElemList.rslt && hwElemList.rslt === "ok") {
+          fullListOfElems.push(...hwElemList.hw);
+          if (reqType === "RSAddOn") {
+            this._connectedAddOns = hwElemList.hw;
+            this._addOnManager.setHWElems(this._connectedAddOns);
+            // Debug
+            RaftLog.debug(
+              `getHWElemList: found ${hwElemList.hw.length} addons/buspixels`
+            );
+          } else if (reqType === "BusPixels") {
+            // BusPixels are treated as an RSAddOn
+            this._connectedAddOns.push(...hwElemList.hw);
+            this._addOnManager.setHWElems(this._connectedAddOns);
+            // Debug
+            RaftLog.debug(
+              `getHWElemList: found ${hwElemList.hw.length} addons/buspixels`
+            
+          } else if (addToNonAddOnsList) {
+            this._hwElemsExcludingAddOns.push(...hwElemList.hw);
+            // Debug
+            RaftLog.debug(
+              `getHWElemList: found ${hwElemList.hw.length} elems matching ${reqType}`
+            );
+          }
+        }
+      } catch (error) {
+        RaftLog.debug(`getHWElemList failed to get ${reqType} ${error}`);
+        return new Array<RICHWElem>();
+      }
+    }
+
+    // Handle any callbacks
+    try {
+      const reports: Array<RaftReportMsg> = [];
+      // add callback to subscribe to report messages
+      this._msgHandler.reportMsgCallbacksSet("getHWElemCB", function (
+        report: RaftReportMsg
+      ) {
+        reports.push(report);
+        RaftLog.debug(`getHWElemCB Report callback ${JSON.stringify(report)}`);
+      });
+
+      // run any required initialisation for the addons
+      const initCmds = this._addOnManager.getInitCmds();
+      // send init commands to the robot
+      const timeInitStart = Date.now();
+      for (let i = 0; i < initCmds.length; i++) {
+        this.runCommand(initCmds[i], {});
+      }
+      // wait a couple of seconds for any report messages to be received
+      await new Promise((resolve) => setTimeout(resolve, 2000));
+      // pass report messages to add on manager for processing
+      this._addOnManager.processReportMsg(reports, timeInitStart);
+
+      // clean up callback
+      this._msgHandler.reportMsgCallbacksDelete("getHWElemCB");
+    } catch (error) {
+      RaftLog.debug(`getHWElemList failed processing callback reports ${error}`);
+      return new Array<RICHWElem>();
+    }
+
+    // return the full list of elements
+    return fullListOfElems;
+  }
+
+  /**
+   *
+   * getAddOnConfigs - get list of add-ons configured on the robot
+   * @returns Promise<RICConfiguredAddOns>
+   *
+   */
+  async getAddOnConfigs(): Promise<RICConfiguredAddOns> {
+    try {
+      const addOnList = await this._msgHandler.sendRICRESTURL<
+        RICConfiguredAddOns
+      >("addon/list");
+      RaftLog.debug("getAddOnConfigs returned " + addOnList);
+      return addOnList;
+    } catch (error) {
+      RaftLog.debug(`getAddOnConfigs Failed to get list of add-ons ${error}`);
+      return new RICConfiguredAddOns();
+    }
+  }
+
+  /**
+     *
+     * runCommand
+     * @param commandName command API string
+     * @param params parameters (simple name value pairs only) to parameterize trajectory
+     * @returns Promise<RaftOKFail>
+     *
+     */
+  async runCommand(commandName: string, params: object): Promise<RaftOKFail> {
+    try {
+      // Format the paramList as query string
+      const paramEntries = Object.entries(params);
+      let paramQueryStr = "";
+      for (const param of paramEntries) {
+        if (paramQueryStr.length > 0) paramQueryStr += "&";
+        paramQueryStr += param[0] + "=" + param[1];
+      }
+      // Format the url to send
+      if (paramQueryStr.length > 0) commandName += "?" + paramQueryStr;
+      return await this._msgHandler.sendRICRESTURL<RaftOKFail>(commandName);
+    } catch (error) {
+      RaftLog.debug(`RaftSystemUtils runCommand failed ${error}`);
+      return new RaftOKFail();
+    }
+  }
+
+  getCachedAddOnList(): Array<RICHWElem> {
+    return this._connectedAddOns;
+  }
+
+  getCachedAllHWElems(): Array<RICHWElem> {
+    const allHWElems = new Array<RICHWElem>();
+    allHWElems.push(...this._connectedAddOns);
+    allHWElems.push(...this._hwElemsExcludingAddOns);
+    return allHWElems;
+  }
+
+  getCachedCalibInfo(): RICCalibInfo | null {
+    return this._calibInfo;
+  }
+}

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

@@ -0,0 +1,20 @@
+export type RICLEDPatternCheckerColour = {
+    led: string;
+    lcd: string;
+  }
+
+  export type RICLedLcdColours = Array<RICLEDPatternCheckerColour>;
+
+  export type RICServoFaultFlags = {
+    intermittentConnection: boolean,
+    noConnection: boolean,
+    faultyConnection: boolean,
+    servoHornPositionError: boolean
+  };
+
+  export class RICCalibInfo {
+    rslt = '';
+    calDone = 0;
+    validMs?= 0;
+  }
+  

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

@@ -0,0 +1,113 @@
+import { RaftSystemType } from "../../../../src/RaftSystemType";
+import { RaftLog, RaftSystemUtils, RaftOKFail, RaftConnEventFn, RaftEventFn, RaftPublishEvent, RaftPublishEventNames } from "../../../../src/main";
+import RICAddOnManager from "./RICAddOnManager";
+import RICCommsStats from "./RICCommsStats";
+import RICLEDPatternChecker from "./RICLEDPatternChecker";
+import RICServoFaultDetector from "./RICServoFaultDetector";
+import { RICStateInfo } from "./RICStateInfo";
+
+export default class SystemTypeMarty implements RaftSystemType {
+  nameForDialogs = "Robotical Marty";
+  defaultWiFiHostname = "Marty";
+  firmwareDestName = "ricfw";
+  normalFileDestName = "fs";
+  connectorOptions = {wsSuffix: "ws"};
+
+  // LED Pattern checker
+  private _ledPatternChecker: RICLEDPatternChecker = new RICLEDPatternChecker();
+  getLEDPatternChecker(): RICLEDPatternChecker {
+    return this._ledPatternChecker;
+  }
+
+  // Latest data from servos, IMU, etc
+  private _ricStateInfo: RICStateInfo = new RICStateInfo();
+  getRICStateInfo(): RICStateInfo {
+    return this._ricStateInfo;
+  }
+
+  // Add-on Manager
+  private _addOnManager = new RICAddOnManager();
+  getAddOnManager(): RICAddOnManager {
+    return this._addOnManager;
+  }
+
+  // Properties for Marty
+  private _ricServoFaultDetector: RICServoFaultDetector | null = null;
+  getRICServoFaultDetector(): RICServoFaultDetector {
+    return this._ricServoFaultDetector!;
+  }
+
+  // RIC comms stats
+  private _commsStats = new RICCommsStats();
+  getCommsStats(): RICCommsStats {
+    return this._commsStats;
+  }
+
+  // Event handler
+  private _onEvent: RaftEventFn | null = null;
+
+  // Raft system utils
+  private _systemUtils: RaftSystemUtils | null = null;
+
+  // Setup
+  setup(systemUtils: RaftSystemUtils, onEvent: RaftEventFn | null): void {
+    this._systemUtils = systemUtils;
+    this._onEvent = onEvent;
+    this._ricServoFaultDetector = new RICServoFaultDetector(this._systemUtils!.getMsgHandler(), this._ricStateInfo);
+  }
+
+  // Subscribe for updates
+  async subscribeForUpdates(systemUtils: RaftSystemUtils, enable: boolean): Promise<void> {
+    // Subscription rate
+    const subscribeRateHz = 10;
+    try {
+      const subscribeDisable = '{"cmdName":"subscription","action":"update",' +
+        '"pubRecs":[' +
+        `{"name":"MultiStatus","rateHz":0,}` +
+        '{"name":"PowerStatus","rateHz":0},' +
+        `{"name":"AddOnStatus","rateHz":0}` +
+        ']}';
+      const subscribeEnable = '{"cmdName":"subscription","action":"update",' +
+        '"pubRecs":[' +
+        `{"name":"MultiStatus","rateHz":${subscribeRateHz.toString()}}` +
+        `{"name":"PowerStatus","rateHz":1.0},` +
+        `{"name":"AddOnStatus","rateHz":${subscribeRateHz.toString()}}` +
+        ']}';
+
+      const msgHandler = systemUtils.getMsgHandler();
+      const ricResp = await msgHandler.sendRICRESTCmdFrame<RaftOKFail>(
+        enable ? subscribeEnable : subscribeDisable
+      );
+
+      // Debug
+      RaftLog.debug(`subscribe enable/disable returned ${JSON.stringify(ricResp)}`);
+    } catch (error: unknown) {
+      RaftLog.warn(`getRICCalibInfo Failed subscribe for updates ${error}`);
+    }
+  }
+
+  // Invalidate state
+  stateIsInvalid(): void {
+    if (this._systemUtils) {
+      this._systemUtils.invalidate();
+    }
+  }
+
+  // Other message type
+  rxOtherMsgType(payload: Uint8Array, frameTimeMs: number) {
+    // RICLog.debug(`onRxROSSerialMsg payload ${RICUtils.bufferToHex(payload)}`);
+    RaftLog.verbose(`onRxROSSerialMsg payloadLen ${payload.length}`);
+    const topicIDs = this._ricStateInfo.updateFromROSSerialMsg(payload, this._commsStats, this._addOnManager, frameTimeMs);
+
+    // Call event handler if registered
+    if (this._onEvent) {
+      this._onEvent("pub", RaftPublishEvent.PUBLISH_EVENT_DATA, RaftPublishEventNames[RaftPublishEvent.PUBLISH_EVENT_DATA],
+        {
+          topicIDs: topicIDs,
+          payload: payload,
+          frameTimeMs: frameTimeMs
+        });
+    }
+  }
+}
+

package/examples/dashboard/src/index.html

@@ -0,0 +1,15 @@
+<!-- index.html -->
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  <meta name="description" content="BusI2CWebTest">
+  <title>BusI2CWebTest</title>
+  <link rel="icon" href="data:image/svg+xml;base64, <?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!-- Created with Inkscape (http://www.inkscape.org/) -->

<svg
   width="511"
   height="511"
   viewBox="0 0 135.20209 135.20209"
   version="1.1"
   id="svg178"
   inkscape:version="1.3.2 (091e20e, 2023-11-25, custom)"
   sodipodi:docname="ScaderUiLogo.svg"
   inkscape:export-filename="logo512.png"
   inkscape:export-xdpi="96.187866"
   inkscape:export-ydpi="96.187866"
   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
   xmlns:xlink="http://www.w3.org/1999/xlink"
   xmlns="http://www.w3.org/2000/svg"
   xmlns:svg="http://www.w3.org/2000/svg">
  <sodipodi:namedview
     id="namedview180"
     pagecolor="#ffffff"
     bordercolor="#666666"
     borderopacity="1.0"
     inkscape:showpageshadow="2"
     inkscape:pageopacity="0"
     inkscape:pagecheckerboard="0"
     inkscape:deskcolor="#d1d1d1"
     inkscape:document-units="mm"
     showgrid="false"
     showguides="true"
     inkscape:zoom="1"
     inkscape:cx="578"
     inkscape:cy="536.5"
     inkscape:window-width="3840"
     inkscape:window-height="1529"
     inkscape:window-x="2552"
     inkscape:window-y="-8"
     inkscape:window-maximized="1"
     inkscape:current-layer="layer1">
    <sodipodi:guide
       position="38.751705,55.202082"
       orientation="0,1"
       id="guide388"
       inkscape:locked="false"
       inkscape:label=""
       inkscape:color="rgb(0,134,229)" />
    <sodipodi:guide
       position="67.750003,143.40417"
       orientation="-1,0"
       id="guide390"
       inkscape:locked="false"
       inkscape:label=""
       inkscape:color="rgb(0,134,229)" />
    <sodipodi:guide
       position="135,66.085245"
       orientation="-1,0"
       id="guide392"
       inkscape:locked="false"
       inkscape:label=""
       inkscape:color="rgb(0,134,229)" />
    <sodipodi:guide
       position="35.000002,92.690893"
       orientation="-1,0"
       id="guide394"
       inkscape:locked="false"
       inkscape:label=""
       inkscape:color="rgb(0,134,229)" />
    <sodipodi:guide
       position="149.27734,-14.79792"
       orientation="0,1"
       id="guide396"
       inkscape:locked="false"
       inkscape:label=""
       inkscape:color="rgb(0,134,229)" />
    <sodipodi:guide
       position="45.000003,98.413693"
       orientation="-1,0"
       id="guide431"
       inkscape:locked="false"
       inkscape:label=""
       inkscape:color="rgb(0,134,229)" />
    <sodipodi:guide
       position="-41.102392,-4.7979211"
       orientation="0,1"
       id="guide433"
       inkscape:locked="false"
       inkscape:label=""
       inkscape:color="rgb(0,134,229)" />
    <sodipodi:guide
       position="125,84.079717"
       orientation="-1,0"
       id="guide435"
       inkscape:locked="false"
       inkscape:label=""
       inkscape:color="rgb(0,134,229)" />
    <sodipodi:guide
       position="14.314266,51.202085"
       orientation="0,1"
       id="guide437"
       inkscape:locked="false"
       inkscape:label=""
       inkscape:color="rgb(0,134,229)" />
    <sodipodi:guide
       position="55.000003,73.887853"
       orientation="-1,0"
       id="guide439"
       inkscape:locked="false"
       inkscape:label=""
       inkscape:color="rgb(0,134,229)" />
    <sodipodi:guide
       position="97.750005,155.83959"
       orientation="-1,0"
       id="guide441"
       inkscape:locked="false"
       inkscape:label=""
       inkscape:color="rgb(0,134,229)" />
    <sodipodi:guide
       position="-36.603621,5.2020794"
       orientation="0,1"
       id="guide443"
       inkscape:locked="false"
       inkscape:label=""
       inkscape:color="rgb(0,134,229)" />
    <sodipodi:guide
       position="-20.65344,47.202085"
       orientation="0,1"
       id="guide445"
       inkscape:locked="false"
       inkscape:label=""
       inkscape:color="rgb(0,134,229)" />
  </sodipodi:namedview>
  <defs
     id="defs175">
    <linearGradient
       id="linearGradient4813"
       inkscape:swatch="solid">
      <stop
         style="stop-color:#000000;stop-opacity:1;"
         offset="0"
         id="stop4811" />
    </linearGradient>
    <linearGradient
       inkscape:collect="always"
       xlink:href="#linearGradient4813"
       id="linearGradient4815"
       x1="64.644437"
       y1="65.867585"
       x2="97.459561"
       y2="65.867585"
       gradientUnits="userSpaceOnUse" />
    <filter
       inkscape:collect="always"
       style="color-interpolation-filters:sRGB"
       id="filter10"
       x="-0.03278197"
       y="-0.02471915"
       width="1.0655639"
       height="1.0537213">
      <feGaussianBlur
         inkscape:collect="always"
         stdDeviation="0.53258204"
         id="feGaussianBlur10" />
    </filter>
    <filter
       inkscape:collect="always"
       style="color-interpolation-filters:sRGB"
       id="filter11"
       x="-0.037762622"
       y="-0.028188698"
       width="1.0755252"
       height="1.0616928">
      <feGaussianBlur
         inkscape:collect="always"
         stdDeviation="0.42542071"
         id="feGaussianBlur11" />
    </filter>
    <filter
       inkscape:collect="always"
       style="color-interpolation-filters:sRGB"
       id="filter12"
       x="-0.029296509"
       y="-0.017507524"
       width="1.058593"
       height="1.035015">
      <feGaussianBlur
         inkscape:collect="always"
         stdDeviation="0.3554596"
         id="feGaussianBlur12" />
    </filter>
  </defs>
  <g
     inkscape:label="Layer 1"
     inkscape:groupmode="layer"
     id="layer1">
    <path
       style="mix-blend-mode:normal;fill:#e6711e;fill-opacity:1;stroke:#ffffff;stroke-width:4;stroke-linecap:butt;stroke-linejoin:bevel;stroke-dasharray:none;stroke-opacity:1;filter:url(#filter10)"
       d="M 17.802083,123.0125 V 53.012501 l 50,-43.032821 49.999997,43.032821 V 123.0125 Z"
       id="path407"
       sodipodi:nodetypes="cccccc"
       transform="matrix(1.1671984,0,0,1.1149362,-10.939528,-8.1997929)" />
    <path
       style="fill:#e6711e;fill-opacity:1;stroke:#ffffff;stroke-width:4;stroke-linecap:butt;stroke-linejoin:bevel;stroke-dasharray:none;stroke-opacity:1;filter:url(#filter11)"
       d="M 27.802083,113.0125 V 57.012501 l 40,-34.168287 39.999997,34.168287 V 113.0125 Z"
       id="path407-9"
       sodipodi:nodetypes="cccccc"
       transform="matrix(1.1047603,0,0,1.0939386,-5.5154617,-5.8744454)" />
    <rect
       style="fill:none;stroke:#000000;stroke-width:0.264583;stroke-linejoin:bevel;stroke-dasharray:none;stroke-opacity:0;fill-opacity:1"
       id="rect2777"
       width="135.20209"
       height="135.20209"
       x="0"
       y="0" />
    <text
       xml:space="preserve"
       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:97.1048px;line-height:1.25;font-family:Calibri;-inkscape-font-specification:'Calibri, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;mix-blend-mode:normal;fill:#ffffff;fill-opacity:1;stroke:#ffffff;stroke-width:0.505206;stroke-dasharray:none;stroke-opacity:1;filter:url(#filter12)"
       x="39.393661"
       y="116.1168"
       id="text2854"
       transform="matrix(1.2201578,0,0,0.94615175,-5.7547399,-2.5485284)"><tspan
         sodipodi:role="line"
         id="tspan2852"
         x="39.393661"
         y="116.1168"
         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:97.1048px;font-family:Calibri;-inkscape-font-specification:'Calibri, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;fill:#ffffff;fill-opacity:1;stroke:#ffffff;stroke-width:0.505206;stroke-dasharray:none;stroke-opacity:1">S</tspan></text>
  </g>
</svg>
" type="image/svg+xml" />
+</head>
+<body>
+  <div id="root"></div>
+  <script type="module" src="./index.tsx"></script>
+</body>
+</html>

package/examples/dashboard/src/index.tsx

@@ -0,0 +1,15 @@
+import React from 'react';
+import { createRoot } from 'react-dom/client';
+import Main from './Main';
+import './styles.css';
+import 'process';
+import 'buffer';
+
+// Find the root element
+const rootElement = document.getElementById('root');
+
+// Create a root
+const root = createRoot(rootElement!);
+
+// Render the Main component into the root
+root.render(<Main />);

package/examples/dashboard/src/styles.css

@@ -0,0 +1,122 @@
+/* Main.css */
+
+/* General styling for the dark theme */
+body,
+.device-screen,
+.device-block-heading,
+.device-attrs-and-actions,
+.device-attrs-form,
+.device-actions-form,
+.device-line-chart {
+    /* Dark background for all components */
+    color: #fff;
+    /* Light text for better readability */
+    font-family: 'Segoe UI', 'Roboto', 'Oxygen',
+        'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue',
+        sans-serif;
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+    background-color: #282c34;
+    color: #ffffff;
+}
+
+code {
+    font-family: source-code-pro, Menlo, Monaco, Consolas, 'Courier New',
+        monospace;
+}
+
+.header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 10px 20px;
+    border: 1px solid #666;
+    /* Adjusting border color for dark theme */
+    border-radius: 8px;
+    margin-bottom: 10px;
+}
+
+h1 {
+    margin: 0;
+}
+
+.always-enabled {
+    pointer-events: auto !important; /* Ensures interactions are always enabled */
+}
+
+.content-body {
+    display: flex;
+    flex-direction: column;
+    gap: 10px;
+}
+
+.content-row {
+    display: flex;
+    justify-content: space-between;
+    margin-bottom: 10px;
+    flex-direction: col;
+}
+
+.conn-indication {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    padding: 10px;
+    border-radius: 8px;
+    margin-bottom: 10px;
+}
+
+.action-button {
+    margin-left: 10px;
+}
+
+.info-boxes {
+    display: flex;
+    justify-content: flex-start;
+    margin-bottom: 10px;
+    gap: 10px;
+}
+
+.info-box {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    border-radius: 10px;
+    padding: 10px 20px;
+    border: 1px solid #666;
+}
+
+.ip-addr-input {
+    width: 100%;
+    margin-bottom: 10px;
+}
+
+.status-screen {
+    display: flex;
+    flex-direction: column;
+    gap: 10px;
+    border-radius: 10px;
+    padding: 10px 20px;
+    border: 1px solid #666;
+}
+
+.info {
+    display: flex;
+    flex-direction: column;
+    justify-content: space-between;
+}
+
+.info-line {
+    display: flex;
+    justify-content: space-between;
+    margin-bottom: 10px;
+}
+
+.info-label {
+    font-weight: bold;
+    margin-right: 10px;
+}
+
+.info-value {
+    font-weight: normal;
+}