Manipulation Task Planning and Motion Control Using Task Relaxations

This paper proposes a robotic manipulation task relaxation method applied to a task and motion planning framework adapted from the literature. The task relaxation method consists of defining regions of interest instead of defining the end-effector pose, which can potentially increase the robot’s redundancy with respect to the manipulation task. Tasks are relaxed by controlling the end-effector distance to a target plane while respecting suitable constraints in the task-space. We formulate the problem as a constrained control problem that enforces both equality and inequality constraints while being reactive to changes in the workspace. We evaluate the adapted framework in a simulated pick-and-place task with similar complexity to the one evaluated in the original framework. The number of plan nodes that our framework generates is 54% smaller than the one in the original framework and our framework is faster both in planning and execution time. Also, the end-effector remains within the regions of interest and moves toward the target region while satisfying additional constraints.


Introduction
One of the major goals in robotics is to design manipulator robots that autonomously plan and execute highly complex manipulation tasks. To that aim, plans can be obtained by integrating task and motion planning (ITMP) and executed by a closed-loop motion controller to cope with changes in the workspace. Also, some tasks require the robot to work under constraints, such as limits of joints and geometrical constraints due to obstacles in the workspace. However, some tasks may not be accomplished when there are too many hard constraints. Nonetheless, some of those tasks can be relaxed and do not require all degrees of freedom (DOF) all the time, hence increasing the chance of a successful execution. In this sense, this work proposes a methodology for solving the B Bruno V. Adorno bruno.adorno@manchester.ac.uk Marcos S. Pereira marcos.si.pereira@gmail.com 1 ITMP problem for manipulation tasks that can be relaxed in a computationally efficient manner by combining state-ofthe-art task planners with constrained motion controllers.
In ITMP, the task planner generates a sequence of actions that the robot must execute, whereas the motion planner generates a trajectory for each action (Kaelbling and Lozano-Perez 2011). If a trajectory cannot be found, a new task plan is required (He et al. 2015;Bhatia et al. 2011;Dantam et al. 2018). As a result, ITMP frameworks spend a lot of time planning and replanning. After obtaining a feasible task and motion plan, a motion controller executes it. In this sense, in our previous work (Pereira and Adorno 2020), we have adapted the ITMP framework of He et al. (2015) to solve the ITMP challenge by using a new approach to replace the motion planning layer by a single constrained motion controller that executes the task plan without the need for replanning. The ITMP framework of He et al. (2015) uses linear temporal logic (LTL) to define task specifications. LTL allows to specify boolean and temporal constraints and has correctness and completeness guarantees (Baier and Katoen 2008, ch. 5), but the number of states of the specified task has combinatorial growth, which is also known as the stateexplosion problem (Wongpiromsarn et al. 2010). Therefore, frameworks based on LTL usually build a discrete abstraction of the robotic system (Kress-Gazit et al. 2007;He et al. 2015;Kloetzer and Belta 2008;Bhatia et al. 2011), but such construction is usually non-trivial and may still suffer from the curse of dimensionality.
In contrast to LTL, Fikes and Nilsson (1971) propose a problem solver called STRIPS (Stanford Research Institute Problem Solver) that searches for a model in a space of world models to reach a desired goal. However, STRIPS does not regard temporal specifications, only uses linear sequences of operators, and requires lower layers to translate its very high-level plans to robot actions. Ferrer-Mestres et al. (2017) propose a constrained task and motion planning framework that encodes the ITMP problem into classical AI problems using Functional STRIPS as the planning language. The framework scales up to 30 or 40 objects, but it has a long preprocessing phase and is suitable only for static environments.
From the application point of view, LTL can be used to specify a wide range of robotic tasks such as coverage, sequencing, conditions, avoidance, and counting (Kress-Gazit et al. 2007;McMahon and Plaku 2014). For manipulation tasks, it is often desirable to specify tasks with temporal constraints that enable enforcing execution order. Hence, LTL is a suitable formalism.
From the task point of view, the framework proposed by He et al. (2015) only allows placing the object in exact locations of interest in the workspace. Nonetheless, some tasks may be relaxed, and thus benefit from using a region of interest instead of an exact location. A common solution is to discretize the workspace in multiple locations to define different possibilities for placing the manipulated objects. Garrett et al. (2018) propose the FFRob algorithm for solving the ITMP problem that uses workspace discretization by defining a relaxed state. In the FFRob, a state is represented by a set of values that indicate the robot configuration, the object being held, and the pose of each object. In this sense, the relaxed state is a set of states formed by all combinations of possible values for a state. In other words, it contains all the possible robot configurations, objects and their poses for the state. However, if a similar approach is used in the work of He et al. (2015), the number of possibilities that the planner must consider quickly grows and the state-explosion problem appears. Another possibility for task relaxation is to explore the kinematic redundancy in a low-level motion controller.
Classic techniques that tackle kinematic redundancy are based on a hierarchical architecture that allows controlling secondary tasks besides the main task. This is done by projecting the control input from lower-priority tasks into the nullspace of the Jacobian matrices associated with higher-priority tasks. Hence, a secondary task that does not disturb the main task and considers constraints can be added (Mansard and Chaumette 2007). In this context, Figueredo et al. (2014) propose the relaxation of task constraints and a switching strategy to automatically choose control objectives that demand fewer degrees of freedom, whenever possible, and hence perform secondary tasks. The switching strategy is based on relaxing the control requirements according to previously defined geometric task objectives. They define which task primitive (i.e. distance, position, orientation, or pose) should be controlled to achieve a geometric task.
To enhance the task relaxation capabilities, additional optimization criteria might be considered. To do this, a possible solution is to use hierarchical least-square optimization (Escande et al. 2014). Least-square optimization can be used to fulfill as best as possible a set of constraints that may not be feasible (Escande et al. 2014). Furthermore, when the constraints are linear in the control inputs, the leastsquare problem is written as a quadratic program. Thus, Escande et al. (2014) propose a method to solve a hierarchical quadratic program in a computationally efficient manner that allows solving problems with many variables fast enough to be used in real-time control.
In contrast to the aforementioned task relaxation methods, Marinho et al. (2019) propose a constrained motion controller based on optimization that allows keeping the robot outside a restricted region or inside a safe region by using constraints. This way, it is possible to define regions of interest and do a coarse discretization of the workspace, which greatly reduces the computational burden of the overall method. The idea is to specify geometrical constraints, based on the regions of interest, to accomplish the desired task generated by the high-level task-planner without resorting to low-level motion planning. Moreover, it is possible to add joints limits and obstacle avoidance constraints while satisfying the task relaxation constraints. After defining all the constraints, the controller can be described by minimization problems (Laumond et al. 2015) that make use of extra available DOFs of the robot to accomplish the task while respecting the constraints. This enables the generation of collision-free motions by using mathematical programming. Nonetheless, in the general case, there is no analytical solution and numeric solvers must be used (Goncalves et al. 2016;Escande et al. 2014).
We propose a robotic manipulation task relaxation method that adapts the ITMP framework of He et al. (2015) to use a motion controller that directly executes the task plan, without resorting to motion planning, reducing the total planning time. The task relaxation method consists of defining regions of interest instead of defining the end-effector pose, which can potentially increase the robot's redundancy with respect to the manipulation task. Tasks are relaxed by controlling the end-effector distance to a target plane while respecting suitable constraints in the task-space. We formulate the problem as a constrained control problem that enforces both equality and inequality constraints while being reactive to changes in the workspace.

