ROS2-TMS: Automated Construction Systems

Updated 8 February 2026

ROS2-TMS for Construction is a cyber-physical system platform that integrates heterogeneous construction machinery through ROS2 middleware and modular task management.
It employs advanced LLM-guided behavior tree generation and real-time synchronization via database-backed flags to ensure robust multi-agent coordination.
Extensive field validation demonstrates high safety, precise control, and scalability in automated earthwork operations under dynamic conditions.

ROS2-TMS for Construction is an integrated cyber-physical system platform for earthwork automation, targeting scalable, safety-assured coordination of heterogeneous construction machinery. Built atop ROS2 middleware and advanced database-centric architectures, ROS2-TMS for Construction extends conventional Task Management Systems to support real-time multi-agent control, virtual construction modeling, high-throughput sensing, and formal timing analysis. Advanced workflows, such as LLM-guided behavior tree generation and eBPF-based timing model synthesis, position the platform as a foundation for robust, autonomous, and auditable civil engineering operations.

1. System Architecture and Core Components

ROS2-TMS for Construction consists of seven primary modules: TMS_SD, TMS_SS, TMS_SP, TMS_DB, TMS_TS, TMS_UR, TMS_RP, and TMS_RC (Tsutsumi et al., 1 Feb 2026, Kasahara et al., 2024). The architecture is highly modular and database-driven, enabling both live site control and virtual simulation.

Sensor Data Modules: TMS_SD and TMS_SS acquire and preprocess multi-modal data (GNSS, IMU, 3D LiDAR, RGB, encoders).
System Database (TMS_DB): Persistent storage for machine parameters (poses, paths, joint angles) and global flags used for inter-machine synchronization. Schema example:
1 2
Machines(machine_id TEXT, param_name TEXT, param_value REAL[]) Flags (flag_name TEXT, state BOOLEAN)
Task Scheduler (TMS_TS): Executes Behavior Trees (via BehaviorTree.CPP) for action orchestration, reading context and plan parameters from TMS_DB.
User Interface (TMS_UR): Supports operator input via GUI or natural language.
Motion Planning (TMS_RP): Employs MoveIt 2 and Navigation2 for geometric and trajectory-level planning.
Low-level Control (TMS_RC): Directs hydraulic and actuator signals to hardware.
OPERA Integration: Interfaces with OPERA (Open Platform for Earthwork with Robotics and Autonomy), translating high-level BT instructions into OPERA-compatible service/action calls (Kasahara et al., 2024).

Machines run independent behavior trees, synchronize via database-backed flags, and participate in a cyber-physical loop that includes OperaSimVR for digital twin updates and safety monitoring.

2. Behavior Tree Orchestration and LLM-Based Automation

ROS2-TMS for Construction utilizes an extended Behavior Tree formalism with a global blackboard for flexible, modular task execution (Kasahara et al., 2024). Each node $n$ in the tree returns status values (RUNNING, SUCCESS, FAILURE); subtree syncronization and data sharing occur via $\mathbb{B}_G$ , the global blackboard.

A two-step LLM-based workflow further advances BT generation for cooperative tasks (Tsutsumi et al., 1 Feb 2026):

High-Level Task Planning (HTP): An LLM receives a natural-language instruction, task catalog, environmental flags, and flag-generation rules. It emits a Python-like sequence of abstract tasks, each annotated with a depends_on clause (flag or condition), an explanatory comment, and new flag declarations. Example output:
1 2
move(mst110cr, load_point) depends_on ZX200_INITIAL_POSE_FLG == true # wait for excavator to finish
Flag-Generation Logic:

flag_set = default_flags.copy()
for each step s in plan:
  for each precondition p in s.depends_on:
    if p not in flag_set:
      new_flag = make_flag_name(machine=s.machine, event=p)
      flag_set.add(new_flag)
      s.depends_on.append(new_flag)

Behavior Tree Generation (BTG): The LLM, using a template grammar, converts high-level scripts and flag logic into BT XML, instantiating custom nodes:
- DBReader(key): Loads flag/parameter from TMS_DB.
- ConditionalExpression(expr): Succeeds if the flag/expression is true.
- RetryUntilSuccessful(...): Repeats child until SUCCESS.
- ReactiveSequence(...): Preempts if any precondition fails mid-execution.

This workflow guarantees that all motion parameters are loaded from the verified database, eliminating LLM-induced hallucination of unsafe values and ensuring safety.

3. Synchronization, Safety Mechanisms, and Real-World Execution

Synchronization of heterogeneous agents is enforced via flag-based conditional execution (Tsutsumi et al., 1 Feb 2026). Each high-level step in the plan specifies depends_on flags that are propagated into the behavior tree structure as follows:

$\begin{aligned} \texttt{ReactiveSequence} \bigl[ & \texttt{Sequence} \bigl[ \texttt{RetryUntilSuccessful} [ \texttt{DBReader(flag)}, \texttt{ConditionalExpression(flag == true)} ], \texttt{ActionNode(parameters)} \bigr] \bigr] \end{aligned}$

