Table of Contents

Introduction

This paper presents a simulation framework able of modeling the dynamics of a hanging tether with adjustable length, connecting a UAV to a UGV. The model incorporates the interaction between the UAV, UGV, and a winch, allowing for dynamic tether adjustments based on the relative motion of the robots. The accuracy and reliability of the simulator are assessed through extensive experiments, including comparisons with real-world experiment, to evaluate its ability to reproduce the complex tether dynamics observed in physical deployments. The results demonstrate that the simulation closely aligns with real-world behavior, particularly in constrained environments where tether effects are significant. This work provides a validated tool for studying tethered robotic systems, offering valuable insights into their motion dynamics and control strategies.

(back to top)

Marsupial System Simulator using Gazebo

Architecture

The marsupial UAV-UGV simulator is built using ROS 2 and Gazebo, integrating multiple core components to simulate tethered robot behavior Fig. 2. Each module plays a specific role, and the system supports both manual and autonomous operation. The main steps are:

• Model Initialization: The simulation initializes in Gazebo by spawning the UGV, UAV, and a coiled tether around the winch. The UAV starts on a platform atop the UGV, and the tether is connected to both. ROS~2 modules manage the system’s operation.

• Trajectory Tracking: This module enables interaction with the system via two methods: (1) YAML files containing waypoints and reference tether lengths, or (2) real-time ROS messages specifying destinations. The UAV, UGV, and winch adjust dynamically to maintain proper tether slack. The framework supports custom trajectory tracking algorithms and control modules.

• Controllers: Each robot has a dedicated controller that executes assigned movements. The UGV controller also manages tether control, adjusting its length as needed. The controllers closely replicate real-world robot behavior but can be modified to accommodate different dynamics.

• Evaluation and Data Recording: An Evaluation Module collects and processes ROS~2 topic data, including UAV/UGV poses and tether length variations. The system compiles key performance metrics such as trajectory accuracy, tether behavior, and system stability, storing the results for further analysis.

Figure 2: Diagram of the Marsupial Simulator. The core modules of simulator are in blue. The base robotics simulator modules are depicted in light yellow color. Green boxes indicate the input data information. Output evaluation metrics are indicated in light purple color.

The simulator is modular and easily customizable, allowing modifications to the UAV, UGV, and tether models.

Models

The simulation environment includes models for the UAV, UGV, winch, and tether, ensuring realistic behavior in Gazebo.

• UAV: Quadrotor with ROS2-compatible position and velocity control.
• UGV: Holonomic ground vehicle with integrated winch.
• Tether: Flexible, multi-segmented tether with dynamic length adjustment. Configurable length, mass, and stiffness.

Default parameters such as length, radius, mass, spring stiffness, and damping Table I can be modified as described here.

Figure 3: Models used in Gazebo simulation.

Additionally, the tether interacts with obstacles via Gazebo’s physics engine, which computes contact forces and tension variations. These interactions affect UAV and UGV dynamics (Fig. 4). The simulator includes six architectural scenarios to analyze tether behavior under different geometric constraints.

Figure 4: Example of tether-obstacle interaction in Gazebo.

(back to top)

Validation Experiments

To evaluate the performance of the simulator and validate its capabilities, we designed a series of scenarios that assess various aspects of the marsupial UAV-UGV system, including stability, tether dynamics, winch operation, and coordination between aerial and ground vehicles under different circumstances. The scenarios are divided into four categories: Tether Model Evaluation, aimed at assessing the accuracy of the simulated tether against a real catenary curve; Simulated Scenarios, focused on testing and verifying the system’s general functionalities; Real Scenarios, that replicate real-world experiments to validate the simulator in practical applications; and Performance Evaluation, dedicated to computational efficiency and real-time capabilities of the simulator under different conditions.

Tether Model Evaluation

To validate the accuracy of the simulated tether against a real catenary, we designed an experiment focusing on the tether’s discretization effect. In these experiments, both the UAV and UGV were positioned approximately 5, 10 and 15 meters apart, and the tether length was set to be 20% longer than the Euclidean distance between them to introduce realistic slack.

