Actin  Version 5.5.1
Software for Robotics Simulation and Control
Actin Tasking

What is Tasking?

Generally referred to as robot programming or scripting, but we can view it from a higher level. Usually robots are scripted with an interpreted language. Tasking is a way to sequence robot motions to perform a task.

  • Pick and place
  • Assembly
  • Inspection
  • Welding
  • Painting
  • Grinding
  • Adhesive Dispensing

Generally tasking involves programming motions (joint + end effector) to move to and from home positions and part positions. Usually end effectors are fully constrained 6 degrees of freedom ( X, Y, Z, Roll, Pitch, Yaw ). Usually constrained in system frame, tool frame, or “part” frame. End effector TCP or tool offsets are typically configured based on tooling geometry only.

What is Natural Tasking?

Tasking a robot is difficult, and this difficulty is increased by tasking robots in an unnatural, over constrained way. Natural tasking is a comprehensive approach to specifying robotic tasks easily without over- or under-constraint. Natural tasking allows you to take advantage of natural symmetry of your tooling and parts, which in turn simplifies programming. Natural tasking allows you to define tasks at a higher level, relative to objects or features on objects (independent of object pose). Tool offsets (TCP) can be generated from existing frames, including tooling and payload geometry and state.

Natural Tasking leverages Actin’s flexible constraint based kinematics. Motion Constraints (End Effector Constraints) define how we wish the link to move. We can constrain up to 6 DOF on a link in space (using a Frame End Effector). Using an arm to move a pen, we can use a 5 axis constraint (Free Spin in Z). Grasping a sphere, we can use a 3 DOF constraint (Point End Effector). These constraints can be relative to the system frame or a link frame.

Path Planning

Natural tasking can leverage Actin’s methods of path planning to find a way to move the end effector from one position to the next.

  • Subject to constraints
    • Avoid colliding with other parts of the robot
    • Avoid colliding with object in the environment
  • Local Path Planning
    • Done in real time as output of kinematic control
    • May settle in local minima (get stuck)
  • Global Path Planning
    • Built on top of kinematic control
    • Motion planned in advance
    • Uses RRT based algorithms

For more information please see here.

Local Path Planning

Local path planning uses Actin Motion Constraints configured as "soft". Local path planning uses the "clever" control method which increases the soft constraint gain as the end effector gets closer to its goal. Local path planning requires optimizations such as collision avoidance and joint limit avoidance to work in conjunction with soft constraints. Local path planning will attempt to take a straight line path until collisions or joint limits force a deviation. Local path planning behaves like a gradient/potential field based path planning, using joint limits and collisions as a form of repulsive potential field. This method is deterministic as long as the starting position, goal, environment, and the control system timestep is deterministic.

  • Advantages
    • Fast (real time)
    • Can handle dynamic targets and dynamic obstacles
  • Disadvantages
    • Convergence not guaranteed
    • May get stuck between obstacles depending on geometry

Global Path Planning

Global path planning uses an RRT based algorithm with path shortening. Global path planning requires time to calculate a path in joint space. Global path planning may not take the same path every time due to randomization (non deterministic). The time required increases with number of obstacles and degrees of freedom on the manipulator. This is shown in the videos below that demonstrates how the robot takes a different path to reach the final goal based on the obstacles in the environment using the "Global Path Planning".

  • Advantages
    • Guarantees a solution if you give the planner enough time
  • Disadvantages
    • Can not handle dynamic targets and dynamic obstacles
    • Not real time

For more information, please see here.

Some Examples of Natural Tasking

There are numerous opportunities to leverage Natural Tasking to simplify programming of robot tasks. One example is grasping a spherical shape or object.

In this case, the robot end effector motion is constrained in only 3 axes (X,Y,Z position). The first motion uses an “approach” tool offset, then moves to a waypoint at the center of the spherical feature. Once complete, the robot uses a closer “grab” tool offset, then moves to a waypoint at the same center of the spherical feature. The orientation of the gripper is optimized using collision avoidance. This allows the system to leverage the symmetry of the sphere, and does not force the programmer to calculate the angle at which to approach or grasp. Actin calculates the most natural or “easiest” for the robot in real-time. When grasping a cylindrical object, a similar approach is used.

