Sean Whitsitt

A passenger comfort controller for an autonomous ground vehicle

Trajectory-following controllers for autonomous ground vehicles must carefully consider the possibility of vehicle instability. Previous approaches have provided a reference velocity along with a trajectory to follow, and a supervisory controller selects low velocity if turns are anticipated. However, such an approach is not robust across different vehicle platforms, and does not take into account passenger comfort. This paper provides a controller and design methodology to couple an existing trajectory controller with a speed limiting controller, where the speed-limiting controller is created based on user driving data. The result is a controller that can be optimized using a set of linearized controllers, and which is also demonstrated to remain below the velocity/turnrate thresholds established by human drivers: a conservative approximation for stability thresholds to prevent rollovers and skidding. Analysis is performed on data gathered using velocities between 0–18 m/s gathered in driving on surface streets as well as maneuvers in an open area, to demonstrate the validity of the thresholds in various conditions.

Model Based Development with the Skeleton Design Method

In the template design method, an algorithm is defined in abstract terms. The template can then be used to create various subclasses to override that abstract behavior. This paper discusses a way in which the template method can be extended to the generation of software artifacts from models. Specifically, this new method will be an amalgam of techniques for applying template design concepts to modeling. This extended method is referred to as the skeleton method and has two major sub- methodologies that compose it. First, skeleton files are created to represent the end artifacts of the modeling language. Second, an interpreter template can be constructed from which language interpreters can be derived. As such, the modeling language can be easily extended to generate software for new programming languages or for new third party middleware. This paper presents two modeling languages which use the skeleton method for model based development.

Message Modeling for the Joint Architecture for Unmanned Systems (JAUS)

The Joint Architecture for Unmanned Systems (JAUS) is a standard for sensing, control, and computational communication of components for unmanned systems. This paper presents a modeling environment capable of producing a domain-specific prototype of the software necessary for inter-computer communications. A metamodel is used to provide the domain-specific modeling language to model both the messages used in JAUS, and the shell interfaces for components that transmit and receive those messages. The produced artifacts are C and C++ code that can be used in unmanned systems and simulations of such systems, including tests that validate the structure and behavior of the generated code. The generated code is compatible with standard JAUS implementations, and is validated using the Open JAUS open source API and framework. Future work describes the second spiral of features and behaviors (currently in the design phase). The case study and test environment for the software generated by this project is an autonomous ground vehicle, modeled on a Ford Escape Hybrid that is used in laboratory experiments.

Runtime hardware/software task transition scheduling for data-adaptable embedded systems

Data-adaptable reconfigurable embedded systems enable a flexible runtime implementation in which a system can transition the execution of tasks between hardware and software while simultaneously continuing to process data during the transition. Efficient runtime scheduling of task transitions is needed to optimize system throughput and latency of the reconfiguration and transition periods. In this paper, we present and analyze several runtime transition scheduling algorithms and highlight the latency and throughput tradeoffs for an example system.

System Throughput Optimization and Runtime Communication Middleware Supporting Dynamic Software-Hardware Task Migration in Data Adaptable Embedded Systems

The complexity of embedded applications has led to highly configurable algorithms and standards that support a wide range of data inputs. Design time optimization of these algorithms is not possible due to combinatorial explosion of data configurations - or data profiles - that can be observed at runtime. To address these challenges, data adaptable design methodologies can be utilized to directly model the correlation of data profiles and algorithmic requirements. This approach enables a reconfigurable implementation that adapts the system execution at runtime to utilize profile-specific hardware tasks in response to changes in the data profile of the current input data. In this paper, we present a simulation-based methodology and heuristic search methodology for determining system configurations considering available hardware accelerators and the sizes of FIFO queues within those accelerators to determine Pareto optimal configurations for system throughput and area. We further present a hardware/software communication wrapper and middleware to support seamless communication between software and hardware tasks.

Generating a ROS/JAUS bridge for an autonomous ground vehicle