Statement of Contributions
This work builds upon our preliminary work (Pereira and Adorno 2020). The main contribution to the state of the art is a task relaxation methodology that reduces the number of DOFs required for a task while imposing joints limits and obstacle avoidance constraints without resulting in high computational complexity for the high-level planner. We also propose a new point-cone constraint that allows defining a circular target region in a simple way using only one constraint, in contrast to rectangular target regions that require four constraints (Pereira and Adorno 2020).

Organization of the Paper
Section 2 gives a brief introduction to LTL and presents the constrained motion controller. Section 3 describes our architecture for integration of task planning with constrained motion control using task relaxations. Section 4 presents a thorough evaluation of the framework through simulations. Finally, Sect. 5 concludes the paper and presents some suggestions for future works.

Preliminaries and Problem Definition
The framework for ITMP used in this paper relies on LTL for defining high-level tasks and a constrained motion controller to execute the manipulation tasks while respecting all geometrical constraints. This section briefly reviews those two techniques.

Linear Temporal Logic
In LTL, a proposition is a statement that can be true or false, but not both, and atomic propositions are the ones that do not depend on the truth or falsity of any other proposition. Let A = {a 0 , a 1 , ..., a N } be a set of atomic propositions. LTL semantics is defined over words on the alphabet 2 A , where 2 A is the power set of A. Given letters A i ∈ 2 A , with i = 0, 1, 2, . . ., words are finite or infinite sequences such as An LTL formula ϕ is composed of atomic propositions, Boolean operators, and basic temporal operators. More specifically, a formula ϕ over A, using a subset of LTL operators, results in 1 where a ∈ A, ϕ 1 and ϕ 2 are formulas. The Boolean operators are "negation" (¬), "and" (∧), and "or" (∨). The temporal operator "until" (U) is such that ϕ 1 is true until ϕ 2 becomes true. The temporal operator "next" (X ) means that ϕ will definitely be true at the next step, and "eventually" (E) means that ϕ will become true at some point in the future. 2 Since the focus of this work is not on model checking, we give here an informal explanation to clarify what a formula ϕ is, and what the operators mentioned above are. Let us define a simple set of atomic propositions containing two elements: A = {a 0 , a 1 }. Therefore, 1. ϕ = T is always true; 3 2. ϕ = a 0 is true if and only if a 0 is true; 3. ϕ = ¬a 0 is true if and only if a 0 is false; 4. if ϕ 0 = a 0 , ϕ 1 = a 1 , then ϕ = ϕ 0 ∧ ϕ 1 is true if and only if both a 0 and a 1 are true; 5. if ϕ 0 = a 0 , ϕ 1 = a 1 , then ϕ = ϕ 0 ∨ ϕ 1 is true if and only if a 0 is true or a 1 is true or both are true; 6. if ϕ 0 = a 0 , ϕ 1 = a 1 , then ϕ = ϕ 0 Uϕ 1 is true if and only if a 1 becomes true after a 0 was already true; 7. if ϕ 1 = a 1 , then ϕ = X ϕ 1 will be definitely true if and only if a 1 becomes true in the next time step; 8. if ϕ 1 = a 1 , then ϕ = Eϕ 1 will be eventually true as a 1 will become true at some point in the future.
The formulas for ϕ, ϕ 1 , and ϕ 2 could be any formula containing the operators in (1) with an arbitrary number of propositions. Although in the previous example we used simple formulas for the sake of clarity, they can be arbitrarily more complex. In our current work, manipulation tasks must be achieved over a finite time horizon. Hence, we use only co-safe LTL formulas, which are the ones that can be interpreted by considering finite words (Kupferman and Y. Vardi 2001). Syntactically, co-safe LTL formulas contain only the temporal operators X , E, U, and the negation operator is only allowed over atomic propositions, but not over temporal formulas.
Examples of LTL specifications for manipulation tasks are given in Sect. 3.1 and can also be found in our previous work (Pereira and Adorno 2020).

