StarControl WebUI
The DSAAV architecture is extremely useful in creating modular AUVs and provides a uniform software interface for all the command and control modules as well as the sensors and actuators.
DSAAV provides a control peer-to-peer communication architecture. It spreads the load and
traffic across all processes and databases. It has a central configuration database. It does not
require TCP/IP, thus it is light weight and can be implemented over Ethernet.
DSAAV has a four-layer architecture:
The RPC (Remote Procedure Call) Framework enables executing a procedure residing in a different address space. For example, using the logging service RPC to log data from sensors. A component can also broadcast a call to all modules if it does not specify a particular address.
The layer above RPC consists of three components { EComm (External Communication), Sensors and Actuators, Core services (contains services for configuration of module, logging and health monitoring). The top-most layer is the vehicle command and control layer that executes missions with the help of the layers below it.
Every DSAAV software component runs in a container. The container act as a separate module with multiple components inside it. A micro-controller runs a container as a single thread or process. The containers are deployed on various hardware nodes (Micro-controllers) in the vehicle. The containers receive RPC requests for the components that reside in them. Thus, DSAAV provides a modular approach to controlling the vehicle's behavior. Thus, it enables users to add additional modules and MCUs and also update them using RPCs.
The Starfish AUV: Starfish is a project by the ARL that aims to develop a platform for cooperation between AUVs and the AUV modules. The Starfish AUV is built using a modular design with 3 sections: nose, tail and the command, control and communications section. The sections contain the various sensors, actuators, communications modem and also slots for additional payloads. All these modules are based on the DSAAV architecture. The core server contains configuration service, logging service health monitor, UDP bridge and runs on a Linux node in the command, control and communications section. The sensors and actuators are connected to microcontrollers in that section which contains the required software drivers and they log their data in a central logging server.
Hierarchical Multi-Agent Command and Control System for Autonomous Underwater Vehicles using Fjage and JC2
It provides a multi-agent approach where mission, navigation and vehicle control tasks are allocated to individual software agents that are arranged in hierarchical order.
Architecture All agents are self-contained and have a uniform software interface to enable communication via messaging. The various agents and components used are (The are named and function similar to positions on a submarine):
Captain- controls execution of missions and operator commands,
Signaling officer- Decodes messages and used for external communication,
Safety Officer- enforces Geofence and detects anomalies from a health monitor,
Backseat Driver- Generates mission points using sensor data and interacts with payload
modules,
Executive Officer- Communicates with navigator and Pilot to transfer points for waypoint
navigation,
Navigator- does Path planning using waypoints,
Health Monitor- The sensor and actuator drivers implement a monitor that analyzed the
incoming data from them,
Pilot- Converts waypoints to primitive vehicle control,
Lookout- Analyses data from sonar for obstacle detection,
Mission Files- contains mission points and mission tasks
Fjage: Fjage provides a platform for implementing the hierarchical agent-based system using Java and Groovy. We can define the various components of an AUV using Fjage agents. We can also define the behavior of an agent which it executes when active.
Agents use messages to interact with each other, thus we can also define various messages and specify the recipient agent with the message behavior. Moreover, Fjage allows us to publish a message to a topic without specifying the recipient agent. All agents that subscribe to that topic receive the message. For example, we can subscribe to a topic called Vehicle Status which gives the status of the AUV. (depth, bearing, etc)
Furthermore, Fjage also allows the user to define services which is a set of messages and behaviors that an agent can provide. Thus, if we have a pool of agents that provide the same service, we can request for an agent that provides the service and an available agent from the agent pool will be returned. This makes it easier to access certain messages.
The JS Gateway library enables browser-based web-applications to communicate with Fjage agents running in the AUV through web sockets. The Gateway communicates with the server that served the webpage, through the web sockets interface on the port specified.
The WebUI has been built with help of an AUV Simulator which hosts the WebUI at "ve- hicleIP:port" on a nodeJS server. The AUV simulator mimics an AUV, it accepts several commands like setting actuator values, running missions(eg: Operator Command Requests) and simulates sensor data by simulating the motion of an AUV. It accepts origin, geofence from a configuration file and uses them as a reference for calculating its position, motion. The simulator just like the vehicle contains various agents implemented using Fjage and provides packages of classes with methods that can be used to carry out various functions like retrieving vehicle status, mission status(by subscribing to services) and sending messages to vehicle agents to execute commands.
This project aims to develop a browser-based application with cloud support that can monitor the AUV as well as control it in case of emergencies.
- Must have a map component that displays the location of the vehicle, geofence, mission points as well as the vehicle path.
- The app should be able to connect to the vehicle using web-sockets over Wi-Fi.
- App must display health and diagnostics of all the components of the vehicle.
- Display logs for DSAAV and other units and enable filter functionality for them.
- File upload and download for missions, configuration.
- Easy and quick interface with hotkeys to view various parameters of the AUV and modify them to control the vehicle.
- Enable editing of mission tasks
- Display status and readings of all sensors and actuators.
- Allow control of AUV using scripts that can be deployed in real time.
- UI should be intuitive and quick to operate.
- On starting the AUV, the operator must be able to see its current location on a map to verify its GPS readings as well as check the readiness of the vehicle and its components like the GSM modules. Chapter 1. Introduction 6
- The operator opens different pages of the application in various windows that can be displayed on screen at once and can be used while using a terminal to control the AUV efficiently.
- The AUV operator may need to take control of the AUV if there is an emergency, this is done quickly using keyboard shortcuts and sending messages to the captain to alter specific parameters of the vehicle like thrust, bearing, etc. Alternatively, in the case of emergencies, the operator executes sub-routines from a script that is uploaded to the AUV.
- Before deploying the AUV into the water, the operator checks the health of each component and also verifies the readings from the sensors and actuators.
- The operator may edit and upload a mission after the AUV has been deployed.
- The operator uses the mission planner to add various mission tasks like lawnmower or loiter.
The application is built using a Single Page Application (Client - downloaded by the browser from the server similar to a website) + Web API (Server in the vehicle that also contains the Fjage agents) model.
The SPA is built using ReactJS. It is a component-based framework with components that
manage their own state and update the UI when there is a change in state. Thus, this results in
a smoother UI without needing to open any new web pages by just replacing one component
with another. React has its own virtual DOM (Data object Model) that can be modified easily
and the changes made to it are reflected in the actual browser DOM.
React primarily consists of JavaScript components (classes or functions) along with HTML tags
for structure and base and CSS for styling the elements.
It also contains the Fjage JS Gateway script that is downloaded by the browser from the server
that enables the UI to interact with the agents on the server side using messages through the
gateway.
The Web API consists of various Fjage agents and services which expose particular requests that
can be used to retrieve the necessary data or send data to control the behavior of the AUV.
The Fjage agents are built using Java, Groovy and the DSAAV framework acts as a middleware
(bridge) between different components of the AUV and the software agents. for example: the
fjage agents and the sentuators)
Components for the main content: The main content displays the required data according to the tab selected. Using the React Router, we can display a particular component according to the URL. The options available are:
The map primarily displays the vehicle position, geofence, mission (whichever is selected) and the vehicle path. All of these can be toggled using the buttons. The map can be viewed offline and is rendered using the lea et library. Major features of the map UI:
- Buttons to open new browser windows to view the Dashboard, Diagnostics, Sentuators and script control components respectively. If a particular window is already open, the browser will bring it in focus instead of opening a duplicate one.
- The missions button opens a dropdown that allows the user to view, run mis- sions(allows user to run only those missions that have been saved to the vehicle successfully) The other buttons represent: center map, toggle geo-fence, toggle mis- sion points, toggle vehicle path respectively.
- Buttons to enable user to manually abort mission, send vehicle home and station keep respectively.
- Draw Geo-fence - Hides the UI layers of the map and allows user to edit the ge- ofence(clear, add, drag geo-fence points).
- Toggle the mission planner. It opens 2 panels: mission tree view panel on the left and and a mission leg panel on the right.
- The mission tree view panel displays all the missions and each mission can be expanded to show all the mission points inside. Each mission has buttons to save and discard changes, delete the mission. Each mission point can be clicked to display it's parameters on the mission leg panel. A mission point can also be deleted using a button. If a mission is edited by the user, an asterisk appears on that particular mission and user cannot run it until the changes are saved or discarded.
- The mission leg panel has 3 tabs: Property (to display the coordinates, and any other mission type specific properties), Parameters (displays a list of pre-defined parameters for each mission task/leg), Payload (displays a json object of the user-defined payload). The user can edit all the fields but changes are not saved to the vehicle unless the save button on the mission tree view panel is pressed.
- A marker to display the position of the vehicle on the map, it is followed by the path taken by the vehicle to reach the current position.
- Displays the mission points and also highlights the selected mission point (from the mission tree view panel). The user can add new mission points in-between 2 mission points or at the end. The mission points can also be dragged to change their position.
- Displays the current position of the vehicle in latitude, longitude as well as local coordinates.
It contains a series of gauges that display various parameters from the vehicle status. The components were created using the d3 js library and made into react components so that they can easily be duplicated.The gauges are periodically updated as and when the application receives a message from the VEHICLESTATUS topic. The message contains the new values for each parameter. There 3 variations of the gauge component:
- Gauge Component
- Bearing Component
- Roll/Pitch Component The Roll, Pitch and Bearing components have minor variations like having a complete circle, different dial values, different pointers and depictions of the vehicle on the gauges.
It enables the user to control the AUV's behavior by uploading and running sub-routines from a script. It contains a text box that can be to view/edit the script. The interface provides buttons to GET the script stored in the vehicle, PUT/Upload changed script to the vehicle, a dropdown to select the subroutine from the script and a RUN button to run the subroutine. The result is displayed in another text box below it. The application automatically detects new subroutines using regex when the script is uploaded. The UI displays a loader animation while the result is being fetched.
It displays the status and health of all the components of the AUV. There are 3 indicators for each component: Online, Healthy and Data. The components that have errors are highlighted in red.
It displays all the sensors and actuators in the different components of the vehicle. The user can check the sentuator values to debug and view their status. The user must first select a component, and then click on a sensor or actuator to view its data. Some sentuators may not display data.
