Robot Control

The present invention relates to robot control.

Modern robots may have at least one of the following features: they may be kinematically redundant, they may be compliant and/or they shall avoid obstacles.

In particular “freeing” or releasing DOF may cause task redundancy, i.e. the DOF of the robot n is bigger than the DOF of the task m (n > m). This may also apply for robots with high(er) numbers of DOF and full DOF Cartesian tasks. Consequently, in such redundant cases, robots can perform more than one task at a time.

Compliant robots can in one embodiment be force-guided by a human: a user can push or hand-guide the robot. This may advantageously, in particular easily, fast, stable and/or reliably, be achieved by torque control, i.e. controlling the torques in the robot joints instead of or additional to poses, i.e. positions and/or orientations, and/or velocities.

In some cases it may be desired to avoid collision with static or moving objects, e.g. a second robot or the like.

A preferred application of the present invention may combine two or three of the following: task control, preferably multi-task control, compliance and obstacle avoidance, in particular in human-robot collaboration, e.g. how to deal with the fact that a robot is manually pushed close to a Cartesian obstacle object while it is performing a task. In other words, how can a controller implement that the task(s), e.g. pick-and-place, i s/are constantly being pursued while the user still can interact with the compliant robot and objects are avoided?

In this respect in particular one or more of the following challenges may remain:

• smooth vs. hard: for torque-controlled robots, tasks should be formulated in terms of forces or joint torques (for the sake of a more compact formulation, pairs of anti-parallel forces, i.e. torques, will sometimes also be called “forces” herein).

• smooth task activation: the obstacle avoidance task should receive top priority. Nevertheless, it preferably should not continuously produce a torque but only be switched on when the Cartesian point on the robot is close to its limit. Switching a top-priority task on and off may lead to discontinuous solutions and oscillations.

• Multi-level constraints: sometimes, it may be advantageous to realize not only e.g. Cartesian pose, in particular position, limits, but alternatively or additionally Cartesian velocity and/or acceleration limits, joint pose limits, torque limits or the like. If these are implemented in a stack of tasks, one of these limits may be sacrificed for another one.

A pose may comprise, in particular be or denote respectively, an one-, two- or three-dimensional position and/or an one-, two- or three-dimensional orientation. A joint pose thus may in particular be or denote respectively a position or orientation of one or more joints of the robot, in particular an angle of a re volute joint.

If those challenges are not properly dealt with, the robot may either react too weak (Cartesian object not avoided, robot hits the object), too hard (high torque peaks), and/or with jerky behavior and oscillations that prevent the task from being completed.

The object of the present invention is to improve control or behavior of a robot, preferably to avoid or reduce one or more of the drawbacks and problems discussed above.

This object is achieved in particular by a method with the features of claim 1. Claims 10, 11 refer to a system or computer program (product) respectively for performing a method as described herein, subclaims relate to advantageous embodiments.

According to an aspect of the present invention Quadratic Programming (QP) is used.

One advantage may be the possibility of including inequality constraints. Additionally or alternatively, it may be possible to have different constraints at the same level of priority. The task(s), e.g. following some trajectory, may be formulated as objective function(s) which preferably are minimized depending on relative importance. The priority between tasks could in particular be soft or strict priority as discussed later herein. Preferably, it can be selected between soft and strict priority, in particular dependent or pose and/or position or depending on a user choice. Constraints which are at the same level of priority like joint limit avoidance or obstacle avoidance may be preferably be formulated as inequality constraints which should never be violated.

In particular in order to include joint torque limits, the optimization problem variables may be (the) joint torques and/or joint accelerations Equality constraints, inequality constraints and/or objective functions preferably should be (affine) functions of either τ or

Quadratic programming (QP) is the process of solving quadratic problems with a convex quadratic cost function, in particular with linear equality and/or inequality constraints and/or box constraints. It may have the following general form where n is the number of variables in the optimization problem and m is the total number of linear equality and inequality constraints:

1bA ≤ Ax ≤ ubA

1b ≤ x ≤ ub wherein H(x) denotes the positive (semi) definite and symmetric Hessian matrix g(x) denotes the gradient vector A denotes the constraint matrix IbA and ubA denote the constraint vector (IbA = ubA for equality constraints) and lb and ub denote the box constraints upper and lower bounds for the problem variables.

