Forward & Inverse Kinematics

Inverse kinematics (IK) and forward kinematics (FK) let you move between joint space and Cartesian space. FK computes the tool p ose from known joint angles, while IK finds joint angles for a desired pose. The kinematics utilities in the Fanuc SDK are off line helpers: you can evaluate poses and joint solutions without connecting to a controller, making them perfect for simulatio n, path validation, and pre-deployment checks.

Why this matters for both industrial arms and cobots

The SDK ships with two analytical solvers and automatically chooses the right one for you:

• OPW industrial arms: Classical 6-axis Fanuc robots with an ortho-parallel base and spherical wrist, based on the paper An Analytical Solution of the Inverse Kinematics Problem of Industrial Serial Manipulators with an Ortho-parallel Basis and a Spherical Wrist by Mathias Brandstötter, Arthur Angerer, and Michael Hofbaur.
• CRX collaborative arms: Fanuc CRX cobots that have their own closed-form solver and optional dual solutions, based on paper Geometric Approach for Inverse Kinematics of the FANUC CRX Collaborative Robot by Manel Abbes and Gérard Poisson.

When you call KinematicsUtils.InverseKinematics(), it inspects DhParameters.KinematicsCategory:

• KinematicsCategory.Opw 👉 dispatches to Opw.OpwKinematicsUtils.InverseKinematics (industrial robots).
• KinematicsCategory.Crx 👉 dispatches to Crx.CrxKinematicsUtils.InverseKinematics (CRX cobots).

That means you can rely on a single entry point and let the SDK route the request appropriately. 🚦

Typical workflows

Run forward kinematics (FK)

static void Main()
{
// Load robot geometry
var dh = DhParameters.FromArmKinematicModel(ArmKinematicModels.CRX10iA);

// Joint angles in degrees (Fanuc convention)
var jointsDeg = new JointsPosition { J1 = 0, J2 = -30, J3 = 45, J4 = 0, J5 = 60, J6 = 90 };

// Compute pose: returns XYZ + WPR
CartesianPosition pose = KinematicsUtils.ForwardKinematics(jointsDeg, dh);
}
}

Solve inverse kinematics (IK) for an OPW robot

static void Main()
{
// OPW industrial robot
var dh = DhParameters.FromArmKinematicModel(ArmKinematicModels.ARCMate120iD);
var target = new CartesianPosition { X = 800, Y = 0, Z = 450, W = 180, P = 0, R = 90 };
JointsPosition[] solutions = KinematicsUtils.InverseKinematics(target, dh);

// CRX cobot with dual solutions
var dhCrx = DhParameters.FromArmKinematicModel(ArmKinematicModels.CRX10iAL);
var targetCrx = new CartesianPosition { X = 400, Y = 250, Z = 650, W = 0, P = 90, R = 0 };
JointsPosition[] crxSolutions = CrxKinematicsUtils.InverseKinematics(
    targetCrx, dhCrx,
    includeDuals: true
);
}
}

Solve inverse kinematics (IK) for a CRX cobot

The CRX solver uses a closed-form geometric approach and returns all valid joint solutions directly. No seed position is required. Pass includeDuals: true (C#) or include_duals=True (Python) to also include the dual configurations defined by the CRX kinematics.

using UnderAutomation.Fanuc.Common;
using UnderAutomation.Fanuc.Kinematics;
using UnderAutomation.Fanuc.Kinematics.Crx;

public class KinematicsIK
{
    static void Main()
    {
        
        // OPW industrial robot
        var dh = DhParameters.FromArmKinematicModel(ArmKinematicModels.ARCMate120iD);
        var target = new CartesianPosition { X = 800, Y = 0, Z = 450, W = 180, P = 0, R = 90 };
        JointsPosition[] solutions = KinematicsUtils.InverseKinematics(target, dh);

        // CRX cobot with dual solutions
        var dhCrx = DhParameters.FromArmKinematicModel(ArmKinematicModels.CRX10iAL);
        var targetCrx = new CartesianPosition { X = 400, Y = 250, Z = 650, W = 0, P = 90, R = 0 };
        JointsPosition[] crxSolutions = CrxKinematicsUtils.InverseKinematics(
            targetCrx, dhCrx,
            includeDuals: true
        );
        
    }
}

Build DH parameters from multiple sources

• Built-in catalog: DhParameters.FromArmKinematicModel(ArmKinematicModels model) gives you ready-to-use geometry for many Fanuc arms and cobots.
• ROBOGUIDE library: DhParameters.FromDefFile(path) parses robot definitions in ProgramData/FANUC/ROBOGUIDE/Robot Library .
• Controller variables: DhParameters.FromSymotnFile and DhParameters.FromMrrGrp convert live $MRR_GRP or symotn.va d ata to reusable DH structures.
• OPW data: DhParameters.FromOpwParameters maps OPW parameters (meters) to Fanuc-style DH while keeping the kinematics cat egory consistent.

Practical tips ✨

• Offline safety: Because all solvers are offline, you can iterate quickly without touching a robot controller.
• Pose normalization: OpwKinematicsUtils.InverseKinematics normalizes angles to (-180, 180] to match Fanuc expectations.
• CRX dual solutions: Pass includeDuals: true to CrxKinematicsUtils.InverseKinematics to include the additional configurations defined by the CRX kinematics model.
• Matrix helpers: KinematicsUtils.Mul multiplies 2D matrices if you need to compose transforms manually.

Happy path-planning! 🛠️

Online Forward and Inverse Kinematics

Forward kinematics using SNPX position registers

Leverage the controller's built-in FK solver by writing joint angles and reading back the Cartesian pose:

FanucRobot _robot = new FanucRobot();
_robot.Connect("192.168.0.1");
// Forward kinematics via SNPX: joints → Cartesian
JointsPosition jointsPosition = new JointsPosition(10, 12, 50, 20, 12, 16);
_robot.Snpx.PositionRegisters.Write(1, jointsPosition);
CartesianPosition cartesianPosition = _robot.Snpx.PositionRegisters.Read(1).CartesianPosition;

// Inverse kinematics via SNPX: Cartesian → joints
CartesianPosition targetPosition = new CartesianPosition() { X = 100, Y = 100, Z = 100 };
targetPosition.Configuration.WristFlip = WristFlip.Flip;
targetPosition.Configuration.ArmUpDown = ArmUpDown.Down;
targetPosition.Configuration.ArmLeftRight = ArmLeftRight.Left;
_robot.Snpx.PositionRegisters.Write(1, targetPosition);
JointsPosition resultJoints = _robot.Snpx.PositionRegisters.Read(1).JointsPosition;
}
}

Inverse kinematics using SNPX position registers

Let the controller solve IK by writing a Cartesian pose and reading back joint angles. You will only have 1 solution since the cartesian position contains the configuration.

Demonstration

Have a look at : https://fanuc-kinematics.underautomation.com

You can also take a look at the Winforms Desktop project source which implements all these features. I can be downloaded here.

Core types at a glance