Global Blackboard Flags: All synchronization flags are stored both in RAM and in TMS_DB; all participating agents poll and set shared flags on BT transitions.
Safety Assurance: Emergency stop commands, position verifications, and all trajectory/pose parameters are only accepted if present in and validated by TMS_DB and upstream perception modules. Emergency stop latencies are measured at $0.25 \pm 0.05~\text{s}$ (ZX200 Backhoe) and $0.30 \pm 0.07~\text{s}$ (IC120 Crawler Dump) (Kasahara et al., 2024).
Real-World Validation: Outdoor trials on an excavator (ZX200) and dump truck (MST110CR) confirmed correct EX–DT cooperation and no human involvement in flag-driven task switches. All cycles completed with 100% success rate and $\leq 0.15~\text{m}$ RMS error (Tsutsumi et al., 1 Feb 2026, Kasahara et al., 2024).

4. Sensor Fusion, Mapping, and Data Flow in Construction Environments

The platform leverages multi-sensor fusion with ROS2 for SLAM, object-level modeling, and environmental feedback (Kasahara et al., 2024, Lee et al., 2022):

Thermal Mapping System (TMS): Integrates 2D LiDAR, consumer IMU, and thermal cameras on ROS2 for concrete curing monitoring, including pose graph optimization, scan matching, and 3D thermal imaging (Lee et al., 2022).
Sensor Data Flow: All ROS2 nodes publish and subscribe via topics such as /imu/data, /scan, /odom, while data is stored in the MongoDB-based TMS_DB. Derived quantities (e.g., processed point clouds, mound shape) are updated dynamically and are accessible to BT nodes for real-time adjustment of motion plans and BT logic.
Integration Stack: Navigation2 provides global planning (NavFn/Dijkstra), while DWB supplies local path optimization based on dynamic windows and constraints; output velocities are directly converted to CAN commands for earthwork vehicles (Kasahara et al., 2024).

5. Trace-Enabled Timing Model Synthesis and Real-Time Analysis

Formally verifying system timing and synchronization is achieved through eBPF-based tracing, model extraction, and schedulability DAG construction (Abaza et al., 2023):

Measurement Architecture: eBPF uprobes instrument all relevant ROS2 middleware entry and exit points, capturing (timestamp, PID, callback/event type, function arguments) for node creation, subscription, publish, service call, and client call operations.
Instance Extraction and Timing Bounds: Callback invocations are extracted from merged trace streams; worst-case (WCET), best-case (BCET), and average-case (ACET) execution times are computed per callback.
DAG Construction: A task/communication graph is synthesized, where nodes represent distinct callbacks (periodic, subscription, service, client), and edges denote topic or service call precedence. Synchronization (AND-join) nodes model message filters and multi-input sensor fusion.
Statistical Model Exports: Timing attributes (e.g., execution times, period bounds, synchronization latency) are serialized for analysis, enabling priority/core assignment or response-time analysis with zero application source code requirement.

6. Experimental Metrics, Performance, and Scalability

Field trials with OperaSim-PhysX and real machinery have produced extensive empirical data (Kasahara et al., 2024, Tsutsumi et al., 1 Feb 2026):

Metric	ZX200 Backhoe	IC120 Crawler Dump
Number of Cycles	5	5
Task Completion Time (mean ± σ) [s]	180 ± 15	150 ± 12
Positional Accuracy (RMS error) [m]	0.15	0.10
Emergency Stop Latency [s]	0.25 ± 0.05	0.30 ± 0.07
Safety Margin to Obstacles [m]	>1.0	>1.0
Success Rate	100%	100%

Key observations:

Decoupling each machine into its own BT and synchronizing via shared flags improves modularity and robustness.
LLM-driven BT generation scales from single machine to multi-machine cooperation without per-scenario hand-coding.
Database validation of every operational parameter ensures operational safety and prevents execution of unvetted/hallucinated actions.
Real-world deployments are robust to environmental disturbances (GPS noise, terrain variance).

7. Future Directions and Extensions

Current deployments and validation highlight the following trajectories (Tsutsumi et al., 1 Feb 2026, Kasahara et al., 2024):

Extension to larger fleets, richer multi-robot task sets, and multi-class machinery (bulldozers, rollers).
Enhancements in compound subtask abstractions within the BT framework for planner reusability.
Online integration of cost-based decorators for on-the-fly action arbitration under resource constraints.
Development of dynamic replanning and semantic segmentation workflows to enable adaptive, perception-driven operations.
Expansion of eBPF-based timing model synthesis to encompass schedulability, parallelism, and priority optimization in increasingly complex multi-agent deployments.

ROS2-TMS for Construction constitutes an auditable, extensible, and experimentally proven CPS platform supporting the next generation of automation in civil engineering and large-scale earthwork (Tsutsumi et al., 1 Feb 2026, Kasahara et al., 2024, Abaza et al., 2023, Lee et al., 2022).