Constrained Kinematic Controller
The constrained controller (Marinho et al. 2019) is based on an optimization problem that minimizes the joint velocities,q ∈ R n , in the 2 -norm sense while respecting hard constraints, such as obstacles in the workspace, joints limits, etc. The controller is derived from the desired closed-loop task-error dynamics. The differential kinematics, given bẏ x = Jq, provides the relation between the velocity of the joints and the task-space velocity. The vector q q(t) ∈ R n is the robot configuration, x x(q) ∈ R m is the task vector, and J J(q) ∈ R m×n is the task Jacobian. Given a desired task vector x d ∈ R m , we define the task errorx x − x d . Consideringẋ d = 0 for all t, the error dynamics is given bẏ x =ẋ. To drivex to zero with an exponential convergence rate, the desired closed-loop dynamics is given byẋ+ηx = 0 where η ∈ (0, ∞) is the gain that determines the convergence rate. Thus, Jq + ηx = 0 and the control input u that minimizes the joint velocitiesq ∈ R n is obtained as: where λ ∈ [0, ∞) is a damping factor and W ∈ R l×n and w ∈ R l are used to impose linear constraints in the control inputs. The constrained motion controller (2)  In this sense, the end effector will be driven, as best as possible, to the specified desired task vector x d .
To prevent collisions with the workspace, we use the Vector Field Inequalities (VFI) framework (Marinho et al. 2019), which requires distance functions between two collidable entities and the corresponding Jacobian matrices, as better described in Sect. 3.3.

Problem Definition and Assumptions
Consider a robot in the workspace that can pick-andplace objects between regions. Given a finite set of objects O = {o 1 , ..., o n }, a finite set of regions {r 1 , ..., r k , r inter }, and a finite set of actions M {GRASP, PLACE, HOLD, MOVE}, the first step is to find a finite sequence of actions α 0 , α 1 , . . . , α m ∈ M that manipulate the objects o 0 , o 1 , . . . , o n ∈ O between regions r 0 , r 1 , . . . , r k ∈ to satisfy a linear temporal logic (LTL) specification ϕ. The next step is to execute the sequence of actions. The actions of GRASP and PLACE are executed by closing and opening the end-effector, respectively, and HOLD and MOVE are executed by the constrained motion controller (2) with con-