Redundancy resolution as a Linear Quadratic Problem

A linear least square problem is of the form: This problem may be transferred to a quadratic problem by rewriting

Since b ^T b is a constant it can be neglected. Thus the quadratic cost function becomes: Comparing to the general QP form, H(x) = A ^T A, g(x) = -A ^T b

A Cartesian or Joint space task respectively can be formulated as: where f _t is the desired Cartesian or joint acceleration respectively and are the task Jacobian, time derivative of the task Jacobian, joint velocities and joint accelerations respectively. The subscript t denotes the task number. In case of a joint space task J _t is constant and equal to identity, I.

The problem can be formulated as a least square problem in terms of the joint accelerations

In that case, the problem can be written in the quadratic form with and in Cartesian space control and in the

Joint space control.

The upper and lower bounds for the optimization problem, ub and lb may preferably be: where τ _min and τ _max are the lower and upper bounds for the joint torques and and are the lower and upper bounds for the joint accelerations, preferably after reshaping using limits of joint pose, velocity and/or acceleration (see below).

For dynamic consistency, the robot's joint space dynamic equation with the mass matrix M may be included as an (in)equality constraint:

Limits in the Cartesian space and/or obstacle avoidance may be augmented to the constraint matrix A and constraint vectors IbA and ubA:

A = [0j _c ] where 0 is a zero matrix with the same size of J _c . The constraint vector may be wherein denotes a Cartesian acceleration of the robot, e.g. its TCP, end effector or flange respectively or the like.

The output will thus be optimal torque and/or joint accelerations that can command the robot.

The problem can analogously or likewise be formulated as a least square problem in terms of the joint accelerations and forces, in particular torques, as follows according to one embodiment respectively: subject to where M, g and h are the mass or inertia matrix respectively, the gravity and the Coriolis forces respectively. The desired acceleration can be defined given the error dynamcis according to one embodiment where Dc is the error X _d - x _c between the desired pose X _d and the current pose x _c .

In particular if interaction/compliant behaviour is desired, the robot may commanded by torque.

Alternatively, in particular if the robot shall move accurate, the optimal joint acceleration can be integrated, thus yielding desired joint pose for every control cycle.

Thus, according to one embodiment different kinds of constraints, in particular force, in particular torque, acceleration, velocity and/or pose limits in joint and/or Cartesian space and/or static and/or moving obstacles, can be ensured while trying to perform at least one task, in particular a set of tasks, and with or without physical human robot interaction.

Quadratic programming (QP) may in particular have the advantage of including a set of constraints and keeping all respected while minimizing a cost function.

Several tasks in one cost function may lead to a dependency on chosen weights and it may be necessary to write the constraints to be linear with the variable to be minimized. E.g. if one minimizes a function depending on torque, f(τ), the it is easy to limit forces, but not as easy to limit poses or velocities. Furthermore, if there arises a conflict between constraints one must be sacrificed by the other one (or the robot should stop if a conflict is encountered). Using quadratic programming can solve this problem and in particular new constraints like torque limits or static or moving obstacles can be included and/or the problem of constraining orientation can be solved as discussed later herein.

Thus, according to one embodiment of the present invention different kinds of constraints are observed or met respectively, in particular Cartesian and/or joint pose, velocity and/or acceleration limits, force and/or torque limits, static obstacles and/or moving obstacles of a torque- and/or pose-controlled robot, in particular while a human user applies external forces onto an arbitrary point of the robot structure. According to one embodiment:

• the robot continues to follow a programmed task or stack of tasks while offering compliance within defined constraints; and/or

• if a Cartesian limit is approached, a counteracting force, in particular torque, particularly for orientations, is, preferably smoothly, induced, advantageously not causing oscillations or jerky robot motion; and/or

• the smoothness is guaranteed by specifying maximum velocity, maximum acceleration and/or maximum force, in particular torque, values that preferably are always respected; and/or two or more, in particular all, limits have identical priority, i.e. none of these limits will be sacrificed in favor of another; and/or

• besides these quantities, no additional parameters such as a function for continuous task activation, magnitude of the Cartesian torque preventing the Cartesian limit or the like need to be specified.

