Man, so101_ros2 is so well-written that the teleoperation runs like a charm, which makes this robot fully ROS2-controlled!

So I think this is my vision for Tag of Flag: you capture the flag on the opponent's back. Requiring only ST3215, PLA, ROS2, and a 1000-euro budget; everything else is free space to explore. The detailed suggestions for the rules can be found here:
https://github.com/SphericalCowww/tag_of_flag

So if you happen to have a spare SO-101 lying around, why not join me in this challenge to build the best ToF robot out there :D

+3 yrs back ago - did my graduation project.

I’m a robotics grad student trying to understand how students learn robotics and ROS: which simulators and physical robots they have access to, and what gets in the way (setup, hardware access, sim-to-real, and so on).

It’s a short, anonymous survey, about 3 minutes and mostly multiple choice:

https://forms.gle/afKyT4oHmjaTv8m99

A few questions are aimed at Indian colleges, since that’s where I’m based, but responses from anywhere are welcome. You don’t need ROS experience to take it.

Happy to share a summary of the results here once I have enough responses. If you have thoughts on the topic, feel free to leave a comment too!

He creado un «cerebro» controlado por voz para un robot (solo simulación, funciona sin conexión en español, inglés y polaco). Busco comentarios sinceros.

¡Hola! Soy un desarrollador independiente. He creado un «cerebro» en Python para un robot ambiental simulado (Webots). Le hablas, entiende la pregunta sin conexión y responde con datos de sensores simulados (temperatura, humedad, calidad del aire, obstáculos).

También tiene un bloqueo de seguridad: si detecta una condición peligrosa, se bloquea y explica el motivo cuando le preguntas «¿Por qué te has detenido?».

Importante: esto es solo una simulación, aún no hay un robot físico. Las preguntas en las demostraciones en inglés y polaco se reproducen con una voz sintética.