Architecture for Integration of Task Planning and Motion Control
The framework for integration of task planning and motion control that we adapt from the literature is composed of a high-level planning framework and a low-level constrained motion controller. We use the high-level planner proposed by He et al. (2015) and the constrained motion controller proposed by Marinho et al. (2019). Figure 1 shows both layers.

Task Planning Framework
The task planning framework is divided into three steps: (1) LTL task specification and the creation of a deterministic finite automaton (DFA); (2) creation of a manipulation abstraction; (3) creation of a product graph. In the first step, a manipulation task ϕ is specified using co-safe LTL that depends only on the objects and the regions where the objects are located. For instance, in a pick-andplace task, we can specify where each object must be at the end without mentioning anything about the robot. Therefore, the propositions of the LTL formulas are defined as (o i , r j ), which means that "object o i is in region r j " (He et al. 2015). Given a workspace with a finite set of objects O, a finite set of regions , the atomic propositions of this scene are elements of O × . For instance, suppose a robot has to place an object o 1 ∈ O at a region r 1 ∈ . The specification for this task can be given by ϕ 1 = E(o 1 , r 1 ), which means that "eventually object 1 will be in region 1." To specify all the manipulation sequence possibilities the robot can do to execute the task, the specification ϕ in LTL is then converted into a DFA.
In the next step of the planning framework, we use a manipulation abstraction that captures how the robot can manipulate the objects in the workspace. Each node in the abstraction is composed of an action α ∈ M, a region r ∈ , a grasped object o ∈ O, and the region of each object in the world o ∈ O , with O being the set of all the possibilities for objects regions.
The third step combines the manipulation abstraction with the DFA into a product graph that represents all the ways the robot can execute the task. Afterward, a graph search algorithm such as Dijkstra's or a Breadth First Search (BFS) is used to search for a path on the product graph that represents a complete task plan. 4 See our previous work (Pereira and Adorno 2020) for a formal definition of the planning framework.

Constrained Motion Control Using Task Relaxations
In the original framework of He et al. (2015), the task plan is sent to a low-level motion planner that generates a motion plan and sends the result back to a coordinating layer, which then sends the plan to the motion controller. If the motion planner does not find a solution, the coordinating layer increases the weight for that plan on the product graph and requires a new task plan on the product graph. This generates a synergy between layers resulting in the generation of feasible continuous trajectories for the manipulator.
Here we adopt a different strategy. Instead of using a motion planner to generate low-level trajectories and then sending those trajectories to a motion controller, the task plan is sent directly to the constrained motion controller that executes it. Hence, there is no need for a motion planner, and, hence, there is no replanning phase, thus saving computational time. Although we lose the probabilistic completeness of the original framework, the system is reactive to changes in the environment because of the closed-loop constrained control.
The constrained motion controller executes the actions of HOLD and MOVE, as mentioned in Sect. 2.3. The HOLD and MOVE actions are independent of each other. In the HOLD action, the robot holds an object towards a region of interest, whereas in the MOVE action, the robot moves the empty end-effector towards the object (HOLD means "moving while holding" whereas MOVE means " moving without holding" ).
In our work, the robot moves the end-effector to pick objects with specific poses; hence, the control objective is set to O pose during the MOVE action. Although there is some margin for relaxation when grasping an object, in the current work we are not exploiting such relaxations because they are highly dependent on the object type. However, we propose the relaxation of the HOLD action. Instead of moving the object to a specific pose, the robot holds the object to a target region on a target plane while satisfying appropriate constraints. This is done by controlling the end-effector distance to the target plane, as shown in Fig. 2, by setting the control objective O distance . This way, instead of using six DOFs to control the end-effector pose, only one DOF is used to control the distance of the object to the target plane. The target region is obtained by using the point-cone constraint presented in Sect. 3.3.1 to obtain a circular target region.

Definition of Constraints
A relaxed task requires fewer DOFs than the original task, but the robot end-effector might perform undesired motions because the relaxed task is underspecified. Therefore, we must define appropriate inequality constraints to prevent those undesired motions. As a consequence, the end-effector is free to move only within the relaxed region. Now, we define such constraints.