One advantage of one embodiment of the present invention is that a robot can continue its programmed task while the user interacts. This can save cycle time in human-robot collaborative applications. Another advantage is the simplified control programming. According to one embodiment only maximum Cartesian pose, velocity, and/or acceleration values are/must be specified. These can be set by the user, depending on the application. Torque limits are specified by robot specification or depending on the task(s) according to one embodiment. Cartesian limits are set depending on the shape of the avoided Cartesian obstacle according to one embodiment. This shape is determined from a CAD Model or computer vision according to one embodiment. Other values that are necessary for state-of-the-art techniques, e.g., a function for continuous task activation, the magnitude of the Cartesian force preventing the Cartesian limit or the like advantageously are not necessary according to one embodiment. These parameters are usually very hard to find, as they strongly depend on the robot structure, its configuration, attached tools etc.

In case of moving obstacles, the motion of the object(s) can be estimated by (computer) vision techniques or by IMU sensors according to one embodiment. In case an object is another robot the encoders of said other robot can be used to specify the motion and velocity of it according to one embodiment.

Although the present invention may particularly advantageously used on robot human interaction, it is not limited thereto but to the contrary can also be used to command the robot in pose or with no (controlled) compliance respectively, which advantageously can produce a high accuracy motion while meeting (all) constraints. According to one embodiment an optimal joint acceleration to produce the (desired) motion of the robot is determined. This acceleration may be integrated to get a joint pose according to one embodiment.

According to one embodiment the robot has two or more tasks to be accomplished. According to one embodiment a prioritization (scheme) is provided to indicate the importance of some task(s) over (an)other(s).

Soft hierarchy

According to one embodiment a soft hierarchy prioritization (scheme) is implemented: in said soft hierarchy scheme, a weight is assigned for each task depending on its relative importance to other tasks. Consider a robot performing k tasks simultaneously, where task _t is of more relative importance to task _t+1 , etc., i.e. priority (task ₁ ) > priority(task ₂ ) > .... priority(task _k ). A higher weight w _t is given to the more prior task taskt, w ₁ > W ₂ > .... W _k . The higher is the ratio between two weights, the stricter is the hierarchy. The soft hierarchy solves only one QP per iteration

For each task, the Hessian matrix H _t and gradient vector g _t are calculated as described herein, particularly above, and then summed together depending on their associate weights:

Soft priority allows that the lower priority tasks could interfere with a higher priority task.

Strict hierarchy According to another embodiment a strict hierarchy prioritization (scheme) is implemented: in said strict hierarchy scheme, priority guaranties the prioritized scheme, lower priority tasks are scarified if they conflict with higher ones.

According to one embodiment of the strict hierarchy prioritization (scheme) the number of QPs solved depends on or equals the number of tasks involved respectively. So in total for k tasks, k QPs are solved per iteration.

For k tasks, in the t ^th QP, task _t is minimized in the null space of all previous tasks tasko, ... , task _t-1 . They are included as (in)equality constraints according to one embodiment. The size of the quadratic problem increases in every QP because of the increase in the set of equality constraints. In particular for two tasks taski (high(er) priority), task2 (low(er) priority):

1 ^st QP: 2 ^nd QP:

For multiple tasks:

As can be seen from the last line(s), the joint coordinates q _i used for task, may in particular be the joint coordinates q _j used for one or more higher prioritized task _j<j or another sub-set of the robot’s joint coordinates fulfilling said equation(s)

Shaping joint acceleration limits

According to one embodiment one or more of the following bounds on the joint ranges, joint velocities and joint accelerations are predetermined:

Q _min < q < Q _max

V _min < < V _max

A _min < < _max In particular if the acceleration bounds come from pure kinematic reasoning then according to one embodiment A _min = -A _max .

According to one embodiment the joint acceleration command is kept constant at the computed value for a time of duration or step dt respectively. Assuming that at t _h = hdt the current joint pose q = q _h and velocity are both feasible the next joint velocity and pose may be estimated by:

Keeping within their bounds yields: and

With the constraints given by the inequalities above and those in the previous two equations a box constraint for the command at time t = t _h may be obtained:

According to one embodiment Vmax and Vmin are shaped as follows, in particular to reduce the velocity smoothly in the proximity to the joint: Thus, the behavior of the joint coming to its limit can be done smoothly to avoid a big change in the velocity in just one instance of time according to one embodiment. Thereby, the quadratic function may be set to properly shape the velocity bundaries. In this way the velocity may advantageously be reduced before coming to the joint limits. Thus, and can advantageously be included in the QP problem.

