Abstract: Robotic systems are typically composed of various subsystems, such as localization and navigation, each encompassing numerous configurable components (e. g., selecting different planning algorithms). Once an algorithm has been selected for a component, its associated configuration options must be set to the appropriate values. Configuration options across the system stack interact non-trivially. Finding optimal configurations for highly configurable robots to achieve desired performance poses a significant challenge due to the interactions between configuration options across software and hardware that result in an exponentially large and complex configuration space. These challenges are further compounded by the need for transferability between different environments and robotic platforms. Data efficient optimization algorithms (e. g., Bayesian optimization) have been increasingly employed to automate the tuning of configurable parameters in cyber-physical systems. However, such optimization algorithms converge at later stages, often after exhausting the allocated budget (e. g., optimization steps, allotted time) and lacking transferability. This paper proposes CURE - a method that identifies causally relevant configuration options, enabling the optimization process to operate in a reduced search space, thereby enabling faster optimization of robot performance. CURE abstracts the causal relationships between various configuration options and robot performance objectives by learning a causal model in the source (a low-cost environment such as the Gazebo simulator) and applying the learned knowledge to perform optimization in the target (e. g., Turtlebot 3 physical robot). We demonstrate the effectiveness and transferability of CURE by conducting experiments that involve varying degrees of deployment changes in both physical robots and simulation

Abstract: Deep Learning methods, particularly Convolutional Neural Networks (CNN), have become widely adopted in indus- trial computer vision applications due to their strong image classification capabilities. In industrial environments, reliable object recognition is essential for automated systems such as warehouse automation and sorting processes, where incorrect classifications may lead to operational failures and reduced system reliability. Despite their performance, CNN-based models remain vulnerable to adversarial perturbations, raising concerns regarding their deployment in safety-critical applications. Industrial vision systems deployed in safety-critical environ- ments must operate reliably under adversarial perturbations and common perception degradations. This work presents a robustness analysis of image classification models for industrial environments using RGB and RGB-D data. An industrial object dataset containing seven classes was constructed through an ob- ject detection and extraction pipeline, resulting in object-centered image samples. Two CNN-based architectures were developed and evaluated: a baseline RGB model and a multimodal RGB-D model. Model robustness was analyzed through both formal verifica- tion and corruption-based robustness evaluation. Formal verifi- cation was performed using the alpha-beta-CROWN framework under different perturbation magnitudes, assessing whether the CNNs preserve their predictions under bounded perturbations. In addition, corruption-based experiments following the ImageNet- C protocol were conducted to evaluate model behavior under common image degradations.

Abstract: The Robot Operating System (ROS) is the de facto framework for building open-source robotic software systems. Developers architect their system by using reusable components, connecting them via config- uration files and source code. These architectures evolve as developers add, remove, and modify components, connections, and configurations. These changes can lead to architectural misconfigurations detectable by specification languages and analysis tools. However, these focus on snapshots in time without considering how architectures evolve. By un- derstanding this evolution, we can help specification writers estimate the maintenance burden of their descriptions and promote tools toward the most change-prone elements. To that end, we conduct an empirical study of architectural evolution in open-source ROS systems. We develop a differential, cross-language architectural recovery tool that extracts components, connections, and configurations from source code and apply it to 294 repositories, with 1728 packages across 9914 releases, spanning ROS 1 and ROS 2 in C/C++, Python, and XML. As ROS repositories aggregate multiple packages at different maturity stages, we analyze evolution at the repository and package levels. We find that evolution di- verges across levels, with repositories remaining addition-dominant while mature packages consolidate by removing connections and configurations. Furthermore, changes co-occur across elements: component removals are associated with the removal of their connections and configurations.

Abstract: Component-based robot software frameworks, such as the Robot Operating System (ROS), allow developers to quickly compose and execute systems by focusing on configuring and integrating reusable, off-the-shelf components. However, these components often lack documentation on how to configure and integrate them correctly. Even when documentation exists, its natural language specifications are not enforced, resulting in misconfigurations that lead to unpredictable and potentially dangerous robot behaviors. In this work, we introduce ROSpec, a ROS-tailored domain-specific language designed to specify and verify component configurations and their integration. ROSpec’s design is grounded in ROS domain concepts and informed by a prior empirical study on misconfigurations, allowing the language to provide a usable and expressive way of specifying and detecting misconfigurations. At a high level, ROSpec verifies the correctness of argument and component configurations, ensures the correct integration of components by checking their communication properties, and checks if configurations respect the assumptions and constraints of their deployment context. We demonstrate ROSpec’s ability to specify and verify components by modeling a medium-sized warehouse robot with 19 components, and by manually analyzing, categorizing, and implementing partial specifications for components from a dataset of 182 misconfiguration questions extracted from a robotics Q&A platform.