Point-cone Constraint: A New Approach to Define Conic Constraints
Consider a manipulation task in which the end-effector must converge to a circular target region on a plane. To accomplish Fig. 3 Point-cone constraint: the target circular region of interest is indicated in red, the green inverted cone trunk is the conical region of interest that constrains the end-effector that, we define a cone cut by a plane such that the centerline of the cone is perpendicular to the plane, as shown in Fig. 3. 5 First, we define the desired radius r of the target circular region. Then, we calculate the cone base radius R as the distance between the end-effector and the centerline l.
Considering the height H of the cone, we use the triangle relationship given by to obtain the distance h between the plane π and the cone apex P A as: where h c (0) is the initial distance between the end-effector and the plane π. Now, we can calculate the tangent of the angle φ between the cone centerline l and the line l 1 (0) that connects the cone apex p A to the initial end-effector position p E (0) as: Since h and φ are defined using the initial conditions R(0) and h c (0), they are calculated only once, at the beginning of a particular HOLD action. However, as the manipulator moves, both h c (t) and R(t) may change for t > 0. Therefore, the distance H (t) from the end-effector to the cone apex changes accordingly: H (t) = h + h c (t). Now, the maximum admissible squared distanceR(t) between the end-effector and the centerline is obtained as: At a given time t, if the squared distance D(t) between the end-effector and the centerline l is smaller thanR(t), then the end-effector is within the cone given by the appex p A and centerline l.
To enforce that, we design the following differential inequality. We first calculate the squared-distance error which is used to define the point-cone constraint given bẏ wherė The derivativeḊ(t) with respect to time is given byḊ(t) = J p,lq (Marinho et al. 2019). To calculateṘ(t), recall that Sinceḣ c = J p,πq (Marinho et al. 2019), thenṘ(t) = 2(h + h c (t)) tan 2 (φ) J p,πq . Therefore, by substitutingṘ(t) andḊ(t) in (9) and applying the result in (8), we obtain the point-cone constraint

Additional Constraints
We use three planes in the environment to prevent endeffector collisions with two walls and the table in the workspace as shown in Fig. 4. Similarly to the work of Quiroz-Omana and Adorno (2019), these three constraints are written as: where i ∈ {1, 2, 3} andd p,n π i = d p,n π i − d π,safe , with d π,safe being the safe distance to each plane and d p,n π i and J p,n π i are the point-static-plane distance and its Jacobian, respectively (Marinho et al. 2019).

Fig. 4
The red cuboid with the blue centerline is the object to be manipulated. The semi-infinite cylinders to prevent collisions with the non-manipulated objects are represented by the light shaded purple cylinder. The light shaded yellow planes are used to prevent collisions with the environment. The coordinate systems indicate locations in the scene, which are used to define the centers of the regions of interest.
The light shaded green cylinder is used to prevent twisted configurations caused by the end-effector passing over the robot In addition to the plane and point-cone constraints, we use joints velocities constraints to prevent saturation of actuators (Quiroz-Omaña and Adorno 2018). To write the joints velocities constraints W(q), let q min and q max represent the lower and upper limits of the joints, respectively. Given the limits of the joints q min ≤ q(t) ≤ q max , we convert them to constraints in the velocity of the joints as: where 0 β ≤ 1 is selected to define a safety margin for the joints limits and k > 0 is used to scale the feasible region ofq (Quiroz-Omaña and Adorno 2018). To impose joints velocities constraints, (13) is rewritten as η min ≤q ≤ η max , where η min = max{v min , k(βq min − q)} and η max = min{v max , k(βq max − q)}, in which v min and v max are the lower and upper limits for the joints velocities, respectively. Hence, where I n ∈ R n×n is the identity matrix.
To prevent end-effector collisions with static objects while an object is manipulated, we add semi-infinite cylindrical constraints to each non-manipulated object, as shown in Fig. 4. Therefore, each static object is constrained by an infi-nite cylinder cut by a plane. Given k objects, we associate a cylindrical and a plane constraint to each one of them, which yields the following inequality: where j ∈ {1, . . . , k}. The row vector J semi, j ∈ R 1×n is given by in which J p,l j satisfiesḊ p,l j = J p,l jq . Also, whereD p,object j = D p,l j − R 2 j , with R j being the radius of the cylinder around the j-th object; D p,l j is the squareddistance from the end-effector to the centerline of the cylinder enclosing the jth object. Analogously, J plane, j ∈ R 1×n is given by and d plane, j = η π d p,n π j ifD p,object j < 0 0 otherwise.
The conditional values for the constraint parameters (16)-(19) mean that when d p,n π j < 0, the end-effector is below the plane π j that cuts the infinite cylinder enclosing the jth object. Therefore, the end-effector must stay outside the cylinder to prevent a collision with the object. Analogously, whenD p,object j < 0, the end-effector is within the infinite cylinder enclosing the jth object, but above it, and thus must stay above the plane π j to prevent a collision with the object. Furthermore, the conditional values for (17) and (19) are defined to prevent the solution from becoming unfeasible. For example, if the end-effector is over the plane π j (i.e., d p,n π j > 0) and within the semi-infinite cylinder (i.e.D p,object j < 0), then it is not colliding with the object. Therefore, J semi, j = 0 1×n . AsD p,object j < 0, if D semi, j was not zeroed (i.e., if D semi, j = η lD p,object j ), the constraint − J semi, jq ≤ D semi, j would be 0 ≤ η lD p,object j < 0, which is infeasible. Equation (17) ensures that D semi, j = 0 when the end-effector is above the object, and thus − J semi, j q ≤ D semi, j becomes 0 ≤ 0, which is always feasible. The same reasoning applies for (19).
To prevent twisted configurations caused by the endeffector passing over the robot, we also add an infinite cylindrical constraint collinear to the z-axis of the coordinate system of the robot base (see Fig. 4). The constraint is given by whereD p,l z = D p,l z − R 2 z , with R z being the radius of the cylinder enclosing the manipulator's base; D p,l z is the squared-distance between the end-effector and the centerline of that cylinder, and J p,l z is the Jacobian matrix that satisfieṡ D p,l z = J p,l zq (Marinho et al. 2019).
Lastly, the robot should not tilt the objects too much to prevent, for instance, dropping the contents from inside a bowl or cup. Hence, to keep a bounded inclination of the end-effector with respect to a vertical line passing through the origin of the end-effector coordinate system, we add linecone constraints W(l z,cone ) to constrain the end-effector zaxis within a cone (Quiroz-Omana and Adorno 2019).