Shaping Cartesian acceleration limits

According to one embodiment one or more of the following bounds on the Cartesian ranges, Cartesian velocities and Cartesian accelerations are predetermined:

X _min X X _max

V _min < < V _max

A _min A _max where X is a vector of the current Cartesian pose of a robot-fixed reference, e.g. the TCP, an end effector or flange respectively, a joint like e.g. the elbow, or the like, in the dimension to be constrained. In particular if the acceleration bounds come from pure kinematic reasoning, then according to one embodiment A _min = -A _max .

According to one embodiment the Cartesian acceleration command is kept constant at the computed value for a time of duration or step dt respectively. Assuming that at t _h = hdt the current Cartesian pose X = X _h and velocity are both feasible, the distance to the max limit may be denoted by: d _max = X _max - X _h d _min = X _min - X _h Keeping the next Cartesian velocity and pose within their bounds yield: and

With the constraints given by the inequalities above and those in the previous two equations a box constraint for the command at time t = t _h may be obtained: According to one embodiment Vmax and Vmin are shaped as follows, in particular to reduce the velocity smoothly in the proximity to the joint:

Thus, the behavior of the Cartesian point coming to its limit can be done smoothly to avoid a big change in the velocity in just one instance of time. Thus, and can advantageously be included in the QP problem.

Computing of Jacobian Jc for position

The Jacobian for the constraint J _c is or defines a subspace of the Cartesian space respectively. The columns of the Jacobian represent each joint of the robot, and the rows represent the dimension in which the limit is set. For example the whole Jacobian / for a 7 DoF robot will have the size 6x7, three translational or positional respectively and three rotational coordinates at a Cartesian point e.g. the TCP [x, y, z, α, β, γ] represent the rows of the Jacobian: If one coordinate, e.g. the coordinate y, is to be limited, e.g. a wall located in a y direction, then, the Jacobian that represents the constrained coordinate, j _c , will be the corresponding row of j, in said example the second row of J : If e.g. the direction z is to be also constrained because the robot should not hit a table, J _c will be the second and the third row of j:

According to one embodiment the Jacobian may be the transformation of the velocity of a robot-fixed reference point or coordinate system (origin) respectively, in particular the TCP or another Cartesian point like e.g. a reference point in the robots elbow, and the joint space, i.e. space of the robots joint coordinates, in particular joint angels. For instance if the direction y and z have to be constrained for the Cartesian position of joint 4 (elbow), ] _c becomes: Avoidance of static obstacles

According to one embodiment, in particular for avoiding obstacles, the Jacobian is rotated and are computed in a predetermined direction: In particular for obstacles like walls or the like that are perpendicular to one of the coordinates a limit value may be defined on one coordinate axis according to one embodiment.

In particular for more complex(ly shaped) obstacles like robot’s arm and other environmental objects, one or more virtual, preferably 3 dimensional, geometric models of the objects are determined according to one embodiment which may in particular include the (controlled) robot itself. According to one embodiment one or more (such) virtual models are determined using (computer) vision techniques.

According to one embodiment, in particular using such virtual model(s), the closest distance between the robot and any object and/or the closest point (to any object) on the robot (CP-R) and/or on the, in particular closest, object (CP-O) are computed.

After identifying such critical points, a momentary goal is (added or defined respectively) to avoid the collision between these points according to one embodiment. Therefore, advantageously only kinematics parameters of CP-R in the direction of CP- O have to be considered. These parameters may include velocity, acceleration and/or the Jacobian of CP-R in the direction of CP-O, basically the direction along the shortest distance, which is denoted “critical direction” herein. This advantageously can ensure the saturation of its acceleration only along critical direction and allows the CP- R’s motion in all other directions.

According to one embodiment the Jacobian is rotated along the critical direction to obtain velocities and acceleration also expressed in this direction. According to one embodiment a rotation matrix is defined or determined respectively which can rotate the coordinate system of critical points in such a way that one of the coordinate axis (e.g. Z-Axis) aligns with the critical direction. Using this rotation matrix Jacobian can be expressed in aligned coordinates.

