Version 3.0.x

fake-runtime/FakeRuntime.ts

@@ -1,25 +1,22 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /*
- * Fake Runtime is not handled by webpack like most of the other JS code but instead
- * will be run "as is" as a child-process of the rest of the application.
- * See DebugMenu.js for handling FakeRuntime within Dawn
+ * Fake Runtime is run as a child-process of the rest of the application.
+ * See DebugMenu.js for handling FakeRuntime within Dawn.
  */
 
 /* eslint-disable camelcase */
 import { DevData, IParam, IDevice, IDevData } from '../protos-main';
-import { createSocket, Socket as UDPSocket } from 'dgram';
-import { createServer, Server as TCPServer } from 'net';
+import { createServer, Server as TCPServer, Socket as TCPSocket } from 'net';
 
 const TCP_PORT = 8101;
-const UDP_SEND_PORT = 9001;
-const UDP_LISTEN_PORT = 9000;
 const MSG_INTERVAL_MSEC = 50;
 
 const randomFloat = (min: number, max: number) => (max - min) * Math.random() + min;
 const sensor = (name: string, type: number, params: IParam[], uid: number): IDevice => ({
   name,
   type,
   params,
-  uid,
+  uid
 });
 
 const param = (name: string, type: string, value: any): IParam => ({
@@ -35,27 +32,18 @@ const print = (output: string) => {
 };
 
 class FakeRuntime {
-  sendSocket: UDPSocket;
-  listenSocket: UDPSocket;
   tcpServer: TCPServer;
 
   constructor() {
-    this.sendSocket = createSocket({ type: 'udp4', reuseAddr: true });
-    this.listenSocket = createSocket({ type: 'udp4', reuseAddr: true });
-
-    this.listenSocket.on('message', (_msg: any) => {
-      // TODO: Handle UDP gamepad recv
-    });
-    this.listenSocket.bind(UDP_LISTEN_PORT);
-
     this.tcpServer = createServer((_c: any) => {
       print('client connected');
     });
     this.tcpServer.listen(TCP_PORT, () => {
       print('server bound');
-    })
-
-    setInterval(this.onInterval, MSG_INTERVAL_MSEC);
+    });
+    this.tcpServer.on('connection', (socket: TCPSocket) => {
+      setInterval(() => this.sendDeviceData(socket), MSG_INTERVAL_MSEC);
+    });
   }
 
   generateFakeData = () => {
@@ -71,7 +59,7 @@ class FakeRuntime {
           [
             param('Val 1', 'float', randomFloat(-100, 100)),
             param('Val 2', 'float', randomFloat(-100, 100)),
-            param('Val 3', 'float', randomFloat(-100, 100)),
+            param('Val 3', 'float', randomFloat(-100, 100))
           ],
           104
         ),
@@ -80,15 +68,26 @@ class FakeRuntime {
         // Special Cases handled in dawn/renderer/reducers/peripherals.js
         // sensor('Ignored', 5, [param('major', 'int', 1), param('minor', 'int', 2), param('patch', 'int', 3)], -1),
         // sensor('Ignored', 5, [param('is_unsafe', 'bool', Math.random() < 0.5), param('v_batt', 'float', randomFloat(0, 15))], 0),
-      ],
+      ]
     };
-  }
+  };
 
-  onInterval = () => {
+  sendDeviceData = (socket: TCPSocket) => {
     const fakeData: IDevData = this.generateFakeData();
-    this.sendSocket.send(DevData.encode(fakeData).finish(), UDP_SEND_PORT, 'localhost');
+    const encodedPayload = DevData.encode(fakeData).finish();
+
+    const msgLength = Buffer.byteLength(encodedPayload);
+    const msgLengthArr = new Uint8Array([msgLength & 0x00ff, msgLength & 0xff00]); // Assuming little-endian byte order, since runs on x64
+    const msgTypeArr = new Uint8Array([3]); // msg type 3 for DevData
+    const packet = Buffer.concat([msgTypeArr, msgLengthArr, encodedPayload], msgLength + 3);
+
+    socket.write(packet, (err?: Error) => {
+      if (err !== undefined) {
+        console.log('Err', err);
+      }
+    });
     // TODO: Handle TCP writes to console
-  }
+  };
 }
 
 new FakeRuntime();

main/MenuTemplate/DebugMenu.ts

@@ -67,6 +67,13 @@ const DebugMenu: MenuItemConstructorOptions = {
         });
       },
     },
+
+    {
+      label: 'Toggle Videofeed DevTools',
+      click() {
+        RendererBridge.toggleWindowDevtools('video_feed');
+      },
+    },
   ],
 };
 

