Motion Primitive

A motion primitive is the smallest, indivisible unit of movement within a robot's skill library. It represents a single, parameterized action like a straight-line reach, a turning arc, or a specific grasp approach. Their atomic nature allows them to be sequenced and composed to form complex, high-level behaviors, promoting code reuse and modular system design.

• Example: A 'linear push' primitive can be reused for tasks as diverse as closing a drawer, inserting a peg, or pressing a button, simply by changing its parameters for start pose, end pose, and velocity.

Each primitive is defined by a set of parameters that instantiate it for a specific context. Common parameters include start and end poses, duration, maximum velocity/acceleration, and via-points. This parameterization separates the what (the type of movement) from the where/when (the execution context), allowing a single primitive definition to generate a vast family of specific trajectories.

• Core Parameters:
  • Geometric: Start configuration, goal pose, path shape.
  • Dynamic: Timing, velocity, acceleration profiles.
  • Contextual: Applied force, compliance, termination conditions.

A well-designed primitive is more than a geometric path; it is a dynamically feasible trajectory. It inherently respects the robot's kinematic and dynamic limits, such as joint velocity/acceleration bounds and torque constraints. This encapsulation ensures that any plan composed of valid primitives is executable by the physical hardware, bridging the gap between abstract task planning and low-level motor control.

• Key Constraint Integration:
  • Kinematic Feasibility: Adheres to the robot's reachable workspace.
  • Dynamic Feasibility: Obeys limits on speed, acceleration, and force.
  • Safety: Often includes built-in checks for self-collision and environmental limits.

By restricting the planner's search to a finite set of known-good motion segments, primitives dramatically reduce the complexity of motion planning. Instead of searching a continuous, high-dimensional action space, a hierarchical task network (HTN) or similar planner searches a discrete graph of primitives. This transforms the planning problem into a more manageable combinatorial search, enabling real-time or near-real-time performance in dynamic environments.

• Planning Benefit: Converts continuous control problem into a discrete sequence selection problem.
• Algorithm Link: Primitives are the 'edges' in graph-based planners like those using Probabilistic Roadmaps (PRM) or searched via A*.

Motion primitives provide a structured representation for learning from demonstration (LfD) and reinforcement learning (RL). In LfD, complex human demonstrations can be segmented into sequences of primitives. In RL, the action space for policy learning is defined by these primitives, which is more sample-efficient than learning low-level torque commands from scratch. This allows robots to generalize skills and adapt parameters (e.g., force, speed) based on sensory feedback.

• Learning Paradigms:
  • Imitation Learning: Demonstrations are parsed into primitive sequences.
  • Reinforcement Learning: The policy selects and parameterizes primitives.
  • Adaptation: Primitives can be modulated online using sensor feedback (e.g., increasing grip force if slippage is detected).

Because each primitive has a well-defined, bounded effect on the robot's state, they enable formal plan validation and safety verification. Engineers can pre-verify the safety and dynamic feasibility of each primitive in isolation. Consequently, any plan composed of these pre-verified blocks inherits a higher assurance of correctness, which is essential for deployment in safety-critical applications alongside humans or fragile equipment.

• Verification Advantage: Enables compositional reasoning about complex plans.
• Safety Application: Primitives can be designed with guaranteed properties, such as bounded energy or strict containment within a safe region of the configuration space.

A fundamental end-effector movement from a start configuration to a target Cartesian coordinate (x, y, z) in space. This primitive is defined by:

• Target Pose: The desired position and orientation of the gripper or tool.
• Velocity Profile: Often a trapezoidal or S-curve to ensure smooth acceleration and deceleration.
• Obstacle Avoidance: May incorporate collision checking against a known occupancy grid.

It is the core action for pick-and-place operations and is frequently solved using inverse kinematics (IK) solvers.

A constrained motion where the robot's end-effector maintains contact with an object while applying force along a straight-line vector. Key parameters include:

• Direction Vector: The axis of applied force.
• Contact Force: The magnitude of normal force to maintain stable contact.
• Trajectory Length: The distance to slide the object.

This primitive is essential for assembly tasks, such as inserting a peg into a hole or aligning a component on a workbench. It requires force-torque sensing or impedance control for successful execution.

A rotational movement, such as turning a knob or screwdriver, that accommodates physical constraints through compliance. Its definition includes:

