Telekinesis Agentic Skill Library

Appearance

Forward Kinematics ​

SUMMARY

Forward Kinematics computes the robot tool pose from a given joint configuration.

This skill is used to validate robot poses, generate Cartesian outputs from joint states, and support downstream planning and control tasks.

SUPPORTED ROBOTS

Available on all supported manipulators.

UNITS

The input joint positions q must be in degrees. The returned TCP pose is in meters for translation and Euler XYZ degrees for orientation.

The Skill ​

python
tcp_pose = robot.forward_kinematics(q=q)

The Code ​

Pass frame_name to compute FK for any configured frame (default TCP, flange, tool, etc.).

python
"""
Forward kinematics example for the Synapse SDK.

This example demonstrates how to compute the forward kinematics for a manipulator
using the Synapse SDK. The example uses the Universal Robots UR10e purely for
illustration, but supports all robot brands.

Usage:
    python forward_kinematics_example.py
"""

from telekinesis.synapse.robots.manipulators import universal_robots


def main():
    """
    Demonstrates forward kinematics computation for the Universal Robot UR10e
    """

    # Create robot instance
    robot = universal_robots.UniversalRobotsUR10E()

    q = [0, -90, 90, 0, 90, 0]
    tcp_pose = robot.forward_kinematics(q=q)
    print("TCP pose: ", tcp_pose)


if __name__ == "__main__":
    main()

The Explanation of the Code ​

Forward kinematics is the process of computing the Cartesian pose of a robot's end-effector (or any configured frame) given a specific joint configuration. In this example, we create an instance of the Universal Robots UR10e manipulator, define a joint configuration q, and call forward_kinematics to compute the corresponding TCP pose.

Create the robot.

python
from telekinesis.synapse.robots.manipulators import universal_robots

robot = universal_robots.UniversalRobotsUR10E()

The joint configuration q is a list with one value per joint, ordered from base to end-effector in degrees.

python
q = [0, -90, 90, 0, 90, 0]

forward_kinematics evaluates the kinematic chain at q, and returns the pose of the requested (or default) TCP frame in the robot's base frame. The returned pose is [x, y, z, rx, ry, rz] where translation is in meters and orientation is Euler XYZ in degrees.

python
pose = robot.forward_kinematics(q=q)

forward_kinematics validates q against the configured joint limits before evaluating. Checkout how to use the parameters in forward kinematics, and the scenarios where it's most useful, in the next sections.

How to Tune the Parameters ​

ParameterTypeDefaultDescription
qlist[float] | np.ndarray-1D joint configuration vector in degrees. Length must match the robot's DOF count.
frame_namestr | NoneNoneName of the TCP frame whose pose should be returned. None selects the currently active TCP (robot.active_tcp).
verboseboolFalseIf True, log diagnostic information when q is outside the configured joint limits.

Return Value ​

TypeDescription
np.ndarrayPose [x, y, z, rx, ry, rz] of the requested (or active) TCP frame. Translation in meters, orientation as Euler XYZ in degrees.

Where to Use the Skill ​

Forward Kinematics is commonly used in the following scenarios:

  • Pose validation - Confirm that a planned joint configuration reaches the intended Cartesian target before issuing a motion command
  • State logging and analysis - Convert recorded joint trajectories to Cartesian paths for visualization or post-processing
  • Simulation cross-checking - Verify that the kinematic model matches expected end-effector positions during development

When Not to Use the Skill ​

Do not use Forward Kinematics when:

  • You need the live end-effector pose during execution - read it directly from Get Cartesian Pose rather than computing FK on every cycle
  • The joint values are outside the configured joint limits - forward_kinematics raises ValueError. Use In Joint Limits to validate beforehand.