According to one embodiment said rotation matrix is derived from axis-angle representation of a coordinate orientation, in particular by rotating one axis, e.g. the Z- Axis, until it aligns with the critical direction vector. If for example the Z-Axis needs to be rotated by Q around the rotation axis which is a perpendicular axis to the plane of rotation, in particular the plane that contains both the Z-Axis and the critical direction vector (see Fig. 1): Let CP-R or CPR respectively be the respective point of the robot and denoted by ( χ ₁ ,x ₂ ,x ₃ ) and CP-0 or CPO respectively be the respective point of the obstacle and denoted by (y ₁ ,y ₂ ,y ₃ )· A unit vector u ((c ₁ , c ₂ , c ₃ )) in the critical direction can be obtained by the following equations: where \L\ is the normalized distance between the two points. The axis of rotation should be perpendicular to the plane of rotation. Hence the cross product between the unit critical direction vector and Z-Axis produces a common perpendicular vector which in turn is perpendicular to the plane of rotation. Therefore, the axis of rotation A _rot = u x (0,0,1). The angle between the Z-Axis z = (0,0,1) and the critical direction vector u can be calculated from their dot product according to:

Based on said axis A _rot and angle Q the required rotation matrix can be determined which by multiplication transforms the representation from base coordinates (O) to aligned (with critical direction) coordinates (C). This rotation is denoted as ^C R ₀ . The equation to determine the coordinates with aligned Z axis is given by: cCP = ^C R ₀ * ^° CP

The maximal or closest distance respectively in this case can be determined according to: d _max = ^C CPO - ^C CPR where ^° CP and ^c CP are coordinates of critical points represented in original coordinate system and aligned coordinate system respectively. If the coordinates are aligned it is sufficient to find the accelerations along one coordinate axis (in this example the Z-Axis) which provides the Cartesian acceleration in the critical direction:

Jn = ^C R ₀ ^c j _t where ] _t are the first 3 rows of J. Thus, ] _c = J _{n 3} , i.e. the third row of j _n , because the Z-Axis is aligned with the z direction are determined from the shaping function with the new rotated velocities according to one embodiment:

X = ^C R ₀ ^c CP

Avoidance of dynamic obstacles

To avoid dynamic obstacles, a change in the shaping function is done according to one embodiment to include the velocity of the object relative to the velocity of the robot. Before we assumed that CP-0 had zero velocity. If the obstacle is moving, this is not true anymore. Therefore, this velocity may be included in the shaping:

The next Cartesian velocity and pose may be estimated according to: Here is the relative velocity between the critical points. where is the velocity of the critical point on the robot. Now the boundaries may be shaped as it was explained above with respect to shaping joint acceleration limits, in particular in section “Shaping joit/Cartesian acceleration limits”. Constraining orientation

According to one embodiment additionally or alternatively to the position limits in Cartesian space the orientation is constrained.

Lets R _cur be a current frame to be constrained, e.g. the end effector frame of the robot, and R _ref from where the limits are referenced. Thus, the goal may e.g. be to limit the orientation around one axis of R _ref in 45°.

In Fig. 2 both frames are shown, R _ref is indicated in dashed lines and R _cur in continuous lines. The rotation frames are composed by unit vectors that represent every axis:

Rref = [X _ref Y _ref Z _ref ] Rcur ⁼ [X _cur Y _cur Z _cur ]

Consider a constrained rotation around the x-axis. For this example z _cur must not be separated more than a maximal distance (given by Θ _max ) of the plane P defined by x _ref and z _ref (dotted in Fig. 2). To determine this distance, z _cur is projected into the plane and then the distance between these two vectors z _cur , z _proj is determined. To avoid singularities of definition and always have a positive value, e may be computed according to:

Then the distance may be determined according to: d _max = Θ _max - Θ . Based on said distance the Jacobian to express velocities in the same frame may be determined: the Jacobian J _r transforms the joint velocities to the velocity in the orientation of the current frame: where w _x , w _y and w _z are the angular velocities around the vectors x _cur , y _cur and z _cur , respectively. In order to rotate the Jacobian in a way that the angular velocity around the x-axis expresses the angular velocity to move z _cur to z _proj , w _{x j} a new rotation frame, Rj = [xj Vj zj] may be used to rotate the Jacobian. As rotation shall be around x ₇ , this vector must be perpendicular to z _cur and z _proj , i.e. x _j = z _proj x z _cur (thus the positive direction of rotation is going away from the plane). y ₇ - is to be the projection of z _proj on the plane defined by x _cur and y _cur . To complete the frame z _j = z _cur . This gives the rotated Jacobian:

