1. Lesson Objective

In this module, we move from simulation to a real industrial robotic cell.

We are not building only a Gazebo demo anymore. We are going to create a complete ROS2-based industrial application using:

A real 6-axis robot
A real gripper
A suction cup
A RealSense depth camera
A Jetson Orin Nano for inference
MoveIt for motion planning
ROS2 for orchestration
Docker for deployment
Behavior Trees for reliable task execution

The goal of this lesson is simple: before we start writing and running code, I want to show you the reference repositories used throughout the module and explain how they fit together.

By the end of this lesson, you should understand the global architecture of the system we are going to build.

2. What We Are Building

The final application is an industrial pick-and-place task:

1. The FR3WML robot picks a bottle from a nest.
2. A RealSense depth camera observes the workspace.
3. A cap is detected on the table.
4. The Jetson runs inference.
5. A 6D pose estimation package computes the cap pose.
6. ROS2 transforms the pose into the robot reference frame.
7. The robot picks the cap using a suction cup.
8. The robot places the cap precisely on the bottle neck.

This is the kind of architecture used in real industrial automation cells: robot, vision, edge AI, gripper control, motion planning, and hardware interfaces working together.

3. Why We Need Multiple Repositories

In a real industrial robotics project, we do not put everything inside one package.

We separate the system into layers:

Robot description layer
MoveIt configuration layer
Robot bridge layer
Tool / gripper bridge layer
Application layer
Vision / inference layer
6D pose estimation layer
Behavior Tree orchestration layer

This separation is important because each layer has a different responsibility.

The robot description should describe the robot.

The MoveIt package should handle planning configuration.

The bridge should communicate with the real robot controller.

The perception packages should run on the Jetson.

The Behavior Tree package should organize the application logic.

This is the difference between a quick prototype and a maintainable industrial application.

4. The Repository Map

4.1 Main Robot Application — Monolithic Baseline

https://github.com/LearnRoboticsWROS/fr3wml_camera_gripper_master_class.git

It contains the robot application in a more classical, monolithic structure.

Inside this repository, you will find:

Xacro files
Robot description
Gripper description
Camera integration
Meshes
Launch files
Controller configuration files
MoveIt-based pick-and-place application logic

This repository is important because it gives us the first working version of the system.

It allows us to control the FR3WML robot, integrate the camera and gripper, and execute a pick-and-place task with MoveIt.

However, as the application grows, the monolithic structure becomes harder to maintain.

That is why later in the module we will refactor this logic into a Behavior Tree architecture.

4.2 MoveIt Configuration Package

https://github.com/LearnRoboticsWROS/fr3wml_camera_gripper_moveit_config_master_class.git

This repository contains the MoveIt configuration package for the FR3WML robot with camera and gripper.

This package defines how MoveIt understands the robot.

It includes:

SRDF configuration
Planning groups
End-effector definition
Kinematics configuration
Joint limits
Planning pipelines
MoveIt controllers
RViz configuration
Launch files for MoveIt

This is the package that allows MoveIt to plan trajectories for the robot.

A key point to understand is this:

The robot description tells ROS what the robot is.

The MoveIt configuration tells MoveIt how to plan with that robot.

Without this package, we can describe the robot, but we cannot properly plan and execute robot motions using MoveIt.

4.3 Fairino Robot Bridge

https://github.com/LearnRoboticsWROS/fairino_bridge_master_class.git

This repository is extremely important when we move from simulation to the real robot.

In an ideal ROS2 industrial setup, the robot manufacturer provides a clean and updated ros2_control hardware interface.

In this case, for the FR3WML robot, we do not rely on a complete official ROS2 hardware interface.

So we create a bridge.

The bridge connects:

ROS2 application layer
        ↓
Fairino robot API / SDK
        ↓
Real robot controller

This bridge allows our ROS2 application to send commands to the real robot.