We simulate the tether using four different lengths of elements: 0.05 m, 0.10 m, 0.15 m and 0.20 m. For each simulation, we recorded the length of each tether element and calculated the averaged error between the positions of the simulated tether elements and those of the theoretical catenary curve under the same conditions. This error measurement provides insights into how the granularity of the tether model influences the simulation’s ability to accurately replicate real-world tether dynamics.

As shown in Table II, the results indicate that the performance is realistic across all tested cases, with averaged errors below 1\% of the tether length. We can see how, in general, as the length of the element increases, the simulation error with respect to the theoretical model also increases, as expected. However, this effect does not hold when the element length is 0.05 m. We think this behaviour is related with the increase of the simulation complexity, setting Gazebo’s solver close to its limits. This is due to the reduced computational load when simulating fewer (longer) elements.

It is important to note that the region around the winch (highlighted in yellow in Fig. 3) exhibits more chaotical tether dynamics due to the high concentration of elements in a small area. This effect is inherent to the discrete nature of the simulation and cannot be directly controlled, leading to small fluctuations in the tether’s appearance near the winch. However, this is purely a visual artifact and does not impact the overall behaviour of the catenary, which remains accurately modeled and is the primary focus of our simulation. Additionally, the winch model used in our simulation does not support tether element lengths greater than 0.2 m due to mechanical constraints. Despite varying the element lengths up to this limit, the precision of the simulation was not affected significantly. This suggests that even with larger element lengths within the supported range, the simulation can maintain a high degree of accuracy in approximating the real catenary curve.

Figure 5: Examples of tether-obstacle collisions with varying degrees of tension.

Beyond comparing the simulated tether to a theoretical catenary, we also conducted experiments to examine how it interacts with the environment. These tests were designed to confirm the simulator’s ability to capture contact dynamics, including collisions with obstacles, wrapping around structures, and adjusting the tether’s tension in response. Thus, Figure 5a illustrates a scenario where the tether remains slack while suspended between two obstacles. In contrast, Figure 5b shows the tether becoming entangled around both obstacles due to the UAV’s trajectory, significantly increasing tension. These interactions influence the overall system behavior, affecting both the UAV’s stability and the UGV’s traction due to the dynamic forces exerted by the tether. This behavior can be better appreciated in the accompanying video.

The ability to simulate these contact events is essential for realistic modeling of marsupial robotic systems, as tether-environment interactions can introduce significant constraints in real-world applications. Our results demonstrate that the simulator correctly captures these effects, enabling detailed analysis of how tether dynamics impact system performance under various operational conditions.

Simulated Scenarios

In the simulated scenarios, we focus on evaluating the fundamental functioning of the simulation framework and analyzing the dynamics of the UAV and UGV when following predefined trajectories. These are designed to cover a range of fundamental operational conditions, allowing us to calibrate the simulator and identify any issues in basic tether management and vehicle control.

Figure 6: Examples of the simulated scenarios used for validation.

• Scenario 1: Vertical Stability Assessment (Figure 6a): In this scenario, the UGV remains stationary while the UAV performs ten consecutive ascents and descents. The objective is to evaluate the winch’s ability to smoothly release and retract the tether in response to vertical movements of the UAV. This scenario focuses on the stability of the UAV during tether length adjustments and the responsiveness of the winch control system.

• Scenario 2: Horizontal Mobility Assessment (Figure 6b): The UAV hovers at a fixed altitude while the UGV moves back and forth between two points ten times. This scenario tests the tether’s behavior during horizontal displacement of the UGV and examines the system’s capability to manage tether slack without compromising the UAV’s position stability.

• Scenario 3: Opposite Direction Coordination (Figure 6c): In this scenario, both the UAV and UGV move simultaneously in opposite directions ten times. The aim is to challenge the system’s coordination mechanisms and the winch’s ability to adjust the tether length dynamically under increased complexity. This scenario simulates more intrincate movements that may occur in real-world operations where both units need to maneuver independently.

