Gazebo Classic Simulation
Last updated
Last updated
:::warning Gazebo Classic is supported with PX4 up to Ubuntu Linux 20.04. It has been superseded by (which was as "Gazebo Ignition") for use on Ubuntu 22.04 and later. :::
Gazebo Classic is a powerful 3D simulation environment for autonomous robots that is particularly suitable for testing object-avoidance and computer vision. This page describes its use with SITL and a single vehicle. Gazebo Classic can also be used with and for .
Supported Vehicles: Quad (, Hex (Typhoon H480), , Tailsitter, Plane, Rover, Submarine/UUV.
@
:::note See for general information about simulators, the simulation environment, and simulation configuration (e.g. supported vehicles). :::
Gazebo Classic 9 or 11 setup is included in our [standard build instructions}(../dev_setup/dev_env.md) for Linux, macOS, and Windows. Additional installation instructions can be found on .
:::note If you plan to use PX4 with ROS you should follow the to install both ROS and Gazebo Classic (and thereby avoid installation conflicts). :::
:::note The following commands can be used to remove and reinstall Gazebo-Classic 11:
Note that aptitude is needed because it can resolve dependency conflicts (by removing certain packages) that apt is unable to handle. :::
Run a simulation by starting PX4 SITL and Gazebo Classic with the airframe configuration to load (multicopters, planes, VTOL, optical flow and multi-vehicle simulations are supported).
The easiest way to do this is to open a terminal in the root directory of the PX4 PX4-Autopilot repository and call make for the desired target. For example, to start a quadrotor simulation (the default):
The supported vehicles and make commands are listed below (click links to see vehicle images).
:::note For the full list of build targets run make px4_sitl list_vmd_make_targets (and filter on those that start with gazebo-classic_). :::
make px4_sitl gazebo-classic
make px4_sitl gazebo-classic_iris_opt_flow
make px4_sitl gazebo-classic_iris_depth_camera
make px4_sitl gazebo-classic_iris_downward_depth_camera
make px4_sitl gazebo-classic_solo
make px4_sitl gazebo-classic_typhoon_h480
make px4_sitl gazebo-classic_plane
make px4_sitl gazebo-classic_plane_catapult
make px4_sitl gazebo-classic_standard_vtol
make px4_sitl gazebo-classic_tailsitter
make px4_sitl gazebo-classic_rover
make px4_sitl gazebo-classic_r1_rover
make px4_sitl gazebo-classic_uuv_hippocampus
make px4_sitl gazebo-classic_boat
make px4_sitl gazebo-classic_cloudship
The commands above launch a single vehicle with the full UI. Other options include:
The make commands above first build PX4, and then run it along with the Gazebo Classic simulator.
Once PX4 has started it will launch the PX4 shell as shown below.
The console will print out status as PX4 loads the airframe-specific initialisation and parameter files, waits for (and connects to) the simulator. Once there is an INFO print that [ecl/EKF] is commencing GPS fusion the vehicle is ready to arm.
:::note Right-clicking the quadrotor model allows to enable follow mode from the context menu, which is handy to keep it in view. :::
You can bring it into the air by typing:
Gazebo Classic can be run in a headless mode in which the Gazebo Classic UI is not launched. This starts up more quickly and uses less system resources (i.e. it is a more "lightweight" way to run the simulation).
Simply prefix the normal make command with HEADLESS=1 as shown:
The variables to set are: PX4_HOME_LAT, PX4_HOME_LON, and PX4_HOME_ALT.
For example:
The simulation speed can be increased or decreased with respect to realtime using the environment variable PX4_SIM_SPEED_FACTOR.
To simulate wind speed, add this plugin to your world file and set windVelocityMean in m/s (replace SET_YOUR_WIND_SPEED with your desired speed). If needed, adapt the windVelocityMax parameter so that it is greater than windVelocityMean:
Wind direction is passed as a direction vector (standard ENU convention), which will be normalized in the gazebo plugin. Additionally you can state wind velocity variance in (m/s)² and direction variance based on a normal distribution to add some random factor into the simulation. Gust is internally handled in the same way as wind, with the slight difference that you can state start time and duration with the following two parameters windGustStart and windGustDuration.
This can cause difficulty when using a distance sensor. If there are unexpected results we recommend you change the model in iris.model from uneven_ground to asphalt_plane.
Gazebo Classic can simulate GPS noise that is similar to that typically found in real systems (otherwise reported GPS values will be noise-free/perfect). This is useful when working on applications that might be impacted by GPS noise - e.g. precision positioning.
GPS noise is enabled if the target vehicle's SDF file contains a value for the gpsNoise element (i.e. it has the line: <gpsNoise>true</gpsNoise>). It is enabled by default in many vehicle SDF files: solo.sdf, iris.sdf, standard_vtol.sdf, delta_wing.sdf, plane.sdf, typhoon_h480, tailsitter.sdf.
To enable/disable GPS noise:
Build any gazebo target in order to generate SDF files (for all vehicles). For example:
:::tip The SDF files are not overwritten on subsequent builds. :::
Open the SDF file for your target vehicle (e.g. ./Tools/simulation/gazebo/sitl_gazebo/models/iris/iris.sdf).
Search for the gpsNoise element:
If it is present, GPS is enabled. You can disable it by deleting the line: <gpsNoise>true</gpsNoise>
If it is not present, GPS is disabled. You can enable it by adding the gpsNoise element to the gps_plugin section (as shown above).
The next time you build/restart Gazebo Classic it will use the new GPS noise setting.
You can load any of the worlds by specifying them as the final option in the PX4 configuration target.
For example, to load the warehouse world, you can append it as shown:
You can also specify the full path to a world to load using the PX4_SITL_WORLD environment variable. This is useful if testing a new world that is not yet included with PX4.
The vehicle gets spawned very close to the origin of the world model at some simulated GPS location.
:::note The vehicle is not spawned exactly at the Gazebo origin (0,0,0), but using a slight offset, which can highlight a number of common coding issues. :::
If using a world that recreates a real location (e.g. a particular airport) this can result in a very obvious mismatch between what is displayed in the simulated world, and what is shown on the ground station map. To overcome this problem you can set the location of the world origin to the GPS coordinates where it would be in "real life".
The location of the world is defined in the .world file by specifying the location of the origin using the spherical_coordinates tag. The latitude, longitude, elevation must all be specified (for this to be a valid).
The video below shows that the location of the environment is aligned with the world:
For extended development sessions it might be more convenient to start Gazebo Classic and PX4 separately or even from within an IDE.
In addition to the existing cmake targets that run sitl_run.sh with parameters for px4 to load the correct model it creates a launcher targets named px4_<mode> that is a thin wrapper around original sitl px4 app. This thin wrapper simply embeds app arguments like current working directories and the path to the model file.
To start Gazebo Classic and PX4 separately:
Run gazebo classic (or any other sim) server and client viewers via the terminal specifying an _ide variant:
or
In your IDE select px4_<mode> target you want to debug (e.g. px4_iris)
Start the debug session directly from IDE
This approach significantly reduces the debug cycle time because simulator is always running in background and you only re-run the px4 process which is very light.
To simulate a plane with this camera:
This publishes depth images and camera information on the /camera/depth/image_raw and /camera/depth/camera_info ROS topics respectively.
To use these images, you will need to install ROS or ROS 2. Note the warning at the top of this page about how to "avoid installation conflicts" when installing ROS and Gazebo.
You can simulate a quadrotor with a forward-facing depth camera:
or a quadrotor with a downward-facing depth camera:
The if750a target has a parachute attached to the vehicle. To simulate the vehicle, run the following command:
For more information see:
PX4 SITL for Gazebo Classic supports UDP video streaming from a camera sensor attached to a simulated vehicle model. When streaming is enabled, you can connect to this stream from QGroundControl (on UDP port 5600) and view video of the Gazebo Classic environment from the simulated vehicle - just as you would from a real camera. The video is streamed using a gstreamer pipeline and can be enabled/disabled using a button in the Gazebo Classic UI.
The simulated camera sensor is supported/enabled on the following frames:
:::note FYI only, the dependencies include: gstreamer1.0-plugins-base, gstreamer1.0-plugins-good, gstreamer1.0-plugins-bad, gstreamer1.0-plugins-ugly, libgstreamer-plugins-base1.0-dev. :::
Video streaming is automatically started when supported by the target vehicle. For example, to start streaming video on the Typhoon H480:
Streaming can be paused/restarted using the Gazebo UI Video ON/OFF button..
The easiest way to view the SITL/Gazebo Classic camera video stream is in QGroundControl. Simply open Application Settings > General and set Video Source to UDP h.264 Video Stream and UDP Port to 5600:
The video from Gazebo Classic should then display in QGroundControl just as it would from a real camera.
:::note The Typhoon world is not very interesting. :::
It is also possible to view the video using the Gstreamer Pipeline. Simply enter the following terminal command:
SITL fails silently when there is something wrong with the model. You can enable more verbose logging using VERBOSE_SIM, as shown:
or
:::note The build system enforces the correct GIT submodules, including the simulator. It will not overwrite changes in files in the directory. :::
(forward-facing)
(downward-facing)
(supports video streaming)
:::note The guide is a useful reference if there are build errors. :::
so that you can keep Gazebo Classic running and only re-launch PX4 when needed (quicker than restarting both).
Run the simulation in , which does not start the Gazebo Classic UI (this uses fewer resources and is much faster).
Options that apply to all simulators are covered in the top level topic (some of these may be duplicated below).
explains how to trigger safety failsafes like GPS failure and battery drain.
The takeoff location in Gazebo Classic can be set using environment variables. This will override both the default takeoff location, and any value .
For more information see: .
You can see how this is done in .
Joystick and thumb-joystick support are supported through QGroundControl ().
The current default world is ), which uses a heightmap as ground.
PX4 supports a number of , which are stored in . By default Gazebo Classic displays a flat featureless plane, as defined in .
:::note There are two underscores after the model (plane_cam) indicating that the default debugger is used (none). See . :::
:::tip If the loaded world does not align with the map, you may need to . :::
:::note You can also set a that does the same thing. However adding the location to the map is easier (and can still be over-ridden by setting a custom location if needed). :::
An example can be found in the :
You can test this by spawning a rover in the using the following make command (note that spawning takes longer the first time as the model needs to be downloaded from the model database):
@
The Gazebo Classic survey camera simulates a that captures geotagged JPEG images and sends camera capture information to a connected ground station. The camera also supports video streaming. It can be used to test camera capture, in particular within survey missions.
The camera emits the message every time an image is captured. The captured images are saved to: PX4-Autopilot/build/px4_sitle_default/tmp/frames/DSC_n_.jpg (where n starts as 00000 and is iterated by one on each capture).
:::note The camera also supports/responds to the following MAVLink commands: , , , , , , , , , , , . :::
:::note The simulated camera is implemented in . :::
The Gazebo Classic simulates an Intel® RealSense™ D455 stereo depth camera using the .
Gazebo Classic can be used to simulate deploying a during (flight termination is triggered by the PWM command that is simulated in Gazebo Classic).
To put the vehicle into flight termination state, you can force it to fail a that has flight termination set as the failsafe action. For example, you could do this by forcing a .
Gstreamer 1.0 is required for video streaming. The required dependencies should already have been (they are included in the standard PX4 installation scripts/instructions for macOS and Ubuntu Linux).
To extend or customize the simulation interface, edit the files in the Tools/simulation/gazebo/sitl_gazebo folder. The code is available on the on Github.
