Ali Paikan

Semantic-Aware Real-Time Scheduling in Robotics

This paper introduces semantic-aware real-time (SeART), an extension to conventional operating systems, which deals with complex real-time robotics applications. SeART addresses the problem of selecting a subset of tasks to be scheduled depending on the current operating context: mission objectives, other tasks currently executed, the availability or unavailability of sensors and other resources, as well as temporal constraints. Toward this end, SeART is able to represent the semantics of tasks to be scheduled, i.e., what tasks are meant for, and to use this information in the scheduling process. This paper describes in detail the SeART architecture by focusing on representations and reasoning procedures, and presenting a case-study which is related to mobile robotics for autonomous objects transportation.

Learning symbolic representations of actions from human demonstrations

In this paper, a robot learning approach is proposed which integrates Visuospatial Skill Learning, Imitation Learning, and conventional planning methods. In our approach, the sensorimotor skills (i.e., actions) are learned through a learning from demonstration strategy. The sequence of performed actions is learned through demonstrations using Visuospatial Skill Learning. A standard action-level planner is used to represent a symbolic description of the skill, which allows the system to represent the skill in a discrete, symbolic form. The Visuospatial Skill Learning module identifies the underlying constraints of the task and extracts symbolic predicates (i.e., action preconditions and effects), thereby updating the planner representation while the skills are being learned. Therefore the planner maintains a generalized representation of each skill as a reusable action, which can be planned and performed independently during the learning phase. Preliminary experimental results on the iCub robot are presented.

A port-arbitrated mechanism for behavior selection in humanoid robotics

Software engineering and best practices promote modularity and composability to reduce debugging and development time of software applications in robotics. This approach, however, increases the complexity of the system and the effort needed to properly coordinate interactions between modules. On the other hand programming robots to cope with an unstructured environment requires the implementation of highly reactive systems. Behavior-based architectures have been proposed as a programming paradigm to build complex, yet, reactive systems by integrating simpler modules. They require however that modules establish special connections dedicated to carry coordination signals. In a distributed architecture these signals must be properly synchronized with the ones that carry data. This article proposes a novel method for developing reactive systems by coordinating concurrent, distributed behaviors. In our approach arbitration exploits the connections that deliver data messages between modules and, for this reason, i) it intrinsically reduces the number of links required for coordination and ii) it can be built without changing existing modules. The proposed architecture is discussed in detail and tested on a real scenario on the iCub humanoid robot.

Enhancing software module reusability using port plug-ins: An experiment with the iCub robot

Systematically developing high-quality reusable software components is a difficult task and requires careful design to find a proper balance between potential reuse, functionalities and ease of implementation. Extendibility is an important property for software which helps to reduce cost of development and significantly boosts its reusability. This work introduces an approach to enhance components reusability by extending their functionalities using plug-ins at the level of the connection points (ports). Application-dependent functionalities such as data monitoring and arbitration can be implemented using a conventional scripting language and plugged into the ports of components. The main advantage of our approach is that it avoids to introduce application-dependent modifications to existing components, thus reducing development time and fostering the development of simpler and therefore more reusable components. Another advantage of our approach is that it reduces communication and deployment overheads as extra functionalities can be added without introducing additional modules. The details of the plug-in system is described in the paper and its advantages for the development of robotics applications are demonstrated by developing a step-by-step example on the iCub humanoid robot.

The icub software architecture: evolution and lessons learned

The complexity of humanoid robots is increasing with the availability of new sensors, embedded CPUs and actuators. This wealth of technologies allows researchers to investigate new problems like whole-body force control, multi-modal human-robot interaction and sensory fusion. Under the hood of these robots, the software architecture has an important role: it allows researchers to get access to the robot functionalities focusing primarily on their research problems, it supports code reuse to minimize development and debugging, especially when new hardware becomes available. But more importantly it allows increasing the complexity of the experiments that can be implemented before system integration becomes unmanageable and debugging draws more resources than research itself. In this paper we illustrate the software architecture of the iCub humanoid robot and the software engineering best practices that have emerged driven by the needs of our research community. We describe the latest developments at the level of the middleware supporting interface definition and automatic code generation, logging, ROS compatibility and channel prioritization. We show the robot abstraction layer and how it has been modified to better address the requirements of the users and to support new hardware as it became available. We also describe the testing framework we have recently adopted for developing code using a test driven methodology. We conclude the paper discussing the lessons we have learned during the past eleven years of software development on the iCub humanoid robot.

Transferring object grasping knowledge and skill across different robotic platforms

This study describes the transfer of object grasping skills between two different humanoid robots with different software frameworks. We realize such a knowledge and skill transfer between the humanoid robots iCub and ARMAR-III. These two robots have different kinematics and are programmed using different middlewares, YARP and ArmarX. We developed a bridge system to allow for the execution of grasping skills of ARMAR-III on iCub. As the embodiment differs, the known feasible grasps for the one robot are not always feasible for the other robot. We propose a reactive correction behavior to detect failure of a grasp during its execution, to correct it until it is successful, and thus adapt the known grasp definition to the new embodiment.

A best-effort approach for run-time channel prioritization in real-time robotic application

Application domains of robotic systems are growing in complexity. It seems therefore plausible that robotic software will continue to be designed to be executed on distributed computer architectures interconnected through a network. It is a common practice today to rely on best-effort performance and assume that the latter are adequate given enough computational and networking resources. This approach however does not make best use of the available resources and, maybe more importantly, does not guarantee that performance remain constant over time. Real-time and Quality of Service become therefore important aspects in the software architecture of a robot. This article describes an approach for introducing these concepts in a publish-subscribe software middleware. The key contribution of our approach is that it leverages on the services provided by the operating system (scheduling priority and packet QoS) and abstracts them in a set of levels of priority that can be assigned dynamically, and with the granularity of individual communication channels. We implemented our approach on the YARP middleware and performed an experimental evaluation that demonstrates its benefit for increasing determinism and reducing latency in data communication. We further demonstrate this in a real-robot experiment that shows increased performance in a closed-loop scenario.

Communication channel prioritization in a publish-subscribe architecture

Real-Time communication is important in distributed applications when timing constraints on task execution and data processing play a fundamental role. Software engineering does not yet specify how real-time properties should be integrated into a publish/subscribe middleware. This article describes an approach for integration of priority Quality of Service (QoS) in a publish/subscribe middleware. The basic idea is to leverage the operating system functionalities to provide a framework where specific communication channels can be prioritized at run-time. This paper presents an implementation of our approach in the YARP (Yet Another Robot Platform) open source middleware and a preliminary experimental evaluation of its performance.

A Generic Testing Framework for Test Driven Development of Robotic Systems

This paper proposes a generic framework for test driven development of robotic systems. The framework provides functionalities for developing and running unit tests in a language and middleware independent manner. Tests are developed as independent plug-ins to be loaded and executed by an automated tool. Moreover, a fixture manager prepares the setup (e.g., running robot drivers or simulator) and actively monitors that all the required resources are available before and during the execution of the tests. These functionalities effectively accelerate the development process and cover different levels of robotic system testing. The paper describes the framework and provides realistic examples to show how it has been used to support software development on our robotic platform.