Refine
Document Type
- Part of a Book (11)
- Article (7)
- Conference Proceeding (5)
- Doctoral Thesis (1)
- Report (1)
Language
- English (25)
Keywords
Institute
- Fakultät für Angewandte Informatik (25)
- Institut für Informatik (25)
- Institut für Software & Systems Engineering (25)
- Lehrstuhl für Softwaretechnik (25)
- Nachhaltigkeitsziele (2)
- Ziel 9 - Industrie, Innovation und Infrastruktur (2)
- Fakultätsübergreifende Institute und Einrichtungen (1)
- Institut für Geographie (1)
- Lehrstuhl für Menschzentrierte Künstliche Intelligenz (1)
- Lehrstuhl für Physische Geographie mit Schwerpunkt Klimaforschung (1)
The TEMAS - the Trust-Enabling Multi-Agent System - is a multi-agent system for open environments. It is based on the Trust-Enabling Middleware, which itself is based on the adaptive, organic middleware OCµ that features self-x properties such as self-healing and self-optimization. Further, the TEMAS incorporates an infrastructure that provides a variety of multiagent system concepts. Apart from facilities for communication in local and distributed environments and a yellow pages service, it allows itself and the agents to use application-specific metrics to derive trust values for different facets from prior experiences with the Trust Metric Infrastructure provided by the Trust-Enabling Middleware. In the TEMAS, agents can be run on nodes, a form of container similar to those used in peer-to-peer networks. Nodes often represent physical devices and can host several agents or reactive services. With respect to the Trust-Enabling Middleware, the TEMAS serves as a facade because it hides the complexity of the underlying infrastructure consisting of nodes and services and dependent interfaces to higher level applications. This results, e.g., in simpler, more common, and natural interfaces for messaging and the application of trust in multi-agent systems.
Programming goal-oriented behavior in collective adaptive systems is complex, requires high effort, and is failure-prone. If the system's user wants to deploy it in a real-world environment, hurdles get even higher: Programs urgently require to be situation-aware. With our framework Maple, we previously presented an approach for easing the act of programming such systems on the level of particular robot capabilities. In this paper, we extend our approach for ensemble programming with the possibility to address virtual swarm capabilities encapsulating collective behavior to whole groups of agents. By using the respective concepts in an extended version of hierarchical task networks and by adapting our self-organization mechanisms for executing plans resulting thereof, we can achieve that all agents, any agent, any other set of agents, or a swarm of agents execute (swarm) capabilities. Moreover, we extend the possibilities of expressing situation awareness during planning by introducing planning variables that can get modified at design-time or run-time as needed. We illustrate the possibilities with examples each. Further, we provide a graphical front-end offering the possibility to generate mission-specific problem domain descriptions for ensembles including a lightweight simulation for validating plans.
Swarm behavior can be very beneficial for real-world robot applications. While analyzing the current state of research, we identified that many studied swarm algorithms foremost aim at modifying the movement vector of the executing robot. In this paper, we demonstrate how we encapsulate this behavior in a general pattern that robots can execute with adjusted parameters for realizing different beneficial swarm algorithms. We integrate the pattern as a virtual swarm capability in our reference architecture for multipotent, reconfigurable multi-robot ensembles and demonstrate its application in proof of concepts. We further illustrate how we can lift the concept of virtual capabilities to also integrate other known approaches for collective system programming as virtual collective capabilities. As an example, we do so by integrating the execution platform for the Protelis aggregate programming language.
Applying unmanned aerial vehicles (UAV) has benefits for many different use-cases.
Existing implementations of ground control stations (GCS) to manage UAVs in such scenarios already provide some support for the operation of multi-unit systems, i.e., ensembles.
However, since they are usually designed for the operation of only one copter at once, this is often not sufficient to react quickly in dangerous situations, e.g., search and rescue scenarios.
To address this problem, we propose an approach for easy observation and control of complete autonomous UAV ensembles:
The Intention of our approach is to greatly reduce the number of personnel required for the operation of an UAV ensemble.
Thereby, we generate the possibility for rapid intervention in potentially dangerous situations in order to prevent damage to the UAVs and the environment.
In this paper, we present a software architecture for this safety-critical multi UAV ground control station including a fully implemented prototype which we also tested in a realistic environment.
The application of autonomous mobile robots can improve many situations of our daily lives. Robots can enhance working conditions, provide innovative techniques for different research disciplines, and support rescue forces in an emergency. In particular, flying robots have already shown their potential in many use-cases when cooperating in ensembles. Exploiting this potential requires sophisticated measures for the goal-oriented, application-specific programming of flying ensembles and the coordinated execution of so defined programs. Because different goals require different robots providing different capabilities, several software approaches emerged recently that focus on specifically designed robots. These approaches often incorporate autonomous planning, scheduling, optimization, and reasoning attributable to classic artificial intelligence. This allows for the goal-oriented instruction of ensembles, but also leads to inefficiencies if ensembles grow large or face uncertainty in the environment. By leaving the detailed planning of executions to individuals and foregoing optimality and goal-orientation, the selforganization paradigm can compensate for these drawbacks by scalability and robustness.
In this thesis, we combine the advantageous properties of autonomous planning with that of self-organization in an approach to Mission Programming for Flying Ensembles. Furthermore, we overcome the current way of thinking about how mobile robots should be designed. Rather than assuming fixed-design robots, we assume that robots are modifiable in terms of their hardware at run-time. While using such robots enables their application in many different use cases, it also requires new software approaches for dealing with this flexible design. The contributions of this thesis thus are threefold. First, we provide a layered reference architecture for physically reconfigurable robot ensembles. Second, we provide a solution for programming missions for ensembles consisting of such robots in a goal-oriented fashion that provides measures for instructing individual robots or entire ensembles as desired in the specific use case. Third, we provide multiple self-organization mechanisms to deal with the system’s flexible design while executing such missions. Combining different self-organization mechanisms ensures that ensembles satisfy the static requirements of missions. We provide additional self-organization mechanisms for coordinating the execution in ensembles ensuring they meet the dynamic requirements of a mission. Furthermore, we provide a solution for integrating goal-oriented swarm behavior into missions using a general pattern we have identified for trajectory-modification-based swarm behavior. Using that pattern, we can modify, quantify, and further process the emergent effect of varying swarm behavior in a mission by changing only the parameters of its implementation. We evaluate results theoretically and practically in different case studies by deploying our techniques to simulated and real hardware.