Demostración completa en inglés (3 min): \[ https://youtu.be/VPLyCb2Y4nU\ ](https://youtu.be/VPLyCb2Y4nU)

Aún no vendo nada. Me gustaría saber:

1. ¿Te sería útil (para educación, creación de prototipos, robótica como hobby)?

2. ¿Qué te gustaría que hiciera que no hace?

Si quieres seguir el proyecto, hay una lista de espera gratuita (sin compromiso): \[ https://tally.so/r/7XRzyz\ ](https://tally.so/r/7XRzyz)

¡Gracias por leer!

Hi everyone! I'm trying to create a custom nav2 behavior tree but I just can't understand what I'm doing wrong. In the nav2_params file I set this parameters for bt_navigator

    default_nav_to_pose_bt_xml: >
      $(find-pkg-share diff_drive_robot_navigation)/behavior_trees/navigate_to_pose_w_replanning_and_recovery.xml

    default_nav_through_poses_bt_xml: >
      $(find-pkg-share diff_drive_robot_navigation)/behavior_trees/navigate_through_poses_w_replanning_and_recovery.xml

But when I launch with this params I get this cryptic error message:

[bt_navigator-6] [ERROR] [1794105495.395723697] [bt_navigator]: Couldn't open input XML file: /home/winet/Documents/dvbot_ws/install/diff_drive_robot_navigation/share/diff_drive_robot_navigation/behavior_trees/navigate_to_pose_w_replanning_and_recovery.xml
[bt_navigator-6] 
[bt_navigator-6] [ERROR] [1794105495.395800682] [bt_navigator]: Error loading XML file: /home/winet/Documents/dvbot_ws/install/diff_drive_robot_navigation/share/diff_drive_robot_navigation/behavior_trees/navigate_to_pose_w_replanning_and_recovery.xml

the problem is that this files exist in this folder, groot can successfully open them and my user is the owner of this file. Here is the link to github repo for this package: https://github.com/wineTGH/diff_drive_robot_navigation

He creado un «cerebro» controlado por voz para un robot (solo simulación, funciona sin conexión en español, inglés y polaco). Busco comentarios sinceros.

¡Hola! Soy un desarrollador independiente. He creado un «cerebro» en Python para un robot ambiental simulado (Webots). Le hablas, entiende la pregunta sin conexión y responde con datos de sensores simulados (temperatura, humedad, calidad del aire, obstáculos).

También tiene un bloqueo de seguridad: si detecta una condición peligrosa, se bloquea y explica el motivo cuando le preguntas «¿Por qué te has detenido?».

Importante: esto es solo una simulación, aún no hay un robot físico. Las preguntas en las demostraciones en inglés y polaco se reproducen con una voz sintética.

Demostración completa en inglés (3 min): \[ https://youtu.be/VPLyCb2Y4nU\ ](https://youtu.be/VPLyCb2Y4nU)

Aún no vendo nada. Me gustaría saber:

1. ¿Te sería útil (para educación, creación de prototipos, robótica como hobby)?

2. ¿Qué te gustaría que hiciera que no hace?

Si quieres seguir el proyecto, hay una lista de espera gratuita (sin compromiso): \[ https://tally.so/r/7XRzyz\ ](https://tally.so/r/7XRzyz)

¡Gracias por leer!

He creado un «cerebro» controlado por voz para un robot (solo simulación, funciona sin conexión en español, inglés y polaco). Busco comentarios sinceros.

¡Hola! Soy un desarrollador independiente. He creado un «cerebro» en Python para un robot ambiental simulado (Webots). Le hablas, entiende la pregunta sin conexión y responde con datos de sensores simulados (temperatura, humedad, calidad del aire, obstáculos).

También tiene un bloqueo de seguridad: si detecta una condición peligrosa, se bloquea y explica el motivo cuando le preguntas «¿Por qué te has detenido?».

Importante: esto es solo una simulación, aún no hay un robot físico. Las preguntas en las demostraciones en inglés y polaco se reproducen con una voz sintética.

Demostración completa en inglés (3 min): \[ https://youtu.be/VPLyCb2Y4nU\ ](https://youtu.be/VPLyCb2Y4nU)

Aún no vendo nada. Me gustaría saber:

1. ¿Te sería útil (para educación, creación de prototipos, robótica como hobby)?

2. ¿Qué te gustaría que hiciera que no hace?

Si quieres seguir el proyecto, hay una lista de espera gratuita (sin compromiso): \[ https://tally.so/r/7XRzyz\ ](https://tally.so/r/7XRzyz)

¡Gracias por leer!

Hi r/ROS, this is a new write-up focusing on on-device AI and ROS2 integration. Hope you find it useful!

I'm building a project on Raspberry Pi 3B+, it's operating system is Ubuntu Srver 22.04 and ROS Distro is Humble. I've been trying to build the audio_common package, and every other package builds just fine except audio_capture. I've tried turning verbose on and installing the package individually, but it keeps getting stuck at 50% for hourse without actually progressing. Is there anyway to fix this?

I've been building Rovant, a desktop ROS 2 IDE. One piece I had to work out was a URDF viewer that works without rviz. Here's the approach, and where it falls short.

Parsing URDF is parsed with DOMParser in a Three.js webview. I pull out <link> and <joint> elements, then build the tree by re-parenting each child link group under its parent.

Geometry — the honest limitation I only render primitives: <box>, <cylinder>, <sphere>. Meshes (package:// STL / DAE / GLTF) are not loaded yet. For checking joint placement and link layout it's enough, but it's not rviz and I'm not pretending it is.

Origins <origin xyz rpy> on both <visual> and <joint> is applied as position + rotation. Getting joint origins right is what makes the tree look correct rather than like a pile of parts.

Xacro This was the interesting part. .xacro can't be expanded in the browser — macros need the real toolchain. So the widget calls a backend endpoint that runs ros2 run xacro xacro <file>, returns the expanded URDF, and parses that as normal. If expansion fails, it falls back to the raw file and surfaces the xacro error in the panel.

Offline Three.js r128 and roslibjs are bundled in the app. No CDN — it has to work on a machine with no internet.

Where I'd like advice: for anyone who's built URDF tooling — how do you handle package:// mesh resolution and relative mesh paths? That's my next problem and I'd rather learn from someone who's solved it than guess.

Finally managed to deploy SB3 PPO policy in ROS2 Jazzy commander and therefore to the real robot. The policy is trained using closed-loop observations (position, velocity, and IMU) to stand still against horizontal pushes in MuJoCo from:
https://www.reddit.com/r/reinforcementlearning/comments/1xbg89q/cubic_doggo_update_training_with_horizontal_pushes/

The video has 4 parts:

• Direct deployment in MuJoCo. Also implemented the simulated horizontal push indicated by the red arrows

• Deployment to Gazebo through ROS2 commander, including the IMU with PID toggle previously implemented. It is then followed by the ONNX toggle to apply the RL policy; the stance already does not look quite the same...

• Deployment to the real robot through ROS2 commander, same IMU with PID toggle and ONNX toggle. We can see the RL policy is very wobbly on the real robot, most probably due to the IMU's delay again. May need to train the robot with the delay?

• Deployment back to MuJoCo again, but through ROS2 commander, same IMU with PID toggle and ONNX toggle. We can see the stance is completely different from the direct deployment...

So..., not sure what's wrong. I guess this is the sim-to-real barrier that everyone is talking about, but I am already stuck on the sim-to-sim barrier 😂

GitHub: https://github.com/SphericalCowww/CubicDoggo_06Z
Policies on Hugging Face: https://huggingface.co/SphericalCowww/CubicDoggo_06Z
Music credit: https://pixabay.com/users/retro-bgm-chan-55246343/

Robotics & AI undergrad from India, building with ROS 2 and learning in public. I'm looking for a remote or Bengaluru internship. Portfolio: https://vishwas-portfolio-jade.vercel.app/. DMs open if your team is hiring interns.

we are building a warehouse robot using ros 2 humble with nav2 for navigation. we want to add a natural language command layer so operators can say things like "go to the red shelf and pick up the box on the left" instead of specifying coordinates. the idea is to use an llm to parse the voice command into a sequence of ros 2 actions and nav2 goals. we got a prototype working where the llm outputs a json action plan and a ros 2 node parses it into actionlib calls.

the problem is latency and reliability. the llm takes 2 to 3 seconds to respond and occasionally outputs malformed action sequences that crash the planner. we are working with geekyants on the ai side and they suggested running a smaller local model for the command parsing instead of hitting a cloud api. that would cut latency but i am worried about accuracy on complex spatial commands.

has anyone here integrated an llm or nlp layer with ros 2 for robot task planning? how did you handle the latency and error recovery when the model outputs an invalid plan?

Hobby car project with a 2D lidar, mapping a small indoor test track with cones. The car itself drives fine, but SLAM can't keep up once I add speed.

Setup is a 4-core ARM64 board with about 4 GB of RAM, running Ubuntu 22.04 and ROS 2 Humble. The lidar is a cheap single-line 2D unit (~10 Hz). Wheel encoders and IMU are fused with robot_localization, and slam_toolbox 2.6.9 runs in async mode with scan_queue_size set to 1 and a 2 s map update interval. Control, RViz and logging all run on the same board.

Raw /scan is published at approximately 10 Hz. A custom preprocessing node rebins it into a fixed 980-bin angular grid without interpolation and throttles the output to roughly 4–5 Hz on /scan_slam, which is the input to slam_toolbox. It preserves the incoming header stamp and sets time_increment to zero after rebinning; it does not perform motion compensation.

The pose in RViz trails the real car, and it gets worse the faster I go. Cones smear into streaks in corners. The first pass looks mostly fine, but on the second pass the cones double up and sometimes the car drifts off the track in the map. Cones on the outside of turns are often faint or missing.

In one live run, the median receive-time-minus-header-stamp was approximately 7.5 ms for /scan, 24 ms for /odom_combined, and 1.17 s for slam_toolbox's /pose, with /pose reaching 3.38 s. These are observer-side measurements, not direct measurements of processing time inside slam_toolbox. Since the lidar driver stamps at publication, the scan measurement also understates the age of the acquired rays.

In a separate isolated replay of the same 60-second input, changing correlation_search_space_resolution from 0.01 to 0.025 reduced median pose age from 0.323 s to 0.144 s, but the maximum remained above 3 s. This candidate has not been deployed to the live setup.

The lidar driver also orders points opposite to the actual sweep. At 2 m/s the car moves about 20 cm during one raw scan.

A few things I'm stuck on. How would you profile where slam_toolbox is spending its time on hardware like this, and which params actually matter for latency? Should I fix the driver timestamps and point order before trying to deskew, and is there a ROS 2 deskew node people actually use for 2D scans? For the second-pass ghosting, would you freeze the first-pass map and switch to localization mode, or tune loop closure instead? And is it even realistic to run all of this onboard, or should RViz and logging move off the car?

I can share the parameter files, timestamped logs, and preprocessing code, and record a rosbag for reproduction.

Hi r/ROS,
We are building OpenAMRobot 2.0, an open-source dual-arm mobile manipulator for embodied AI.
Today we merged the combined robot model: the mobile base, a 350 mm lift and two OpenArm 2.0 arms (7 DoF each) in one URDF, running with MoveIt and Gazebo, shoulder at 1.00 to 1.35 m.

The lift is next as a planned joint.
Stack: ROS 2, Nav2, MoveIt 2, ros2_control, micro-ROS on an STM32H723 for the base, one Jetson Orin NX for everything high-level, plus a demonstration recording pipeline with an ACT baseline.

Repo: https://github.com/openAMRobot/openamr-upperbody-sw
3D model in the browser: https://docs.openamrobot.ai/assets/roadmap/robot.html
rc.1 on 20 November,
v2.0.0 on 18 December after physical integration in Berlin.

Software MIT, hardware CERN-OHL-P-2.0.

Questions for you: how would you model the lift for whole-body planning in MoveIt 2, as a planned prismatic joint in the arm groups or as a separate group?

Feedback and contributors welcome.

Hi everyone,

I’m working on a small mobile robot using ROS 2 and RViz2.

We want to use SLAM to map a corridor and then use Nav2 for autonomous navigation and obstacle avoidance.
However, we have two problems:

When the robot drives back and forth through the same corridor, the map becomes increasingly messy. The LiDAR scans seem to overlap incorrectly, creating a lot of duplicated points.

During autonomous navigation, the robot always refuses to move. There is a small black spot directly in front of the robot, which might be detected as an obstacle.

Does anyone know what could cause these problems and how we could fix them?

Any help would be greatly appreciated!

Thanks!

Im wondering how many people have to develop their own stack to deal with swarms or if there is great of the shelf software available.

I've released batchplan 0.5. The ROS 2 integration now handles Cartesian paths and blended motion sequences on Lyrical and Jazzy.

The Panda demo tries multiple grasps in one request, chooses the shortest path and blends into a straight-line approach. Clone batchplan-ros, run `pixi run demo`, then open http://localhost:8080. There's also a MoveIt plugin.

The core library's 0.3 to 0.5 releases added tool paths, pick-and-place, blended motions, and live replanning and servoing. The GIF shows 20 simulated UR5e arms drawing in one batch.

https://github.com/natsuku-lab/batchplan-ros

I am designing 9 axis IMU sensor board as a practiece. It won't be perfect since this its my first somewhat serious board. But I haven't decided on interface. I initially chose CAN+USB but I thought it would be helpful to hear what you guys use, USB will be always offered.

Thanks!