In this paper we present two approaches for solving robot manipulation tasks with articulated objects by using knowledge representation and reasoning languages and tools. Such languages and tools are used both for representing initial and nal con gurations from an ontology description and for planning the robot (manipulation) actions. In the rst approach, standard PDDL language and solvers are used to plan those actions, and DL solvers for ontology consistency checking. In the second (ongoing) approach, ASP is employed as a unifying framework for both ontology checking and planning.
Articulated objects are made up of links connected via joints that can move
with respect to each other. The manipulation of such objects (which can be
considered as a good approximation for strings, ropes or cables) is of the utmost
importance in di erent application scenarios [
Apart from robot manipulation actions, the con gurations of such objects depend on their parts and may be the result also of external factors, such as the constraints imposed by the geometry of the environment or the e ects of gravity. This leads to a multi-faceted representation problem: on the one hand, we must address how to maintain the representation of articulated (or exible) objects depending on how they are perceived by the robot; on the other hand, we must ground reasoning on such representation to manipulate such objects in order to obtain a given goal con guration.
In the literature, a number of ad hoc solutions have been discussed, including
ones where robots manipulate ropes [
In this paper we present two action planning and execution architectures for robot manipulation tasks with articulated objects. The two architectures are aimed at reasoning about any pair of abstract representations of articulated or exible objects and the transitions induced by an appropriate sequence of manipulation actions, based on knowledge representation and reasoning (KR&R) languages and tools. Such languages and tools are used both for representing initial and nal object con gurations in an ontology-based description and for planning the robot manipulation actions. Both architectures are under testing on a robot hybrid reactive/deliberative framework using a dual-arm Baxter robot from Rethink Robotics.
In the rst architecture (outlined in Section 2), the standard Planning
Domain Description Language (PDDL) and domain-independent solvers are used
for modeling and planning those actions, and DL solvers are employed to check
for consistency in an OWL ontology [
Capitanelli et al. [
Two di erent manipulation modes are allowed, and therefore we consider data obtained by each of the two following modes:
CAPF: for any given link, it is possible to operate only on the successive link, and therefore only forward motion propagation is allowed, e.g., it is possible to move link 2 only keeping link 1 rmly and acting on link 2 ; CAPFD: it is possible to move each link in each direction, therefore either forward or back propagation is allowed, e.g., it is possible to move link 2 by grasping link 1 or link 3 and then operating on link 2.
As far as the ontology is concerned, the architecture is able to store and compute the di erences between initial (and, in general, current) and goal object con gurations, in terms of normative knowledge. In this way, we can remove unused constraints from the problem le and thus alleviate the planner's workload. The architecture computes these di erences at each action execution step. 4 Web: https://github.com/EMAROlab/armor 5 Web: http://moveit.ros.org/ Due this this feature, we can use SWRL rules to enforce plan execution robustness and exibility: if a given link is accidentally misplaced by the robot, or a human interacting with the robot does it purposely during plan execution, SWRL rules compute the di erence between current and goal con gurations and bootstrap a new planning process. 3
The second architecture, which is subject of on-going work, is similar to the rst one, but it is completely based on ASP. An architecture based on a uni ed logic framework is expected to have better performance or to nd solutions to the planning problem that are better optimized with respect to di erent parameters. The parameter we aim at optimizing (in this case, minimizing) is the number of actions computed by the planner.
Di erently from PDDL, ASP is a general purpose language for a variety of
applications (e.g.[
We want to compute plans with both Clingo [
ASP solutions to the planning problem are translated to the same output format used by the standard PDDL-based planners, which is to be checked by VAL.
We tried di erent options for the ASP-based planner: Wrapper. We compute the plan varying the number of allowed maximum steps starting from 1 and increasing it by one unit if the plan is not found. This allows us to nd the optimal solution in terms of the number of actions but sacri cing CPU performance.
Weak Constraint [
Random. We select the maximum number of steps randomly. This does not ensure an optimal solution neither with respect to the number of actions nor in terms of planning computation time.
Currently, we are completing the development and the integration of the ASP-based ontology component by means of an ASP encoding. 4
In this section we discuss preliminary results obtained for the planning module
in the second architecture. As a reference, we analyze two of the experiments we
carried out. For each experiment, we have two di erent tables: the rst shows
the planning execution time in seconds, the second shows the number of actions
as computed by the planners. Each table contains results for di erent set-ups:
Madagascar: results obtained using the PDDL solver Madagascar [
Clingo: results obtained with the ASP solver Clingo using the Wrapper setup as discussed above.
Clingo Weak: results obtained with the ASP solver Clingo using the Weak Constraint set-up as explained before.
Clingo Not Optimal: results obtained with the ASP solver Clingo using the Random set-up as discussed above.
The name of each experiment is composed by two numbers, respectively representing the number of joints of the articulated object and the number of possible angles that a link can assume. For each experiment, 10 di erent problem instances, with di erent initial states and goals, were tested, with a timeout of 1 hour. The median value is computed and shown in the tables. A "TIME" (resp.
1) indicates that the solver can not nd a solution (resp. a plan) within an hour. 4.1
Experiment Number 1 2 3 4 5 6 7 8 9 10 Madagascar 0.15 0.31 0.1 0.18 0.02 0.18 0.03 0.1 0.11 0.13
Probe 0.01 0.05 0.02 0.02 0.01 0.01 0.02 0.01 0.01 0.01
Clingo 1.53 4.81 1.88 1.91 0.01 2.20 0.01 0.01 1.46 1.71
Clingo Weak 6.26 11.86 6.77 6.24 0.32 6.76 0.41 1.42 5.23 5.00
In tables 1 and 2 we show an experiment with a medium size problem (5 links and 6 possible angles). We have di erent result depending on the selected approach:
Clingo: As we said we have always the optimal solution. This result comes at the cost of a longer execution time to compute the plan.
Clingo Weak: As before it always nds an optimal solution. With this approach we avoid the need of external script (e.g. wrapper), but it comes with a slower execution time to compute the plan.
Clingo Not Optimal: the computed solutions are way larger than the ones computed by the two previous approaches. We expected a not optimal solution but we also expected to have a faster execution time. however, as the table shows, the execution times is similar to the times of the Clingo Weak approach. 4.2
In tables 3 and 4 we show an experiment with a larger problem (7 links and 6 possible angles). We have di erent result depending on the selected approach: Clingo: As for the previous problem, the solution is always optimal and this, in some cases, leads us to plans that are 50% smaller than the ones computed from the PDDL solvers. However, since the problem is bigger than before, some plans require too much time to be computed by the ASP solvers and consequently we are unable to have a solutions for those problems. Clingo Weak: As before we ensure an optimal solution but we encounter the same problems we have with the Clingo approach.
Clingo Not Optimal: the computed solutions are way larger than the ones computed by the two previous approaches. However it can be noticed from the table that, even though the execution time is high, the plan is always computed within the time limit.
The ASP-based approach is able to return plans sometimes signi cantly smaller than in the previous solution, sometimes at the price of increased CPU time. However, we should take into account that in real environment action's execution is not instantaneous (hypothesis of classical planning), but takes time, so the total time for executing the plan by the architecture could be highly in uenced by the number of performed actions. 5
In this paper, we have presented two KR&R approaches for solving robot manipulation tasks with articulated objects.
Current and future work include: Completing the ASP-based framework: the implementation of the storage module has to be nished and validated.
Testing the architecture, in particular the planning module, with DLV2.
Testing the architectures on di erent robot platforms to evaluate the
portability of our solutions, and adding more KR&R approaches, e.g. using the
mixed discrete-continuous approach of PDDL+ [
Bertolucci et al.