Edit on Github

Building ROS 2 on Windows

This guide is about how to setup a development environment for ROS 2 on Windows.

Prerequisites

First follow the steps for Installing Prerequisites on the Binary Installation page.

Stop and return here when you reach the “Downloading ROS 2” section.

Additional Prerequisites

When building from source you’ll need a few additional prerequisites installed.

Install Additional Prerequisites from Chocolatey

First install git:

> choco install -y git

You will need to append the Git cmd folder C:\Program Files\Git\cmd to the PATH (you can do this by clicking the Windows icon, typing “Environment Variables”, then clicking on “Edit the system environment variables”. In the resulting dialog, click “Environment Variables”, the click “Path” on the bottom pane, then click “Edit” and add the path).

Then install patch:

> choco install -y patch

You may need to close the cmd prompt and open a new one, but at this point you should be able to run git, python, cmake, and patch.exe --version.

Installing Developer Tools

Now we are ready to install some our tools that we use to help in developing ROS 2.

Let’s start with vcstool:

> pip install -U vcstool

You can test it out by just running vcs (you should be able to do this in the same cmd prompt).

Next, install colcon:

> pip install -U colcon-common-extensions

You can test it out by just running colcon (you should be able to do this in the same cmd prompt).

Also, you should install curl:

> choco install -y curl

Install dependencies

Next install the latest version of setuptools and pip:

> <PATH_TO_PYTHON_EXECUTABLE> -m pip install -U setuptools pip

Where PATH_TO_PYTHON_EXECUTABLE looks like: c:\python37\python.exe

Then you can continue installing other Python dependencies:

> pip install -U catkin_pkg EmPy lark-parser pyparsing pyyaml

Next install testing tools like pytest and others:

> pip install -U pytest coverage mock

Next install linters and checkers like flake8 and others:

> pip install -U flake8 flake8-blind-except flake8-builtins flake8-class-newline flake8-comprehensions flake8-deprecated flake8-docstrings flake8-import-order flake8-quotes pep8 pydocstyle

Next install cppcheck:

> choco install -y cppcheck

You will need to add C:\Program Files\Cppcheck to the PATH.

Next install xmllint:

Install Qt5

This section is only required if you are building rviz, but it comes with our default set of sources, so if you don’t know, then assume you are building it.

First get the installer from Qt’s website:

https://www.qt.io/download

Select the Open Source version and then the Qt Online Installer for Windows.

Run the installer and install Qt5. We recommend you install it to the default location of C:\Qt, but if you choose somewhere else, make sure to update the paths below accordingly. When selecting components to install, the only thing you absolutely need for bouncy and later is the appropriate MSVC 64-bit component under the Qt -> Qt 5.10.0 tree. We’re using 5.10.0 as of the writing of this document and that’s what we recommend since that’s all we test on Windows, but later version will probably work too. For bouncy and later, be sure to select MSVC 2017 64-bit. For ardent use MSVC 2015 64-bit. After that, the default settings are fine.

Finally, set the Qt5_DIR environment variable in the cmd.exe where you intend to build so that CMake can find it:

> set Qt5_DIR=C:\Qt\5.10.0\msvc2017_64
: You could set it permanently with ``setx -m Qt5_DIR C:\Qt\5.10.0\msvc2017_64`` instead, but that requires Administrator.

Note

This path might change based on which MSVC version you’re using or if you installed it to a different directory.

RQt dependencies

> pip install -U pydot PyQt5

Getting the Source Code

Now that we have the development tools we can get the ROS 2 source code.

First setup a development folder, I use C:\dev\ros2_crystal:

> md \dev\ros2_crystal\src
> cd \dev\ros2_crystal

Get the ros2.repos file which defines the repositories to clone from:

# CMD
> curl -sk https://raw.githubusercontent.com/ros2/ros2/crystal/ros2.repos -o ros2.repos

# PowerShell
> curl https://raw.githubusercontent.com/ros2/ros2/crystal/ros2.repos -o ros2.repos

Next you can use vcs to import the repositories listed in the ros2.repos file:

# CMD
> vcs import src < ros2.repos

# PowerShell
> vcs import --input ros2.repos src

Install additional DDS implementations (optional)

If you would like to use another DDS or RTPS vendor besides the default, eProsima’s Fast RTPS, you can find instructions here.

Building the ROS 2 Code

