Repo symbol

crx_kinematics repository

crx_kinematics crx_kinematics_py

ROS Distro
humble

Repository Summary

Checkout URI https://github.com/danielcranston/crx_kinematics.git
VCS Type git
VCS Version master
Last Updated 2026-01-23
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
crx_kinematics 0.0.0
crx_kinematics_py 0.0.0

README

crx_kinematics

[![Humble](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml) [![Jazzy](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml) [![Kilted](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml) [![Rolling](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml)

This repo hosts C++ and Python code implementing FK/IK for the Fanuc CRX series. The implementation closely follows Geometric Approach for Inverse Kinematics of the FANUC CRX Collaborative Robot by Abbes and Poisson (2024).

Compared to general optimization-based IK solvers like KDL, the implementation in this repo

  • Deterministically finds all IK solutions
  • Has near-zero dependencies (numpy+scipy for Python, Eigen for C++)
  • Is fast (C++ implementation runs in ~50 μs on a Intel Core i7-13650HX)

The approach reduces the IK problem to a 1-D search for zeros over a scalar function. See DERIVATION.md for an overview of the approach.

The C++ package also hosts a Moveit 2 Kinematics plugin that is compatible out of the box with the official Fanuc URDF descriptions.

Examples

The Python package comes with a interactive demo:

ros2 launch crx_kinematics_py demo.launch.py run_rviz:=true

In terms of API:

#include "crx_kinematics/robot.hpp"

int main(int argc, char** argv)
{
    auto robot = crx_kinematics::CRXRobot();  // Defaults to CRX-10iA
    Eigen::Isometry3d pose = robot.fk({ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 });

    std::vector<std::array<double, 6>> joint_solutions = robot.ik(pose);
}

from crx_kinematics_py.robot import CRXRobot
import numpy as np

robot = CRXRobot()  # Defaults to CRX-10iA
pose: np.ndarray = robot.fk([0.0, 0.0, 0.0, 0.0, 0.0, 0.0])

joint_solutions, debug_data = robot.ik(pose)

Moveit 2 Kinematics Plugin

To use the Moveit 2 Kinematics plugin, build the crx_kinematics package in your workspace, then edit the kinematics.yaml file of your Moveit 2 config package to use the plugin:

manipulator:
-  kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin
+  kinematics_solver: crx_kinematics/CRXKinematicsPlugin

The plugin also works with custom URDFs, provided their base and tip frames, as well as the name of the URDF, match the equivalent URDF from Fanuc.

Note that the Fanuc official driver does not yet support ROS 2 Jazzy/Kilted, so unless you’re on Humble, using the controllers provided in the Fanuc driver repo (e.g. ScaledJointTrajectoryController) will not work out of the box. Hopefully Fanuc will add support for Jazzy/Kilted soon.

Cloning and building

Using standard ROS 2 steps:

# Clone
cd ~/your_workspace/src
git clone git@github.com:danielcranston/crx_kinematics.git

# Install binary dependencies via rosdep
rosdep install --from-paths crx_kinematics --ignore-src -y

# Build
cd ~/your_workspace
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release --packages-up-to crx_kinematics crx_kinematics_py

# Test
colcon test --event-handlers console_cohesion+ --packages-select crx_kinematics crx_kinematics_py

License

MIT

Repo symbol

crx_kinematics repository

crx_kinematics crx_kinematics_py

ROS Distro
jazzy

Repository Summary

Checkout URI https://github.com/danielcranston/crx_kinematics.git
VCS Type git
VCS Version master
Last Updated 2026-01-23
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
crx_kinematics 0.0.0
crx_kinematics_py 0.0.0

README

crx_kinematics

[![Humble](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml) [![Jazzy](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml) [![Kilted](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml) [![Rolling](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml)

This repo hosts C++ and Python code implementing FK/IK for the Fanuc CRX series. The implementation closely follows Geometric Approach for Inverse Kinematics of the FANUC CRX Collaborative Robot by Abbes and Poisson (2024).

Compared to general optimization-based IK solvers like KDL, the implementation in this repo

  • Deterministically finds all IK solutions
  • Has near-zero dependencies (numpy+scipy for Python, Eigen for C++)
  • Is fast (C++ implementation runs in ~50 μs on a Intel Core i7-13650HX)

The approach reduces the IK problem to a 1-D search for zeros over a scalar function. See DERIVATION.md for an overview of the approach.

The C++ package also hosts a Moveit 2 Kinematics plugin that is compatible out of the box with the official Fanuc URDF descriptions.

Examples

The Python package comes with a interactive demo:

ros2 launch crx_kinematics_py demo.launch.py run_rviz:=true

In terms of API:

#include "crx_kinematics/robot.hpp"

int main(int argc, char** argv)
{
    auto robot = crx_kinematics::CRXRobot();  // Defaults to CRX-10iA
    Eigen::Isometry3d pose = robot.fk({ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 });

    std::vector<std::array<double, 6>> joint_solutions = robot.ik(pose);
}

from crx_kinematics_py.robot import CRXRobot
import numpy as np

robot = CRXRobot()  # Defaults to CRX-10iA
pose: np.ndarray = robot.fk([0.0, 0.0, 0.0, 0.0, 0.0, 0.0])

joint_solutions, debug_data = robot.ik(pose)

Moveit 2 Kinematics Plugin

To use the Moveit 2 Kinematics plugin, build the crx_kinematics package in your workspace, then edit the kinematics.yaml file of your Moveit 2 config package to use the plugin:

manipulator:
-  kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin
+  kinematics_solver: crx_kinematics/CRXKinematicsPlugin

The plugin also works with custom URDFs, provided their base and tip frames, as well as the name of the URDF, match the equivalent URDF from Fanuc.

Note that the Fanuc official driver does not yet support ROS 2 Jazzy/Kilted, so unless you’re on Humble, using the controllers provided in the Fanuc driver repo (e.g. ScaledJointTrajectoryController) will not work out of the box. Hopefully Fanuc will add support for Jazzy/Kilted soon.

Cloning and building

Using standard ROS 2 steps:

# Clone
cd ~/your_workspace/src
git clone git@github.com:danielcranston/crx_kinematics.git

# Install binary dependencies via rosdep
rosdep install --from-paths crx_kinematics --ignore-src -y

# Build
cd ~/your_workspace
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release --packages-up-to crx_kinematics crx_kinematics_py

# Test
colcon test --event-handlers console_cohesion+ --packages-select crx_kinematics crx_kinematics_py

License

MIT

Repo symbol

crx_kinematics repository

crx_kinematics crx_kinematics_py

ROS Distro
kilted

Repository Summary

Checkout URI https://github.com/danielcranston/crx_kinematics.git
VCS Type git
VCS Version master
Last Updated 2026-01-23
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
crx_kinematics 0.0.0
crx_kinematics_py 0.0.0

README

crx_kinematics

[![Humble](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml) [![Jazzy](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml) [![Kilted](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml) [![Rolling](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml)

This repo hosts C++ and Python code implementing FK/IK for the Fanuc CRX series. The implementation closely follows Geometric Approach for Inverse Kinematics of the FANUC CRX Collaborative Robot by Abbes and Poisson (2024).

Compared to general optimization-based IK solvers like KDL, the implementation in this repo

  • Deterministically finds all IK solutions
  • Has near-zero dependencies (numpy+scipy for Python, Eigen for C++)
  • Is fast (C++ implementation runs in ~50 μs on a Intel Core i7-13650HX)

The approach reduces the IK problem to a 1-D search for zeros over a scalar function. See DERIVATION.md for an overview of the approach.

The C++ package also hosts a Moveit 2 Kinematics plugin that is compatible out of the box with the official Fanuc URDF descriptions.

Examples

The Python package comes with a interactive demo:

ros2 launch crx_kinematics_py demo.launch.py run_rviz:=true

In terms of API:

#include "crx_kinematics/robot.hpp"

int main(int argc, char** argv)
{
    auto robot = crx_kinematics::CRXRobot();  // Defaults to CRX-10iA
    Eigen::Isometry3d pose = robot.fk({ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 });

    std::vector<std::array<double, 6>> joint_solutions = robot.ik(pose);
}

from crx_kinematics_py.robot import CRXRobot
import numpy as np

robot = CRXRobot()  # Defaults to CRX-10iA
pose: np.ndarray = robot.fk([0.0, 0.0, 0.0, 0.0, 0.0, 0.0])

joint_solutions, debug_data = robot.ik(pose)

Moveit 2 Kinematics Plugin

To use the Moveit 2 Kinematics plugin, build the crx_kinematics package in your workspace, then edit the kinematics.yaml file of your Moveit 2 config package to use the plugin:

manipulator:
-  kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin
+  kinematics_solver: crx_kinematics/CRXKinematicsPlugin

The plugin also works with custom URDFs, provided their base and tip frames, as well as the name of the URDF, match the equivalent URDF from Fanuc.

Note that the Fanuc official driver does not yet support ROS 2 Jazzy/Kilted, so unless you’re on Humble, using the controllers provided in the Fanuc driver repo (e.g. ScaledJointTrajectoryController) will not work out of the box. Hopefully Fanuc will add support for Jazzy/Kilted soon.

Cloning and building

Using standard ROS 2 steps:

# Clone
cd ~/your_workspace/src
git clone git@github.com:danielcranston/crx_kinematics.git

# Install binary dependencies via rosdep
rosdep install --from-paths crx_kinematics --ignore-src -y

# Build
cd ~/your_workspace
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release --packages-up-to crx_kinematics crx_kinematics_py

# Test
colcon test --event-handlers console_cohesion+ --packages-select crx_kinematics crx_kinematics_py

License

MIT

Repo symbol

crx_kinematics repository

crx_kinematics crx_kinematics_py

ROS Distro
rolling

Repository Summary

Checkout URI https://github.com/danielcranston/crx_kinematics.git
VCS Type git
VCS Version master
Last Updated 2026-01-23
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
crx_kinematics 0.0.0
crx_kinematics_py 0.0.0

README

crx_kinematics

[![Humble](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml) [![Jazzy](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml) [![Kilted](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml) [![Rolling](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml)

This repo hosts C++ and Python code implementing FK/IK for the Fanuc CRX series. The implementation closely follows Geometric Approach for Inverse Kinematics of the FANUC CRX Collaborative Robot by Abbes and Poisson (2024).

Compared to general optimization-based IK solvers like KDL, the implementation in this repo

  • Deterministically finds all IK solutions
  • Has near-zero dependencies (numpy+scipy for Python, Eigen for C++)
  • Is fast (C++ implementation runs in ~50 μs on a Intel Core i7-13650HX)

The approach reduces the IK problem to a 1-D search for zeros over a scalar function. See DERIVATION.md for an overview of the approach.

The C++ package also hosts a Moveit 2 Kinematics plugin that is compatible out of the box with the official Fanuc URDF descriptions.

Examples

The Python package comes with a interactive demo:

ros2 launch crx_kinematics_py demo.launch.py run_rviz:=true

In terms of API:

#include "crx_kinematics/robot.hpp"

int main(int argc, char** argv)
{
    auto robot = crx_kinematics::CRXRobot();  // Defaults to CRX-10iA
    Eigen::Isometry3d pose = robot.fk({ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 });

    std::vector<std::array<double, 6>> joint_solutions = robot.ik(pose);
}

from crx_kinematics_py.robot import CRXRobot
import numpy as np

robot = CRXRobot()  # Defaults to CRX-10iA
pose: np.ndarray = robot.fk([0.0, 0.0, 0.0, 0.0, 0.0, 0.0])

joint_solutions, debug_data = robot.ik(pose)

Moveit 2 Kinematics Plugin

To use the Moveit 2 Kinematics plugin, build the crx_kinematics package in your workspace, then edit the kinematics.yaml file of your Moveit 2 config package to use the plugin:

manipulator:
-  kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin
+  kinematics_solver: crx_kinematics/CRXKinematicsPlugin

The plugin also works with custom URDFs, provided their base and tip frames, as well as the name of the URDF, match the equivalent URDF from Fanuc.

Note that the Fanuc official driver does not yet support ROS 2 Jazzy/Kilted, so unless you’re on Humble, using the controllers provided in the Fanuc driver repo (e.g. ScaledJointTrajectoryController) will not work out of the box. Hopefully Fanuc will add support for Jazzy/Kilted soon.

Cloning and building

Using standard ROS 2 steps:

# Clone
cd ~/your_workspace/src
git clone git@github.com:danielcranston/crx_kinematics.git

# Install binary dependencies via rosdep
rosdep install --from-paths crx_kinematics --ignore-src -y

# Build
cd ~/your_workspace
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release --packages-up-to crx_kinematics crx_kinematics_py

# Test
colcon test --event-handlers console_cohesion+ --packages-select crx_kinematics crx_kinematics_py

License

MIT

No version for distro ardent showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

crx_kinematics repository

crx_kinematics crx_kinematics_py

ROS Distro
humble

Repository Summary

Checkout URI https://github.com/danielcranston/crx_kinematics.git
VCS Type git
VCS Version master
Last Updated 2026-01-23
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
crx_kinematics 0.0.0
crx_kinematics_py 0.0.0

README

crx_kinematics

[![Humble](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml) [![Jazzy](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml) [![Kilted](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml) [![Rolling](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml)

This repo hosts C++ and Python code implementing FK/IK for the Fanuc CRX series. The implementation closely follows Geometric Approach for Inverse Kinematics of the FANUC CRX Collaborative Robot by Abbes and Poisson (2024).

Compared to general optimization-based IK solvers like KDL, the implementation in this repo

  • Deterministically finds all IK solutions
  • Has near-zero dependencies (numpy+scipy for Python, Eigen for C++)
  • Is fast (C++ implementation runs in ~50 μs on a Intel Core i7-13650HX)

The approach reduces the IK problem to a 1-D search for zeros over a scalar function. See DERIVATION.md for an overview of the approach.

The C++ package also hosts a Moveit 2 Kinematics plugin that is compatible out of the box with the official Fanuc URDF descriptions.

Examples

The Python package comes with a interactive demo:

ros2 launch crx_kinematics_py demo.launch.py run_rviz:=true

In terms of API:

#include "crx_kinematics/robot.hpp"

int main(int argc, char** argv)
{
    auto robot = crx_kinematics::CRXRobot();  // Defaults to CRX-10iA
    Eigen::Isometry3d pose = robot.fk({ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 });

    std::vector<std::array<double, 6>> joint_solutions = robot.ik(pose);
}

from crx_kinematics_py.robot import CRXRobot
import numpy as np

robot = CRXRobot()  # Defaults to CRX-10iA
pose: np.ndarray = robot.fk([0.0, 0.0, 0.0, 0.0, 0.0, 0.0])

joint_solutions, debug_data = robot.ik(pose)

Moveit 2 Kinematics Plugin

To use the Moveit 2 Kinematics plugin, build the crx_kinematics package in your workspace, then edit the kinematics.yaml file of your Moveit 2 config package to use the plugin:

manipulator:
-  kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin
+  kinematics_solver: crx_kinematics/CRXKinematicsPlugin

The plugin also works with custom URDFs, provided their base and tip frames, as well as the name of the URDF, match the equivalent URDF from Fanuc.

Note that the Fanuc official driver does not yet support ROS 2 Jazzy/Kilted, so unless you’re on Humble, using the controllers provided in the Fanuc driver repo (e.g. ScaledJointTrajectoryController) will not work out of the box. Hopefully Fanuc will add support for Jazzy/Kilted soon.

Cloning and building

Using standard ROS 2 steps:

# Clone
cd ~/your_workspace/src
git clone git@github.com:danielcranston/crx_kinematics.git

# Install binary dependencies via rosdep
rosdep install --from-paths crx_kinematics --ignore-src -y

# Build
cd ~/your_workspace
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release --packages-up-to crx_kinematics crx_kinematics_py

# Test
colcon test --event-handlers console_cohesion+ --packages-select crx_kinematics crx_kinematics_py

License

MIT

No version for distro bouncy showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

crx_kinematics repository

crx_kinematics crx_kinematics_py

ROS Distro
humble

Repository Summary

Checkout URI https://github.com/danielcranston/crx_kinematics.git
VCS Type git
VCS Version master
Last Updated 2026-01-23
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
crx_kinematics 0.0.0
crx_kinematics_py 0.0.0

README

crx_kinematics

[![Humble](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml) [![Jazzy](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml) [![Kilted](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml) [![Rolling](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml)

This repo hosts C++ and Python code implementing FK/IK for the Fanuc CRX series. The implementation closely follows Geometric Approach for Inverse Kinematics of the FANUC CRX Collaborative Robot by Abbes and Poisson (2024).

Compared to general optimization-based IK solvers like KDL, the implementation in this repo

  • Deterministically finds all IK solutions
  • Has near-zero dependencies (numpy+scipy for Python, Eigen for C++)
  • Is fast (C++ implementation runs in ~50 μs on a Intel Core i7-13650HX)

The approach reduces the IK problem to a 1-D search for zeros over a scalar function. See DERIVATION.md for an overview of the approach.

The C++ package also hosts a Moveit 2 Kinematics plugin that is compatible out of the box with the official Fanuc URDF descriptions.

Examples

The Python package comes with a interactive demo:

ros2 launch crx_kinematics_py demo.launch.py run_rviz:=true

In terms of API:

#include "crx_kinematics/robot.hpp"

int main(int argc, char** argv)
{
    auto robot = crx_kinematics::CRXRobot();  // Defaults to CRX-10iA
    Eigen::Isometry3d pose = robot.fk({ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 });

    std::vector<std::array<double, 6>> joint_solutions = robot.ik(pose);
}

from crx_kinematics_py.robot import CRXRobot
import numpy as np

robot = CRXRobot()  # Defaults to CRX-10iA
pose: np.ndarray = robot.fk([0.0, 0.0, 0.0, 0.0, 0.0, 0.0])

joint_solutions, debug_data = robot.ik(pose)

Moveit 2 Kinematics Plugin

To use the Moveit 2 Kinematics plugin, build the crx_kinematics package in your workspace, then edit the kinematics.yaml file of your Moveit 2 config package to use the plugin:

manipulator:
-  kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin
+  kinematics_solver: crx_kinematics/CRXKinematicsPlugin

The plugin also works with custom URDFs, provided their base and tip frames, as well as the name of the URDF, match the equivalent URDF from Fanuc.

Note that the Fanuc official driver does not yet support ROS 2 Jazzy/Kilted, so unless you’re on Humble, using the controllers provided in the Fanuc driver repo (e.g. ScaledJointTrajectoryController) will not work out of the box. Hopefully Fanuc will add support for Jazzy/Kilted soon.

Cloning and building

Using standard ROS 2 steps:

# Clone
cd ~/your_workspace/src
git clone git@github.com:danielcranston/crx_kinematics.git

# Install binary dependencies via rosdep
rosdep install --from-paths crx_kinematics --ignore-src -y

# Build
cd ~/your_workspace
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release --packages-up-to crx_kinematics crx_kinematics_py

# Test
colcon test --event-handlers console_cohesion+ --packages-select crx_kinematics crx_kinematics_py

License

MIT

No version for distro crystal showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

crx_kinematics repository

crx_kinematics crx_kinematics_py

ROS Distro
humble

Repository Summary

Checkout URI https://github.com/danielcranston/crx_kinematics.git
VCS Type git
VCS Version master
Last Updated 2026-01-23
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
crx_kinematics 0.0.0
crx_kinematics_py 0.0.0

README

crx_kinematics

[![Humble](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml) [![Jazzy](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml) [![Kilted](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml) [![Rolling](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml)

This repo hosts C++ and Python code implementing FK/IK for the Fanuc CRX series. The implementation closely follows Geometric Approach for Inverse Kinematics of the FANUC CRX Collaborative Robot by Abbes and Poisson (2024).

Compared to general optimization-based IK solvers like KDL, the implementation in this repo

  • Deterministically finds all IK solutions
  • Has near-zero dependencies (numpy+scipy for Python, Eigen for C++)
  • Is fast (C++ implementation runs in ~50 μs on a Intel Core i7-13650HX)

The approach reduces the IK problem to a 1-D search for zeros over a scalar function. See DERIVATION.md for an overview of the approach.

The C++ package also hosts a Moveit 2 Kinematics plugin that is compatible out of the box with the official Fanuc URDF descriptions.

Examples

The Python package comes with a interactive demo:

ros2 launch crx_kinematics_py demo.launch.py run_rviz:=true

In terms of API:

#include "crx_kinematics/robot.hpp"

int main(int argc, char** argv)
{
    auto robot = crx_kinematics::CRXRobot();  // Defaults to CRX-10iA
    Eigen::Isometry3d pose = robot.fk({ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 });

    std::vector<std::array<double, 6>> joint_solutions = robot.ik(pose);
}

from crx_kinematics_py.robot import CRXRobot
import numpy as np

robot = CRXRobot()  # Defaults to CRX-10iA
pose: np.ndarray = robot.fk([0.0, 0.0, 0.0, 0.0, 0.0, 0.0])

joint_solutions, debug_data = robot.ik(pose)

Moveit 2 Kinematics Plugin

To use the Moveit 2 Kinematics plugin, build the crx_kinematics package in your workspace, then edit the kinematics.yaml file of your Moveit 2 config package to use the plugin:

manipulator:
-  kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin
+  kinematics_solver: crx_kinematics/CRXKinematicsPlugin

The plugin also works with custom URDFs, provided their base and tip frames, as well as the name of the URDF, match the equivalent URDF from Fanuc.

Note that the Fanuc official driver does not yet support ROS 2 Jazzy/Kilted, so unless you’re on Humble, using the controllers provided in the Fanuc driver repo (e.g. ScaledJointTrajectoryController) will not work out of the box. Hopefully Fanuc will add support for Jazzy/Kilted soon.

Cloning and building

Using standard ROS 2 steps:

# Clone
cd ~/your_workspace/src
git clone git@github.com:danielcranston/crx_kinematics.git

# Install binary dependencies via rosdep
rosdep install --from-paths crx_kinematics --ignore-src -y

# Build
cd ~/your_workspace
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release --packages-up-to crx_kinematics crx_kinematics_py

# Test
colcon test --event-handlers console_cohesion+ --packages-select crx_kinematics crx_kinematics_py

License

MIT

No version for distro eloquent showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

crx_kinematics repository

crx_kinematics crx_kinematics_py

ROS Distro
humble

Repository Summary

Checkout URI https://github.com/danielcranston/crx_kinematics.git
VCS Type git
VCS Version master
Last Updated 2026-01-23
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
crx_kinematics 0.0.0
crx_kinematics_py 0.0.0

README

crx_kinematics

[![Humble](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml) [![Jazzy](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml) [![Kilted](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml) [![Rolling](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml)

This repo hosts C++ and Python code implementing FK/IK for the Fanuc CRX series. The implementation closely follows Geometric Approach for Inverse Kinematics of the FANUC CRX Collaborative Robot by Abbes and Poisson (2024).

Compared to general optimization-based IK solvers like KDL, the implementation in this repo

  • Deterministically finds all IK solutions
  • Has near-zero dependencies (numpy+scipy for Python, Eigen for C++)
  • Is fast (C++ implementation runs in ~50 μs on a Intel Core i7-13650HX)

The approach reduces the IK problem to a 1-D search for zeros over a scalar function. See DERIVATION.md for an overview of the approach.

The C++ package also hosts a Moveit 2 Kinematics plugin that is compatible out of the box with the official Fanuc URDF descriptions.

Examples

The Python package comes with a interactive demo:

ros2 launch crx_kinematics_py demo.launch.py run_rviz:=true

In terms of API:

#include "crx_kinematics/robot.hpp"

int main(int argc, char** argv)
{
    auto robot = crx_kinematics::CRXRobot();  // Defaults to CRX-10iA
    Eigen::Isometry3d pose = robot.fk({ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 });

    std::vector<std::array<double, 6>> joint_solutions = robot.ik(pose);
}

from crx_kinematics_py.robot import CRXRobot
import numpy as np

robot = CRXRobot()  # Defaults to CRX-10iA
pose: np.ndarray = robot.fk([0.0, 0.0, 0.0, 0.0, 0.0, 0.0])

joint_solutions, debug_data = robot.ik(pose)

Moveit 2 Kinematics Plugin

To use the Moveit 2 Kinematics plugin, build the crx_kinematics package in your workspace, then edit the kinematics.yaml file of your Moveit 2 config package to use the plugin:

manipulator:
-  kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin
+  kinematics_solver: crx_kinematics/CRXKinematicsPlugin

The plugin also works with custom URDFs, provided their base and tip frames, as well as the name of the URDF, match the equivalent URDF from Fanuc.

Note that the Fanuc official driver does not yet support ROS 2 Jazzy/Kilted, so unless you’re on Humble, using the controllers provided in the Fanuc driver repo (e.g. ScaledJointTrajectoryController) will not work out of the box. Hopefully Fanuc will add support for Jazzy/Kilted soon.

Cloning and building

Using standard ROS 2 steps:

# Clone
cd ~/your_workspace/src
git clone git@github.com:danielcranston/crx_kinematics.git

# Install binary dependencies via rosdep
rosdep install --from-paths crx_kinematics --ignore-src -y

# Build
cd ~/your_workspace
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release --packages-up-to crx_kinematics crx_kinematics_py

# Test
colcon test --event-handlers console_cohesion+ --packages-select crx_kinematics crx_kinematics_py

License

MIT

No version for distro dashing showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

crx_kinematics repository

crx_kinematics crx_kinematics_py

ROS Distro
humble

Repository Summary

Checkout URI https://github.com/danielcranston/crx_kinematics.git
VCS Type git
VCS Version master
Last Updated 2026-01-23
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
crx_kinematics 0.0.0
crx_kinematics_py 0.0.0

README

crx_kinematics

[![Humble](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml) [![Jazzy](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml) [![Kilted](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml) [![Rolling](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml)

This repo hosts C++ and Python code implementing FK/IK for the Fanuc CRX series. The implementation closely follows Geometric Approach for Inverse Kinematics of the FANUC CRX Collaborative Robot by Abbes and Poisson (2024).

Compared to general optimization-based IK solvers like KDL, the implementation in this repo

  • Deterministically finds all IK solutions
  • Has near-zero dependencies (numpy+scipy for Python, Eigen for C++)
  • Is fast (C++ implementation runs in ~50 μs on a Intel Core i7-13650HX)

The approach reduces the IK problem to a 1-D search for zeros over a scalar function. See DERIVATION.md for an overview of the approach.

The C++ package also hosts a Moveit 2 Kinematics plugin that is compatible out of the box with the official Fanuc URDF descriptions.

Examples

The Python package comes with a interactive demo:

ros2 launch crx_kinematics_py demo.launch.py run_rviz:=true

In terms of API:

#include "crx_kinematics/robot.hpp"

int main(int argc, char** argv)
{
    auto robot = crx_kinematics::CRXRobot();  // Defaults to CRX-10iA
    Eigen::Isometry3d pose = robot.fk({ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 });

    std::vector<std::array<double, 6>> joint_solutions = robot.ik(pose);
}

from crx_kinematics_py.robot import CRXRobot
import numpy as np

robot = CRXRobot()  # Defaults to CRX-10iA
pose: np.ndarray = robot.fk([0.0, 0.0, 0.0, 0.0, 0.0, 0.0])

joint_solutions, debug_data = robot.ik(pose)

Moveit 2 Kinematics Plugin

To use the Moveit 2 Kinematics plugin, build the crx_kinematics package in your workspace, then edit the kinematics.yaml file of your Moveit 2 config package to use the plugin:

manipulator:
-  kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin
+  kinematics_solver: crx_kinematics/CRXKinematicsPlugin

The plugin also works with custom URDFs, provided their base and tip frames, as well as the name of the URDF, match the equivalent URDF from Fanuc.

Note that the Fanuc official driver does not yet support ROS 2 Jazzy/Kilted, so unless you’re on Humble, using the controllers provided in the Fanuc driver repo (e.g. ScaledJointTrajectoryController) will not work out of the box. Hopefully Fanuc will add support for Jazzy/Kilted soon.

Cloning and building

Using standard ROS 2 steps:

# Clone
cd ~/your_workspace/src
git clone git@github.com:danielcranston/crx_kinematics.git

# Install binary dependencies via rosdep
rosdep install --from-paths crx_kinematics --ignore-src -y

# Build
cd ~/your_workspace
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release --packages-up-to crx_kinematics crx_kinematics_py

# Test
colcon test --event-handlers console_cohesion+ --packages-select crx_kinematics crx_kinematics_py

License

MIT

No version for distro galactic showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

crx_kinematics repository

crx_kinematics crx_kinematics_py

ROS Distro
humble

Repository Summary

Checkout URI https://github.com/danielcranston/crx_kinematics.git
VCS Type git
VCS Version master
Last Updated 2026-01-23
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
crx_kinematics 0.0.0
crx_kinematics_py 0.0.0

README

crx_kinematics

[![Humble](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml) [![Jazzy](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml) [![Kilted](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml) [![Rolling](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml)

This repo hosts C++ and Python code implementing FK/IK for the Fanuc CRX series. The implementation closely follows Geometric Approach for Inverse Kinematics of the FANUC CRX Collaborative Robot by Abbes and Poisson (2024).

Compared to general optimization-based IK solvers like KDL, the implementation in this repo

  • Deterministically finds all IK solutions
  • Has near-zero dependencies (numpy+scipy for Python, Eigen for C++)
  • Is fast (C++ implementation runs in ~50 μs on a Intel Core i7-13650HX)

The approach reduces the IK problem to a 1-D search for zeros over a scalar function. See DERIVATION.md for an overview of the approach.

The C++ package also hosts a Moveit 2 Kinematics plugin that is compatible out of the box with the official Fanuc URDF descriptions.

Examples

The Python package comes with a interactive demo:

ros2 launch crx_kinematics_py demo.launch.py run_rviz:=true

In terms of API:

#include "crx_kinematics/robot.hpp"

int main(int argc, char** argv)
{
    auto robot = crx_kinematics::CRXRobot();  // Defaults to CRX-10iA
    Eigen::Isometry3d pose = robot.fk({ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 });

    std::vector<std::array<double, 6>> joint_solutions = robot.ik(pose);
}

from crx_kinematics_py.robot import CRXRobot
import numpy as np

robot = CRXRobot()  # Defaults to CRX-10iA
pose: np.ndarray = robot.fk([0.0, 0.0, 0.0, 0.0, 0.0, 0.0])

joint_solutions, debug_data = robot.ik(pose)

Moveit 2 Kinematics Plugin

To use the Moveit 2 Kinematics plugin, build the crx_kinematics package in your workspace, then edit the kinematics.yaml file of your Moveit 2 config package to use the plugin:

manipulator:
-  kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin
+  kinematics_solver: crx_kinematics/CRXKinematicsPlugin

The plugin also works with custom URDFs, provided their base and tip frames, as well as the name of the URDF, match the equivalent URDF from Fanuc.

Note that the Fanuc official driver does not yet support ROS 2 Jazzy/Kilted, so unless you’re on Humble, using the controllers provided in the Fanuc driver repo (e.g. ScaledJointTrajectoryController) will not work out of the box. Hopefully Fanuc will add support for Jazzy/Kilted soon.

Cloning and building

Using standard ROS 2 steps:

# Clone
cd ~/your_workspace/src
git clone git@github.com:danielcranston/crx_kinematics.git

# Install binary dependencies via rosdep
rosdep install --from-paths crx_kinematics --ignore-src -y

# Build
cd ~/your_workspace
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release --packages-up-to crx_kinematics crx_kinematics_py

# Test
colcon test --event-handlers console_cohesion+ --packages-select crx_kinematics crx_kinematics_py

License

MIT

No version for distro foxy showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

crx_kinematics repository

crx_kinematics crx_kinematics_py

ROS Distro
humble

Repository Summary

Checkout URI https://github.com/danielcranston/crx_kinematics.git
VCS Type git
VCS Version master
Last Updated 2026-01-23
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
crx_kinematics 0.0.0
crx_kinematics_py 0.0.0

README

crx_kinematics

[![Humble](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml) [![Jazzy](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml) [![Kilted](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml) [![Rolling](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml)

This repo hosts C++ and Python code implementing FK/IK for the Fanuc CRX series. The implementation closely follows Geometric Approach for Inverse Kinematics of the FANUC CRX Collaborative Robot by Abbes and Poisson (2024).

Compared to general optimization-based IK solvers like KDL, the implementation in this repo

  • Deterministically finds all IK solutions
  • Has near-zero dependencies (numpy+scipy for Python, Eigen for C++)
  • Is fast (C++ implementation runs in ~50 μs on a Intel Core i7-13650HX)

The approach reduces the IK problem to a 1-D search for zeros over a scalar function. See DERIVATION.md for an overview of the approach.

The C++ package also hosts a Moveit 2 Kinematics plugin that is compatible out of the box with the official Fanuc URDF descriptions.

Examples

The Python package comes with a interactive demo:

ros2 launch crx_kinematics_py demo.launch.py run_rviz:=true

In terms of API:

#include "crx_kinematics/robot.hpp"

int main(int argc, char** argv)
{
    auto robot = crx_kinematics::CRXRobot();  // Defaults to CRX-10iA
    Eigen::Isometry3d pose = robot.fk({ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 });

    std::vector<std::array<double, 6>> joint_solutions = robot.ik(pose);
}

from crx_kinematics_py.robot import CRXRobot
import numpy as np

robot = CRXRobot()  # Defaults to CRX-10iA
pose: np.ndarray = robot.fk([0.0, 0.0, 0.0, 0.0, 0.0, 0.0])

joint_solutions, debug_data = robot.ik(pose)

Moveit 2 Kinematics Plugin

To use the Moveit 2 Kinematics plugin, build the crx_kinematics package in your workspace, then edit the kinematics.yaml file of your Moveit 2 config package to use the plugin:

manipulator:
-  kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin
+  kinematics_solver: crx_kinematics/CRXKinematicsPlugin

The plugin also works with custom URDFs, provided their base and tip frames, as well as the name of the URDF, match the equivalent URDF from Fanuc.

Note that the Fanuc official driver does not yet support ROS 2 Jazzy/Kilted, so unless you’re on Humble, using the controllers provided in the Fanuc driver repo (e.g. ScaledJointTrajectoryController) will not work out of the box. Hopefully Fanuc will add support for Jazzy/Kilted soon.

Cloning and building

Using standard ROS 2 steps:

# Clone
cd ~/your_workspace/src
git clone git@github.com:danielcranston/crx_kinematics.git

# Install binary dependencies via rosdep
rosdep install --from-paths crx_kinematics --ignore-src -y

# Build
cd ~/your_workspace
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release --packages-up-to crx_kinematics crx_kinematics_py

# Test
colcon test --event-handlers console_cohesion+ --packages-select crx_kinematics crx_kinematics_py

License

MIT

No version for distro iron showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

crx_kinematics repository

crx_kinematics crx_kinematics_py

ROS Distro
humble

Repository Summary

Checkout URI https://github.com/danielcranston/crx_kinematics.git
VCS Type git
VCS Version master
Last Updated 2026-01-23
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
crx_kinematics 0.0.0
crx_kinematics_py 0.0.0

README

crx_kinematics

[![Humble](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml) [![Jazzy](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml) [![Kilted](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml) [![Rolling](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml)

This repo hosts C++ and Python code implementing FK/IK for the Fanuc CRX series. The implementation closely follows Geometric Approach for Inverse Kinematics of the FANUC CRX Collaborative Robot by Abbes and Poisson (2024).

Compared to general optimization-based IK solvers like KDL, the implementation in this repo

  • Deterministically finds all IK solutions
  • Has near-zero dependencies (numpy+scipy for Python, Eigen for C++)
  • Is fast (C++ implementation runs in ~50 μs on a Intel Core i7-13650HX)

The approach reduces the IK problem to a 1-D search for zeros over a scalar function. See DERIVATION.md for an overview of the approach.

The C++ package also hosts a Moveit 2 Kinematics plugin that is compatible out of the box with the official Fanuc URDF descriptions.

Examples

The Python package comes with a interactive demo:

ros2 launch crx_kinematics_py demo.launch.py run_rviz:=true

In terms of API:

#include "crx_kinematics/robot.hpp"

int main(int argc, char** argv)
{
    auto robot = crx_kinematics::CRXRobot();  // Defaults to CRX-10iA
    Eigen::Isometry3d pose = robot.fk({ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 });

    std::vector<std::array<double, 6>> joint_solutions = robot.ik(pose);
}

from crx_kinematics_py.robot import CRXRobot
import numpy as np

robot = CRXRobot()  # Defaults to CRX-10iA
pose: np.ndarray = robot.fk([0.0, 0.0, 0.0, 0.0, 0.0, 0.0])

joint_solutions, debug_data = robot.ik(pose)

Moveit 2 Kinematics Plugin

To use the Moveit 2 Kinematics plugin, build the crx_kinematics package in your workspace, then edit the kinematics.yaml file of your Moveit 2 config package to use the plugin:

manipulator:
-  kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin
+  kinematics_solver: crx_kinematics/CRXKinematicsPlugin

The plugin also works with custom URDFs, provided their base and tip frames, as well as the name of the URDF, match the equivalent URDF from Fanuc.

Note that the Fanuc official driver does not yet support ROS 2 Jazzy/Kilted, so unless you’re on Humble, using the controllers provided in the Fanuc driver repo (e.g. ScaledJointTrajectoryController) will not work out of the box. Hopefully Fanuc will add support for Jazzy/Kilted soon.

Cloning and building

Using standard ROS 2 steps:

# Clone
cd ~/your_workspace/src
git clone git@github.com:danielcranston/crx_kinematics.git

# Install binary dependencies via rosdep
rosdep install --from-paths crx_kinematics --ignore-src -y

# Build
cd ~/your_workspace
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release --packages-up-to crx_kinematics crx_kinematics_py

# Test
colcon test --event-handlers console_cohesion+ --packages-select crx_kinematics crx_kinematics_py

License

MIT

No version for distro lunar showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

crx_kinematics repository

crx_kinematics crx_kinematics_py

ROS Distro
humble

Repository Summary

Checkout URI https://github.com/danielcranston/crx_kinematics.git
VCS Type git
VCS Version master
Last Updated 2026-01-23
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
crx_kinematics 0.0.0
crx_kinematics_py 0.0.0

README

crx_kinematics

[![Humble](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml) [![Jazzy](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml) [![Kilted](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml) [![Rolling](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml)

This repo hosts C++ and Python code implementing FK/IK for the Fanuc CRX series. The implementation closely follows Geometric Approach for Inverse Kinematics of the FANUC CRX Collaborative Robot by Abbes and Poisson (2024).

Compared to general optimization-based IK solvers like KDL, the implementation in this repo

  • Deterministically finds all IK solutions
  • Has near-zero dependencies (numpy+scipy for Python, Eigen for C++)
  • Is fast (C++ implementation runs in ~50 μs on a Intel Core i7-13650HX)

The approach reduces the IK problem to a 1-D search for zeros over a scalar function. See DERIVATION.md for an overview of the approach.

The C++ package also hosts a Moveit 2 Kinematics plugin that is compatible out of the box with the official Fanuc URDF descriptions.

Examples

The Python package comes with a interactive demo:

ros2 launch crx_kinematics_py demo.launch.py run_rviz:=true

In terms of API:

#include "crx_kinematics/robot.hpp"

int main(int argc, char** argv)
{
    auto robot = crx_kinematics::CRXRobot();  // Defaults to CRX-10iA
    Eigen::Isometry3d pose = robot.fk({ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 });

    std::vector<std::array<double, 6>> joint_solutions = robot.ik(pose);
}

from crx_kinematics_py.robot import CRXRobot
import numpy as np

robot = CRXRobot()  # Defaults to CRX-10iA
pose: np.ndarray = robot.fk([0.0, 0.0, 0.0, 0.0, 0.0, 0.0])

joint_solutions, debug_data = robot.ik(pose)

Moveit 2 Kinematics Plugin

To use the Moveit 2 Kinematics plugin, build the crx_kinematics package in your workspace, then edit the kinematics.yaml file of your Moveit 2 config package to use the plugin:

manipulator:
-  kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin
+  kinematics_solver: crx_kinematics/CRXKinematicsPlugin

The plugin also works with custom URDFs, provided their base and tip frames, as well as the name of the URDF, match the equivalent URDF from Fanuc.

Note that the Fanuc official driver does not yet support ROS 2 Jazzy/Kilted, so unless you’re on Humble, using the controllers provided in the Fanuc driver repo (e.g. ScaledJointTrajectoryController) will not work out of the box. Hopefully Fanuc will add support for Jazzy/Kilted soon.

Cloning and building

Using standard ROS 2 steps:

# Clone
cd ~/your_workspace/src
git clone git@github.com:danielcranston/crx_kinematics.git

# Install binary dependencies via rosdep
rosdep install --from-paths crx_kinematics --ignore-src -y

# Build
cd ~/your_workspace
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release --packages-up-to crx_kinematics crx_kinematics_py

# Test
colcon test --event-handlers console_cohesion+ --packages-select crx_kinematics crx_kinematics_py

License

MIT

No version for distro jade showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

crx_kinematics repository

crx_kinematics crx_kinematics_py

ROS Distro
humble

Repository Summary

Checkout URI https://github.com/danielcranston/crx_kinematics.git
VCS Type git
VCS Version master
Last Updated 2026-01-23
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
crx_kinematics 0.0.0
crx_kinematics_py 0.0.0

README

crx_kinematics

[![Humble](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml) [![Jazzy](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml) [![Kilted](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml) [![Rolling](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml)

This repo hosts C++ and Python code implementing FK/IK for the Fanuc CRX series. The implementation closely follows Geometric Approach for Inverse Kinematics of the FANUC CRX Collaborative Robot by Abbes and Poisson (2024).

Compared to general optimization-based IK solvers like KDL, the implementation in this repo

  • Deterministically finds all IK solutions
  • Has near-zero dependencies (numpy+scipy for Python, Eigen for C++)
  • Is fast (C++ implementation runs in ~50 μs on a Intel Core i7-13650HX)

The approach reduces the IK problem to a 1-D search for zeros over a scalar function. See DERIVATION.md for an overview of the approach.

The C++ package also hosts a Moveit 2 Kinematics plugin that is compatible out of the box with the official Fanuc URDF descriptions.

Examples

The Python package comes with a interactive demo:

ros2 launch crx_kinematics_py demo.launch.py run_rviz:=true

In terms of API:

#include "crx_kinematics/robot.hpp"

int main(int argc, char** argv)
{
    auto robot = crx_kinematics::CRXRobot();  // Defaults to CRX-10iA
    Eigen::Isometry3d pose = robot.fk({ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 });

    std::vector<std::array<double, 6>> joint_solutions = robot.ik(pose);
}

from crx_kinematics_py.robot import CRXRobot
import numpy as np

robot = CRXRobot()  # Defaults to CRX-10iA
pose: np.ndarray = robot.fk([0.0, 0.0, 0.0, 0.0, 0.0, 0.0])

joint_solutions, debug_data = robot.ik(pose)

Moveit 2 Kinematics Plugin

To use the Moveit 2 Kinematics plugin, build the crx_kinematics package in your workspace, then edit the kinematics.yaml file of your Moveit 2 config package to use the plugin:

manipulator:
-  kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin
+  kinematics_solver: crx_kinematics/CRXKinematicsPlugin

The plugin also works with custom URDFs, provided their base and tip frames, as well as the name of the URDF, match the equivalent URDF from Fanuc.

Note that the Fanuc official driver does not yet support ROS 2 Jazzy/Kilted, so unless you’re on Humble, using the controllers provided in the Fanuc driver repo (e.g. ScaledJointTrajectoryController) will not work out of the box. Hopefully Fanuc will add support for Jazzy/Kilted soon.

Cloning and building

Using standard ROS 2 steps:

# Clone
cd ~/your_workspace/src
git clone git@github.com:danielcranston/crx_kinematics.git

# Install binary dependencies via rosdep
rosdep install --from-paths crx_kinematics --ignore-src -y

# Build
cd ~/your_workspace
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release --packages-up-to crx_kinematics crx_kinematics_py

# Test
colcon test --event-handlers console_cohesion+ --packages-select crx_kinematics crx_kinematics_py

License

MIT

No version for distro indigo showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

crx_kinematics repository

crx_kinematics crx_kinematics_py

ROS Distro
humble

Repository Summary

Checkout URI https://github.com/danielcranston/crx_kinematics.git
VCS Type git
VCS Version master
Last Updated 2026-01-23
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
crx_kinematics 0.0.0
crx_kinematics_py 0.0.0

README

crx_kinematics

[![Humble](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml) [![Jazzy](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml) [![Kilted](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml) [![Rolling](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml)

This repo hosts C++ and Python code implementing FK/IK for the Fanuc CRX series. The implementation closely follows Geometric Approach for Inverse Kinematics of the FANUC CRX Collaborative Robot by Abbes and Poisson (2024).

Compared to general optimization-based IK solvers like KDL, the implementation in this repo

  • Deterministically finds all IK solutions
  • Has near-zero dependencies (numpy+scipy for Python, Eigen for C++)
  • Is fast (C++ implementation runs in ~50 μs on a Intel Core i7-13650HX)

The approach reduces the IK problem to a 1-D search for zeros over a scalar function. See DERIVATION.md for an overview of the approach.

The C++ package also hosts a Moveit 2 Kinematics plugin that is compatible out of the box with the official Fanuc URDF descriptions.

Examples

The Python package comes with a interactive demo:

ros2 launch crx_kinematics_py demo.launch.py run_rviz:=true

In terms of API:

#include "crx_kinematics/robot.hpp"

int main(int argc, char** argv)
{
    auto robot = crx_kinematics::CRXRobot();  // Defaults to CRX-10iA
    Eigen::Isometry3d pose = robot.fk({ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 });

    std::vector<std::array<double, 6>> joint_solutions = robot.ik(pose);
}

from crx_kinematics_py.robot import CRXRobot
import numpy as np

robot = CRXRobot()  # Defaults to CRX-10iA
pose: np.ndarray = robot.fk([0.0, 0.0, 0.0, 0.0, 0.0, 0.0])

joint_solutions, debug_data = robot.ik(pose)

Moveit 2 Kinematics Plugin

To use the Moveit 2 Kinematics plugin, build the crx_kinematics package in your workspace, then edit the kinematics.yaml file of your Moveit 2 config package to use the plugin:

manipulator:
-  kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin
+  kinematics_solver: crx_kinematics/CRXKinematicsPlugin

The plugin also works with custom URDFs, provided their base and tip frames, as well as the name of the URDF, match the equivalent URDF from Fanuc.

Note that the Fanuc official driver does not yet support ROS 2 Jazzy/Kilted, so unless you’re on Humble, using the controllers provided in the Fanuc driver repo (e.g. ScaledJointTrajectoryController) will not work out of the box. Hopefully Fanuc will add support for Jazzy/Kilted soon.

Cloning and building

Using standard ROS 2 steps:

# Clone
cd ~/your_workspace/src
git clone git@github.com:danielcranston/crx_kinematics.git

# Install binary dependencies via rosdep
rosdep install --from-paths crx_kinematics --ignore-src -y

# Build
cd ~/your_workspace
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release --packages-up-to crx_kinematics crx_kinematics_py

# Test
colcon test --event-handlers console_cohesion+ --packages-select crx_kinematics crx_kinematics_py

License

MIT

No version for distro hydro showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

crx_kinematics repository

crx_kinematics crx_kinematics_py

ROS Distro
humble

Repository Summary

Checkout URI https://github.com/danielcranston/crx_kinematics.git
VCS Type git
VCS Version master
Last Updated 2026-01-23
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
crx_kinematics 0.0.0
crx_kinematics_py 0.0.0

README

crx_kinematics

[![Humble](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml) [![Jazzy](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml) [![Kilted](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml) [![Rolling](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml)

This repo hosts C++ and Python code implementing FK/IK for the Fanuc CRX series. The implementation closely follows Geometric Approach for Inverse Kinematics of the FANUC CRX Collaborative Robot by Abbes and Poisson (2024).

Compared to general optimization-based IK solvers like KDL, the implementation in this repo

  • Deterministically finds all IK solutions
  • Has near-zero dependencies (numpy+scipy for Python, Eigen for C++)
  • Is fast (C++ implementation runs in ~50 μs on a Intel Core i7-13650HX)

The approach reduces the IK problem to a 1-D search for zeros over a scalar function. See DERIVATION.md for an overview of the approach.

The C++ package also hosts a Moveit 2 Kinematics plugin that is compatible out of the box with the official Fanuc URDF descriptions.

Examples

The Python package comes with a interactive demo:

ros2 launch crx_kinematics_py demo.launch.py run_rviz:=true

In terms of API:

#include "crx_kinematics/robot.hpp"

int main(int argc, char** argv)
{
    auto robot = crx_kinematics::CRXRobot();  // Defaults to CRX-10iA
    Eigen::Isometry3d pose = robot.fk({ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 });

    std::vector<std::array<double, 6>> joint_solutions = robot.ik(pose);
}

from crx_kinematics_py.robot import CRXRobot
import numpy as np

robot = CRXRobot()  # Defaults to CRX-10iA
pose: np.ndarray = robot.fk([0.0, 0.0, 0.0, 0.0, 0.0, 0.0])

joint_solutions, debug_data = robot.ik(pose)

Moveit 2 Kinematics Plugin

To use the Moveit 2 Kinematics plugin, build the crx_kinematics package in your workspace, then edit the kinematics.yaml file of your Moveit 2 config package to use the plugin:

manipulator:
-  kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin
+  kinematics_solver: crx_kinematics/CRXKinematicsPlugin

The plugin also works with custom URDFs, provided their base and tip frames, as well as the name of the URDF, match the equivalent URDF from Fanuc.

Note that the Fanuc official driver does not yet support ROS 2 Jazzy/Kilted, so unless you’re on Humble, using the controllers provided in the Fanuc driver repo (e.g. ScaledJointTrajectoryController) will not work out of the box. Hopefully Fanuc will add support for Jazzy/Kilted soon.

Cloning and building

Using standard ROS 2 steps:

# Clone
cd ~/your_workspace/src
git clone git@github.com:danielcranston/crx_kinematics.git

# Install binary dependencies via rosdep
rosdep install --from-paths crx_kinematics --ignore-src -y

# Build
cd ~/your_workspace
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release --packages-up-to crx_kinematics crx_kinematics_py

# Test
colcon test --event-handlers console_cohesion+ --packages-select crx_kinematics crx_kinematics_py

License

MIT

No version for distro kinetic showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

crx_kinematics repository

crx_kinematics crx_kinematics_py

ROS Distro
humble

Repository Summary

Checkout URI https://github.com/danielcranston/crx_kinematics.git
VCS Type git
VCS Version master
Last Updated 2026-01-23
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
crx_kinematics 0.0.0
crx_kinematics_py 0.0.0

README

crx_kinematics

[![Humble](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml) [![Jazzy](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml) [![Kilted](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml) [![Rolling](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml)

This repo hosts C++ and Python code implementing FK/IK for the Fanuc CRX series. The implementation closely follows Geometric Approach for Inverse Kinematics of the FANUC CRX Collaborative Robot by Abbes and Poisson (2024).

Compared to general optimization-based IK solvers like KDL, the implementation in this repo

  • Deterministically finds all IK solutions
  • Has near-zero dependencies (numpy+scipy for Python, Eigen for C++)
  • Is fast (C++ implementation runs in ~50 μs on a Intel Core i7-13650HX)

The approach reduces the IK problem to a 1-D search for zeros over a scalar function. See DERIVATION.md for an overview of the approach.

The C++ package also hosts a Moveit 2 Kinematics plugin that is compatible out of the box with the official Fanuc URDF descriptions.

Examples

The Python package comes with a interactive demo:

ros2 launch crx_kinematics_py demo.launch.py run_rviz:=true

In terms of API:

#include "crx_kinematics/robot.hpp"

int main(int argc, char** argv)
{
    auto robot = crx_kinematics::CRXRobot();  // Defaults to CRX-10iA
    Eigen::Isometry3d pose = robot.fk({ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 });

    std::vector<std::array<double, 6>> joint_solutions = robot.ik(pose);
}

from crx_kinematics_py.robot import CRXRobot
import numpy as np

robot = CRXRobot()  # Defaults to CRX-10iA
pose: np.ndarray = robot.fk([0.0, 0.0, 0.0, 0.0, 0.0, 0.0])

joint_solutions, debug_data = robot.ik(pose)

Moveit 2 Kinematics Plugin

To use the Moveit 2 Kinematics plugin, build the crx_kinematics package in your workspace, then edit the kinematics.yaml file of your Moveit 2 config package to use the plugin:

manipulator:
-  kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin
+  kinematics_solver: crx_kinematics/CRXKinematicsPlugin

The plugin also works with custom URDFs, provided their base and tip frames, as well as the name of the URDF, match the equivalent URDF from Fanuc.

Note that the Fanuc official driver does not yet support ROS 2 Jazzy/Kilted, so unless you’re on Humble, using the controllers provided in the Fanuc driver repo (e.g. ScaledJointTrajectoryController) will not work out of the box. Hopefully Fanuc will add support for Jazzy/Kilted soon.

Cloning and building

Using standard ROS 2 steps:

# Clone
cd ~/your_workspace/src
git clone git@github.com:danielcranston/crx_kinematics.git

# Install binary dependencies via rosdep
rosdep install --from-paths crx_kinematics --ignore-src -y

# Build
cd ~/your_workspace
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release --packages-up-to crx_kinematics crx_kinematics_py

# Test
colcon test --event-handlers console_cohesion+ --packages-select crx_kinematics crx_kinematics_py

License

MIT

No version for distro melodic showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

crx_kinematics repository

crx_kinematics crx_kinematics_py

ROS Distro
humble

Repository Summary

Checkout URI https://github.com/danielcranston/crx_kinematics.git
VCS Type git
VCS Version master
Last Updated 2026-01-23
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
crx_kinematics 0.0.0
crx_kinematics_py 0.0.0

README

crx_kinematics

[![Humble](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml) [![Jazzy](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml) [![Kilted](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml) [![Rolling](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml)

This repo hosts C++ and Python code implementing FK/IK for the Fanuc CRX series. The implementation closely follows Geometric Approach for Inverse Kinematics of the FANUC CRX Collaborative Robot by Abbes and Poisson (2024).

Compared to general optimization-based IK solvers like KDL, the implementation in this repo

  • Deterministically finds all IK solutions
  • Has near-zero dependencies (numpy+scipy for Python, Eigen for C++)
  • Is fast (C++ implementation runs in ~50 μs on a Intel Core i7-13650HX)

The approach reduces the IK problem to a 1-D search for zeros over a scalar function. See DERIVATION.md for an overview of the approach.

The C++ package also hosts a Moveit 2 Kinematics plugin that is compatible out of the box with the official Fanuc URDF descriptions.

Examples

The Python package comes with a interactive demo:

ros2 launch crx_kinematics_py demo.launch.py run_rviz:=true

In terms of API:

#include "crx_kinematics/robot.hpp"

int main(int argc, char** argv)
{
    auto robot = crx_kinematics::CRXRobot();  // Defaults to CRX-10iA
    Eigen::Isometry3d pose = robot.fk({ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 });

    std::vector<std::array<double, 6>> joint_solutions = robot.ik(pose);
}

from crx_kinematics_py.robot import CRXRobot
import numpy as np

robot = CRXRobot()  # Defaults to CRX-10iA
pose: np.ndarray = robot.fk([0.0, 0.0, 0.0, 0.0, 0.0, 0.0])

joint_solutions, debug_data = robot.ik(pose)

Moveit 2 Kinematics Plugin

To use the Moveit 2 Kinematics plugin, build the crx_kinematics package in your workspace, then edit the kinematics.yaml file of your Moveit 2 config package to use the plugin:

manipulator:
-  kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin
+  kinematics_solver: crx_kinematics/CRXKinematicsPlugin

The plugin also works with custom URDFs, provided their base and tip frames, as well as the name of the URDF, match the equivalent URDF from Fanuc.

Note that the Fanuc official driver does not yet support ROS 2 Jazzy/Kilted, so unless you’re on Humble, using the controllers provided in the Fanuc driver repo (e.g. ScaledJointTrajectoryController) will not work out of the box. Hopefully Fanuc will add support for Jazzy/Kilted soon.

Cloning and building

Using standard ROS 2 steps:

# Clone
cd ~/your_workspace/src
git clone git@github.com:danielcranston/crx_kinematics.git

# Install binary dependencies via rosdep
rosdep install --from-paths crx_kinematics --ignore-src -y

# Build
cd ~/your_workspace
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release --packages-up-to crx_kinematics crx_kinematics_py

# Test
colcon test --event-handlers console_cohesion+ --packages-select crx_kinematics crx_kinematics_py

License

MIT

No version for distro noetic showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

crx_kinematics repository

crx_kinematics crx_kinematics_py

ROS Distro
humble

Repository Summary

Checkout URI https://github.com/danielcranston/crx_kinematics.git
VCS Type git
VCS Version master
Last Updated 2026-01-23
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
crx_kinematics 0.0.0
crx_kinematics_py 0.0.0

README

crx_kinematics

[![Humble](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/humble.yml) [![Jazzy](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/jazzy.yml) [![Kilted](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/kilted.yml) [![Rolling](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml/badge.svg?branch=master)](https://github.com/danielcranston/crx_kinematics/actions/workflows/rolling.yml)

This repo hosts C++ and Python code implementing FK/IK for the Fanuc CRX series. The implementation closely follows Geometric Approach for Inverse Kinematics of the FANUC CRX Collaborative Robot by Abbes and Poisson (2024).

Compared to general optimization-based IK solvers like KDL, the implementation in this repo

  • Deterministically finds all IK solutions
  • Has near-zero dependencies (numpy+scipy for Python, Eigen for C++)
  • Is fast (C++ implementation runs in ~50 μs on a Intel Core i7-13650HX)

The approach reduces the IK problem to a 1-D search for zeros over a scalar function. See DERIVATION.md for an overview of the approach.

The C++ package also hosts a Moveit 2 Kinematics plugin that is compatible out of the box with the official Fanuc URDF descriptions.

Examples

The Python package comes with a interactive demo:

ros2 launch crx_kinematics_py demo.launch.py run_rviz:=true

In terms of API:

#include "crx_kinematics/robot.hpp"

int main(int argc, char** argv)
{
    auto robot = crx_kinematics::CRXRobot();  // Defaults to CRX-10iA
    Eigen::Isometry3d pose = robot.fk({ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 });

    std::vector<std::array<double, 6>> joint_solutions = robot.ik(pose);
}

from crx_kinematics_py.robot import CRXRobot
import numpy as np

robot = CRXRobot()  # Defaults to CRX-10iA
pose: np.ndarray = robot.fk([0.0, 0.0, 0.0, 0.0, 0.0, 0.0])

joint_solutions, debug_data = robot.ik(pose)

Moveit 2 Kinematics Plugin

To use the Moveit 2 Kinematics plugin, build the crx_kinematics package in your workspace, then edit the kinematics.yaml file of your Moveit 2 config package to use the plugin:

manipulator:
-  kinematics_solver: kdl_kinematics_plugin/KDLKinematicsPlugin
+  kinematics_solver: crx_kinematics/CRXKinematicsPlugin

The plugin also works with custom URDFs, provided their base and tip frames, as well as the name of the URDF, match the equivalent URDF from Fanuc.

Note that the Fanuc official driver does not yet support ROS 2 Jazzy/Kilted, so unless you’re on Humble, using the controllers provided in the Fanuc driver repo (e.g. ScaledJointTrajectoryController) will not work out of the box. Hopefully Fanuc will add support for Jazzy/Kilted soon.

Cloning and building

Using standard ROS 2 steps:

# Clone
cd ~/your_workspace/src
git clone git@github.com:danielcranston/crx_kinematics.git

# Install binary dependencies via rosdep
rosdep install --from-paths crx_kinematics --ignore-src -y

# Build
cd ~/your_workspace
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release --packages-up-to crx_kinematics crx_kinematics_py

# Test
colcon test --event-handlers console_cohesion+ --packages-select crx_kinematics crx_kinematics_py

License

MIT