 |
USRP Hardware Driver and USRP Manual
Version: 4.7.0.0
UHD and USRP Manual
|
|
|
USRP Hardware Driver and USRP Manual
Version: 4.7.0.0
UHD and USRP Manual
|
|
Linux Notes: This is dependent on the distribution you are using, but most, if not all, of the dependencies should be available in the package repositories for your package manager.
Mac OS X Notes: Install the Xcode app to get the build tools (GCC and Make). Use MacPorts to get the Boost and Mako dependencies. Other dependencies can be downloaded as DMG installers from the web or installed via MacPorts. See the UHD OS X build instructions for more information: Build Instructions (Mac OS X)
Windows Notes: The dependencies can be acquired through installable EXE files. Usually, the Windows installer can be found on the project's website. Some projects do not host Windows installers, and if this is the case, follow the auxiliary download URL for the Windows installer (below).
The following compilers are known to work and officially supported:
Other compilers (or lower versions) may work, but are unsupported.
For Windows users, copy the CMake file to Program Files, e.g. C:\Program Files\cmake-3.13.4-win32-x86. The CMake path, e.g. C:\Program Files\cmake-3.13.4-win32-x86\bin needs to be added to the environment variables.
The Boost binary installer must be selected to match the architecture of Windows being run.
The directory to which you extract libusb must not contain spaces. This is to say that C:\local\lib usb-1.0.22 will cause compile issues moving forward.
Windows x86-64 MSI Installer -> python-version.amd64.msi needs to be used.Install fundamental packages for Python: On Windows Terminal, navigate to Python scripts folder, e.g. C:\local\Python37\Scripts, and execute the following commands to install requests and numpy packages, respectively:
pip3 install requests pip3 install numpy pip3 install ruamel.yaml pip3 install setuptools
For curses package installation:
curses-2.2-cp37-cp37m-win_amd64.whl.pip3 install wheel
python3 -m pip3 install curses-2.2-cp37-cp37m-win_amd64.whl
Note: Pybind11 is shipped with UHD, and if no version of Pybind11 is found in the usual paths, the in-tree version will be used. For compatibility with other software that also uses Pybind11 (e.g., GNU Radio) it is generally recommended to use the system version, but it is no requirement for UHD in general.
Alternative method: You can use pip3 or easy_install to install Mako from PyPi. To install it using 'pip3' on Windows, navigate to Python scripts folder, e.g. C:\local\Python37\Scripts, and run the following command:
pip3 install mako
Required to check out the repository (not necessary if building from tarballs).
On Windows, install Cygwin from https://www.cygwin.com/ with Git support to checkout the repository or install msysGit from http://code.google.com/p/msysgit/downloads/list.
You can install all the dependencies through the package manager:
sudo apt-get install autoconf automake build-essential ccache cmake cpufrequtils doxygen ethtool \ g++ git inetutils-tools libboost-all-dev libncurses5 libncurses5-dev libusb-1.0-0 libusb-1.0-0-dev \ libusb-dev python3-dev python3-mako python3-numpy python3-requests python3-scipy python3-setuptools \ python3-ruamel.yaml
Your actual command may differ.
You can install all the dependencies through the package manager:
sudo yum -y install boost-devel libusb1-devel doxygen python3-docutils python3-mako python3-numpy python3-requests python3-ruamel-yaml python3-setuptools cmake make gcc gcc-c++
or
sudo dnf -y install boost-devel libusb1-devel doxygen python3-docutils python3-mako python3-numpy python3-requests python3-ruamel-yaml python3-setuptools cmake make gcc gcc-c++
Your actual command may differ.
The UHD source is stored in a git repository. To download it, follow these instructions:
git clone https://github.com/EttusResearch/uhd.git
Our source code repository contains of the following branches:
We might also be publishing experimental feature branches which can then be found in the same repository. All of our versioned releases are associated with tags in the repository.
PyBOMBS is a command-line tool for Linuxes (and some Unixes) from the GNU Radio ecosystem and will do a source build of UHD, including setting up prerequisites/dependencies (regardless of the distribution). Assuming you have PyBOMBS set up, you can install UHD with the following command:
$ pybombs install uhd
Head to the PyBOMBS Homepage for more instructions. PyBOMBS can install UHD (as well as GNU Radio or similar projects) both into system directories as well as into user's home directories, omitting the requirement for superuser access.
cd <uhd-repo-path>/host mkdir build cd build cmake ../
Additionally, configuration variables can be passed into CMake via the command line. The following common-use configuration variables are listed below:
-DCMAKE_INSTALL_PREFIX=<install-path>cmake -DLIB_SUFFIX=64Example usage:
cmake -DCMAKE_INSTALL_PREFIX=/opt/uhd ../
Ubuntu 20.04 note: When building for Ubuntu 20.04, you may run into errors such as this during CMake's generation stage:
CMake Error in python/CMakeLists.txt: Imported target "Boost::chrono" includes non-existent path "/include" in its INTERFACE_INCLUDE_DIRECTORIES. Possible reasons include: The path was deleted, renamed, or moved to another location. An install or uninstall procedure did not complete successfully. The installation package was faulty and references files it does not provide.
These errors occur when CMake finds filesystem items by following the /bin symlink to /usr/bin and thus incorrectly calculating the root path for various directories needed by the build.
If you encounter this issue, ensure that /usr/bin appears before /bin in the PATH environment variable of the process executing CMake. Alternatively, you can pass the CMAKE_FIND_ROOT_PATH configuration variable to CMake with a value of /usr to point it to the right starting directory for filesystem item searches.
Example usage:
cmake -DCMAKE_FIND_ROOT_PATH=/usr ../
make make test # This step is optional sudo make install
Make sure that libuhd.so is in your LD_LIBRARY_PATH, or add it to /etc/ld.so.conf and make sure to run:
sudo ldconfig
When compiling for ARM platforms, the assumption is made that NEON extensions are available if the arm_neon.h header is found. However, this might not be true, e.g., when cross-compiling for an arm7l target (e.g., the Odroid XU4) using a standard SDK. In this case, it's necessary to tell CMake to disable NEON extensions:
cmake -DNEON_SIMD_ENABLE=OFF [...]
<uhd-repo-path>/host.<uhd-repo-path>\host\build.Boost_INCLUDE_DIR should point to the PATH where the Boost .hpp files are, e.g. C:\local\boost_version\Boost_LIBRARY_DIR should point to the pre-built libraries, e.g. C:\local\boost_version\lib64-msvc-14.0)CMAKECMAKE_BUILD_TYPE: Release and change it to CMAKE_BUILD_TYPE: Debug.<uhd-repo-path>\host\build\ALL_BUILD.vcxproj in visual studio, generate the project. Watch the output console for errors.CMAKE_INSTALL_PREFIX where your user has write privileges, you must close Visual Studio, run it again with Administrator Privileges, and open ALL_BUILD.vcxproj.On Windows, CMake does not have the advantage of pkg-config, so we must manually tell CMake how to locate the LibUSB header and lib.
LIBUSB_INCLUDE_DIRS to the directory for libusb.h, e.g. C:\local\libusb-1.0.22\include\libusb-1.0.LIBUSB_LIBRARIES to the full path for libusb-1.0.lib, e.g. C:\local\libusb-1.0.22\MS64\dll\libusb-1.0.lib.libusb-1.0.lib to simplify runtime dependencies.Note: On Windows, LibUSB v1.0.19 is required to use most USB3 controllers.
C:\cygwin64\home\admin\uhd\host\build\UHD.sln.Note: You may not have permission to build the install target. You need to be an administrator or to run MSVC as administrator.
Open the Visual Studio Command Prompt Shorcut:
cd <uhd-repo-path>\host\build DevEnv uhd.sln /build Release /project ALL_BUILD DevEnv uhd.sln /build Release /project INSTALL
Add the UHD bin path to PATH% (usually C:\Program Files\UHD\bin)
Note: The default interface for editing environment variable paths in Windows is very poor. We recommend using "Rapid Environment Editor" (http://www.rapidee.com) over the default editor.
For the purposes of building and using UHD, you can use Apple's Terminal.app if you so choose, no matter how you install UHD.
That said, running almost any graphical interface (GUI) will require downloading and installing X11/XQuartz first. Through OSX 10.8, Apple provided a means to install X11.app, but XQuartz has always been more up to date. Staring in 10.9, Apple no longer provides a full working version of X11.app. Hence, just use XQuartz from the get-go. Note that unless you experiment with using the Quartz interface to various graphical toolkits (e.g., GTK), you must use X11 as the terminal interface for any GUI applications.
Apple provides a fully integrated development environment via their Xcode toolkit, which can be downloaded either via the App store or directly from Apple's Developer area depending on the version of OSX in use. Xcode provides the compilers and related development tools needed to build or execute UHD and its dependencies.
Once Xcode is installed, you must still install the Command Line Tools, which can be accomplished by running Xcode.app, then going to Preferences... -> Downloads and making sure Command Line Tools is selected/enabled [feel free to select other downloads too]. You might be able to install the Command Line Tools in a terminal using
xcode-select --install
but this command will not work with every OSX / Xcode combination (e.g., does not work with OSX 10.8 and Xcode 5, but does work with OSX 10.9 and Xcode 5).
Once the Command Line Tools are installed, UHD and other projects can be installed either from source or, preferably, via MacPorts.
There are a number of background libraries and applications that must be installed from source or binary in order to compile or execute UHD; for a full list, see Build Dependencies. These can be obtained by using MacPorts, Fink, HomeBrew, and/or from source / scratch. MacPorts tends to be more up-to-date with respect to new releases, which can be both a blessing and a curse since sometimes new released are untested and result in build or runtime errors. MacPorts, HomeBrew, and Fink offer thousands of ready-to-install libraries and applications, and hence they are highly recommended to use instead of installing from source / scratch.
Many UHD developers first install UHD using MacPorts in order to get all of the necessary background dependencies installed, then remove just UHD via
sudo port install uhd sudo port uninstall uhd
NOTE: We highly recommended that all dependencies be installed via the same package manager! When issues arise, they are much easier to track down, and updating to newer versions of UHD as well as dependencies is much easier.
NOTE: Other package managers (e.g., Fink, HomeBrew) will require different commands than the above to install all dependencies and then remove the UHD install. Please consult the specific package manager in use for how to do these commands properly; they will not be covered here.
Installing UHD from source follows the standard cmake method as found in many places, with a few arguments to make sure cmake always finds the correct version of Python, and uses the desired compiler. First, download the source code either via a release or via GIT.
For example, on OSX 10.8+ and using Xcode's legacy Apple GCC (via llvm), MacPorts installed into /opt/local (the default), and for Python 2.7 as installed by MacPorts, issue the following commands from within the UHD source directory:
$ mkdir build $ cd build $ CC=/usr/bin/llvm-gcc CXX=/usr/bin/llvm-g++ cmake -DCMAKE_INSTALL_PREFIX=/opt/local -DPYTHON_EXECUTABLE=/opt/local/bin/python2.7 -DPYTHON_INCLUDE_DIR=/opt/local/Library/Frameworks/Python.framework/Versions/2.7/Headers -DPYTHON_LIBRARY=/opt/local/Library/Frameworks/Python.framework/Versions/2.7/Python ../host $ make
If make succeeds, then you can test the build for errors via
$ make test
To install the build, issue
$ sudo make install
Selecting another compiler is as simple as changing the CC and CXX pre-arguments to the cmake command. Similarly, one can change the install prefix by changing the setting of the variable CMAKE_INSTALL_PREFIX.
NOTE: All of the PYTHON defines must point to the same install of Python, otherwise runtime errors are likely to occur.
NOTE: When using some other package manager (e.g., Fink, HomeBrew), the actual variable settings (-D...=...) will be different than those above. Please consult the specific package manager in use for how to do these settings properly; they will not be covered here.
uhd_images_downloader on the command line, or one of these executables (the actual path may differ based on your installation):If your application uses CMake as a build system, the following command will setup up your build environment to link against UHD:
This will set the CMake variable UHD_INCLUDE_DIRS and UHD_LIBRARIES accordingly.
See the example in examples/init_usrp for more details, as well as the UHDConfig.cmake file that gets installed along with the UHD libraries.
Using CMake, UHD can be built as a static library by switching on ENABLE_STATIC_LIBS.
cmake -DENABLE_STATIC_LIBS=ON <path to UHD source>
When linking the static library, you must ensure that the library is loaded in its entirety, otherwise global objects aren't initialized at load-time and it will always fail to detect any devices. Also, all UHD dependencies for UHD must be provided unless your linker has other ways of resolving library dependencies.
With the GNU ld linker (e.g. on Linux platforms), this is done using the --whole-archive switch. Using the GNU C++ compiler, the correct command line is:
g++ your_uhd_app.cpp -Wl,-whole-archive <path to UHD libs>/libuhd.a -Wl,-no-whole-archive -ldl -lpthread -l<all other libraries>
Note that --whole-archive is disabled after including libuhd.a. The exact list of libraries depends on your UHD build. When using UHDConfig.cmake (see Building applications that require UHD using CMake), the path to libuhd.a is saved into UHD_LIBRARIES, and UHD_STATIC_LIB_DEPS lists the required dependencies. See UHDConfig.cmake for details.
1.8.13