Simulation & Discussion
We implemented our adapted task planning and motion control framework and the original ITMP framework proposed by He et al. (2015) in C++ with the Boost Graph Library 6 and the automata utilities from the Open Motion Planning Library (OMPL) (Sucan et al. 2012). The LTL task is processed using Spot (Duret-Lutz and Poitrenaud 2004), and we performed simulations on CoppeliaSim 7 using ROS. 8 Motion planning was done with the CoppeliaSim OMPL tools with RRTconnect. Furthermore, we used the DQ Robotics library (Adorno and Marques Marinho 2021) for robot modeling and control and to define the geometrical constraints. We used the constrained convex optimization utilities from the DQ Robotics library that were implemented using IBM ILOG CPLEX Optimization Studio. 9 All the experiments were done on a single computer running Ubuntu 20.04 x64 with an Intel Core i7-8550U CPU with 16GiB of memory and a video card GeForce MX150. 6 https://www.boost.org/doc/libs/1_71_0/libs/graph/doc/index.html 7 http://www.coppeliarobotics.com/ 8 https://www.ros.org/ 9 https://www.ibm.com/products/ilog-cplex-optimization-studio

Evaluation of Our Planning Framework and comparison with the ITMP framework proposed by He et al. (2015)
To evaluate our framework and compare it with the original ITMP framework proposed by He et al. (2015), we created a simulation scene on CoppeliaSim in which a Kinova JACO robot must execute assistive tasks for a seated person, with limited or no lower limbs mobility, who cannot reach farther objects in the workspace. The robot is placed on a table and the person is seated on a chair in front of it. There are four colored cuboid objects o meat , o salad , o book , o pen representing, meat (red), salad (green), book (blue) and a pen (orange), respectively. In addition, eight colored regions of interest are depicted representing preparation area r prep (dark gray), heating area r heat (red), cooling area r cool (green), waiting area r wait (cyan), book area r book (blue), two person-areas r pers (yellow), and pen area r pen (orange). Initially, the meat is in the preparation area, the salad is in the waiting area, the pen is in the pen area, and the book is in one of the person areas, as shown in Fig. 5. 10 To compare both frameworks, we first analyze the number of nodes explored in the product graph and the total planning and execution time. We propose a task ϕ that exploits the LTL temporal operators to plan for a task with a certain degree of spontaneity. In other words, we give the planner more possibilities to accomplish a task. Consider the subtasks T A to T D and the whole task T : As a result, ϕ is given by in which ϕ A = p p,pers ∧ p b,pers , ϕ B = p m,h , ϕ C = p m,pers ∧ p s,pers , and ϕ D = p b,b ∧ p p, p enforces T A to T D , respectively. The motivation of this task is that the person will eventually eat the food and eventually use the pen to make annotations in the book, but the order is not specified. Last, we add an arbitrary waiting time T wait that the robot must wait every time after it places an object in front of the person. This is done to give some time for the person to accomplish her task and prevent the robot from moving the object away from the person too early. The automaton generated from ϕ has twelve states. Our adapted framework explores 244556 nodes in the product graph whereas the original framework explores 531748 nodes, as summarized in Table 1. To evaluate the computational burden of each method, we executed both methods successively until the time variance of the variables of interest stabilized at an approximately constant value. Therefore, we executed both our method and He et al. (2015)'s method 117 times. This is necessary because the motion planner used by He et al. (2015) is probabilistic. Hence, it generates different motion plans at each execution. Also, there is some intrinsic time variability during simulation because CoppeliaSim is subject to the operating system's scheduler. Therefore, even deterministic formalisms, such as ours, have variability in the execution time when running in a simulated environment. Figure 6 shows that our method has a faster execution time and a faster task-planning time than the method of He et al. (2015), not only in average but also considering the standard deviation, and it does not require motion planning. As a result, our method is considerably faster.
With regard to the high-level plan, in our adapted framework there is no need to generate more than one high-level plan due to changes in the scene, in terms of the modeled geometric primitives, as long as there are mechanisms to track their changes. As a consequence, there is no increase in the number of generated planning nodes during the task planning phase, and Dijkstra's algorithm searches for a task plan on a static graph. For the same task in the original framework, our |A ϕ | and |E Aϕ | are the number of states and edges in the DFA, respectively, |V P | is the total number of nodes in the product graph

