[Documentation] [TitleIndex] [WordIndex] 

Planet ROS

Planet ROS - http://planet.ros.org

Planet ROS - http://planet.ros.org[WWW] http://planet.ros.org

ROS Discourse General: Rapid deployment of OpenClaw and GraspGen crawling system

OpenClawPi: AgileX Robotics Skill Set Library

License
Language
Platform

OpenClawPi is a modular skill set repository focused on the rapid integration and reuse of core robot functions. Covering key scenarios such as robotic arm control, grasping, visual perception, and voice interaction, it provides out-of-the-box skill components for secondary robot development and application deployment.

From Zero to AI Robot Grasping: OpenClaw + GrabGen Full Setup Guide (Step-by-Step)

I. Quick Start

OpenClaw Deployment

Visit the OpenClaw official website: https://openclaw.ai/

Execute the one-click installation command:

curl -fsSL https://openclaw.ai/install.sh | bash

Next, configure OpenClaw:

  1. Select ‘YES’

    image

  2. Select ‘QuickStart’

  3. Select ‘Update values’

    image

    image

  4. Select your provider (recommended: free options like Qwen, OpenRouter, or Ollama)

    image

  5. Select the company model you wish to use.

    image

  6. Select a default model.

    image

  7. Select the APP you will connect to OpenClaw.

  8. Select a web search provider.

    image

  9. Select skills (not required for now).

  10. Check all Hook options.

    image

  11. Select ‘restart’.

  12. Select ‘Web UI’.

    image

1. Clone the Project

git clone https://github.com/vanstrong12138/OpenClawPi.git

2. Prompt the Agent to Learn Skills

Using the vision skill as an example:

User: Please learn vl_vision_skill

:package: Skill Modules Overview

Module Name Description Core Dependencies
agx-arm-codegen Robotic arm code generation tool; automatically generates trajectory planning and joint control code. Supports custom path templates. pyAgxArm
grab_skill Robot grasping skill, including gripper control, target pose calibration, and grasping strategies (single-point/adaptive). pyAgxArm
vl_vision_skill Visual perception skill, supporting object detection, visual positioning, and image segmentation. SAM3, Qwen3-VL
voice_skill Voice interaction skill, supporting voice command recognition, voice feedback, and custom command set configuration. cosyvoice

II. GrabGen - Pose Generation and Grasping

This article demonstrates the identification, segmentation, pose generation, and grasping of arbitrary objects using SAM3 and pose generation tools.

Repositories

Hardware Requirements

Project Deployment Environment

  1. Install NVIDIA Graphics Driver
sudo apt update
sudo apt upgrade
sudo add-apt-repository ppa:graphics-drivers/ppa
sudo apt update
sudo apt install nvidia-driver-570
# Restart
reboot
  1. Install CUDA Toolkit 12.8
wget https://developer.download.nvidia.com/compute/cuda/12.8.1/local_installers/cuda_12.8.1_570.124.06_linux.run
sudo sh cuda_12.8.1_570.124.06_linux.run
  1. Add Environment Variables
echo 'export PATH=/usr/local/cuda-12.8/bin:$PATH' >> ~/.bashrc
echo 'export LD_LIBRARY_PATH=/usr/local/cuda-12.8/lib64:$LD_LIBRARY_PATH' >> ~/.bashrc
source ~/.bashrc
  1. Verify Installation
    Execute nvcc -V to check CUDA information.
nvcc -V
  1. Install cuDNN
sudo cp cuda/include/cudnn*.h /usr/local/cuda/include
sudo cp cuda/lib/libcudnn* /usr/local/cuda/lib64
sudo chmod a+r /usr/local/cuda/include/cudnn*.h /usr/local/cuda/lib64/libcudnn*
  1. Install TensorRT
    Download the TensorRT tar file from the NVIDIA Official Website.
    image
# Extract
tar -xvf TensorRT-10.16.0.72.Linux.x86_64-gnu.cuda-12.9.tar.gz 

# Enter directory
cd TensorRT-10.16.0.72.Linux.x86_64-gnu.cuda-12.9/

# Move to /usr/local
sudo mv TensorRT-10.16.0.72/ /usr/local/

# Enter MNIST sample directory
cd /usr/local/TensorRT-10.16.0.72/samples/sampleOnnxMNIST

# Compile
make

# Run the executable found in bin
cd /usr/local/TensorRT-10.16.0.72/bin
./sample_onnx_mnist

SAM3 Deployment

  1. Create Conda Virtual Environment
conda create -n sam3 python=3.12
conda deactivate
conda activate sam3
  1. Install PyTorch and Dependencies
# For 50-series GPUs, CUDA 12.8 and Torch 2.8 are recommended
# Downgrade numpy to <1.23 if necessary
pip install torch==2.8.0 torchvision==0.23.0 torchaudio==2.8.0 --index-url https://download.pytorch.org/whl/cu128

cd sam3
pip install -e .
  1. Model Download
    1. Submit the form to gain download access on HuggingFace: https://huggingface.co/facebook/sam3
    2. Or search via local mirror sites.

Robotic Arm Driver Deployment

The project outputs target_pose (end-effector pose), which can be manually adapted for different robotic arms.

  1. Example: PiPER Robotic Arm
pip install python-can

git clone https://github.com/agilexrobotics/pyAgxArm.git

cd pyAgxArm
pip install .

Cloning

Clone this project to your local machine:

cd YOUR_PATH
git clone -b ros2_jazzy_version https://github.com/AgilexRobotics/GraspGen.git

Running the Project

  1. Grasping Node
python YOUR_PATH/sam3/realsense-sam.py --prompt "Target Object Name in English"
  1. Grasping Task Execution Controls
A = Zero-force mode (Master arm) | D = Normal mode + Record pose | S = Return to home
X = Replay pose | Q = Open gripper | E = Close gripper | P = Pointcloud/Grasp
T = Change prompt | G = Issue grasp command | Esc = Exit
  1. Automatic Grasping Task
python YOUR_PATH/sam3/realsense-sam.py --prompt "Target Object Name" --auto

1 post - 1 participant

Read full topic

[WWW] https://discourse.openrobotics.org/t/rapid-deployment-of-openclaw-and-graspgen-crawling-system/53764

ROS Discourse General: Interactive GUI toolkit for robotics visualization - Python & C++, runs on desktop and web

Hi everyone,

I’d like to share Dear ImGui Bundle, an open-source framework for building interactive GUI applications in Python and C++. It wraps Dear ImGui with 23 integrated libraries (plotting, image inspection, node editors, 3D gizmos, etc.) and runs on desktop, mobile, and web.

I’m a solo developer and have been working hard on this for 4 years. I am new here, but I thought it might be useful for robotics developers.

It provides:

Real-time visualization

Interactive parameter tuning

Cross-platform deployment

Example: live camera + Laplacian filter with colormaps in 54 lines

image

import cv2
import numpy as np
from imgui_bundle import imgui, immvision, immapp


class AppState:
    def __init__(self):
        self.cap = cv2.VideoCapture(0)
        self.image = None
        self.filtered = None
        self.blur_sigma = 2.0
        # ImmVision params
        # For the camera image
        self.params_image = immvision.ImageParams()
        self.params_image.image_display_size = (400, 0)
        self.params_image.zoom_key = "cam"
        # For the filtered image (synced zoom via zoom_key)
        self.params_filter = immvision.ImageParams()
        self.params_filter.image_display_size = (400, 0)
        self.params_filter.zoom_key = "cam"
        self.params_filter.show_options_panel = True


