Friendly ROS 2 Humble integration for controlling FANUC robots through fanucpy/MAPPDK. Includes robot state, teleoperation, I/O, TP programs, RViz2 visualization, and MoveIt 2 execution.

Projects
, , , ,
1

fanucpy_ros2: A ROS 2 interface tested with an older FANUC R-30iA Mate controller

Hello ROS community,

I would like to share fanucpy_ros2, an independent ROS 2 interface that I developed and tested with a FANUC M-10iA robot and an R-30iA Mate controller.

Motivation

While working with this robot, I wanted to integrate it into a ROS 2 Humble environment for monitoring, motion commands, visualization, and MoveIt 2 planning.

My available controller is an R-30iA Mate running software version V7.70P/56. This configuration falls outside the controller families and minimum software versions listed in the current official FANUC ROS 2 driver documentation.

This does not indicate a problem with the official driver; its documented requirements simply do not cover the older controller available in my setup.

I therefore investigated fanucpy, an existing Python library developed by Agajan Torayev and its contributors. It provides communication with a FANUC controller using controller-side programs and a TCP connection.

Using fanucpy as the underlying communication layer, I developed fanucpy_ros2 to expose selected robot and controller functionality through standard ROS 2 concepts.

This is a community-developed project. It is not an official FANUC driver and is not intended to replace the official FANUC ROS 2 driver.

Package overview

The current communication architecture is:

ROS 2 applications or MoveIt 2
              |
    Topics, services and actions
              |
      fanucpy_ros2 driver
              |
           fanucpy
              |
    Controller-side MAPPDK server
              |
       FANUC controller

A single ROS 2 driver node owns and manages the connection to the controller. It publishes robot state and provides controlled interfaces for supported controller operations and robot motion.

The repository currently contains eight ROS 2 packages covering the driver, custom interfaces, launch configuration, examples, trajectory execution, RViz visualization, controller utilities, and MoveIt 2 integration.

Main features

The current implementation provides:

  • Joint-state publishing through /joint_states
  • Cartesian state and ROS PoseStamped publishing
  • Driver connection and configuration status
  • Numeric-register read and gated write services
  • Digital-output read and gated write services
  • Configurable digital gripper control
  • Relative Cartesian movement through a ROS 2 action
  • Allowlisted TP program execution
  • A standard FollowJointTrajectory action for MoveIt 2 integration
  • RViz visualization using live robot feedback
  • MoveIt 2 configurations for mock and real-hardware modes
  • Keyboard Cartesian teleoperation and controller utility examples
  • Automatic reconnection following ordinary communication failures
  • Validation of motion requests, joint limits, velocities, frames and trajectory waypoints

Controller writes, robot motion and TP program execution have independent enable parameters, and all are disabled by default.

The current release is version 0.8.0 and is distributed under the Apache License 2.0.

Tested environment

The package has been physically tested using the following configuration:

Component Tested configuration
Robot FANUC M-10iA
Controller FANUC R-30iA Mate
Controller software V7.70P/56
Controller options used R632 KAREL and R648 User Socket Messaging
Operating system Ubuntu 22.04
ROS distribution ROS 2 Humble
Python System Python 3.10
Communication fanucpy with a controller-side MAPPDK server

This table describes only my tested configuration. I have not established compatibility with other FANUC controller families, software versions, robot models or ROS 2 distributions.

MoveIt 2 integration

The repository includes a MoveIt 2 configuration for the FANUC M-10iA with both mock and real-hardware launch modes.

In real-hardware mode, MoveIt sends trajectories through the standard FollowJointTrajectory action provided by the driver. The current execution method uses validated point-to-point controller commands rather than a hard real-time streaming interface.

The included robot model is useful for planning and visualization, but users must verify the joint limits, coordinate frames, tooling, mounting and collision geometry against their own physical installation.

Scope and limitations

This package depends on the communication protocol and controller-side programs provided by fanucpy. It is a request-response TCP interface and does not provide hard real-time or high-bandwidth streaming control.

At present, hardware testing is limited to my specific M-10iA and R-30iA Mate configuration. The automated tests use simulated transports and configuration checks rather than a physical FANUC controller.

The software validation and enable gates are additional engineering precautions, not replacements for FANUC safety functions, physical safeguarding or a proper workcell risk assessment. Any physical testing should be performed at reduced speed by someone familiar with the controller, with the teach pendant and emergency stop accessible.

Repository and demonstration

The README and documentation contain the complete installation, controller configuration, safety checks and usage instructions.

Feedback

I would appreciate feedback from ROS 2, MoveIt and ROS-Industrial users, especially regarding:

  • The ROS 2 interface design
  • The trajectory-execution approach
  • Controller connection and recovery
  • Safety-related configuration
  • Experiences with other older FANUC controller configurations

Reports from other FANUC installations would be particularly helpful when accompanied by the robot model, controller family, controller software version, installed options and test scope.

Issues, documentation improvements and pull requests are welcome through the GitHub repository.