This is a very common industrial reality: sometimes the robot does not expose the exact ROS2 interface we want, so we build an intermediate software layer.

The important concept is not only this specific bridge.

The important concept is the pattern:

When the hardware does not speak ROS2 directly,
we create a bridge that exposes stable ROS2 interfaces.

4.4 Gripper and Suction Cup Bridge

https://github.com/LearnRoboticsWROS/fairino_bridge_gripper_master_class.git

The robot does not only move.

In a real industrial cell, the robot must also control tools:

Soft gripper
Suction cup
Pneumatic actuators
Digital outputs
Vacuum activation
Tool release

This repository handles the bridge between ROS2 and the physical gripping system.

The idea is to expose simple ROS2 interfaces for actions such as:

close gripper
open gripper
activate suction
deactivate suction
set tool idle

Behind these commands, the bridge talks to the real robot controller or digital outputs.

This is important because the application layer should not care about the low-level electrical details.

The application should say:

activate suction

not:

set digital output 3 to true using vendor-specific command X

That is how we create hardware abstraction.

5. Vision and Inference Layer on Jetson

The perception part is separated from the robot control side.

This is realistic.

In industrial applications, camera acquisition and inference often run on an edge device such as a Jetson.

5.1 Inference Package

https://github.com/LearnRoboticsWROS/inference_running_jetson.git

This package manages the inference pipeline.

It is designed to run on a Jetson Orin Nano, not directly on the main PC.

It runs inside the Docker image:

learnroboticswros/ros2-ultralytics-trt:pcl-snapshot

This container already includes:

ROS2 Humble
Ultralytics
TensorRT-related environment
The required runtime dependencies

Important point:

This package makes sense only inside the correct Jetson container.

When we start the container, we will mount the package folder inside the container so that ROS2 can build and run it in the correct environment.

5.2 6D Pose Estimation Package

https://github.com/LearnRoboticsWROS/sixd_pose_pcl.git

This package takes the output of the detection/inference pipeline and computes the 6D pose of the detected object.

In simple terms:

The inference package detects the object.
The 6D pose package estimates where the object is in 3D space and how it is oriented.
It publishes on a topic that the Robot's application layer can see and process.

This is what allows the robot to pick a cap that is not always in the same fixed position.

Again, this package is designed to run on the Jetson side, inside the correct container.

The output of this perception layer will then be consumed by the robot application through ROS2 topics and TF transformations.

6. Behavior Tree Layer

As the application becomes more complex, a monolithic pick-and-place node is not enough anymore.

A real industrial task needs:

clear task sequencing
failure handling
retry logic
tool activation
vision input
motion primitives
recoveries
modular behavior

This is where Behavior Trees become important.

6.1 Generic Behavior Tree Framework

https://github.com/LearnRoboticsWROS/industrial_bt_framework.git

This repository is the generic, robot-agnostic Behavior Tree framework.

It is not specific to the FR3WML robot.

The goal of this framework is to provide reusable building blocks such as:

move to named target
move to joint target
execute Cartesian segment
activate tool
release tool
get detected object pose
compute pick posere
move scene objectlog message
wait

This framework is designed to be reusable across different robots and applications.

This is an important architectural decision:

The framework should be generic.
The application package should be specific.

6.2 Fairino-Specific Behavior Tree Application

https://github.com/LearnRoboticsWROS/fairino_industrial_bt.git

This repository is the Fairino-specific instance of the generic Behavior Tree framework.

It adapts the generic framework to our real application:

FR3WML robot
Fairino bridge
Soft gripper
Suction cup
Bottle and cap task
Real application configuration
Robot-specific launch files
Robot-specific YAML files
BT XML task description

This is where the industrial application becomes cleaner.

Instead of writing one large C++ file that contains everything, we define the task as a Behavior Tree.

The logic becomes easier to understand:

Go to pre-pick
Move down linearly
Activate gripper
Retreat
Move to place
Release object
Get cap pose from vision
Move to cap
Activate suction
Place cap on bottle