According to Table III , the UGV traveled significant distances in Scenarios 2 and 3, covering 49.99 meters and 50.88 meters, respectively. The UGV consistently adhered to the designated paths, exhibiting smooth and stable movements that reflect reliable ground dynamics.

In contrast, the UAV experienced minor perturbations in its flight path, particularly during complex maneuvers or when operating in close proximity to the UGV. These disturbances are primarily attributed to the complex dynamics of the tether. The interactions among the tether’s elements introduce dynamic forces that influence the UAV’s stability and control. The most significant perturbations occur when the UAV and UGV are very close to each other or aligned vertically, as the reduced spatial separation amplifies the interaction forces from the tether. This effect is evident in Figure 6c, where the UAV’s trajectory shows deviations during such configurations.

Notably, Scenario 3 resulted in the UAV traveling the greatest distance among the scenarios, covering 65.21 meters. The discrepancies between the UAV’s actual path and the reference trajectory are further illustrated in Fig.~\ref{figure:test_position_ugv_uav}, which displays the UAV’s and UGV’s positions relative to their targets over time, highlighting slight oscillations due to the tether’s influence.

Specifically, the table reports key performance metrics: the simulation time (in seconds), the number of targets reached, the total distance traveled by the UAV and UGV (in meters), and the amount of tether released and collected (in meters) throughout the experiment

Figure 6: Visualization of the position of the UGV (left) and UAV (right) on each axis with respect to the reference in Scenario 3 (Opposite Direction Coordination).

Despite these challenges, the UAV successfully reached all predefined target points across the stage, demonstrating the robustness of the control algorithms and the effectiveness of the tether management system. The control system effectively mitigated the disturbances induced by the tether, allowing the UAV to maintain its overall trajectory.

Fig. 7 depicts the tether length adjustments throughout the simulated scenario. The tether length is dynamically adjusted by the winch system to be 5\% greater than the relative distance between the UAV and UGV. This strategy ensures that the tether maintains slightly slack, preventing excessive tightness that might impact the UAV’s stability. The tether length closely follows the target length, indicating the winch’s responsiveness and the effectiveness of the tether management algorithms in real-time operation.

Figure 7: Tether length adjustments during Scenario 3, showing the evolution of the tether's actual length, target length, and distance between the UAV and UGV over time.

Overall, the simulated scenarios confirm that while the tether introduces additional complexity into the UAV’s dynamics, the system is capable of maintaining accurate trajectory tracking.

Performance Evaluation

The computational performance of the simulator was evaluated to assess its real-time capabilities and scalability. All experiments were conducted on a laptop with 32 GB of RAM, a 13th Gen Intel Core i7-13620H (10 cores, 16 threads), and an NVIDIA GeForce RTX 4060 Laptop GPU. To analyze the impact of system components on simulation efficiency, a comparison was made with a more powerful desktop PC (64 GB RAM, 12th Gen Intel Core i9-12900F, and an NVIDIA GeForce RTX 3060 GPU). Each experiment was repeated 10 times, and since the mean deviation was negligible, the values correspond to the calculated averages.

Figure 8: Performance comparison between the laptop and desktop configurations. The real-time factor (RTF) is shown for tether element counts ranging from 100 to 700.

As shown in Fig. 8, the desktop PC demonstrated superior performance. The number of tether elements directly influenced computational load. For the laptop, the real-time factor (RTF) decreased from 0.92 (100 elements) to 0.14 (700 elements), while the desktop PC maintained higher RTF values, ranging from 0.99 (100 elements) to 0.19 (700 elements), with a tether element length of 0.15 m in all cases. This divergence underscores the importance of system specifications for simulating high-fidelity tethered systems. Notably, the desktop achieved an RTF of 0.47 with 300 elements while the laptop required element counts below 200 to maintain RTF >0.50.

These results highlight the simulator’s ability to run on mid-tier hardware while showcasing the benefits of higher-end systems for demanding simulations. As the number of tether elements increases, maintaining real-time performance becomes progressively more demanding. While the simulator remains functional across a range of systems, achieving high real-time factors, which is necessary if real-time execution is required, demands sufficient computational resources. Therefore, selecting the appropriate hardware is crucial to balancing simulation accuracy and computational feasibility in real-time applications.