In this example, the end effector is constrained by 5 degrees of freedom, using a “freeSpinInZ” end effector constraint. This constrains the position (XYZ) as well as the roll and pitch but not the yaw rotation about the Z axis. To grab a cylindrical object, the first motion uses an “approach” tool offset, with its Z axis aligned with the axis of the cylinder, then moves to a waypoint at the center of the cylindrical feature. Once complete, the robot uses a closer “grab” tool offset, then moves to a waypoint at the same center of the cylindrical feature. The rotation of the gripper around the cylinder is optimized using collision avoidance. This allows the system to leverage the rotational symmetry of the cylinder, and does not require the programmer to decide which side of the cylinder to grasp. When grasping a part from a round hole (internal grasp,) a slightly different approach is taken.

In this case, we still use a 5 Axis “freeSpinInZ” end effector constraint, but the “approach” and “grab” are handled using poses relative to the part using a constant tool offset. In this example, the tool offset is set at the center of the bent fingers when they are closed, with the Z axis aligned so that the fingers are free to rotate about their axis of symmetry. This frees the programmer from needing to specify at what angle to grab the hole, taking advantage of the rotational symmetry of the hole. Actin will choose what is most natural, given the kinematics of the system. When coordinating limbs of branching robots, programmers can easily coordinate the end effectors by constraining one relative to another. Here we show coordinated motion, using a 5 axis constraint, with a tool offset controlling a feature on the part.

In this example, one end effector is constrained with a tool offset to the feature on the part, and the other end effector is constrained relative to the other end effector. This approach does not require the programmer to calculate and execute the trajectory of one arm relative to the other, or try to synchronize the motion of each arm. All of these will be done automatically by the Actin inverse kinematics.

Handoffs use a similar constraint setup.

Watch the video above and you’ll see that we first constrain the left end effector (robot) relative to the right using our 5 axis FreeSpinInZ constraint. This is the only constraint used for this setup, which allows for automatic coordination of each arm. The end effector moves to an “approach” and “grab” waypoint, then grasps with the gripper. The waypoints have their Z direction aligned with the round hole just like the earlier example, allowing for the robot to grasp at whatever rotation about the hole is most “natural” given the kinematics of the robot. When completing the handoff, we attach the object to the other end effector link, then we use another set of constraints to constrain the right end effector relative to the left to retract.

How Can We Task a System with Actin?

Low Level C++

It is possible to create the motions at a low level by generating EcEndEffectorPlacement using C++, and then calling calculateState on the EcPositionControlSystem (or EcControlSystemExecutiveModifier) , and handling the sequencing and convergence at each timestep, but there are easier ways.

Group Motion Manager

The Group Motion Manager allows users to finely configure the motions at a C++ level. This method allows users to leverage existing motion primitives, and handle blending and convergence.

Motion Library Classes

The Motion Library provides rich motion primitives and logic to control manipulators. It can be used by writing EcScript or programmatically. All motion classes are subclasses of EcMotionScriptObject. Each motion has an interal state. Other primitives besides motion include attachments, collision exclusion, tool offsets, and switching motion settings (ee set, control descriptor).

EcScript

The Motion Library provides rich motion primitives and logic to control manipulators. It can be used by writing EcScript or programmatically. EcScript adopts LISP-like syntax. An EcScript is a list of command token, parameters, and EcScripts.

In Summary

Constrain only what is required for the task, to allow for simpler programming. Allow Actin to optimize the remaining degrees of freedom using optimizations. Approach/Grab can be handled by tool offsets or part relative poses depending on motion required. Relative end effectors can handle coordination between branches of the robot/mechanism. Use Motion Script classes to sequence the motions to perform tasks