The first row of j _j · relates the joint velocities with the angular velocity w _{x j} : w _{x j} and d are the inputs for the shaping of the constraints function and ] _hl will be the Jacobian to determine the constraints in the QP problem: J _c = j _{j 1} . Vividly what is happening is that the vector x _curr is avoiding to go out of two cones that are symmetrically separated by the plane of x _ref and z _ref .

To constrain orientation around y, analogously the distance between z _cur and the plane y _ref and z _ref may be determined. R _j in this case then may be R _j =

[Zproj x Z _cur z _cur x (z _proj x z _cur ) z _curr ] where z _proj for this case is the projection of z _cur into the plane of y _ref and z _ref .

To constrain orientation around z, analogously the distance between y _cur and the plane y _ref and z _ref may be determined. R _j in this case then may be R _j =

[y _Proj x y _cur ycur ^x (y _proj x y _cur ) Vcurr ] where z _proj for this case is the projection of y _cur into the plane of y _ref and z _ref .

In order to constrain two orientations according to one embodiment the Jacobians and maximal and minimal acceleration values are stacked or a single cone for one axis is used. ff for example rotation around x and y is to be constrained to 45°, the arrow or vector z _cur must not leave the cone as shown in Fig. 3. The distance is the angle between z _cur to z _ref , determined according to: d _max = Θ _max

The rotation matrix to rotate the Jacobian may

Rj = [ ^z ref ^{X z} cur ^z cur ^X ( ^z ref ^{X z} cur) ^z curr]·

This may be generalized by d = θ _max-θ and

Rj = [Vref ^X Vcur ^z cur X (Vref X Vcur) Vcurr] where V is the unit vector that is not limited (of the corresponding frame), e.g.:

V _ref/curr = x _ref/curr when constraining y and z

V _ref/curr = Y _ref/curr when constraining x and z

V _ref/curr = z _ref/curr when constraining x and y

The constrained Jacobian J _c = j _{j 1} .

In order to constrain three rotational angles according to one embodiment the Jacobians and the maximal accelerations in the QP problem obtained by computing them for two axes and one axis independently may be stacked. According to one aspect of the present invention a method to control a robot to perform at least one Cartesian or joint space task comprises: using or applying quadratic programming respectively (so as) to determine joint forces, in particular joint torques, and/or joint accelerations of said robot based one or more cost function(s) which depend(s) on said task.

According to one embodiment, said at least one Cartesian or joint space task is defined or (pre)determined on or in or with respect to one or more coordinates respectively, according to one embodiment position and/or orientation coordinates, in particular of a robot-fixed reference like the TCP, end effector or flange respectively, joint or the like, in Cartesian space or joint coordinates of the robot. The number of said coordinates may be six according to one embodiment or differ from six according to another embodiment.

As described herein, quadratic programming may be used advantageously to control a robot. In particular, quadratic programming may allow to control a robot to perform one or more tasks in a fast(er), (more) reliable and/or smooth(er) way. In particular, as already described in detail, a task f _t may comprise or be defined respectively by desired Cartesian or joint acceleration, e.g.:

For example to approach an Cartesian pose X _d or follow a Cartesian path may be formulated as a proportional and/or integral and/or differential control law, for example f _t = K(X _d - X). The cost function depending on the task may be of the form:

This can be written in the quadratic form with Cartesian space control and in the Joint space control.

As already described herein, according to one embodiment both, joint forces, in particular joint torques, and joint accelerations are both together used as problem variables, which not only can allow advantageously considering (in)equality constrains, in particular Cartesian and/or joint space and/or force, in particular torque, limits, but also may be used in force-control, in particular torque-control (which may particularly useful for compliant control of the robot) as well as in pose control (when using the determined joint accelerations, in particular integrating them into desired joint poses and/or velocities).

As already described herein, according to one embodiment the robot is redundant with respect to the at least one task. Preferably the robot comprises at least six, more preferably at least seven joints, in particular revolute joints. Quadratic programming may be used advantageously to control such redundant robots since the redundancy can be resolved easily in the cost function or quadratic problem respectively.