def gui(s: AppState):
    # grab
    has_image, frame = s.cap.read()
    if has_image:
        s.image = cv2.resize(frame, (640, 480))
        gray = cv2.cvtColor(s.image, cv2.COLOR_BGR2GRAY)
        gray_f = gray.astype(np.float64) / 255.0
        blurred = cv2.GaussianBlur(gray_f, (0, 0), s.blur_sigma)
        s.filtered = cv2.Laplacian(blurred, cv2.CV_64F, ksize=5)

    # Refresh images only if needed
    s.params_image.refresh_image = has_image
    s.params_filter.refresh_image = has_image

    if s.image is not None:
        immvision.image("Camera", s.image, s.params_image)
        imgui.same_line()
        immvision.image("Filtered", s.filtered, s.params_filter)

    # Controls
    _, s.blur_sigma = imgui.slider_float("Blur", s.blur_sigma, 0.5, 10.0)


state = AppState()
immvision.use_bgr_color_order()
immapp.run(lambda: gui(state), window_size=(1200, 550), window_title="Camera Filter", fps_idle=0)

The filtered image is float64 - click “Options” to try different colormaps (Heat, Jet, Viridis…). Both views are zoom-linked: pan one, the other follows.

Try it:

Install: pip install imgui-bundle

Adoption:
The framework is used in several research projects, including CVPR 2024 papers (4K4D), Newton Physics, and moderngl. The Python bindings are auto-generated with litgen, so they stay in sync with upstream Dear ImGui.

Happy to answer any questions or discuss how it could fit into ROS workflows.

Best,
Pascal

1 post - 1 participant

Read full topic

[WWW] https://discourse.openrobotics.org/t/interactive-gui-toolkit-for-robotics-visualization-python-c-runs-on-desktop-and-web/53752

ROS Discourse General: On message standardization (and a call for participation)

Hi folks!

I presume at least some of you are aware of the OSRA efforts towards better supporting Physical AI applications. Some of those efforts revolve around messaging and interfaces, and in that context, a few gaps in standard sensing messages have been identified. In a way, this is orthogonal to Physical AI, yet still we may as well seize the opportunity to improve the state of things.

To that end, the Standardized Interfaces & Messages Working Group will be hosting public sessions to discuss, review, and craft proposals to address those gaps. Either through implementation or through recommendation if the community has already organically developed a solution. Academic researchers and industry practitioners are more than welcome to join. If you design or manufacture sensor hardware, even better.

Our friends at Ouster already took the lead and posted a proposal for a new 3D LiDAR message, so our focus during the first couple sessions will likely be on LiDAR technology. Tactile is a close second. We’ve heard complains about the IMU message structure too. Feel free to propose more (and challenge others too).

We’ll meet on Mondays, biweekly, starting Mon, Apr 6, 2026 3:00 PM UTC. Fill this form to join the meetings. Hope to see you there!

1 post - 1 participant

Read full topic

[WWW] https://discourse.openrobotics.org/t/on-message-standardization-and-a-call-for-participation/53744

ROS Discourse General: Announcing MoveIt Pro 9 with ROS 2 Jazzy Support

Hi ROS Community!

It’s been a while, but we’re excited to announce MoveIt Pro 9.0, the latest major release of PickNik’s manipulation developer platform built on ROS 2. MoveIt Pro includes comprehensive support for AI model training & execution, Behavior Trees, MuJoCo simulation, and all the classic capabilities you expect like motion planning, collision avoidance, inverse kinematics, and real-time control.

This release adds support for ROS 2 Jazzy LTS (while still supporting ROS Humble), along with significant improvements to teleoperation, motion planning, developer tooling, and robot application workflows. MoveIt Pro now includes new joint-space and Cartesian-space motion planners that outperform previous implementations, to improve cycle time, robustness, and industry-required reliability. See the full benchmarking comparison for details

MoveIt Pro is developed by the team behind MoveIt 2, and our goal is to make it easier for robotics teams to build and deploy real-world manipulation systems using ROS. Many organizations in manufacturing, aerospace, logistics, agriculture, industrial cleaning, and research use MoveIt Pro to accelerate development without needing to build large amounts of infrastructure from scratch.

image

What’s new

Improved real-time control and teleoperation with Joint Jog

MoveIt Pro now includes a new “Joint Jog” teleoperation mode for controlling robots directly from the web UI. This replaces the previous MoveIt Servo based teleoperation implementation and introduces continuous collision checking, configurable safety factors, and optional link padding for safer manual control during debugging or demonstrations.

Scan-and-plan workflows

New scan-and-plan capabilities allow robots to scan surfaces with a sensor and automatically generate tool paths for tasks like spraying, sanding, washing, or grinding. These workflows make it easier to build surface-processing applications.

scan-and-plan-capabilities-for-spraying-f1782ba23bff8f3dbedf9550a8dd3403

New Python APIs for MoveIt Pro Core

New low-level Python APIs expose the core planners, solvers, and controllers directly, enabling developers to build custom applications outside of the Behavior Tree framework. These APIs provide fine-grained control over motion planning and kinematics, including advanced features like customizable nullspace optimization and path constraints.

Improved motion planning APIs

Several updates improve flexibility for motion generation, including: improved path inverse kinematics, orientation tracking as a nullspace cost, customizable nullspace behavior, tunable path deviation tolerances.

Developer productivity improvements

The MoveIt Pro UI and Behavior Tree tooling received a number of improvements to make debugging and application development faster, including a redesigned UI layout and improved editing workflows, Behavior Tree editor improvements such as search and node snapping, better debugging tools including TF visualization and alert history

Expanded Library of Reusable Manipulation Skills

MoveIt Pro also includes a large library of reusable robot capabilities implemented as thread-safe Behavior Tree nodes, allowing developers to compose complex manipulation applications from modular building blocks instead of writing large amounts of robotics infrastructure from scratch. See our Behaviors Hub to explore the 200+ available Behaviors.

enhanced-ai-processing-of-point-clouds-4ec0f48f9070435cd417ab4915e90bed

Built for the ROS ecosystem

MoveIt Pro integrates with the broader ROS ecosystem, including standard ROS drivers and packages. PickNik has been deeply involved in the MoveIt project since its early development, and we continue investing heavily in open-source robotics such as developing many ROS drivers for major vendors.

Learn more

Full release notes:
https://docs.picknik.ai/release-notes/

We’d love feedback from the ROS community, and we’re excited to see what developers build with these new capabilities. Contact us to learn more.

4 posts - 3 participants

Read full topic

[WWW] https://discourse.openrobotics.org/t/announcing-moveit-pro-9-with-ros-2-jazzy-support/53723

ROS Discourse General: [Policy Change] Detailed Standards for REP-2026-04 (Lyrical Enforcement)

Hi everyone,

Following up on the recent announcement regarding the Lyrical Luth release requirements, the PMC has finalized the automated enforcement protocols. To ensure our May release remains on schedule, we are providing expanded guidelines and examples for the new rhyme-lint and README.shanty checks.

Effective immediately, all pull requests targeting the rolling or lyrical branches must pass these poetic audits.

1. The rhyme-lint Mandatory CI Check

All pull requests will now trigger a rhyme-lint action. If your commit message lacks proper meter or rhyme, the build will fail with a 403: UNPOETIC_CONTRIBUTION error.

