feat(LibCarla/ros2): publish traffic light info and status as latched topics

A driving stack running against the native ROS 2 interface is blind to
traffic lights: the simulator knows every light and its state, but none
of it reaches the ROS graph, so planners fall back on the Python API or
on the deprecated external bridge.

The simulator now describes its traffic lights on two latched topics
whenever ROS 2 is enabled. /carla/traffic_lights/info is published once
per episode and carries the static picture of every light: its id, its
pose in the world and its trigger volume, the same data the Python API
exposes. /carla/traffic_lights/status carries the state of every light
and is republished only when a state changes; since the last sample is
latched, a subscriber that joins between changes still receives the
current state immediately. Both topics reuse the message definitions
already published in ros-carla-msgs, so nothing new is required on the
ROS side and no flag beyond --ros2 is involved.

As the closing piece of the data-output series, this also adds a
reference of every topic the native interface publishes and subscribes
to under Docs/ros2/topics.md, together with the consolidated changelog
entry for the series.

Author: JArmandoAnaya

CHANGELOG.md

@@ -1,4 +1,5 @@
 ## Latest Changes
+ * Extended the native ROS2 interface (`--ros2`) with the data outputs standard AD stacks need: a latched OpenDRIVE map on `/carla/map`, ego vehicle odometry, status and info topics, a REP-105 TF tree (`map -> odom -> vehicle -> sensors`), and always-on traffic light info/status topics. Every topic uses standard or ros-carla-msgs message definitions and no new CARLA flags are introduced; see `Docs/ros2/topics.md` for the full topic reference.
  * Added Zenoh as a third ROS 2 middleware backend, selectable at runtime via `--rmw=zenoh` alongside `--rmw=fastdds` and `--rmw=cyclonedds`.
  * Renamed the ROS2 abstraction layer from dds/DDS* to generic middleware/Middleware* naming to support future non-DDS backends like Zenoh. FastDDS and CycloneDDS vendor classes are unchanged.
  * Added NumPy 2 compatibility to the PythonAPI: replaced removed aliases (`np.bool`, `np.matrix`) in example scripts and upgraded Boost to 1.90.0, which ships the upstream NumPy 2 C ABI fix (boostorg/python#432) so the C extension builds against both NumPy 1.x (>=1.18.4) and NumPy 2.x

Docs/ros2/topics.md

@@ -0,0 +1,126 @@
+# Native ROS 2 topic reference
+
+This page lists every topic the native ROS 2 interface publishes and
+subscribes to when CARLA runs with `--ros2` (middleware selectable with
+`--rmw=fastdds|cyclonedds|zenoh`). The interface follows one scope rule:
+it exposes the data a real drive-by-wire vehicle would produce and accepts
+the control commands such a vehicle would accept. Simulation control
+(spawning, weather, synchronous ticking) stays in the Python API.
+
+Standard message types ship with every ROS 2 distribution. The
+`carla_msgs/*` types are the ones published from the bridge era in
+[ros-carla-msgs](https://github.com/carla-simulator/ros-carla-msgs);
+install that package on the ROS side to deserialize them.
+
+Topic names below are the ROS names. On the DDS wire each topic carries
+the standard `rt/` prefix (for example `rt/carla/map`), which ROS 2 tools
+hide.
+
+## Simulation-wide topics
+
+Published as soon as the simulator starts; no actor opt-in needed.
+
+| Topic | Type | QoS | Cadence |
+|-------|------|-----|---------|
+| `/clock` | `rosgraph_msgs/Clock` | volatile | every frame |
+| `/carla/map` | `std_msgs/String` | transient_local | once per episode |
+| `/carla/traffic_lights/info` | `carla_msgs/CarlaTrafficLightInfoList` | transient_local | once per episode |
+| `/carla/traffic_lights/status` | `carla_msgs/CarlaTrafficLightStatusList` | transient_local | on state change |
+| `/tf_static` | `tf2_msgs/TFMessage` | transient_local | on hero registration |
+| `/tf` | `tf2_msgs/TFMessage` | volatile | every frame |
+
+- `/carla/map` carries the full OpenDRIVE description of the current map,
+  the same string `carla.Map.to_opendrive()` returns. Latched, so late
+  joiners receive it without waiting for a map change.
+- `/carla/traffic_lights/info` describes every traffic light once per
+  episode: actor id, world pose, and the trigger volume as a center
+  relative to that pose plus a full box size, matching what the Python API
+  exposes as `actor.trigger_volume`.
+- `/carla/traffic_lights/status` carries the state of every light
+  (`RED=0, YELLOW=1, GREEN=2, OFF=3, UNKNOWN=4`). The full list is
+  republished only when at least one light changed state; the latched
+  sample keeps the current state available to late joiners between
+  changes.
+
+## Ego vehicle topics
+
+Created when a vehicle with `role_name` `hero` is spawned. `<ros_name>`
+is the vehicle's `ros_name` attribute (defaults to `actor<id>` when
+unset). Destroying the vehicle removes the topics.
+
+| Topic | Direction | Type | QoS | Cadence |
+|-------|-----------|------|-----|---------|
+| `/carla/<ros_name>/odometry` | publish | `nav_msgs/Odometry` | volatile | every frame |
+| `/carla/<ros_name>/vehicle_status` | publish | `carla_msgs/CarlaEgoVehicleStatus` | volatile | every frame |
+| `/carla/<ros_name>/vehicle_info` | publish | `carla_msgs/CarlaEgoVehicleInfo` | transient_local | once at spawn |
+| `/carla/<ros_name>/vehicle_control_cmd` | subscribe | `carla_msgs/CarlaEgoVehicleControl` | volatile | consumer-driven |
+| `/carla/<ros_name>/ackermann_control_cmd` | subscribe | `ackermann_msgs/AckermannDriveStamped` | volatile | consumer-driven |
+
+- Odometry pose is ground truth in ROS coordinates with
+  `frame_id: odom` and `child_frame_id: <ros_frame_id>`; the twist is
+  expressed in the vehicle body frame.
+- Vehicle status carries speed, acceleration (computed from the velocity
+  history), world orientation, and an echo of the last applied control.
+- Vehicle info is the latched static description from the vehicle physics
+  control: mass, wheels, gearbox, center of mass.
+
+## TF tree
+
+The transform topics compose a REP-105 tree:
+
+```
+map -> odom -> <vehicle frame> -> <sensor frames>
+```
+
+- `map -> odom`: identity, latched on `/tf_static` when the hero vehicle
+  registers. CARLA publishes ground truth, so the `odom` frame never
+  drifts from `map`.
+- `odom -> <vehicle frame>`: published on `/tf` every frame for the hero
+  vehicle.
+- `<parent frame> -> <sensor frame>`: published on `/tf` every frame for
+  each sensor with ROS 2 enabled, where the parent is the actor the
+  sensor is attached to (or `map` for unattached sensors).
+
+A sensor's frame defaults to its `ros_name` and can be overridden with
+the `ros_frame_id` attribute; per-actor TF publishing can be disabled
+with the `ros_publish_tf` attribute.
+
+## Sensor topics
+
+Sensor publishing is opt-in per actor: call `enable_for_ros()` on the
+sensor from the Python API (`ros2_native.py` in `PythonAPI/examples/ros2`
+does this for a whole sensor stack). The base name composes the
+attachment hierarchy: `/carla/<parent ros_name>/<sensor ros_name>` for an
+attached sensor, `/carla/<sensor ros_name>` otherwise. All sensor topics
+are volatile and publish at the sensor's own tick rate.
+
+| Sensor | Topics | Types |
+|--------|--------|-------|
+| RGB camera | `<base>/image`, `<base>/camera_info` | `sensor_msgs/Image`, `sensor_msgs/CameraInfo` |
+| Depth camera | `<base>/image`, `<base>/camera_info` | `sensor_msgs/Image`, `sensor_msgs/CameraInfo` |
+| Semantic segmentation camera | `<base>/image`, `<base>/camera_info` | `sensor_msgs/Image`, `sensor_msgs/CameraInfo` |
+| Instance segmentation camera | `<base>/image`, `<base>/camera_info` | `sensor_msgs/Image`, `sensor_msgs/CameraInfo` |
+| Normals camera | `<base>/image`, `<base>/camera_info` | `sensor_msgs/Image`, `sensor_msgs/CameraInfo` |
+| Optical flow camera | `<base>/image`, `<base>/camera_info` | `sensor_msgs/Image`, `sensor_msgs/CameraInfo` |
+| DVS camera | `<base>/image`, `<base>/camera_info`, `<base>/point_cloud` | `sensor_msgs/Image`, `sensor_msgs/CameraInfo`, `sensor_msgs/PointCloud2` |
+| LiDAR (ray cast) | `<base>/point_cloud` | `sensor_msgs/PointCloud2` |
+| Semantic LiDAR | `<base>/point_cloud` | `sensor_msgs/PointCloud2` |
+| Hybrid solid-state LiDAR | `<base>/point_cloud` | `sensor_msgs/PointCloud2` |
+| Radar | `<base>/point_cloud` | `sensor_msgs/PointCloud2` |
+| GNSS | `<base>` | `sensor_msgs/NavSatFix` |
+| IMU | `<base>` | `sensor_msgs/Imu` |
+| Collision | `<base>` | `carla_msgs/CarlaCollisionEvent` |
+
+Lane invasion, obstacle detection and RSS sensors have no native ROS 2
+publisher; read them through the Python API.
+
+## QoS summary
+
+Every publisher is reliable with keep-last history. Topics marked
+transient_local above are latched with depth 1: a subscriber that joins
+late immediately receives the last published sample. Match the
+durability when echoing them, for example:
+
+```sh
+ros2 topic echo --qos-durability transient_local --qos-reliability reliable /carla/map
+```

LibCarla/source/carla/ros2/ROS2.cpp

@@ -38,6 +38,8 @@
 #include "publishers/CarlaSemanticLidarPublisher.h"
 #include "publishers/CarlaSSCameraPublisher.h"
 #include "publishers/CarlaStaticTransformPublisher.h"
+#include "publishers/CarlaTrafficLightInfoPublisher.h"
+#include "publishers/CarlaTrafficLightStatusPublisher.h"
 #include "publishers/CarlaTransformPublisher.h"
 
 #include "subscribers/AckermannControlSubscriber.h"
@@ -568,6 +570,33 @@ void ROS2::ProcessVehicleInfo(
   it->second.info->Publish();
 }
 
+void ROS2::ProcessTrafficLightStates(const std::vector<TrafficLightState> &states) {
+  std::lock_guard<std::recursive_mutex> lock(_mutex);
+  if (!_enabled) {
+    return;
+  }
+  if (!_traffic_lights_status_publisher) {
+    _traffic_lights_status_publisher = std::make_shared<CarlaTrafficLightStatusPublisher>();
+  }
+  // Write reports whether any light changed state since the last publish;
+  // the latched sample keeps the previous list available to late joiners.
+  if (_traffic_lights_status_publisher->Write(states)) {
+    _traffic_lights_status_publisher->Publish();
+  }
+}
+
+void ROS2::ProcessTrafficLightInfo(const std::vector<TrafficLightInfo> &info) {
+  std::lock_guard<std::recursive_mutex> lock(_mutex);
+  if (!_enabled) {
+    return;
+  }
+  if (!_traffic_lights_info_publisher) {
+    _traffic_lights_info_publisher = std::make_shared<CarlaTrafficLightInfoPublisher>();
+  }
+  _traffic_lights_info_publisher->Write(info);
+  _traffic_lights_info_publisher->Publish();
+}
+
 void ROS2::Shutdown() {
   std::lock_guard<std::recursive_mutex> lock(_mutex);
   // Destroy publishers first so DataWriter unregister-dispose messages are
@@ -581,6 +610,8 @@ void ROS2::Shutdown() {
   _clock_publisher.reset();
   _map_publisher.reset();
   _static_tf_publisher.reset();
+  _traffic_lights_info_publisher.reset();
+  _traffic_lights_status_publisher.reset();
 
   _subscribers.clear();
 

LibCarla/source/carla/ros2/ROS2.h

@@ -10,6 +10,7 @@
 #include "carla/BufferView.h"
 #include "carla/geom/Transform.h"
 #include "carla/ros2/ROS2CallbackData.h"
+#include "carla/ros2/TrafficLightData.h"
 #include "carla/ros2/middleware/Middleware.h"
 #include "carla/streaming/detail/Types.h"
 
@@ -52,6 +53,8 @@ namespace ros2 {
   class CarlaEgoVehicleStatusPublisher;
   class CarlaEgoVehicleInfoPublisher;
   class CarlaStaticTransformPublisher;
+  class CarlaTrafficLightInfoPublisher;
+  class CarlaTrafficLightStatusPublisher;
 
 class ROS2
 {
@@ -171,6 +174,12 @@ class ROS2
       const std::string &role_name,
       const carla::geom::Transform vehicle_transform,
       const carla::rpc::VehiclePhysicsControl &physics_control);
+    // Publishes the full traffic light status list, but only when any light
+    // changed state since the last publish. Called once per frame.
+    void ProcessTrafficLightStates(const std::vector<TrafficLightState> &states);
+    // Publishes the latched static description of every traffic light.
+    // Called once per episode, after the lights spawn.
+    void ProcessTrafficLightInfo(const std::vector<TrafficLightInfo> &info);
 
   private:
     std::shared_ptr<CarlaTransformPublisher> GetOrCreateTransformPublisher(void *actor);
@@ -217,6 +226,9 @@ class ROS2
   };
   std::unordered_map<void *, VehiclePublishers> _vehicle_publishers;
   std::shared_ptr<CarlaStaticTransformPublisher> _static_tf_publisher;
+
+  std::shared_ptr<CarlaTrafficLightInfoPublisher> _traffic_lights_info_publisher;
+  std::shared_ptr<CarlaTrafficLightStatusPublisher> _traffic_lights_status_publisher;
 };
 
 } // namespace ros2

LibCarla/source/carla/ros2/TrafficLightData.h

@@ -0,0 +1,39 @@
+// Copyright (c) 2026 Computer Vision Center (CVC) at the Universitat Autonoma de Barcelona (UAB).
+// This work is licensed under the terms of the MIT license.
+// For a copy, see <https://opensource.org/licenses/MIT>.
+
+#pragma once
+
+#include <cstdint>
+
+#include "carla/geom/Location.h"
+#include "carla/geom/Transform.h"
+#include "carla/geom/Vector3D.h"
+
+namespace carla {
+namespace ros2 {
+
+  /// Snapshot of one traffic light's state, gathered by the simulator each
+  /// frame. The state encoding follows carla_msgs/CarlaTrafficLightStatus:
+  /// RED=0, YELLOW=1, GREEN=2, OFF=3, UNKNOWN=4 (same ordinals as
+  /// carla::rpc::TrafficLightState).
+  struct TrafficLightState {
+    uint32_t id = 0u;
+    uint8_t state = 0u;
+  };
+
+  /// Static description of one traffic light, gathered once per episode.
+  /// All values use UE coordinates in meters; the ROS conversion happens in
+  /// the publisher.
+  struct TrafficLightInfo {
+    uint32_t id = 0u;
+    /// World pose of the light.
+    carla::geom::Transform transform;
+    /// Trigger volume center, relative to the light transform.
+    carla::geom::Location trigger_center;
+    /// Trigger volume half-extent.
+    carla::geom::Vector3D trigger_extent;
+  };
+
+} // namespace ros2
+} // namespace carla

LibCarla/source/carla/ros2/publishers/CarlaTrafficLightInfoPublisher.cpp

@@ -0,0 +1,42 @@
+// Copyright (c) 2026 Computer Vision Center (CVC) at the Universitat Autonoma de Barcelona (UAB).
+// This work is licensed under the terms of the MIT license.
+// For a copy, see <https://opensource.org/licenses/MIT>.
+
+#include "CarlaTrafficLightInfoPublisher.h"
+
+#include "carla/ros2/publishers/UeToRosConversions.h"
+
+namespace carla {
+namespace ros2 {
+
+bool CarlaTrafficLightInfoPublisher::Write(
+    const std::vector<TrafficLightInfo> &info) {
+  auto message = _impl->GetMessage();
+
+  message->traffic_lights.clear();
+  message->traffic_lights.reserve(info.size());
+  for (const auto &light : info) {
+    msg::CarlaTrafficLightInfo light_info;
+    light_info.id = light.id;
+
+    light_info.transform.position.x = light.transform.location.x;
+    light_info.transform.position.y = -light.transform.location.y;
+    light_info.transform.position.z = light.transform.location.z;
+    light_info.transform.orientation =
+        ue_rotation_to_ros_quaternion(light.transform.rotation);
+
+    // Center stays relative to the light transform, flipped to right-handed;
+    // the size is the full box extent and carries no axis sign.
+    light_info.trigger_volume.center = ue_vector_to_ros_vector(light.trigger_center);
+    light_info.trigger_volume.size.x = light.trigger_extent.x * 2.0;
+    light_info.trigger_volume.size.y = light.trigger_extent.y * 2.0;
+    light_info.trigger_volume.size.z = light.trigger_extent.z * 2.0;
+
+    message->traffic_lights.push_back(light_info);
+  }
+
+  return true;
+}
+
+}  // namespace ros2
+}  // namespace carla

LibCarla/source/carla/ros2/publishers/CarlaTrafficLightInfoPublisher.h

@@ -0,0 +1,51 @@
+// Copyright (c) 2026 Computer Vision Center (CVC) at the Universitat Autonoma de Barcelona (UAB).
+// This work is licensed under the terms of the MIT license.
+// For a copy, see <https://opensource.org/licenses/MIT>.
+
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "carla/ros2/TrafficLightData.h"
+#include "carla/ros2/publishers/BasePublisher.h"
+#include "carla/ros2/publishers/PublisherImpl.h"
+
+#include "carla/ros2/types/msg/CarlaTrafficLightInfoList.h"
+
+namespace carla {
+namespace ros2 {
+
+  /// Publishes the static description of every traffic light in the map as a
+  /// latched carla_msgs/CarlaTrafficLightInfoList on
+  /// rt/carla/traffic_lights/info. Published once per episode; the
+  /// transient_local durability lets late-joining subscribers receive the
+  /// list without CARLA re-publishing it.
+  class CarlaTrafficLightInfoPublisher : public BasePublisher {
+    public:
+      struct InfoListMsgTraits {
+        using msg_type = msg::CarlaTrafficLightInfoList;
+      };
+
+      CarlaTrafficLightInfoPublisher() :
+        BasePublisher("rt/carla/traffic_lights/info"),
+        _impl(std::make_shared<PublisherImpl<InfoListMsgTraits>>()) {
+          PublisherQos qos;
+          qos.durability = DurabilityKind::TransientLocal;
+          if (!_impl->Init(GetBaseTopicName(), qos)) {
+            log_warning("CarlaTrafficLightInfoPublisher: Init failed for topic: ", GetBaseTopicName());
+          }
+      }
+
+      bool Publish() {
+        return _impl->Publish();
+      }
+
+      bool Write(const std::vector<TrafficLightInfo> &info);
+
+    private:
+      std::shared_ptr<PublisherImpl<InfoListMsgTraits>> _impl;
+  };
+
+}  // namespace ros2
+}  // namespace carla

LibCarla/source/carla/ros2/publishers/CarlaTrafficLightStatusPublisher.cpp

@@ -0,0 +1,32 @@
+// Copyright (c) 2026 Computer Vision Center (CVC) at the Universitat Autonoma de Barcelona (UAB).
+// This work is licensed under the terms of the MIT license.
+// For a copy, see <https://opensource.org/licenses/MIT>.
+
+#include "CarlaTrafficLightStatusPublisher.h"
+
+namespace carla {
+namespace ros2 {
+
+bool CarlaTrafficLightStatusPublisher::Write(
+    const std::vector<TrafficLightState> &states) {
+  if (_has_last_states && StatesEqual(states, _last_states)) {
+    return false;
+  }
+  auto message = _impl->GetMessage();
+
+  message->traffic_lights.clear();
+  message->traffic_lights.reserve(states.size());
+  for (const auto &state : states) {
+    msg::CarlaTrafficLightStatus status;
+    status.id = state.id;
+    status.state = state.state;
+    message->traffic_lights.push_back(status);
+  }
+
+  _last_states = states;
+  _has_last_states = true;
+  return true;
+}
+
+}  // namespace ros2
+}  // namespace carla