Natural Tasking with the Actin SDK

Brett Limone
Sep 9, 2019 9:00:41 AM

Robot arms can be programmed to perform any number of desired tasks, including bin picking, pick and place, assembly, inspection, welding, painting, grinding, sanding, adhesive dispensing, solder, and many more not listed. To make a robot arm perform the desired task, the motions of the robot must be “programmed” to do what the user wants. This is generally referred to as programming, scripting, training, teaching or tasking. Generally, commercially available robot arms are programmed with an interpreted language. Tasking usually involves sequencing motions –both joint level and end effector level– to move to and from home positions and part and tool positions. Usually, this end effector motion is constrained fully in 6 degrees of freedom (X, Y, Z, Roll, Pitch, Yaw). End effector motion usually can be defined relative to the system frame, tool frame, or “part” frame. The tool offset from the tool flange is based on the tooling geometry. Tasking a robot is difficult, and this difficulty is increased by tasking robots in an unnatural, over constrained way. Actin is a robot control SDK, which includes features like robot modelling, kinematics, tasking, and path planning. In this post, we will explain what “Natural Tasking” is in Actin, and how it makes programming robots easier.

What is Natural Tasking?

Natural Tasking is a comprehensive approach to specifying robotic tasks easily, without over- or under-constraint. Natural Tasking leverages Actin’s flexible constraint-based robot kinematics, and pre-defined low-level motion scripts, and path planning. Motion Constraints (End Effector Constraints) define how a link on robot model is allowed to move. A link can be constrained up to 6 DOF on a link in space (using a Frame End Effector). Sometimes this is unnatural or over-constrained. Depending on the task, we can use other constraints. Using a robot 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.

When controlling this system, we use two 3 DOF point constraints on the index finger and the thumb to move to waypoints on either side of the ball in order to grasp. The position of the wrist and the other fingers are free to optimize and settle to their most natural configurations.

Why is Natural Tasking Important?

Natural Tasking allows robot programmers to take advantage of natural symmetry of robot tooling and parts, which makes robot workcells more flexible, expands robot working areas, and simplifies programming. Natural Tasking allows users to define tasks at a higher level relative to objects or features on objects (independent of object pose). Robot tool offsets (TCP) can be generated from existing frames, including tooling and payload geometry and state.

Real-World Uses 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 (XYZ 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.

motion constraints

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.

In summary, natural tasking allows users to simplify robot tasking using the Actin framework. With Actin, constrain only what is required for the task to allow for simpler programming. Allow Actin to optimize any remaining degrees of freedom. Generally, when sequencing “approach” and “grab” motions, the offset can be handled in system coordinates, part coordinates, or tool coordinates depending on what motion is required and what symmetry can be leveraged. When coordinated motion is required between arms or external axes, relative end effectors can handle coordination between branches of the robot/mechanism. Actin has tools developers can use to sequence out these motions, path planning, attachments, collision reasoning, and tool offset calculation.

Free Whitepaper: Robot Kinematic Control

This white paper describes Energid’s kinematic control software, which is part of the Actin SDK.

Actin provides generic control for kinematically redundant serial and bifurcating manipulators. It uses a patented configurable augmented Jacobian control technique that is implemented within a software framework that allows the easy creation of supervised and traded control systems using C++. Through Extensible Markup Language (XML) configuration, Energid’s system allows the accommodation of even the most complex mechanisms, multiple end-effector constraints, different optimization criteria, and control-system exchange at runtime.

Get the Whitepaper

Subscribe by Email

No Comments Yet

Let us know what you think