As already described herein, according to one embodiment the robot is force controlled, in particular torque controlled, and/or compliant controlled. In this way, advantageously human-robot interaction or cooperation can be realized respectively.

As already described herein, according to one embodiment the robot is pose controlled. In this way, advantageously precise robot movement or operation can be realized respectively.

As already described herein, according to one embodiment the robot is controlled to perform simultaneously said at least one Cartesian or joint space task and at least one other Cartesian or joint space task, in particular

• two or more Cartesian space task(s);

• two or more joint space task(s);

• one or more Cartesian space task(s) and one or more joint space task(s).

According to one embodiment, said at least one other Cartesian or joint space task is defined or (pre)determined on or in or with respect to one or more coordinates respectively, according to one embodiment position and/or orientation coordinates, in particular of a robot fixed reference like the TCP, end effector or flange respectively, joint or the like, in Cartesian space or joint coordinates of the robot. The number of said coordinates may be six according to one embodiment or differ from six according to another embodiment. As already described herein, according to one embodiment quadratic programming is used to determine (the) joint forces, in particular joint torques, and/or joint accelerations of said robot based on said two or more tasks, wherein one or more quadratic problem(s) is/are solved to determine said joint forces, in particular joint torques, and/or joint accelerations.

In particular one quadratic problem may be solved, applying soft hierarchy (scheme) as already described. Additionally or alternatively two or more quadratic problems may be solved, applying strict hierarchy (scheme) as already described, wherein one quadratic problem reflects at least one of the tasks and at least one other quadratic problem reflects at least one other of the tasks, wherein the high(er) prioritized tasks are reflected in (in)equality constraints of the (quadratic problems of the) low(er) prioritized tasks as already described.

As already described herein, according to one embodiment quadratic programming is used to determine the joint forces, in particular joint torques, and/or joint accelerations based on one or more inequality constraints, in particular

• one or more, in particular upper and/or lower, pose limits, in particular position limits and/or orientation limits, in Cartesian space; and/or

• one or more, in particular upper and/or lower, velocity limits in Cartesian space; and/or

• one or more, in particular upper and/or lower, acceleration limit in Cartesian space; and/or

• one or more, in particular upper and/or lower, pose limits in joint space; and/or

• one or more, in particular upper and/or lower, velocity limits in joint space; and/or

• one or more, in particular upper and/or lower, acceleration limit in joint space.

As already described herein, according to one embodiment at least one Cartesian and/or joint velocity and/or acceleration constraint is shaped such that a velocity limit becomes zero at a pose limit.

Additionally or alternatively, according to one embodiment orientation of a robot-fixed reference such as its TCP, end effector or flange respectively, tool or a joint like e.g. the el I bow is limited with respect to at least one predetermined direction in Cartesian space as already described herein. As already described herein, according to one embodiment the robot is controlled to perform the one or more Cartesian and/or joint space tasks while avoiding one or more static obstacles and/or one or more dynamic obstacles. Avoiding one or more (of said) obstacles may in particular be performed based on a Jacobian representing a constraint. Additionally or alternatively, according to one embodiment one or more (of said) obstacles, in particular its pose (relative to the robot) and/or shape, are determined based on a model, preferably a CAD model or the like, of the robots environment and/or based on computer vision.

According to one aspect of the present invention a system is hard- and/or software-wise configured to perform a method as described herein and/or comprises means for controlling the robot to perform the at least one Cartesian or joint space task using quadratic programming to determine joint forces, in particular joint torques, and/or joint accelerations of said robot based on at least one cost function which depends on said task.