Accepted Commit Styles:

fix: A buffer overflow was found in C,
We've locked the heap to keep the memory free.

feat: The twenty-standard now we must embrace,
To bring C++20 speed to every space.

Packets drift like leaves,
The middleware finds the path,
Silence in the logs.

2. The README.shanty Documentation Standard

Any new package added to the core must include a README.shanty file. This ensures our documentation can be easily memorized and sung during long deployment cycles or deep-sea robotics missions.

Example: README.shanty for rcl::Buffer

(To the tune of “The Wellerman”)

There once was a node that sent a frame,
Without a copy or a name,
The CPU was much to blame,
For latency so high! (HUH!)

Soon may the Zero-Copy come,
To bring us throughput, megabytes, and fun,
When the data transfer’s done,
We’ll take our leave and go!
We used the vendor’s memory backend,
A pointer sent to every friend,
The bandwidth limit met its end,
Beneath the Lyrical sky!

3. The Lyrical Luth Rhyming Dictionary

We recognize that many maintainers may find this transition challenging. To assist, the PMC has curated an initial dictionary of “Technical Rhymes” to help you pass CI.

ROS Term Approved Rhymes Example
Node Code, Mode, Load, Road “A lonely node / with heavy load.”
DDS Success, Progress, Finesse “Tune the DDS / with pure finesse.”
Topic Myopic, Tropic, Microscopic “A hidden topic / so microscopic.”
RMW Now, How, Allow, Brow “The RMW / we fix it now.”
Linter Splinter, Winter, Printer “The static linter / cold as winter.”
Pointer Anointer, Appointer “The null pointer / a soul-disappointer.”
Humble Rumble, Stumble, Grumble “Backported from Humble / without a stumble.”

Compliance and “ROS-ffice Hours”

We understand this is a significant shift in our development workflow, but we believe it is necessary to harmonize our ecosystem. To help with the transition, our upcoming “ROS-ffice Hours” sessions will be dedicated to bardic troubleshooting.

Let’s make this May the most harmonious release in robotics history.

5 posts - 4 participants

Read full topic

[WWW] https://discourse.openrobotics.org/t/policy-change-detailed-standards-for-rep-2026-04-lyrical-enforcement/53717

ROS Discourse General: Custom Capabilities in Transitive Robotics | Cloud Robotics WG Meeting 2026-04-13

Please come and join us for this coming meeting at Mon, Apr 13, 2026 4:00 PM UTC→Mon, Apr 13, 2026 5:00 PM UTC, where we plan to continue our Transitive Robotics tryout by trying one of the more advanced features: writing and deploying a custom capability. This feature allows customers to write their own custom code and deploy it to their robots alongside the features available directly from Transitive Robotics.

Last session, we tried running Transitive Robotics on a Turtlebot. We managed to remotely operate the robot, plus set up Maps as a capability which unfortunately didn’t work due to incompatibility with ROS 2 Jazzy (support has since been added for Jazzy). If you’re interested to watch the meeting, it is available on YouTube.

The meeting link for next meeting is here, and you can sign up to our calendar or our Google Group for meeting notifications or keep an eye on the Cloud Robotics Hub.

Hopefully we will see you there!

1 post - 1 participant

Read full topic

[WWW] https://discourse.openrobotics.org/t/custom-capabilities-in-transitive-robotics-cloud-robotics-wg-meeting-2026-04-13/53709

ROS Discourse General: Upcomming RMW Feature Freeze - April 6th, 2026 - ROS Lyrical

Hi all,

On Tue, Apr 7, 2026 6:59 AM UTC, we will freeze all RMW-related packages to prepare for the upcoming Lyrical Luth release on Fri, May 22, 2026 7:00 AM UTC.

Once this freeze takes effect, we will not accept new features to the RMW packages until Lyrical branches from ROS Rolling. This restriction applies to the following packages and vendor packages:

We still welcome bug fixes after the freeze date.

Find more information on the Lyrical Luth release timeline here: ROS 2 Lyrical Luth (codename ‘lyrical’; May, 2026).

1 post - 1 participant

Read full topic

[WWW] https://discourse.openrobotics.org/t/upcomming-rmw-feature-freeze-april-6th-2026-ros-lyrical/53696

ROS Discourse General: ROS2 Launch File Validation

Introducing an XML launch file scheme

XSD schema for validating ROS2 XML launch files.
Catch syntax errors before runtime and get IDE support.

Why

For the package.xml we have had it for years, a scheme.

But we found my muscle memory often typing type= instead of exec=.
Or $(find my_pkg) instead of $(find-pkg-share my_pkg).

And we could unit-test the node all we wanted, these errors only popped up in integration tests or even on the robot itself.
Would it not be nice if your editor already warned about you it?

image

How

Embed in launch file

Start your launchfile like this:

<?xml version="1.0"?>
<?xml-model href="https://nobleo.github.io/ros2_launch_validation/ros2_launch.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>

<launch>

Command-line validation

Quickstart! Validate all your launch xml files in your workspace right now!