The Behavior Tree makes the application easier to maintain, debug, and extend.

7. How Everything Fits Together

The final architecture will look like this:

At a higher level:

The PC orchestrates the robotic application.
The robot bridge talks to the real robot.
The gripper bridge controls the tools.
The Jetson runs perception and inference.
The Behavior Tree coordinates the complete task.
MoveIt handles motion planning.
ROS2 connects everything together.

This is the architecture we will progressively build during the module.

8. From Monolithic Code to Industrial Architecture

At the beginning, we use the monolithic repository:

fr3wml_camera_gripper_master_class

This is useful because it helps us understand the full application flow in one place.

But then we move toward the more scalable architecture:

industrial_bt_framework
fairino_industrial_bt

This transition is one of the most important parts of the module.

The goal is not only to make the robot move.

The goal is to structure the application like a real industrial robotics software project.

The student should understand:

What belongs to the robot description
What belongs to MoveIt
What belongs to the bridge layer
What belongs to the perception layer
What belongs to the application layer
What belongs to the Behavior Tree framework

Once this separation is clear, adapting the system to another robot, another gripper, or another industrial task becomes much easier.

9. What We Will Do During the Module

During this module, we will progressively go through these repositories and understand how they work.

We will not explain everything in this first lesson.

This lesson is only the map.

Later, we will go deeper into:

How the FR3WML robot is described with Xacro
How the MoveIt configuration package is structured
How the Fairino bridge communicates with the real robot
How the gripper and suction cup are controlled from ROS2
How the RealSense camera and inference pipeline run on the Jetson
How the 6D pose estimation package computes the object pose
How the monolithic pick-and-place application works
How to refactor the task into a Behavior Tree
How to deploy the full system on real hardware

The important thing now is that you know where each piece lives.

10. Demo / Practical Setup Preview

In the practical part of the module, the workspace will contain several packages.

A simplified structure will look like this:

fr3wml_ws/
└── src/
    ├── fr3wml_camera_gripper_master_class/
    ├── fr3wml_camera_gripper_moveit_config_master_class/
    ├── fairino_bridge_master_class/
    ├── fairino_bridge_gripper_master_class/
    ├── industrial_bt_framework/
    └── fairino_industrial_bt/

On the Jetson side, the perception workspace will contain:

jetson_ws/
└── src/
    ├── inference_running_jetson/
    └── sixd_pose_pcl/

And those Jetson packages will be used inside the Docker container:

learnroboticswros/ros2-ultralytics-trt:pcl-snapshot

This separation is intentional.

The robot application and orchestration can run on the PC.

The vision and inference workload can run on the Jetson.

ROS2 allows these nodes to communicate across machines, as long as the network, ROS domain, and middleware configuration are correctly set. (We will see everithing together)

11. Key Takeaways

The repositories in this module are not random packages. They represent a complete industrial robotics architecture.

The monolithic application repository gives us the first working pick-and-place implementation.

The MoveIt configuration package gives MoveIt the information it needs to plan robot motion.

The Fairino bridge allows ROS2 to communicate with the real robot controller.

The gripper bridge abstracts the pneumatic tools and digital outputs.

The Jetson inference package runs object detection on the edge device.

The 6D pose package converts perception data into robot-usable pose information.

The generic Behavior Tree framework gives us reusable industrial task bricks.

The Fairino Behavior Tree repository adapts that framework to our real FR3WML application.

The final objective is not only to run a robot demo.

The objective is to understand how to design, organize, deploy, and maintain a real ROS2 industrial robotic application.

By the end of this module, you should be able to look at a real robotic cell and understand how to separate the system into clean software layers: robot control, tool control, perception, inference, planning, orchestration, and deployment.

That is the real value of this module: you will not only learn how to move from simulation to reality — you will learn how to think like a robotics system architect.