Fig. 6
Average total planning and execution times, in logarithmic scale, of both planning frameworks. The variability whiskers represent the one standard deviation. The standard deviations are also in logarithmic scale. Therefore, although the task planning time variance of our method (0.4822 s) appears to be larger than in He et al. (2015)'s method (0.6618 s), it is not approach has greatly reduced the number of generated task plan nodes. Nonetheless, some high-level plans might not be realizable, not only because of obstacles that prevent the robot from executing the plan, but because the closed-loop controller can get stuck in a local minimum. (The closedloop system is stable, but not asymptotically stable.) This, of course, can be mitigated by searching for alternative plans in the product graph, in case the robot fails, but this is out of scope of the current work. The smaller planning time in our framework is a result of task relaxations. More specifically, the number of valid nodes in the manipulation abstraction is given by 2(| |+1)P (| |+1) |O| (He et al. 2015), where | | is the number of regions, |O| is the number of objects and P k n is the k-permutation from n elements. Differently from He et al. (2015), who partition the search space into a set of discrete poses and consequently need large values for | |, partitioning the search space into regions provides a much coarser discretization, considerably reducing the computational time. Also, because those regions have fewer dimensions than the six-dimensional space of poses, the task requires fewer degrees of freedom and, consequently, the controller can potentially accommodate more constraints.
From the point of view of real-world implementations, sensor resolutions determine the minimum size for a given region, which means that if we wanted to determine regions smaller than the sensor resolution, it would not be possible. Fortunately, we want the opposite, that is, we define large regions to give the controller more " freedom" to place objects, which also has the side-effect of reducing the overall complexity. On the other hand, real-world implementations of He et al. (2015)'s framework rely on very accurate sensors to build the workspace. This is because their method is not robust even to small changes in the scene environment as it lacks reactivity. Indeed, after a motion plan is found, it is executed in open-loop, whereas our method accounts for those changes because the constraints are continuously updated during execution.

Description of the Constraints Used in the Simulation and Constraints Corresponding Parameters
The constraints used in the simulation are: three plane constraints to prevent collision with the two walls and the table, semi-infinite cylindrical constraints to prevent collisions with non-manipulated objects, an infinite cylindrical constraint around the robot z-axis to prevent twisted configurations, and a line-cone constraint to prevent the grasped objects from tilting too much, and the point-cone constraint to drive the object to the target region. Figure 7 shows the simulation scene with the constraints. The point-cone constraint is shown in Fig. 3 and also in Fig. 7. Table 2 presents the parameters used for each constraint.

Constrained Motion Controller Parameters
The parameters of the constrained motion controller were also constant during all simulations, in which η = 100 and λ = 0.001 (see (2)). For the sampling time, we used T sampling = 5 ms.