According to one embodiment the system or its means respectively comprise: means for pose control or force control, in particular torque control, and/or for compliant control of the robot based on the determined joint forces, in particular joint torques, and/or joint accelerations; and/or means for controlling the robot to perform simultaneously said at least one Cartesian or joint space task and at least one other Cartesian or joint space task, wherein quadratic programming is used to determine joint forces, in particular joint torques, and/or joint accelerations of said robot based on said at least two tasks, wherein at least one quadratic problem is solved to determine the joint forces, in particular joint torques, and/or joint accelerations; and/or means for prioritizing said at least two tasks among each other, in particular by a soft or strict hierarchy; and/or means for using quadratic programming to determine the joint forces, in particular joint torques, and/or joint accelerations based on at least one inequality constraint, in particular at least one pose limit, in particular position limit and/or orientation limit, at least one velocity limit and/or at least one acceleration limit in Cartesian and/or joint space; and/or means for shaping at least one Cartesian and/or joint velocity and/or acceleration constraint such that a velocity limit becomes zero at a pose limit; and/or means for limiting orientation of a robot-fixed reference with respect to at least one predetermined direction in Cartesian space; and/or means for controlling the robot to perform the one or more Cartesian and/or joint space tasks while avoiding at least one static or dynamic obstacle, in particular based on a Jacobian representing a constraint and/or determining said at least one obstacle based on a model of the robots environment and/or computer vision.

Means in the sense of the present invention can in particular be embodied by or comprise hardware and/or software respectively, in particular one or more programs or program modules and/or at least one, preferably digital, processing unit, in particular microprocessor unit (CPU), graphic card (GPU) or the like, preferably connected to a memory system and/or bus system data- or signal-wise respectively, in particular at least one computer. The processing unit can be adapted to process commands that are implemented as a program stored in a memory system, to receive input signals from a data bus and/or to output signals to a data bus. A memory system can comprise one or more, in particular different and/or digital, storage media, in particular optical, magnetic, solid-state and/or other non-volatile media. The program can be (designed or implemented in) such (a way) that it embodies or is capable of executing a method described herein, so that the processing unit, in particular computer, can carry out the steps of such a method and thus in particular can control the robot. In one embodiment, a computer program product can comprise, in particular, be a, preferably non-volatile, storage medium for storing a program or with a program stored thereon respectively, wherein an execution of this program causes a system or a controller, in particular a computer, to carry out a method as described herein or one or more of its steps.

In one embodiment, one or more, in particular all, steps of the method are carried out completely or partially automatically, in particular by the system or its means.

In one embodiment, the system comprises the robot.

Further advantages and features can be gathered from the dependent claims and the exemplary embodiments. Hereto it is shown, partly schematically, in: Fig. 1 : a critical direction between critical points of a robot and an obstacle;

Fig. 2: a reference frame and a current frame;

Fig. 3: the reference frame and current frame with a cone;

Fig. 4: a method to control the robot according to one embodiment of the present invention; and

Fig. 5: a system with the robot according to one embodiment of the present invention.

Fig. 5 shows a system comprising a 7-DOF robot 1 and a robot control(ler) 2 control robot 1 to perform different Cartesian or joint space tasks simultaneously according to one embodiment of the present invention q1 , ... q7 denote the joint poses of robot 1 , thus defining its joint space.

Fig. 4 shows a method performed by the robot control (ler) 2 to control robot 1 according to one embodiment of the present invention.

In a first step S10 a user determines the task(s) to be performed and/or pose, in particular position and/or orientation, limits in Cartesian space, e.g. limits for the robots TCP and/or an elbow of robot 1 , velocity limits in Cartesian space, e.g. for the robots end effector or flange respectively, and/or pose and/or velocity limits in joint space, e.g. limits for q1 , ... q7, and/or their time derivatives respectively. The user may determine the task(s) and/or limits by programing, selecting and/or parametrizing program modules or the like. The robot control(ler) 2 receives corresponding data in step S10.

In step S20 robot control(ler) 2 receives signals indicating the actual joint coordinates q1 , ... q7, and/or their time derivatives and/or actual torques τ1 , ... τ7, acting at the joint axes. Additionally it may receive signals from a computer vision system determining obstacles (not shown). Based thereon robot control(ler) 2 solves the respective quadratic problem(s) to perform the predetermined task(s) while observing or complying with the predetermined limits respectively (step S30).

Joint torques τ1 , ... τ7 and joint accelerations are used as optimization problem variables. Thus, robot control(ler) 2 determines optimal joint torques and accelerations in step S30.

According to one embodiment, said optimal joint torques are used in a torque control in step S40, thus realizing a compliant control which allows a human operator to hand-guide the robot while it performs the task(s). According to another embodiment, said optimal joint accelerations are used in a pose control in step S40.

If the task(s) has/have been completed (step S50: Ύ”), the method ends (step S60). Otherwise (step S50: “N”), a next cycle or time step is performed.