To build ROS 2 you will need a Visual Studio Command Prompt (usually titled “x64 Native Tools Command Prompt for VS 2017” for bouncy and later or “x64 Native Tools Command Prompt for VS 2015” for ardent and earlier) running as Administrator.

FastRTPS is bundled with the ROS 2 source and will always be built unless you put an AMENT_IGNORE file in the src\eProsima folder.

To build the \dev\ros2_crystal folder tree:

> colcon build --merge-install

Note

We’re using --merge-install here to avoid a PATH variable that is too long at the end of the build. If you’re adapting these instructions to build a smaller workspace then you might be able to use the default behavior which is isolated install, i.e. where each package is installed to a different folder.

Note

If you are doing a debug build use python_d path\to\colcon_executable colcon. See Extra stuff for debug mode for more info on running Python code in debug builds on Windows.

Environment setup

Start a command shell and source the ROS 2 setup file to set up the workspace:

> call C:\dev\ros2_crystal\local_setup.bat

This will automatically set up the environment for any DDS vendors that support was built for.

It is normal that the previous command, if nothing else went wrong, outputs “The system cannot find the path specified.” exactly once.

Testing and Running

Note that the first time you run any executable you will have to allow access to the network through a Windows Firewall popup.

You can run the tests using this command:

> colcon test --merge-install

Note

--merge-install should only be used if it was also used in the build step.

Afterwards you can get a summary of the tests using this command:

> colcon test-result

To run the examples, first open a clean new cmd.exe and set up the workspace by sourcing the local_setup.bat file. Then, run a C++ talker:

> call install\local_setup.bat
> ros2 run demo_nodes_cpp talker

In a separate shell you can do the same, but instead run a Python listener:

> call install\local_setup.bat
> ros2 run demo_nodes_py listener

You should see the talker saying that it’s Publishing messages and the listener saying I heard those messages. This verifies both the C++ and Python APIs are working properly. Hooray!

See the tutorials and demos for other things to try.

Note

It is not recommended to build in the same cmd prompt that you’ve sourced the local_setup.bat.

Troubleshooting

Troubleshooting techniques can be found here.

Extra stuff for Debug mode

If you want to be able to run all the tests in Debug mode, you’ll need to install a few more things:

  • To be able to extract the Python source tarball, you can use PeaZip:

> choco install -y peazip
  • You’ll also need SVN, since some of the Python source-build dependencies are checked out via SVN:

> choco install -y svn hg
  • You’ll need to quit and restart the command prompt after installing the above.

  • Get and extract the Python 3.7.4 source from the tgz:

  • Now, build the Python source in debug mode from a Visual Studio command prompt:

> cd C:\dev\Python-3.7.4\PCbuild
> get_externals.bat
> build.bat -p x64 -d
  • Finally, copy the build products into the Python37 installation directories, next to the Release-mode Python executable and DLL’s:

> cd C:\dev\Python-3.7.4\PCbuild\amd64
> copy python_d.exe C:\Python37 /Y
> copy python37_d.dll C:\Python37 /Y
> copy python3_d.dll C:\Python37 /Y
> copy python37_d.lib C:\Python37\libs /Y
> copy python3_d.lib C:\Python37\libs /Y
> for %I in (*_d.pyd) do copy %I C:\Python37\DLLs /Y
  • Now, from a fresh command prompt, make sure that python_d works:

> python_d
> import _ctypes
  • To create executables python scripts(.exe), python_d should be used to invoke colcon

> python_d path\to\colcon_executable build
  • Hooray, you’re done!

SROS2 Debug Mode

In order to use SROS2 in Debug mode on Windows, a corresponding debug build for lxml must be installed.

  • A pre-built Python wheel binary for lxml debug is provided, to install:

> pip install https://github.com/ros2/ros2/releases/download/lxml-archives/lxml-4.3.2-cp37-cp37dm-win_amd64.whl
  • To verify installation

> python_d
> from lxml import etree
  • No import errors should appear.

  • Note, in order to switch back to release, reinstall the release wheel of lxml via pip:

> pip install lxml

Uninstall

  1. If you installed your workspace with colcon as instructed above, “uninstalling” could be just a matter of opening a new terminal and not sourcing the workspace’s setup file. This way, your environment will behave as though there is no Crystal install on your system.

  2. If you’re also trying to free up space, you can delete the entire workspace directory with:

    rmdir /s /q \ros2_crystal