Robotic systems have benefitted from standardized middleware that can componentize the development of new capabilities for a robot. The popularity of these robotic middleware systems has resulted in sizable libraries of components that are now available to roboti- cists. However, many robotic systems (such as autonomous vehicles) must adhere to externally defined standards that do not contain a large repository of components. Due to the real-time and safety concerns that accompany the domain of unmanned systems, it is not trivial to interface these middleware systems. However, previous attempts to do so have succeeded at the cost of ad hoc design and implementation. This paper describes a domain-specific approach to the synthesis of a bridge between the popular Robotic Operating System (ROS) and the Joint Architecture for Unmanned Systems (JAUS). The domain-specific nature of the approach permits the bridge to be limited in scope by the applications specific messages (and their attribute mappings between JAUS/ROS), resulting in smaller code size and overhead than would be incurred by a generic solution. Our approach is validated by tests performed on an unmanned vehicle with and without the JAUS/ROS bridge.

Modeling Autonomous Systems

Middleware designed to describe sensing, control, and computational communications of components within unmanned systems enables the creation of clean interfaces between the low-level mechanics of such systems and the higher-level logic designed to control them. This paper presents a modeling environment with a domain-specific ontology for autonomous systems, capable of generating software necessary for intercomputer communications according to existing autonomous systems middleware standards. Metamodels are used to specify the domain-specific modeling language to model the messages used, the interfaces between components, and some of the functionality of the components that transmit and receive messages. The generated code supports the high data rates expected in autonomous systems that use lossy message compression. Tests for the messaging infrastructure are also generated for the messages. Also, using this research, this code generation process can be extended to any component-based platform with a sim...

An overseer control methodology for data adaptable embedded systems

The performance of software algorithms can be improved by performing those algorithms on specialized embedded hardware. However, complex algorithms that rely on input data at runtime for configuration have a combinatorial explosion of possible configurations, which has historically put hardware acceleration out of reach for applications wishing to serve large configuration spaces. Data adaptable embedded systems overcome this limitation by allowing for hardware reconfiguration during runtime, but the complexity of the specification of these systems is difficult to manage with traditional techniques. In this paper, a modeling approach is discussed in order to concurrently model two aspects of the final system: dependencies between algorithm tasks, and desired hardware configurations for each task. The contribution of the work is the model-based generation of hardware and software tasks, as well as a control scheme customized to each model that oversees the dynamic reconfiguration process.

A hybrid controller for autonomous vehicle lane changing with epsilon dragging

Trajectory control for an autonomous ground vehicle typically utilizes the error from the desired path or trajectory (i.e., crosstrack error) to produce velocity and steering commands. If an obstacle is in the path, previous techniques have synthesized a new trajectory that avoids the obstacles, and the vehicle directly follows this new path. This approach has drawbacks at high velocity, because the synthesized trajectory must satisfy the stability criteria of the vehicle. This paper introduces a technique which we call epsilon dragging. The approach modifies the existing trajectory by some value e in order to avoid an obstacle at high speeds, while preserving the original trajectory as the desired path. Epsilon dragging is performed by inducing an additional error to the crosstrack error of the vehicle; this induced error can be bounded in order to stay within the velocity/turnrate profile that governs safe behavior at high speeds. The paper provides a method to construct epsilon such that a vehicle can avoid an obstacle at high speeds without the need to verify the trajectorys curvature before it is synthesized. The technique is demonstrated in completing a lane-change maneuver at different velocities, and verifying that the velocity/turnrate profiles are not exceeded.

Efficient reconfiguration methods to enable rapid deployment of runtime reconfigurable systems

Todays sensing and processing algorithms operate on vast data streams coming from a broad range on input sources. In response, embedded computing applications require a large degree of configurability and adaptability to operate on a variety of data inputs where the characteristic of the data inputs may also change over time. To address these challenges, runtime reconfigurable systems can enable efficient implementations in which hardware accelerators can be reconfigured in response to the characteristics of the current data inputs. In this paper, we present an overview of the framework and runtime reconfiguration methods developed in the data-adaptable reconfigurable embedded systems (DARES) project. We provide an overview of the rapid deployment and runtime reconfiguration capabilities of this methodology, showcasing an adaptable implementation of a JPEG2000 image compression application.