Evaluation of Constraints
To illustrate the satisfaction of the constraints enforced by the constrained controller, we selected different parts during the execution of task ϕ. For instance, to evaluate the pointcone constraint, we selected the action HOLD that is used to move the meat to the heating region. Figure 8 shows the trajectory of the end-effector towards the target region while being constrained by a conical surface.
In comparison with the plane constraints used to define a squared region of interest in our previous work (Pereira and Adorno 2020), this point-cone constraint requires less complex calculations during running time and requires only one inequality. On the other hand, when using four planes to define a squared region of interest, it is necessary to calculate four Jacobian matrices, four point-static-plane distances, and they require four inequalities in the control law.
We also present the results for all other constraints during the whole execution of task ϕ. To verify if any collision happened, we analyze the signed distances between the respective collidable entities. Figure 9 shows the signed distance between the end-effector and the walls and the table. The signed distance remains positive during the whole task execution, meaning that there is no collision between the end-effector and those obstacles. Figure 10 shows the signed distance between the endeffector and the cylinders enclosing the objects. The task planner decides to begin the task by heating the meat. Hence, it approaches the meat and the signed distance to it becomes slightly negative because we remove the constraints for a manipulated object. However, the signed distance to other non-manipulated objects remains positive, indicating that no collision occurred with those objects. Likewise, the signed distance remains slightly negative while the end-effector moves the meat because the robot is grasping it. Next, the end-effector places the meat on the heating region and moves away from it (i.e. the signed distance becomes positive and the constraints for the meat are inserted again as the meat is not manipulated). In the sequence, the end-effector approaches the pen (i.e. the signed distance decreases and becomes slightly negative because we remove the constraints for the pen). This procedure repeats until all the objects are manipulated and placed in the regions specified by the task. Also, a similar analysis can be done for the signed distance to the planes of the objects, which decreases when the end- Semi-infinite cylinders enclosing the objects W(c j ) for j ∈ {1, . . . , k} η l = 5.0, η π = 5.0 R = 0.0567m, d π,safe = 0.0m Robot z-axis cylinder W(l z ) η l = 5.0 R z = 0.15m End-effector z-axis line-cone W(l z,cone ) η l = 50.0 φ safe = 0.1rad  (table top, right wall, and front wall). Middle: signed distance between the end-effector and the vertical cylinder enclosing the robot base. In both cases, a positive distance means that the constraint has never been violated. Bottom: line-cone constraint angle between end effector z-axis and static line parallel to the z-axis of the reference frame located at the base of the manipulator. The dotted-black vertical lines indicate when an object is grasped or placed effector is approaching an object to grasp it or placing an object on the table. Figure 9 also shows the signed distance between the endeffector and the cylinder enclosing the robot base. It remains positive during the whole task execution indicating that the constraint was always satisfied. There is also the line-cone Fig. 10 Signed distance between the end-effector and the objects. The dotted-black vertical lines indicate when an object is grasped or placed constraint that limits the tilting of the end-effector, and Fig. 9 shows that the angle between the end-effector z-axis and the static line remains within the safety angle φ safe . Last, Figure 11 shows that all joints angles are kept within the joints limits, indicating that the constraint is satisfied, as expected.
It is important to emphasize that, although the objects in our simulation are static, our framework is in principle suitable for dynamically changing environments, as opposed to the framework of Ferrer-Mestres et al. (2017). This is because the constrained motion controller that we employ can prevent collisions with moving obstacles, as shown by (Marinho et al. Fig. 11 Constraints to enforce joints limits. The dotted-black vertical lines indicate when an object is grasped or placed 2019, Sec. III.A). The only requirement is that the information about obstacles velocities must be available either by direct measurements or estimation. Finally, the task will always be completed correctly as long as the changes in the environment do not affect the sequencing order of the task and the constraints do not make the closed-loop system be stuck in local minima.

Conclusion
This work adapts the LTL-based manipulation framework of He et al. (2015), which uses sampling-based motion planners as the low-level planner, to use instead a constrained motion controller that allows the definition of regions of interest while making the system reactive. Furthermore, we exploit the use of regions of interest from our previous work (Pereira and Adorno 2020) to relax tasks in a computationally efficient way. This is achieved by doing a coarse discretization of the workspace instead of discretization in the robot's and objects' configuration spaces as in the work of He et al. (2015). As a result, the number of states in the planner is reduced. With respect to total execution and planning time, our framework is faster and more robust to changes in the environment due to the reactivity. Our other contribution is the definition of a novel point-cone constraint that ensures that the end-effector will move towards the target region by using only one simple inequality constraint. Hence, fewer complex calculations are needed during runtime.
Regarding the regions of interest, an interesting investigation would be a formalization of how to determine regions from a broad geometrical description. With regard to the controller, although in our framework we have a closedloop system at the motion-control level, there is no feedback to the task planner in the case of failure. In this sense, a possible extension of the work would be to close the loop between the task planner and the motion controller. That way, the planner would try to find another solution whenever the closed-loop system gets stuck in a local minimum. (The closed-loop system is stable but not asymptotically stable.) Lastly, future works will explore combining the high-level LTL task specification in the constrained motion controller to obtain an abstraction-free planning framework that does not suffer from the curse of dimensionality.