(back to top)

Installation

Dependencies

This package has been designed and tested in an x86_64 machine under a Ubuntu 22.04 operating system and ROS2 Humble distribution. The following repositories are required for the implementation of the project:

• sjtu_drone: (https://github.com/noshluk2/sjtu_drone/tree/ros2, branch: ros2)
• gazebo_ros_link_attacher: (https://github.com/davidorchansky/gazebo_ros_link_attacher, branch: humble-devel)
• gazebo_ros2_control: (https://github.com/ros-controls/gazebo_ros2_control/tree/master, branch: humble)

Build Instructions

It is recommended to use the provided Docker image to ensure a consistent environment. Follow these steps:

1. Navigate to the folder where the Dockerfile is located.

2. Build the Docker image with the following command:

    docker build -t marsupial_image .
    

1. Enable X11 forwarding (for GUI support, e.g., Gazebo) by running:

    xhost +local:docker
    

1. Run the Docker container with the necessary permissions:

    docker run -it --env DISPLAY=$DISPLAY --volume /tmp/.X11-unix:/tmp/.X11-unix marsupial_image
    

1. After creating the container, simply source the workspace environment by executing:

    source install/setup.bash
    

Once sourced, you can use all the commands described in the following section.

1. Open additional terminal windows in the running container (if needed) using:

    docker run -it --env DISPLAY=$DISPLAY --volume /tmp/.X11-unix:/tmp/.X11-unix marsupial_image
    

Replace  ```<container_id> ``` with the actual container ID or name.

(back to top)

Usage

Six scenarios with different features can be set to use the optimizer. S1: Open environment, S2: Narrow/constrained environment, S3: Confined environment, S5: Open environment, S6: Confined environment, S7: Open environment, as shown in the next figure.

An extra scenario has been included to replicate the trajectory tracking experiment in a theatre conducted for the Path and Trajectory paper. Uncomment the spawn theatre line in the

``` file to see the theatre model (This can noticeably slow down the simulation on older hardware.). 

<div align="center">
  <img src="images/theatre.png" alt="theatre simulation" width="900">
</div>

The package has a set of predefined configurations (and completely extendable according to the user's need) that relate to the stage number and initial position number. 


### Manual control
To launch the marsupial system in manual mode just launch the file `launch/marsupial_manual_simulation.launch.py`. The control of the ugv can be done using a remote control (default option) or the keyboard. The uav is controlled by the teleop option. To manage the scenario and initial position predefined is recommended to use the parameters for this launch, `world` and `pos_x`, `pos_y`, `pos_z`. Thus, for example, to use S5 and initial position (3, 1, 0):
1. Launch of the gazebo environment:
    
```bash
    ros2 launch marsupial_simulator_ros2 marsupial_manual_simulation.launch.py world:=stage_5.world pos_x:=3 pos_y:=1 pos_z:=0
    

1. In order to control the drone it is necessary to send a message for take-off:

    ros2 topic pub /sjtu_drone/takeoff std_msgs/msg/Empty {} --once
    

1. Landing message:

    ros2 topic pub /sjtu_drone/land std_msgs/msg/Empty {} --once
    

Automatic control

To launch the marsupial system in automatic mode just launch the file launch/marsupial_simulation.launch.py. To manage the scenario and initial position predefined is recommended to use the parameters for this launch, world and pos_x, pos_y, pos_z. Thus, for example, to use S5 and initial position (3, 1, 0):

1. Launch of the gazebo environment:

    ros2 launch marsupial_simulator_ros2 marsupial_simulation.launch.py world:=stage_5.world pos_x:=3 pos_y:=1 pos_z:=0
    

1. To start the movement to the defined point:

    ros2 launch marsupial_simulator_ros2 marsupial_to_point.launch.py uav_x:=1.0 uav_y:=2.0 uav_z:=7.0 ugv_x:=5.0 ugv_y:=3.0
    

1. To change the destination point during simulation:
   • UGV

      ros2 topic pub /target_position_ugv geometry_msgs/msg/Pose '{position: {x: 3.0, y: 2.0, z: 0.0}, orientation: {x: 0.0, y: 0.0, z: 0.0, w: 1.0}}' --once
      

- UAV

      ros2 topic pub /target_position_uav geometry_msgs/msg/Pose '{position: {x: 3.0, y: 2.0, z: 7.0}, orientation: {x: 0.0, y: 0.0, z: 0.0, w: 1.0}}' --once
      

1. To record a bag:

    ros2 bag record /sjtu_drone/gt_pose /sjtu_drone/cmd_vel /ugv_gt_pose /forward_velocity_controller/commands /cable_length /target_position_uav /target_position_ugv /tether_positions
    

Experiments

To replicate the experiments conducted just launch the file launch/marsupial_simulation.launch.py and launch/marsupial_experiment.launch.py. It is recommended to perform the experiments in the predefined scenario to increase the efficiency of the simulator.

1. Launch of the gazebo environment:

    ros2 launch marsupial_simulator_ros2 marsupial_simulation.launch.py
    

1. To start the experiment:

    ros2 launch marsupial_simulator_ros2 marsupial_experiment.launch.py mission:=test1
    

1. To record a bag: the bag is recorded automatically

The tests carried out are as follows:

• Test 1. The UGV is kept static. UAV ascends and descends N times.
• Test 2. The UAV is kept static. The UGV moves between two points N times.
• Test 3. UAV and UGV move in opposite directions N times.
• Test 4. The test performed inside a theatre is replicated. The length of the tether is calculated as a function of the relative distance between the UAV and the UGV. The test is maintained up to the target point 100.
• Test 5. The test performed inside a theatre is replicated again. In this case, the length of the tether is provided by the test trajectory. The test is maintained up to the target point 100.

It is possible to modify the self.tether_coef value of the ugv_theter_trajectory_follower.py script to adjust the behaviour of the tether. The test0 is included for this purpose. This parameter should be changed between 0 and 1 until a realistic result is achieved.

(back to top)

Customization

How to modify tether model

By adjusting these parameters, you can simulate different types of tethers and study their behavior under various conditions. The parameters of the tether connecting the UAV and UGV can be customized through a Jinja file. This file allows you to adjust various physical properties of the tether elements to better suit your simulation needs.

1. Open the Jinja file located at models > tether > tether.sdf.jinja.

2. Adjust the values of the parameters as needed. To increase the size of the tether, it is recommended to focus on increasing the number_elements parameter. This will result in a longer tether composed of more segments.

3. Save the changes to the Jinja file.

4. Recompile your workspace if necessary to apply the changes to the simulation.

5. To implement the changes run:

    python3  ~/marsupial/src/marsupial_simulator_ros2/scripts/jinja_gen.py   ~/marsupial/src/marsupial_simulator_ros2/models/tether/tether.sdf.jinja ~/marsupial/src/marsupial_simulator_ros2/models/tether 
    

How to include new scenarios

You can easily introduce additional scenarios in the simulator by creating or copying a Gazebo .world file and placing it in the appropriate directory. This allows you to customize the environment layout (e.g., obstacles, buildings) while preserving the marsupial UAV-UGV simulation functionalities. Follow these steps:

1. Copy the .world file into the worlds directory

    ~/marsupial/src/marsupial_simulator_ros2/worlds
    

1. Add required plugins In your .world file, make sure to include the essential plugins for octomap construction and link attachment, as shown below. Insert these lines inside the tag:

    <world name="new:_world">

    <!-- World elements  -->

    <plugin name="gazebo_octomap" filename="libBuildOctomapPlugin.so"/>
    <plugin name="ros_link_attacher_plugin" filename="libgazebo_ros_link_attacher_plugin.so"/>

    </world>
    

(back to top)

Cite this work

This simulator has been submitted to a journal and is currently under review.

(back to top)