Simulate Industrial Robots in FreeCAD

Simulating industrial robot trajectories and pick-and-place tasks in FreeCAD requires using the dedicated Robot Workbench to model kinematic chains, define motion trajectories, and script event-driven tasks. This guide walks you through setting up a standard six-axis manipulator, creating Waypoints for the Tool Center Point (TCP), verifying reachability and collision-free paths, and using Python scripts to execute realistic pick-and-place sequences.

1. Enable the Robot Workbench and Load a Manipulator

FreeCAD includes a native Robot Workbench tailored for six-axis industrial arms such as KUKA models.

  1. Open FreeCAD and switch to the Robot workbench using the workbench dropdown menu.
  2. In the top toolbar, click Insert a Robot to choose a predefined robot model (such as a KUKA KR-16 or KR-500).
  3. FreeCAD creates a kinematic definition and loads the visual 3D mesh representation into your document tree.
  4. Position your workpiece and target bins in the 3D view using the Part Workbench or standard transform tools to define your physical environment.

2. Define Waypoints and Generate Trajectories

A robot trajectory consists of a series of spatial targets (Waypoints) that define the position and orientation of the Tool Center Point (TCP).

  1. Set the Tool Center Point: Select your robot in the tree view and assign a TCP offset under the robot's data properties if you are using an attached gripper.
  2. Create a Trajectory Object: Click Insert a Trajectory in the Robot toolbar. This creates an empty path container.
  3. Insert Waypoints:
    • Move the robot's TCP manually using the joint controllers in the Tasks panel, or align the TCP to specific geometric vertices on your pick/place objects.
    • Click Insert Waypoint to record the current position and orientation into the active trajectory.
    • Repeat this for the Home position, Pre-Pick, Pick, Retract, Pre-Place, Place, and Return steps.
  4. Trajectory Interpolation: FreeCAD automatically interpolates between these waypoints. Verify that the motion parameters (linear vs. joint-interpolated movement) and target velocities match your application needs.

3. Implement Pick-and-Place Logic

FreeCAD’s basic graphical interface simulates continuous trajectory motion, but dynamic gripping (attaching and detaching workpieces) requires using the integrated Python console.

  1. Set Up the Scene Hierarchy: Place the part to be moved inside the main document. Ensure its coordinates match the "Pick" waypoint location.
  2. Script the Attachment Event: Open the FreeCAD Python console (View > Panels > Python Console). When the trajectory reaches the "Pick" waypoint timestamp, dynamically re-parent the object to the robot end-effector:
import FreeCAD

doc = FreeCAD.ActiveDocument
robot = doc.getObject("Robot")
part = doc.getObject("Workpiece")

# Attach the workpiece to the robot end-effector link
robot.Group += [part]
doc.recompute()
  1. Script the Release Event: When the trajectory reaches the "Place" position, decouple the workpiece from the robot link and place it back into the global coordinate space:
# Detach the workpiece from the robot
robot.Group.remove(part)
part.Placement = (
    robot.Placement.multiply(robot.getLinkPlacement("Link6"))
    * part.Placement
)
doc.recompute()

4. Run and Validate the Simulation

  1. Double-click the trajectory object in the Model tree to open the trajectory control panel.
  2. Press Play to visually inspect the motion path.
  3. Observe the robot axes in the Task panel to verify that none of the six joints exceed their minimum or maximum rotation limits during the cycle.
  4. Check for singularities where the arm cannot compute an inverse kinematic solution. Adjust waypoint positions or part layouts if any joint warnings occur.

5. Export Trajectory Data

Once validated, the simulated trajectory can be exported for downstream programming:

  1. Select the trajectory object in the document tree.
  2. Click Export Trajectory in the Robot menu.
  3. Save the path as a standard robot language file (such as KUKA KRL format) for deployment or further post-processing.