main/main-process.ts

@@ -61,6 +61,8 @@ export default function showAPI() {
 }
 
 app.on('ready', () => {
+  let videoWindow: BrowserWindow | null = null;
+
   Runtime.setup();
   ipcMain.on('FC_CONFIG_CHANGE', FCObject.changeFCInfo);
   ipcMain.on('FC_INITIALIZE', initializeFC);
@@ -73,6 +75,31 @@ app.on('ready', () => {
     }
   });
 
+  ipcMain.on('SHOW_VIDEO_FEED', () => {
+    if (!videoWindow) {
+      videoWindow = new BrowserWindow({
+        webPreferences: {
+          nodeIntegration: true,
+          enableRemoteModule: true,
+        },
+        width: 1000,
+        height: 700,
+      });
+      RendererBridge.registerWindow('video_feed', videoWindow);
+      videoWindow.on('closed', () => {
+        videoWindow = null;
+      });
+      videoWindow.maximize();
+      videoWindow.loadURL(`file://${__dirname}/../static/video-feed/video.html`);
+      videoWindow.webContents.on('dom-ready', () => RendererBridge.dispatch('video_feed', 'shepherdScoreboardServerIpAddress', FCObject.bridgeAddress))
+      videoWindow.on('ready-to-show', () => {
+        if (videoWindow) {
+          videoWindow.show();
+        }
+      });
+    }
+  })
+
   // Binding for the main process to inject into Redux workflow
   RendererBridge.registerWindow('main', mainWindow);
 

main/networking/FieldControl.ts

@@ -20,7 +20,7 @@ class FCInternals {
   }
 
   init() {
-    this.socket = io(`http://${this.bridgeAddress}:7000`);
+    this.socket = io.connect(this.bridgeAddress);
     this.socket.on('connect', () => {
       this.logger.log('Connected to Field Control Socket');
       this.socket!.on('robot_state', (data: any) => {
@@ -76,6 +76,7 @@ export const FCObject = {
 
     if (arg.bridgeAddress !== null) {
       FCObject.bridgeAddress = arg.bridgeAddress;
+      RendererBridge.dispatch('video_feed', 'shepherdScoreboardServerIpAddress', arg.bridgeAddress);
     }
   },
 };

main/networking/Runtime.ts

@@ -5,6 +5,7 @@ import * as protos from '../../protos-main';
 import RendererBridge from '../RendererBridge';
 import { updateConsole } from '../../renderer/actions/ConsoleActions';
 import { infoPerMessage } from '../../renderer/actions/InfoActions';
+import { runtimeConnect, runtimeDisconnect } from '../../renderer/actions/InfoActions';
 import { updatePeripherals } from '../../renderer/actions/PeripheralActions';
 import { Logger, defaults } from '../../renderer/utils/utils';
 import { Peripheral } from '../../renderer/types';
@@ -140,13 +141,14 @@ class RuntimeConnection {
   logger: Logger;
   socket: TCPSocket;
   leftoverBytes: Buffer | undefined;
+  connectionInterval: ReturnType<typeof setInterval>;
 
   constructor(logger: Logger) {
     this.logger = logger;
     this.socket = new TCPSocket();
 
     // Connect to most recent IP
-    setInterval(() => {
+    this.connectionInterval = setInterval(() => {
       if (!this.socket.connecting && this.socket.pending) {
         if (runtimeIP !== defaults.IPADDRESS) {
           let port = DEFAULT_TCP_PORT;
@@ -164,11 +166,12 @@ class RuntimeConnection {
 
     this.socket.on('connect', () => {
       this.logger.log('Runtime connected');
+      RendererBridge.reduxDispatch(runtimeConnect());
       this.socket.write(new Uint8Array([1])); // Runtime needs first byte to be 1 to recognize client as Dawn (instead of Shepherd)
     });
 
     this.socket.on('end', () => {
-      // RendererBridge.reduxDispatch(runtimeDisconnect());
+      RendererBridge.reduxDispatch(runtimeDisconnect());
       this.logger.log('Runtime disconnected');
     });
 
@@ -187,22 +190,22 @@ class RuntimeConnection {
       for (const packet of processedTCPPackets) {
         let decoded;
 
-        switch (packet.type) {
-          case MsgType.LOG:
-            decoded = protos.Text.decode(packet.payload);
-            RendererBridge.reduxDispatch(updateConsole(decoded.payload));
-            break;
+        try {
+          switch (packet.type) {
+            case MsgType.LOG:
+              decoded = protos.Text.decode(packet.payload);
+              RendererBridge.reduxDispatch(updateConsole(decoded.payload));
+              break;
 
-          case MsgType.TIME_STAMPS:
-            decoded = protos.TimeStamps.decode(packet.payload);
-            const oneWayLatency = (Date.now() - Number(decoded.dawnTimestamp)) / 2;
+            case MsgType.TIME_STAMPS:
+              decoded = protos.TimeStamps.decode(packet.payload);
+              const oneWayLatency = (Date.now() - Number(decoded.dawnTimestamp)) / 2;
 
-            // TODO: we can probably do an average of n timestamps so the display doesn't change too frequently
-            RendererBridge.reduxDispatch(setLatencyValue(oneWayLatency));
-            break;
+              // TODO: we can probably do an average of n timestamps so the display doesn't change too frequently
+              RendererBridge.reduxDispatch(setLatencyValue(oneWayLatency));
+              break;
 
-          case MsgType.DEVICE_DATA:
-            try {
+            case MsgType.DEVICE_DATA:
               RendererBridge.reduxDispatch(infoPerMessage());
               const sensorData: protos.Device[] = protos.DevData.decode(packet.payload).devices;
               const peripherals: Peripheral[] = [];
@@ -221,16 +224,15 @@ class RuntimeConnection {
                 peripherals.push({ ...device, uid: device.uid.toString() });
               });
               RendererBridge.reduxDispatch(updatePeripherals(peripherals));
-            } catch (err) {
-              this.logger.log(err);
-            }
-            break;
+              break;
 
-          default:
-            this.logger.log(`Unsupported received message type: ${packet.type}`)
+            default:
+              this.logger.log(`Unsupported received message type: ${packet.type}`);
+          }
+        } catch (err) {
+          this.logger.log(err);
         }
       }
-
       this.leftoverBytes = leftoverBytes;
     });
 

package.json

@@ -117,14 +117,17 @@
     "bufferutil": "4.0.1",
     "create-react-class": "15.6.2",
     "electron-json-storage": "4.0.2",
-    "formik": "^2.2.6",
+    "html-loader": "^0.5.5",
+    "html-react-parser": "^1.2.4",
     "immutable": "3.8.2",
+    "jquery": "^3.6.0",
     "json-loader": "0.5.7",
     "keymirror": "0.1.1",
     "lodash": ">=4.17.21",
     "mousetrap": "1.6.1",
     "numeral": "2.0.6",
     "object-assign": "4.1.1",
+    "ovenplayer": "^0.10.0-alpha.1",
     "patch-package": "^6.2.2",
     "postinstall-postinstall": "^2.1.0",
     "prop-types": "15.6.0",
@@ -141,7 +144,7 @@
     "redux-saga": "^1.1.3",
     "seedrandom": "2.4.3",
     "smalltalk": "^4.0.6",
-    "socket.io-client": "^2.3.0",
+    "socket.io-client": "^4.0.0",
     "ssh2": "^0.8.9",
     "superagent": "3.8.2",
     "ts-node": "^9.0.0",

renderer/components/App.tsx

@@ -4,6 +4,7 @@ import { remote, ipcRenderer } from 'electron';
 import * as electronJSONStorage from 'electron-json-storage';
 import { connect } from 'react-redux';
 import { Dispatch } from 'redux';
+import smalltalk from 'smalltalk';
 import { Dashboard } from './Dashboard';
 import { DNav } from './DNav';
 import { joyrideSteps } from './JoyrideSteps';
@@ -20,6 +21,12 @@ library.add(fas);
 
 const storage = remote.require('electron-json-storage') as ElectronJSONStorage;
 
+interface AlertType {
+  heading: string;
+  message: string;
+  id: number;
+}
+
 interface StateProps {
   connectionStatus: boolean;
   runtimeStatus: boolean;
@@ -41,6 +48,21 @@ export const AppComponent = (props: Props) => {
   const [tourRunning, changeTourRunning] = useState(false);
   startLog();
 
+  useEffect(() => {
+    const latestAlert = props.asyncAlerts[props.asyncAlerts.length - 1] as AlertType | undefined;
+
+    if (latestAlert !== undefined) {
+      smalltalk.alert(latestAlert.heading, latestAlert.message).then(
+        () => {
+          props.onAlertDone(latestAlert.id);
+        },
+        () => {
+          props.onAlertDone(latestAlert.id);
+        }
+      );
+    }
+  }, [props.asyncAlerts])
+
   useEffect(() => {
     addSteps(joyrideSteps);
     ipcRenderer.on('start-interactive-tour', () => {