xmllint --noout --schema <(curl -s https://nobleo.github.io/ros2_launch_validation/ros2_launch.xsd) **/*.launch.xml

This was verified internally and on some larger public repositories like autoware. Even found an issue :slight_smile:

6 posts - 2 participants

Read full topic

[WWW] https://discourse.openrobotics.org/t/ros2-launch-file-validation/53686

ROS Discourse General: RFC: Open standard for robot-to-human light signaling — looking for technical feedback from ROS 2 developers

Hi everyone,

I’m working on an open standard called LSEP (Luminae Signal Expression Protocol) — a state machine specification for how robots communicate intent, awareness, and safety states to humans through light signals.

The problem it solves:

Most robotic platforms implement ad-hoc LED patterns with no shared semantics. Robot A blinks blue for “idle,” Robot B blinks blue for “navigating.” There’s no interoperability, and no way for a human in a shared workspace to learn one signal language that transfers across platforms.

LSEP defines a modular 9-state architecture: 6 Core states (IDLE, AWARENESS, INTENT, CARE, CRITICAL, THREAT) and 3 Extended states (MED_CONF, LOW_CONF, INTEGRITY) with deterministic mappings from sensor inputs like Time-to-Collision (TTC) to signal outputs. The full spec is open: https://lsep.org

Where ROS 2 comes in:

We’ve designed LSEP to run as an isolated safety node — it reads from your perception pipeline (TTC, proximity, sensor health) and publishes signal commands. It doesn’t touch your navigation stack. The architecture pattern uses lifecycle nodes to keep the signaling guardrail separate from autonomy logic.

What I’m looking for:

We’re running a free Beta program for 20 ROS 2 developers who want to stress-test the integration. No cost — your payment is brutal, unfiltered technical feedback and (optionally) a short write-up on how it fits into your stack.

The program covers:

- Translating TTC and proximity data to deterministic state machine outputs

- EU AI Act compliance layers (Art. 9 & 50) for high-risk physical AI transparency

- LSEP core & extended states: mechanics of the 9-state multimodal standard

- ROS 2 integration: isolating the LSEP safety node from your navigation stack

- Sensor fusion resilience: hysteresis and fallback patterns for sensor dropouts

Not looking for:

This isn’t a pitch. I’m not selling anything here. I’m looking for the people who actually build these systems to tell me where LSEP breaks, what’s missing, and what’s naive. The harshest feedback is the most useful.

Full spec: https://lsep.org

Beta registration: https://www.experiencedesigninstitute.ch

— Nemanja Galić

2 posts - 2 participants

Read full topic

[WWW] https://discourse.openrobotics.org/t/rfc-open-standard-for-robot-to-human-light-signaling-looking-for-technical-feedback-from-ros-2-developers/53656

ROS Industrial: PLCnext ROS Bridge: Enabling Hardware Interoperability Between Industrial PLCs and ROS

For developers already working with ROS, the integration of industrial fieldbuses, I/Os, and functional safety into robotic applications often introduces unexpected challenges. ROS offers a flexible and modular software framework, although connecting it to industrial automation hardware typically requires additional integration layers and specialized knowledge.

This led to the idea of creating a solution that allows ROS developers to leverage a PLC where it excels, for example in deterministic control, industrial communication, and safety, while high performance computation and complex logic remain handled within ROS.

PLCnext Technology Architecture Overview

PLCnext Controls run PLCnext Linux, a real-time capable operating system that hosts the PLCnext Runtime. The Runtime manages deterministic process data and stores it in the Global Data Space (GDS).

Key architectural components :

PLCnext ROS Bridge

Concept

At its core, the PLCnext ROS Bridge is a custom ROS node with dedicated services running inside a Docker container, packaged as a PLCnext App. It provides a bidirectional communication gateway between the PLCnext Global Data Space (industrial side) and ROS topics (robotics side).

To illustrate this, consider a motor connected to the PLC via EtherCAT/FSoE or PROFINET/PROFIsafe. The motor, along with its associated safety functions, can be managed through simple PLC logic and represented by a set of variables. Depending on the implementation, these variables, such as setpoints, command velocities, etc., can be exposed to ROS. When the navigation stack publishes a command velocity, the ROS Bridge, as a subscriber to this topic, writes the received values to the corresponding variable on the PLC side. Likewise, information such as safety status or system state can be sent from the PLC to ROS and made available through a defined topic.

Commissioning Workflow

The ROS Bridge Node is generated through an automated code-generation process. This process is driven by the Interface Description File (IDF), which defines the PLC instance paths (variables) that should be exposed to ROS.

A typical build process performs the following steps:

  1. Building the ROS Packages
    • Parse the IDF and generate the source code for the topic, publisher and subscribers
    • Build the ROS Node
  2. Place the resulting binaries and gRPC dependencies into a Docker image with a minimal ros-core installation.
  3. Package the Docker image, together with required metadata, into a read-only PLCnext App.

The resulting App can be deployed to a PLCnext Controller using the Web-Based Management (WBM) interface. While it is possible to build everything in a local environment, the project is designed to be built via CI/CD. An example pipeline can also be found in the GitHub repository.

Runtime Behaviour

After installation, the App starts the container defined via the compose file. Inside this container, the generated ROS Node connects to the Global Data Space using the built gRPC client and then exposes the selected PLC variables via ROS publishers and subscribers. This enables ROS developers to integrate automation components, such as sensors, actuators, I/O modules, and fieldbus devices, into a ROS-based architecture through the GDS. Moreover, the Bridge sets up a set of services that enable users to read and write information at runtime.

Further Reading

More Information about the PLCnext Technology:

[WWW] https://rosindustrial.org/news/2026/3/27/plcnext-ros-bridge-enabling-hardware-interoperability-between-industrial-plcs-and-ros

ROS Discourse General: Questions on Zero-Copy for Variable-Size Messages (PointCloud2) with Iceoryx in ROS 2

Hi everyone,

I am currently working on optimizing high-bandwidth sensor data transmission (specifically LiDAR point clouds) using ROS 2 and Iceoryx for zero-copy communication.

I have successfully set up the Iceoryx environment and confirmed zero-copy works for fixed-size types. However, I am facing challenges when applying this to variable-size messages, such as sensor_msgs/msg/PointCloud2.

As I understand it, Iceoryx typically requires pre-allocated memory pools with fixed chunks. In the case of PointCloud2, the data size can vary depending on the LiDAR’s points (in my case, around 5.2MB per message).

I have two specific questions:

1. Best practices for variable-size data like PointCloud2

How should we handle messages where the size is not strictly fixed at compile-time while still maintaining zero-copy benefits? Should we always pre-allocate the “worst-case” maximum size for the underlying buffers? If anyone has implemented this for sensor_msgs/msg/PointCloud2 or similar dynamic types, I would appreciate any advice or examples.

2. Tuning RouDi Configuration (size and count)

Regarding the roudi_config.toml (or the RouDi memory pool setup), what is the general rule of thumb for determining the optimal size and count?

For high-resolution LiDAR data:

I’ve already got Iceoryx installed and basic IPC working, but I want to ensure my configuration is production-ready for large-scale sensor data.

Thank you in advance for your insights!

4 posts - 3 participants

Read full topic

[WWW] https://discourse.openrobotics.org/t/questions-on-zero-copy-for-variable-size-messages-pointcloud2-with-iceoryx-in-ros-2/53585

ROS Discourse General: WEBINAR: Accelerating Robotics Development with Qt Robotics Framework

Join Qt Group Webinar

Accelerating Robotics Development with Qt Robotics Framework

image

Qt Robotics Framework (QRF) introduces a fast, reliable way to connect Qt‑based applications (QML and C++) with ROS2 middleware. By automatically generating strongly‑typed Qt/QML bindings from ROS2 interface definitions, QRF enables robotics teams to integrate control, visualization, and simulation capabilities with minimal boilerplate and maximum safety.

In this webinar, Qt Group’s engineers and industry experts demonstrate how QRF simplifies prototyping, reduces integration complexity, and helps teams move rapidly from concept to production.

Whether you’re building robot controllers, diagnostics dashboards, or simulation environments, Qt Robotics Framework reduces the development cycle and improves reliability across your robotics stack.

Speakers:

Accelerating Robotics Development with Qt Robotics Framework

1 post - 1 participant

Read full topic

[WWW] https://discourse.openrobotics.org/t/webinar-accelerating-robotics-development-with-qt-robotics-framework/53584

ROS Discourse General: ROS2 Studio — GUI tool for performance monitoring, bag operations and system dashboard

Hi ROS community! :waving_hand:

I’d like to share a tool I built — ROS2 Studio, a single GUI that brings together the most common ROS2 monitoring and bag operations in one place.

What is ROS2 Studio?

ROS2 Studio is a PyQt5-based desktop GUI that runs as a native ROS2 CLI extension (ros2 studio). Instead of juggling multiple terminal windows, everything is accessible from one interface.

Features

Installation

cd ~/ros2_ws/src
git clone https://github.com/Sourav0607/ROS2-STUDIO
cd ~/ros2_ws
colcon build --packages-select ros2_studio
source install/setup.bash
ros2 studio

Compatibility

Tested on ROS2 Humble and Jazzy on Ubuntu 22.04.

Links

Feedback, issues, and contributions are very welcome! I’m actively maintaining this and plan to add more features based on community input.

— Sourav

systm dashboard

bag play

bag recorder

convert to csv

performanc metrics

1 post - 1 participant

Read full topic

[WWW] https://discourse.openrobotics.org/t/ros2-studio-gui-tool-for-performance-monitoring-bag-operations-and-system-dashboard/53554

ROS Discourse General: Remote Control of Robotic Arms – Using a Standard Gamepad

Gamepad Control for PiPER Manipulator

1. Abstract

This document implements intuitive control of the PiPER robotic arm using a standard gamepad. With a common gamepad, you can operate the PiPER manipulator in a visualized environment, delivering a precise and intuitive control experience.

Tags

PiPER Manipulator, Gamepad Teleoperation, Joint Control, Pose Control, Gripper Control, Forward & Inverse Kinematics

2. Repositories

3. Function Demo

20260326-173204

4. Environment Setup

Clone the project and enter the root directory:

git clone https://github.com/kehuanjack/Gamepad_PiPER.git
cd Gamepad_PiPER

Install common dependencies and kinematics libraries (choose one option; pytracik is recommended):

Option 1: Based on pinocchio

(Python == 3.9; requires piper_ros and sourcing the ROS workspace, otherwise meshes will not be found)

conda create -n test_pinocchio python=3.9.* -y
conda activate test_pinocchio
pip3 install -r requirements_common.txt --upgrade
conda install pinocchio=3.6.0 -c conda-forge
pip install meshcat
pip install casadi

In main.py and main_virtual.py, select:from src.gamepad_pin import RoboticArmController

Option 2: Based on PyRoKi

(Python >= 3.10)

conda create -n test_pyroki python=3.10.* -y
conda activate test_pyroki
pip3 install -r requirements_common.txt --upgrade
pip3 install pyroki@git+https://github.com/chungmin99/pyroki.git@f234516

In main.py and main_virtual.py, select:from src.gamepad_limit import RoboticArmController orfrom src.gamepad_no_limit import RoboticArmController

Option 3: Based on cuRobo

(Python >= 3.8; CUDA 11.8 recommended)

conda create -n test_curobo python=3.10.* -y
conda activate test_curobo
pip3 install -r requirements_common.txt --upgrade
sudo apt install git-lfs && cd ../
git clone https://github.com/NVlabs/curobo.git && cd curobo
pip3 install "numpy<2.0" "torch==2.0.0" pytest lark
pip3 install -e . --no-build-isolation
python3 -m pytest .
cd ../Gamepad_PiPER

In main.py and main_virtual.py, select:from src.gamepad_curobo import RoboticArmController

Option 4: Based on pytracik

(Python >= 3.10)

conda create -n test_tracik python=3.10.* -y
conda activate test_tracik
pip3 install -r requirements_common.txt --upgrade
git clone https://github.com/chenhaox/pytracik.git
cd pytracik
pip install -r requirements.txt
sudo apt install g++ libboost-all-dev libeigen3-dev liborocos-kdl-dev libnlopt-dev libnlopt-cxx-dev
python setup_linux.py install --user

In main.py and main_virtual.py, select:from src.gamepad_trac_ik import RoboticArmController

5. Execution Steps

  1. Connect manipulator and activate CAN interface:sudo ip link set can0 up type can bitrate 1000000

  2. Connect gamepad:Connect the gamepad to the PC via USB or Bluetooth.

  3. Launch control script:Run python3 main.py or python3 main_virtual.py in the project directory.It is recommended to test with main_virtual.py first in simulation mode.

  4. Verify gamepad connection:Check console output to confirm the gamepad is recognized.

  5. Web visualization:Open a browser and go to http://localhost:8080 to view the manipulator status.

  6. Start control:Operate the manipulator according to the gamepad mapping.

6. Gamepad Control Instructions

6.1 Button Mapping

Button Short Press Function Long Press Function
HOME Connect / Disconnect manipulator None
START Switch high-level control mode (Joint / Pose) Switch low-level control mode (Joint / Pose)
BACK Switch low-level command mode (Position-Velocity 0x00 / Fast Response 0xAD) None
Y Go to home position None
A Save current position Clear current saved position
B Restore previous saved position None
X Switch playback order Clear all saved positions
LB Increase speed factor (high-level) Decrease speed factor (high-level)
RB Increase movement speed (low-level) Decrease movement speed (low-level)

6.2 Joystick & Trigger Functions

Control Joint Mode Pose Mode
Left Joystick J1 (Base rotation): Left / RightJ2 (Shoulder): Up / Down End-effector X / Y translation
Right Joystick J3 (Elbow): Up / DownJ6 (Wrist rotation): Left / Right End-effector Z translation & Z-axis rotation
D-Pad J4 (Wrist yaw): Left / RightJ5 (Wrist pitch): Up / Down End-effector X / Y-axis rotation
Left Trigger (LT) Close gripper Close gripper
Right Trigger (RT) Open gripper Open gripper

6.3 Special Functions

6.3.1 Gripper Control

6.3.2 Speed Control

6.3.3 Position Memory

Notes

1 post - 1 participant

Read full topic

[WWW] https://discourse.openrobotics.org/t/remote-control-of-robotic-arms-using-a-standard-gamepad/53550

ROS Discourse General: FusionCore, which is a ROS 2 Jazzy sensor fusion package (robot_localization replacement)

Hey everyone,
I’ve been working on FusionCore for the last few months… it’s a ROS 2 Jazzy sensor fusion package that aims to bridge the gap left by the deprecation of robot_localization.

There wasn’t anything user-friendly available for ROS 2 Jazzy. It merges IMU, wheel encoders, and GPS/GNSS into a single, reliable position estimate at 100Hz. No need for manual covariance matrices…. just one YAML config file.

GitHub: https://github.com/manankharwar/fusioncore

image

I respond to issues within 24 hours. If you’re working on a wheeled robot with GPS on ROS 2 Jazzy and hit problems….. open an issue or reply here.

6 posts - 3 participants

Read full topic

[WWW] https://discourse.openrobotics.org/t/fusioncore-which-is-a-ros-2-jazzy-sensor-fusion-package-robot-localization-replacement/53502

ROS Discourse General: ROSCon Global 2026: Call for Sponsors

ROSCon_2026_Horizontal_FINAL

ROSCon Global 2026: Call for Sponsors

Hi Everyone,

The ROSCon executive committee is happy to announce that sponsorship opportunities are now available for ROSCon Global 2026 in Toronto (September 22-24)!

If you would like to get your product or service in front of over a thousand robot application developers, decision makers, and students, ROSCon Global is the place to be!

This year we are aiming for over 1,000 attendees, and if this event is anything like ROSCon 2025, our attendees will represent:

This year we will be offering our largest number of sponsorship opportunities yet, including the chance to:

Our full ROSCon Global 2026 sponsorship prospectus is now available on the ROSCon website, and you can start your ROSCon journey by emailing roscon-2026-ec@roscon.org. We recommend you start your sponsorship conversation as soon as possible, as ROSCon booths and sponsorship opportunities tend to sell out quickly!

2 posts - 1 participant

Read full topic

[WWW] https://discourse.openrobotics.org/t/roscon-global-2026-call-for-sponsors/53498

ROS Discourse General: iRoboCity2030 Summer School 2026: ROS 2, AI and Field Robotics

International iRoboCity2030 Summer School 2026: ROS 2, AI and Field Robotics

Madrid, Spain, 22–26 June 2026

Web: iRoboCity2030 Summer School 2026 – ROS 2, AI and Field Robotics
Email: irobocity2030@gmail.com

Registration deadlines:

MOTIVATION AND DESCRIPTION

The iRoboCity2030 Summer School 2026, entitled “ROS 2: AI and Field Robotics”, offers undergraduate and graduate students from all over the world an intensive one-week experience focused on the technologies driving the new generation of autonomous and intelligent robots. The program combines theoretical and practical training in ROS 2 (Robot Operating System 2), Artificial Intelligence, and Field Robotics, guided by researchers from leading universities and technological centers in Madrid. Over five days, participants will advance both theoretical knowledge and practical skills, from the fundamentals of ROS 2 to the application of AI techniques in different field robotics domains such as autonomous driving, quadrupedal robots, agricultural robotics, aerial robotics.

In addition to the academic program, the summer school will feature two plenary lectures delivered by internationally recognized leaders in the ROS 2 ecosystem. The first will be given by Steve Macenski (OpenNavigation), lead developer of the Nav2 system, widely regarded as the reference standard for autonomous robot navigation in ROS 2. The second will be delivered by Davide Faconti, creator of BehaviorTrees.CPP and Groot, tools that are extensively used for developing robotics applications based on Behavior Trees.

The school’s pedagogical approach is strongly practical and collaborative: participants will learn by doing, combining knowledge of artificial intelligence, control, and perception with their direct application in ROS 2, both in simulation environments and on real robotic platforms. Beyond its technical dimension, the school promotes intercultural collaboration and international teamwork, creating a dynamic environment for learning and experimentation.
This summer school is part of the iRoboCity2030 initiative, the robotics innovation network of the Community of Madrid, and represents a joint effort by the region’s leading universities and research centers to promote advanced training and knowledge transfer in robotics and artificial intelligence.

LIST OF SPEAKERS AND INSTRUCTORS

Steve Macenski (OpenNavigation) — “Nav2 & ROS 2 Overview: Techniques & Applications Powering an Industry”
Davide Faconti (BehaviorTrees.CPP / Groot) — “Being a roboticist in the era of AI: what changed and what didn’t”

Carlos Balaguer, UC3M
Francisco Martín Rico, URJC
José M. Cañas, URJC
Luis Miguel Bergasa, UAH
Fabio Sánchez, UAH
Miguel Antunes, UAH
Santiago Montiel, UAH
Rodrigo Gutiérrez, UAH
Christyan Cruz, UPM
Roemi Fernández, CSIC
Raúl Fernández, UCM
…

ORGANIZATION

This summer school is part of the iRoboCity2030 initiative, the Robotics Innovation Network of the Madrid Region. It represents a joint effort by leading universities and research institutions to promote advanced training and knowledge transfer in robotics and artificial intelligence.

SOCIAL EXPERIENCE

The Summer School will take place in the city centre of Madrid and well connected by public transport. The city is famous for its lively atmosphere, outdoor cafés, cultural events, and late-evening social life, providing countless opportunities to meet people and enjoy experiences beyond the classroom. With its warm climate, rich culture, excellent food, and safe, walkable neighborhoods, Madrid combines academic learning with an unforgettable social experience.

1 post - 1 participant

Read full topic

[WWW] https://discourse.openrobotics.org/t/irobocity2030-summer-school-2026-ros-2-ai-and-field-robotics/53487

ROS Discourse General: Polka: A unified node for all pointcloud pre-processing/merging

Hello folks,

Point cloud pre-processing including deskewing, merging, and filtering traditionally requires a chain of nodes working in tandem, many of which are no longer actively maintained. Setting up these individual filtering stages often consumes excessive CPU cycles and precious DDS bandwidth.

What if you had a single, low-latency node that could voxellize, deskew, downsample, and merge scans in one go? By passing only mission-critical features to your odometry nodes and downstream, you significantly reduce lag and bandwidth usage across your entire navigation or SLAM stack. A single node to accomplish this.

I developed Polka to solve this. It’s a drop-in replacement for multiple pre-processing nodes and if you need to save CPU, you can run the entire pipeline on your GPU.

Latency across both being ~40ms.

Current features:

I’d love your feedback, and if you find the project useful, please consider leaving a star on GitHub!

GitHub - Pana1v/polka

4 posts - 2 participants

Read full topic

[WWW] https://discourse.openrobotics.org/t/polka-a-unified-node-for-all-pointcloud-pre-processing-merging/53457

ROS Discourse General: TechSolstice '26 (Annual Technical Fest of MIT Bengaluru)

Hello ROS Community,

Tech Solstice 2026 is the annual technology festival hosted by the Manipal Institute of Technology (MIT), Bengaluru, featuring a diverse lineup of competitive robotics events.

We invite students, robotics enthusiasts, and builders to participate in a series of hands-on challenges designed to test speed, control systems, autonomous navigation, and combat robotics.

Total Prize Pool: ₹2.6 Lakhs+

Robotics Events (further details can be found on the website)
• Robo Race
• Cosmo Clench
• Maze Runner
• Line Follower
• Robo Wars

Format & Timeline
Event Dates: 27 March – 29 March 2026

Participants will compete on-site across multiple rounds depending on the event format, with final winners determined through performance-based evaluation.

Participants are encouraged to utilize embedded systems, ROS-based architectures, simulation tools, and custom-built hardware where applicable.

Further details and registration:
https://techsolstice.mitblr.in

We look forward to participation from the robotics community.

1 post - 1 participant

Read full topic

[WWW] https://discourse.openrobotics.org/t/techsolstice-26-annual-technical-fest-of-mit-bengaluru/53405

ROS Discourse General: Transitive Robotics Tryout | Cloud Robotics WG Meeting 2026-03-23

Please come and join us for this coming meeting at Mon, Mar 23, 2026 4:00 PM UTC→Mon, Mar 23, 2026 5:00 PM UTC, where we plan to try out Transitive Robotics. Transitive Robotics is a service that allows users to deploy and manage robots, including giving full-stack robotic capabilities. Capabilities include data capture and storage, which makes Transitive Robotics a useful case study for our focus on Logging & Observability.

Last session, we continued our tryout of the Canonical Observability Stack (COS) from the previous meeting. We were successful in hosting the full stack and viewing the public pages, as well as connecting a simulated robot to the stack. We could view logs and system statistics from the simulated robot. If you’re interested to watch the recorded part of the meeting, it is available on YouTube.

The meeting link for next meeting is here, and you can sign up to our calendar or our Google Group for meeting notifications or keep an eye on the Cloud Robotics Hub.

Hopefully we will see you there!

1 post - 1 participant

Read full topic

[WWW] https://discourse.openrobotics.org/t/transitive-robotics-tryout-cloud-robotics-wg-meeting-2026-03-23/53385

ROS Discourse General: Mastering Nero – MoveIt2 Part II

Mastering Nero – MoveIt2 Part II

In the previous session, we built a complete MoveIt2 package from a URDF model using the MoveIt Setup Assistant, and realized motion planning and visual control of the robotic arm.

In this session, we will explain how to set up a co-simulation environment for MoveIt2 and Isaac Sim. By configuring the ROS Bridge, adjusting hardware interface topics, and integrating the URDF model, we will achieve seamless connection between the simulator and motion planning, providing a complete practical solution for robot algorithm development and system integration.

Abstract

Co-simulation of MoveIt2 and Isaac Sim

Tags

ROS2, MoveIt2, robotic arm, Nero

Repositories

Operating Environment

System: Ubuntu 22.04
ROS Version: Humble
Isaac Sim Version: 5.1

Download USD Model

We use the Nero USD model provided by AgileX Robotics:

cd ~/nero_ws/src
git clone https://github.com/agilexrobotics/agx_arm_sim

If you haven’t installed Isaac Sim or want to import your own URDF model, refer to:

Isaac_Sim Import PiPER URDF

Launch Isaac Sim

Navigate to the Isaac Sim folder, use the script to launch the ROS Bridge Extension, then click Start to launch Isaac Sim:

cd isaac-sim-standalone-5.1.0-linux-x86_64/
./isaac-sim.selector.sh

isaac_1

Then drag and drop the newly downloaded USD model into Isaac Sim to open it:

isaac_2

In the USD file, you need to add an ActionGraph for communication with the ROS side. The ActionGraph is as follows:

isaac_3

Configure ActionGraph

articulation_controller

Modify targetPrim according to actual conditions; targetPrim is generally /World/nero_description/base_link:

isaac_4

ros2_subscribe_joint_state

Modify topicName according to actual conditions; topicName must correspond to the URDF, here it is isaac_joint_commands:

isaac_5

ros2_publish_joint_state

Modify targetPrim and topicName according to actual conditions; targetPrim is generally /World/nero_description/base_link; topicName must correspond to the URDF, here it is isaac_joint_states:

isaac_6

After starting the simulation, use ros2 topic list in the terminal; the following topics can be viewed:

isaac_7

Modify MoveIt Package

Open nero_description.ros2_control.xacro and add topic parameters:

gedit nero_ws/src/nero_moveit2_config/config/nero_description.ros2_control.xacro

isaac_8

            <hardware>
                <!-- By default, set up controllers for simulation. This won't work on real hardware -->
                <!-- <plugin>mock_components/GenericSystem</plugin> -->
                <plugin>topic_based_ros2_control/TopicBasedSystem</plugin>
                <param name="joint_commands_topic">/isaac_joint_commands</param>
                <param name="joint_states_topic">/isaac_joint_states</param>
            </hardware>

Then save and compile the code, then launch MoveIt2:

cd ~/nero_ws
colcon build
source install/setup.bash
ros2 launch nero_moveit2_config demo.launch.py

1 post - 1 participant

Read full topic

[WWW] https://discourse.openrobotics.org/t/mastering-nero-moveit2-part-ii/53369

ROS Discourse General: NWO Robotics API `pip install nwo-robotics - Production Platform Built on Xiaomi-Robotics-0

My name is Ciprian Pater, and I’m reaching out on behalf of PUBLICAE (formerly a student firm at UiA Nyskaping Incubator) to introduce you to NWO Robotics Cloud (nworobotics.cloud) - a comprehensive production-grade API platform we’ve built that extends and enhances the capabilities of the groundbreaking Xiaomi-Robotics-0 model. While Xiaomi-Robotics-0 represents a remarkable achievement in Vision-Language-Action modeling, we’ve identified several critical gaps between a research-grade model and a production-ready robotics platform. Our API addresses these gaps while showcasing the full potential of VLA architecture.

(Attaching some screenshots below for UX reference).

Technical whitepaper at https://www.researchgate.net/publication/401902987_NWO_Robotics_API_WHITEPAPER

NWO Robotics CLI COMMAND GROUPS

Install instantly via pip and start in seconds:

pip install nwo-robotics

Quick Start: nwo auth login → Enter your API key from: nworobotics.cloud → nwo robot “pick up the box”

═══════════════════════════════

• nwo auth - Login/logout with API key

• nwo robot - Send commands, health checks, learn params

• nwo models - List models, preview routing decisions

• nwo swarm - Create swarms, add agents

• nwo iot - Send commands with sensor data

• nwo tasks - Task planning and progress tracking

• nwo learning - Access learning system

• nwo safety - Enable real-time safety monitoring

• nwo templates - Create reusable task templates

• nwo config - Manage CLI configuration etc:

NWO ROBOTICS API v2.0 - BREAKTHROUGH CAPABILITIES

═══════════════════════════════════════

FEATURE | TECHNICAL DESCRIPTION

-------------------------|------------------------------------------

Model Router | Semantic classification + 35% latency

                     | reduction through intelligent LM selection

-------------------------|------------------------------------------

Task Planner | DAG decomposition with topological

                     | sorting + checkpoint recovery

-------------------------|------------------------------------------

Learning System | Vector database + collaborative filtering

                     | for parameter optimization

-------------------------|------------------------------------------

IoT Fusion | Kalman-filtered multi-modal sensor

                     | streams with sub-10cm accuracy

-------------------------|------------------------------------------

Enterprise API | SHA-256 auth, JWT sessions, multi-tenant

                     | isolation

-------------------------|------------------------------------------

Edge Deployment | 200+ locations, Anycast routing, <50ms

                     | latency, 99.99% SLA

-------------------------|------------------------------------------

Model Registry | Real-time p50/p95/p99 metrics + A/B testing

-------------------------|------------------------------------------

Robot Control | RESTful endpoints with collision detection

                     | + <10ms emergency stop

-------------------------|------------------------------------------

═════════════════

INTELLIGENT MODEL ROUTER (v2.0)

═════════════════

Our multi-model routing system analyzes natural language instructions

in real-time using semantic classification algorithms, automatically

selecting the optimal language model for each specific task type.

For OCR tasks, the router selects DeepSeek-OCR-2B with 97% accuracy;

for manipulation tasks, it routes to Xiaomi-Robotics-0. This

intelligent selection reduces inference latency by 35% while

improving task success rates through model specialization.

═════════════════

TASK PLANNER (Layer 3 Architecture)

═════════════════

The Task Planner decomposes high-level natural language instructions

into executable subtasks using dependency graph analysis and

topological sorting. When a user requests “Clean the warehouse,”

the system generates a directed acyclic graph of subtasks

(navigate→identify→grasp→transport→place) with estimated durations

and parallel execution paths. This hierarchical planning reduces

complex mission failure rates by implementing checkpoint recovery

at each subtask boundary.

═════════════════

LEARNING SYSTEM (Layer 4 - Continuous Improvement)

═════════════════

Our parameter optimization engine maintains a vector database of

task execution outcomes, using collaborative filtering algorithms

to recommend optimal grip forces, approach velocities, and grasp strategies based on historical performance data.

For fragile object manipulation, the system has learned that 0.28N grip force with

12cm/s approach velocity yields 94% success rates across 127 similar

tasks, automatically adjusting robot parameters without human

intervention.

═════════════════

IOT SENSOR FUSION (Layer 2 - Environmental Context)

═════════════════

The API integrates multi-modal sensor streams (GPS coordinates,

LiDAR point clouds, IMU orientation, temperature/humidity readings)

into the inference pipeline through Kalman-filtered sensor fusion.

This environmental awareness enables context-aware decision making -

for example, automatically reducing grip force when temperature

sensors detect a hot object, or adjusting navigation paths based

on real-time LiDAR obstacle detection with sub-10cm accuracy.

═════════════════

ENTERPRISE API INFRASTRUCTURE

═════════════════

We’ve implemented a complete enterprise API layer including X-API-Key

authentication with SHA-256 hashing, JWT token-based session

management, per-organization rate limiting with token bucket

algorithms, and comprehensive audit logging. The system supports

multi-tenant deployment with complete data isolation between

organizations, enabling commercial deployment scenarios that raw

model weights cannot address.

═════════════════

EDGE DEPLOYMENT (Global Low-Latency)

═════════════════

Our Cloudflare Worker deployment distributes inference across 200+

global edge locations using Anycast routing, achieving <50ms response

times from anywhere in the world through intelligent geo-routing.

The serverless architecture eliminates cold start latency entirely

while providing automatic DDoS protection and 99.99% uptime SLA -

critical capabilities for production robotics deployments that

require sub-100ms control loop response times.

═════════════════

MODEL REGISTRY & PERFORMANCE ANALYTICS

═════════════════

The Model Registry maintains real-time performance metrics including

per-model success rates, p50/p95/p99 latency percentiles, and

cost-per-inference calculations across different hardware

configurations. This telemetry enables data-driven model selection

and automatic A/B testing of model versions, ensuring optimal

performance as your Xiaomi-Robotics-0 model evolves.

═════════════════

ROBOT CONTROL API

═════════════════

We provide RESTful endpoints for real-time robot state querying

(joint angles, gripper position, battery telemetry) and action

execution with safety interlocks. The action execution pipeline

includes collision detection through bounding box overlap

calculations, emergency stop capabilities with <10ms latency, and

execution confirmation through sensor feedback loops - essential

safety features absent from the base model inference API.

MULTI-AGENT COORDINATION

Enable multiple robots to collaborate on complex tasks. Master

agents break down objectives and distribute work to worker agents

with shared memory and handoff zones.

→ Swarm intelligence, task delegation, conflict resolution

FEW-SHOT LEARNING

Robots learn new tasks from just 3-5 demonstrations instead of

programming. Skills adapt to user preferences and improve

continuously from execution feedback.

→ Learn from demonstrations, skill composition, personalisation.

ADVANCED PERCEPTION

Multi-modal sensor fusion (camera, depth, LiDAR, thermal) with

6DOF pose estimation. Detect humans, recognize gestures, predict

motion, and calculate optimal grasp points.

→ 3D scene understanding, human detection, gesture recognition

SAFETY LAYER

Continuous safety validation with 50ms checks. Force/torque

limits, human proximity detection, collision prediction,

configurable safety zones, and full audit logging for compliance.

→ Real-time monitoring, emergency stop, collision prediction

GESTURE CONTROL

Real-time hand gesture recognition for intuitive robot control.

Wave to pause/stop, point to direct attention, draw paths for

navigation. Works from 0.5-3 meters with 95%+ accuracy.

→ Wave to stop, point to indicate location

VOICE WAKE WORD

Always-listening voice activation with custom wake words.

Natural language command parsing with intent extraction. Supports

multiple languages and voice profiles for personalised interactions.

→ “Hey Robot, [command]”

PROGRESS UPDATES

Real-time task progress reporting with time estimation.

Subscribable WebSocket streams for live updates. Milestone

notifications when tasks reach defined checkpoints.

→ “Task 60% complete, 2 minutes remaining”

FAILURE RECOVERY

Intelligent error recovery with strategy adaptation. If grasp

fails, automatically try different angles, grip forces, or

approaches. Escalates to human operator only after exhausting

recovery options.

→ Auto-retry with different angles/strategies

TASK TEMPLATES

Pre-configured task sequences for common workflows. Schedule-based

activation with variable substitution. Templates can be nested,

parameterized, and shared across robot fleets.

→ “Morning routine”, “Closing procedures”

PHYSICS-AWARE PLANNING

Motion planning with real-world physics simulation. Detects

impossible trajectories, unstable grasps, and collision risks

before execution. Integrates with MuJoCo and Isaac Sim.

→ Simulate before execute, avoid physics violations

REAL-TIME SAFETY

Runtime safety monitoring with microsecond latency. Dynamically

adjusts robot speed based on proximity to humans. Emergency stop

with guaranteed response time under 10ms.

→ Continuous monitoring, dynamic speed adjustment

SEMANTIC NAVIGATION

Navigate using natural language landmarks instead of coordinates.

Understand spatial relationships (“next to the table”, "behind

the sofa"). Dynamic path recalculation when obstacles appear.

Thank you in advance for your consideration and feedback.

Sincere Regards

Ciprian Pater

PUBLICAE / NWO Robotics

+4797521288

1 post - 1 participant

Read full topic

[WWW] https://discourse.openrobotics.org/t/nwo-robotics-api-pip-install-nwo-robotics-production-platform-built-on-xiaomi-robotics-0/53349

ROS Discourse General: JdeRobot Google Summer of Code 2026

Hi folks,

we at JdeRobot org are partipating in Google Summer of Code 2026. All our proposed projects are on open source Robotics, and most of them (7/8) in ROS 2 related software. They are all described at our ideas list for GSoC-2026, including their summary and illustrative videos.

Motivated candidates are welcome :slight_smile: Please check the Application Instructions, as we request a Technical Challenge and some interactions in our GitHub repositories before talking to our mentors and submitting your proposal.

Cheers,

JoseMaria

1 post - 1 participant

Read full topic

[WWW] https://discourse.openrobotics.org/t/jderobot-google-summer-of-code-2026/53344

ROS Discourse General: Introducing the Connext Robotics Toolkit for ROS 2

Hi ROS 2 Community,

I’m pleased to announce that RTI released enhanced support for ROS 2 and rmw_connextdds today. The new Connext Robotics Toolkit makes it much easier for ROS users to take advantage of Connext and DDS features to improve their development experience.

As many of you know, RTI has supported ROS 2 since the very beginning by providing our core DDS implementation at no charge for non-commercial use. The Connext Robotics Toolkit extends that support to our full Connext Professional product. This includes our broader platform around DDS – things like network tuning and debugging tools, system observability, and diverse network support, from shared memory to WAN.

In addition, we’re expanding our free license to include commercial prototyping. This means startups and other product teams building ROS-based systems can now take advantage of Connext at no charge. Starting with production-grade communication infrastructure will make it easier to scale from prototype to deployment.

Connext Robotics Toolkit

The Connext Robotics Toolkit is currently available for Kilted Kaiju and will be available for Lyrical Luth upon its release. If you’re exploring ways to leverage ROS in commercial systems or looking at RMW options beyond the default, you can find more details and installation instructions here: Connext Robotics Toolkit for ROS | RTI

Happy to answer questions or discuss with anyone interested.

1 post - 1 participant

Read full topic

[WWW] https://discourse.openrobotics.org/t/introducing-the-connext-robotics-toolkit-for-ros-2/53311

ROS Discourse General: Per-robot economic settlement for industrial ROS2 fleets

As ROS2 fleets move into commercial deployments serving external clients, one infrastructure gap is shared economic verification between the fleet operator and their customer. The operator’s internal logs don’t give the client independent verification of what work was completed, leading to manual reconciliation and disputes as fleets scale.

Built a settlement layer that monitors ROS2 lifecycle events and generates verified timestamped records per robot per completed task. Both operator and client can verify independently. Each robot builds a portable work history over time useful for service billing, equipment valuation, and proving utilization to potential customers.

Already compatible with standard ROS2 lifecycle management. Integration details here:https://github.com/FoundryNet/foundry_net_MINT/blob/main/FoundryNet%20API%20Client/foundry-client.py

Interested in feedback from anyone deploying ROS2 fleets commercially and dealing with the billing side of multi-client operations.

Cheers!

1 post - 1 participant

Read full topic

[WWW] https://discourse.openrobotics.org/t/per-robot-economic-settlement-for-industrial-ros2-fleets/53268

2026-04-04 12:18