• Rotation Axis: The centerline around which torque is applied.
• Angular Displacement: The target angle (e.g., 90° for a valve).
• Compliance Model: A stiffness or admittance parameter that allows the end-effector to yield slightly to misalignment.

This primitive is critical for tasks requiring mechanical coupling without precise fixture, preventing jamming and excessive force buildup.

A cautious approach trajectory terminated by an external sensory event rather than a pre-defined position. It is characterized by:

• Search Direction: The axis of approach.
• Termination Condition: A threshold event from a force sensor, tactile array, or proximity sensor.
• Slow Speed: A deliberately low velocity to prevent impact damage.

Commonly used for surface finding, connector mating, or tasks where the environment's exact geometry is uncertain. It is a key primitive for contact-rich manipulation.

A curved trajectory for mobile robots or robotic arms that accounts for kinodynamic constraints, such as maximum centripetal force or wheel slippage. Parameters include:

• Turning Radius: The curvature of the path.
• Velocity & Acceleration Limits: Bounds that ensure stability.
• Friction Cone Model: Constraints based on surface traction.

This is not just a geometric arc but a time-parameterized path respecting the system's dynamics. It is foundational for autonomous vehicle navigation and agile mobile robot motion.

A repeating, rhythmic motion pattern such as wiping, sanding, or stirring. It is defined by:

• Oscillation Pattern: Sine wave, sawtooth, or ellipse.
• Amplitude & Frequency: The spatial reach and speed of the cycle.
• Phase Offset: For coordinating multiple joints or end-effectors.

These primitives are often encoded as Dynamic Movement Primitives (DMPs) or Central Pattern Generators (CPGs), allowing robust, periodic execution that can be modulated in real-time.

A planning formalism that decomposes high-level tasks into a hierarchy of subtasks using a library of methods until primitive, executable actions are reached. It provides the logical structure above motion primitives.

• Key Mechanism: Uses task reduction, breaking abstract tasks (e.g., 'deliver package') into concrete actions (e.g., 'pick', 'move', 'place').
• Relation to Motion Primitives: The leaf nodes of an HTN plan are often parameterized calls to specific motion primitives from a skill library.

A curated repository of reusable, parameterized behaviors—including motion primitives—that a robot can sequence to accomplish complex tasks. It encapsulates expertise and ensures reliable execution.

• Contents: Contains primitive actions (e.g., 'turn 90°', 'grasp cylinder') and potentially more complex skills built from them.
• Engineering Benefit: Promotes code reuse, simplifies high-level planning, and allows for skill learning where new primitives are added through demonstration or optimization.

The computational process of finding a time-parameterized path that minimizes a cost function (e.g., energy, time, jerk) while satisfying dynamic constraints and avoiding collisions. It often refines or generates motion primitives.

• Methods: Includes direct collocation and Model Predictive Control (MPC).
• Input/Output: Takes a motion primitive's start/goal and constraints, outputs a smooth, dynamically-feasible trajectory specifying positions, velocities, and accelerations over time.

A mathematical representation where every possible state (configuration) of a robot is mapped to a single point. Physical obstacles become forbidden regions (C-obstacles) in this abstract space.

• Core Purpose: Simplifies motion planning by transforming the problem of moving a complex shape into moving a point through space.
• Critical for Primitives: Motion primitives are short, valid paths through free space (the complement of C-obstacles). Sampling-based planners like RRT explore C-space to connect primitives.

A class of motion planning algorithms that avoid explicit geometric modeling of obstacles by probing the configuration space with random samples. They are used to plan long-horizon paths composed of motion primitives.

• RRT (Rapidly-exploring Random Tree): Incrementally builds a space-filling tree from the start, biasing growth toward the goal. Efficient for single-query problems.
• PRM (Probabilistic Roadmap): Pre-computes a graph of collision-free configurations during a learning phase, then queries it for paths. Efficient for multi-query problems in static environments.

An advanced control method where a dynamic model of the system is used to predict future behavior over a finite horizon. It solves an online optimization problem at each time step to determine optimal control inputs, often tracking a motion primitive's trajectory.

• Real-Time Replanning: Compensates for disturbances and model inaccuracies by continuously re-optimizing from the current state.
• Connection to Primitives: MPC can be the low-level executor that takes the reference trajectory from a motion primitive and generates the actual motor commands, ensuring stability and constraint satisfaction.