Abstract: Component-based architectures in robotics, like the Robot Operating System (ROS), simplify system development by integrating reusable, off-the-shelf components. However, these components often lack sufficient documentation on their use and the architectures they form, leading to architectural misconfigurations. General-purpose Architectural Description Languages (ADLs) effectively provide properties to detect misconfigurations but are burdensome to use, as they require mapping new language-specific concepts to the ROS domain. This work introduces rospec, a novel ADL embedding ROS-specific knowledge to help developers specify and detect architectural misconfigurations. By mapping the language's syntax with ROS concepts, we argue that practitioners can more easily understand and reason about specifications written in the language. We provide an example and compare it with a general-purpose ADL.

Abstract: Self-adaptive systems increasingly need to reason about and adapt both structural and behavioral system aspects, such as in mobile service robots, which must reason about missions that they need to achieve and the architecture of the software executing them. Deciding how to best adapt these systems to run time changes is challenging because it entails considering mutual dependencies between the software architecture that the system is running and the outcome of plans for completing tasks, while also considering multiple trade-offs and uncertainties. Considering all these aspects in planning for adaptation often yields large solution spaces which cannot be adequately explored at run time. We address this challenge by proposing a planning approach able to consider the impact of mutual dependencies between software architecture and task planning on the satisfaction of mission goals. The approach is able to reason quantitatively about the outcome of adaptation decisions handling both the reconfiguration of the system's architecture and adaptation of task plans under uncertainty and in a rich trade-off space. Our results show: (i) feasibility of run-time decision-making for self-adaptation in an otherwise intractable solution space by dividing-and-conquering adaptation into architecture reconfiguration and task planning sub-problems, and (ii) improved quality of adaptation decisions with respect to decision making that does not consider dependencies between architecture and task planning.

Abstract: Robotics systems are complex component-based systems that can consist of many interacting components. When composing and evolving complex component-based systems, the resulting behavior of component interactions sometimes differs from the developers’ expectations. This can, for example, manifest itself in components indefinitely waiting for a required message that no other component sends, components reaching a deadlock state, or messages getting ignored due to systems being in an incorrect state. These bugs, which we call behavioral architecture composition bugs, are often hard to find because the fault locations are spread throughout many different locations in the system. Model-based analysis is a common technique to identify incorrect behavioral composition of complex, safety-critical systems, such as robotics systems. However, in practice, robotics companies usually do not have any formal models, as models for hundreds of software components is a very costly and often labor-intensive and error-prone process. Behavioral models, which would need to be updated whenever the behavior of the component changes, are especially expensive to create. In this dissertation, I present an approach to automatically infer behavioral models for components of systems based on the Robot Operating System (ROS), the most popular framework for robotics systems, using a combination of static and dynamic analysis by exploiting assumptions about the usage of the ROS framework Application Programming Interface (API) and behavioral idioms. Static analysis looks for architecturally-relevant API calls that implement message sending, handling received messages, sleeping for a periodic interval, and behavioral idioms that implement state-dependent behavior and state transitions. Based on this information, static analysis infers state machine models of architecturally-relevant component behavior. Due to limitations of static analysis, the resulting models are often partial. To complement statically inferred models, I present an approach to instrument the source locations of known unknowns and dynamically observe their values. Then, resulting models will be translated into the common language TLA+/PlusCal used for model-checking. Furthermore, I present a model-based analysis technique to find architecture-misconfiguration bugs in the resulting TLA+ models. Then, I present a technique that automatically generates visual diagrams from the inferred models. Our human study with practicing roboticists and graduate students finds that these diagrams support the understanding of architecturally-relevant component behavior without slowing down participants. This work is a contribution towards making well-proven and powerful but infrequently used methods of model-based analysis more accessible and economical in practice to make robotics systems more reliable and safe