aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--host/CMakeLists.txt25
-rw-r--r--host/cmake/debian/control1
-rw-r--r--host/docs/pythonapi.dox32
-rw-r--r--host/lib/stream_python.hpp73
-rw-r--r--host/lib/types/filters_python.hpp27
-rw-r--r--host/lib/types/metadata_python.hpp49
-rw-r--r--host/lib/types/sensors_python.hpp24
-rw-r--r--host/lib/types/serial_python.hpp16
-rw-r--r--host/lib/types/time_spec_python.hpp24
-rw-r--r--host/lib/types/tune_python.hpp12
-rw-r--r--host/lib/types/types_python.hpp35
-rw-r--r--host/lib/usrp/dboard_iface_python.hpp26
-rw-r--r--host/lib/usrp/fe_connection_python.hpp11
-rw-r--r--host/lib/usrp/multi_usrp_python.hpp589
-rw-r--r--host/lib/usrp/subdev_spec_python.hpp19
-rw-r--r--host/lib/utils/gil_release_python.hpp31
-rw-r--r--host/python/CMakeLists.txt11
-rw-r--r--host/python/pyuhd.cpp179
-rw-r--r--host/python/types.py5
19 files changed, 337 insertions, 852 deletions
diff --git a/host/CMakeLists.txt b/host/CMakeLists.txt
index 3ae6fbffb..092c2348f 100644
--- a/host/CMakeLists.txt
+++ b/host/CMakeLists.txt
@@ -284,11 +284,9 @@ endif(WIN32)
# Choose a version of Python
########################################################################
option(ENABLE_PYTHON3 "Enable Python 3. Default is Python 2" OFF)
-set(BOOST_PYTHON_COMPONENT python)
-set(BOOST_PYTHON_VERSION 2.7)
+set(PYBIND11_PYTHON_VERSION 2.7)
if(${ENABLE_PYTHON3})
- set(BOOST_PYTHON_COMPONENT python3)
- set(BOOST_PYTHON_VERSION 3)
+ set(PYBIND11_PYTHON_VERSION 3)
endif()
########################################################################
@@ -307,7 +305,6 @@ set(BOOST_REQUIRED_COMPONENTS
serialization
)
-set(BOOST_OPTIONAL_COMPONENTS ${BOOST_PYTHON_COMPONENT})
if(MINGW)
list(APPEND BOOST_REQUIRED_COMPONENTS thread_win32)
else()
@@ -344,14 +341,6 @@ find_package(Boost ${BOOST_MIN_VERSION} COMPONENTS ${BOOST_REQUIRED_COMPONENTS})
include_directories(${Boost_INCLUDE_DIRS})
link_directories(${Boost_LIBRARY_DIRS})
-#Check to see if the Python version we're looking for exists
-set(BOOST_PYTHON_FOUND ${Boost_PYTHON_FOUND})
-set(BOOST_PYTHON_LIBRARY ${Boost_PYTHON_LIBRARY})
-if(${ENABLE_PYTHON3})
- set(BOOST_PYTHON_FOUND ${Boost_PYTHON3_FOUND})
- set(BOOST_PYTHON_LIBRARY ${Boost_PYTHON3_LIBRARY})
-endif()
-
message(STATUS "Boost include directories: ${Boost_INCLUDE_DIRS}")
message(STATUS "Boost library directories: ${Boost_LIBRARY_DIRS}")
message(STATUS "Boost libraries: ${Boost_LIBRARIES}")
@@ -367,8 +356,8 @@ include(UHDLog)
########################################################################
# Check Python Modules
########################################################################
-find_package(PythonInterp ${BOOST_PYTHON_VERSION})
-find_package(PythonLibs ${BOOST_PYTHON_VERSION})
+find_package(PythonInterp ${PYBIND11_PYTHON_VERSION})
+find_package(PythonLibs ${PYBIND11_PYTHON_VERSION})
include(UHDPython)
set(PYTHON_VERSION "platform.python_version() >= '2.7' and platform.python_version() < '3.0'")
@@ -377,7 +366,7 @@ if(${ENABLE_PYTHON3})
endif()
PYTHON_CHECK_MODULE(
- "Python version ${BOOST_PYTHON_VERSION} or greater"
+ "Python version ${PYBIND11_PYTHON_VERSION} or greater"
"platform" ${PYTHON_VERSION}
HAVE_PYTHON_PLAT_MIN_VERSION
)
@@ -430,9 +419,9 @@ UHD_INSTALL(FILES
LIBUHD_REGISTER_COMPONENT("LibUHD" ENABLE_LIBUHD ON "Boost_FOUND;HAVE_PYTHON_PLAT_MIN_VERSION;HAVE_PYTHON_MODULE_MAKO" OFF ON)
LIBUHD_REGISTER_COMPONENT("LibUHD - C API" ENABLE_C_API ON "ENABLE_LIBUHD" OFF OFF)
if(WIN32)
- LIBUHD_REGISTER_COMPONENT("LibUHD - Python API" ENABLE_PYTHON_API OFF "ENABLE_LIBUHD;BOOST_PYTHON_FOUND;HAVE_PYTHON_MODULE_NUMPY;PythonLibs_FOUND" OFF OFF)
+ LIBUHD_REGISTER_COMPONENT("LibUHD - Python API" ENABLE_PYTHON_API OFF "ENABLE_LIBUHD;HAVE_PYTHON_MODULE_NUMPY;PythonLibs_FOUND" OFF OFF)
else()
- LIBUHD_REGISTER_COMPONENT("LibUHD - Python API" ENABLE_PYTHON_API ON "ENABLE_LIBUHD;BOOST_PYTHON_FOUND;HAVE_PYTHON_MODULE_NUMPY;PythonLibs_FOUND" OFF OFF)
+ LIBUHD_REGISTER_COMPONENT("LibUHD - Python API" ENABLE_PYTHON_API ON "ENABLE_LIBUHD;HAVE_PYTHON_MODULE_NUMPY;PythonLibs_FOUND" OFF OFF)
endif(WIN32)
LIBUHD_REGISTER_COMPONENT("Examples" ENABLE_EXAMPLES ON "ENABLE_LIBUHD" OFF OFF)
LIBUHD_REGISTER_COMPONENT("Utils" ENABLE_UTILS ON "ENABLE_LIBUHD" OFF OFF)
diff --git a/host/cmake/debian/control b/host/cmake/debian/control
index fc53a929e..4a6bd19ee 100644
--- a/host/cmake/debian/control
+++ b/host/cmake/debian/control
@@ -10,7 +10,6 @@ Build-Depends: cmake,
libboost-dev,
libboost-filesystem-dev,
libboost-program-options-dev,
- libboost-python-dev,
libboost-regex-dev,
libboost-serialization-dev,
libboost-system-dev,
diff --git a/host/docs/pythonapi.dox b/host/docs/pythonapi.dox
index e290f1ea5..3f73c3a74 100644
--- a/host/docs/pythonapi.dox
+++ b/host/docs/pythonapi.dox
@@ -5,10 +5,17 @@ for your application.
\section python_install Installing the Python API
-In order to install the Python API when building UHD from source, make sure all
-the dependencies are available (see also \ref page_build_guide, you need
-Boost.Python from your Boost library). Make sure you have the CMake variable
-`ENABLE_PYTHON_API` set to ON (e.g., by running `cmake -DENABLE_PYTHON_API=ON`).
+In order to install the Python API when building UHD from source, make sure you
+have the CMake variable `ENABLE_PYTHON_API` set to ON (e.g., by running
+`cmake -DENABLE_PYTHON_API=ON`).
+UHD requires Python header files in order to compile the Python API. On most
+Linux systems, there are packages called "python3-dev" or "python3-devel" that
+provide that functionality. On Windows, these headers always get installed when
+using the binary installers provided on https://www.python.org/downloads/windows/.
+
+If CMake can't find the Python headers or library, specify
+the `PYTHON_INCLUDE_DIRS` and/or `PYTHON_LIBRARY` CMake variables manually.
+
\subsection python_install_2v3 Python 2 vs. 3
@@ -20,13 +27,18 @@ Python 3.
\subsection python_install_windows Installing on Windows
-On Windows, only certain combinations of MSVC and Boost have proven functional.
-The following combinations are known to work (others might also work):
+Static linking on is unsupported on Windows. Otherwise, compiling the Python API
+on Windows is no different from other operating systems.
+
+\subsection python_install_adv Advanced Usage Notes
-- Visual Studio 2017 (version 15.7.3), Release X64 on Windows 10 with Boost
- 1.65.1 and Boost 1.66, Python27 x64 bit.
+UHD uses the PyBind11 library to generate its Python bindings. UHD ships its own
+copy of PyBind11, in order to facilitate the access to that library, as it is
+not packaged for many operating systems, but also to lock down its version. For
+the purpose of experimentation, it is, however possible to replace the version
+of PyBind11 shipped with UHD by overriding the `PYBIND11_INCLUDE_DIR` CMake
+variable.
-Static linking on is currently unsupported on Windows.
\section python_usage Using the Python API
@@ -93,7 +105,7 @@ def recv_to_file():
This kind of API is particularly useful in combination with Jupyter Notebooks or
similar interactive environments.
-\section python_usage_gil Python Global Interpreter Lock
+\section python_usage_gil Thread Safety and the Python Global Interpreter Lock
From the <a href="https://wiki.python.org/moin/GlobalInterpreterLock">Python wiki page on the GIL:</a>
> In CPython, the global interpreter lock, or GIL, is a mutex that protects
diff --git a/host/lib/stream_python.hpp b/host/lib/stream_python.hpp
index 0760edf1b..1cb922b52 100644
--- a/host/lib/stream_python.hpp
+++ b/host/lib/stream_python.hpp
@@ -1,5 +1,6 @@
//
// Copyright 2017-2018 Ettus Research, a National Instruments Company
+// Copyright 2019 Ettus Research, a National Instruments Brand
//
// SPDX-License-Identifier: GPL-3.0-or-later
//
@@ -7,24 +8,15 @@
#ifndef INCLUDED_UHD_STREAM_PYTHON_HPP
#define INCLUDED_UHD_STREAM_PYTHON_HPP
-#include "utils/gil_release_python.hpp"
#include <uhd/stream.hpp>
#include <uhd/types/metadata.hpp>
-
#include <boost/format.hpp>
static size_t wrap_recv(uhd::rx_streamer *rx_stream,
- bp::object &np_array,
- bp::object &metadata,
+ py::object &np_array,
+ uhd::rx_metadata_t &metadata,
const double timeout = 0.1)
{
- // Extract the metadata
- bp::extract<uhd::rx_metadata_t&> get_metadata(metadata);
- if (not get_metadata.check())
- {
- return 0;
- }
-
// Get a numpy array object from given python object
// No sanity checking possible!
PyObject* array_obj = PyArray_FROM_OF(np_array.ptr(), NPY_ARRAY_CARRAY);
@@ -70,12 +62,12 @@ static size_t wrap_recv(uhd::rx_streamer *rx_stream,
// Release the GIL only for the recv() call
const size_t result = [&]() {
- scoped_gil_release gil_release;
+ py::gil_scoped_release release;
// Call the real recv()
return rx_stream->recv(
channel_storage,
nsamps_per_buff,
- get_metadata(),
+ metadata,
timeout
);
}();
@@ -84,21 +76,12 @@ static size_t wrap_recv(uhd::rx_streamer *rx_stream,
Py_DECREF(array_obj);
return result;
}
-BOOST_PYTHON_FUNCTION_OVERLOADS(overload_wrap_recv, wrap_recv, 3, 4);
static size_t wrap_send(uhd::tx_streamer *tx_stream,
- bp::object &np_array,
- bp::object &metadata,
+ py::object &np_array,
+ uhd::tx_metadata_t& metadata,
const double timeout = 0.1)
{
- // Extract the metadata
- bp::extract<uhd::tx_metadata_t&> get_metadata(metadata);
- // TODO: throw an error here?
- if (not get_metadata.check())
- {
- return 0;
- }
-
// Get a numpy array object from given python object
// No sanity checking possible!
// Note: this increases the ref count, which we'll need to manually decrease at the end
@@ -140,12 +123,12 @@ static size_t wrap_send(uhd::tx_streamer *tx_stream,
// Release the GIL only for the send() call
const size_t result = [&]() {
- scoped_gil_release gil_release;
+ py::gil_scoped_release release;
// Call the real send()
return tx_stream->send(
channel_storage,
nsamps_per_buff,
- get_metadata(),
+ metadata,
timeout
);
}();
@@ -154,28 +137,25 @@ static size_t wrap_send(uhd::tx_streamer *tx_stream,
Py_DECREF(array_obj);
return result;
}
-BOOST_PYTHON_FUNCTION_OVERLOADS(overload_wrap_send, wrap_send, 3, 4);
static bool wrap_recv_async_msg(uhd::tx_streamer *tx_stream,
uhd::async_metadata_t &async_metadata,
double timeout = 0.1)
{
// Release the GIL
- scoped_gil_release gil_release;
-
+ py::gil_scoped_release release;
return tx_stream->recv_async_msg(async_metadata, timeout);
}
-BOOST_PYTHON_FUNCTION_OVERLOADS(overload_wrap_recv_async_msg, wrap_recv_async_msg, 2, 3);
-void export_stream()
+void export_stream(py::module& m)
{
using stream_args_t = uhd::stream_args_t;
using rx_streamer = uhd::rx_streamer;
using tx_streamer = uhd::tx_streamer;
- bp::class_<stream_args_t>
- ("stream_args", bp::init<const std::string&, const std::string&>())
-
+ py::class_<stream_args_t>
+ (m, "stream_args")
+ .def(py::init<const std::string&, const std::string&>())
// Properties
.def_readwrite("cpu_format", &stream_args_t::cpu_format)
.def_readwrite("otw_format", &stream_args_t::otw_format)
@@ -183,29 +163,28 @@ void export_stream()
.def_readwrite("channels" , &stream_args_t::channels )
;
- bp::class_<
- rx_streamer,
- boost::shared_ptr<rx_streamer>,
- uhd::noncopyable>("rx_streamer", "See: uhd::rx_streamer", bp::no_init)
-
+ py::class_<rx_streamer, rx_streamer::sptr>(m, "rx_streamer", "See: uhd::rx_streamer")
// Methods
- .def("recv" , &wrap_recv, overload_wrap_recv() )
+ .def("recv" , &wrap_recv,
+ py::arg("np_array"),
+ py::arg("metadata"),
+ py::arg("timeout") = 0.1)
.def("get_num_channels" , &uhd::rx_streamer::get_num_channels )
.def("get_max_num_samps", &uhd::rx_streamer::get_max_num_samps)
.def("issue_stream_cmd" , &uhd::rx_streamer::issue_stream_cmd )
;
- bp::class_<
- tx_streamer,
- boost::shared_ptr<tx_streamer>,
- uhd::noncopyable>("tx_streamer", "See: uhd::tx_streamer", bp::no_init)
-
+ py::class_<tx_streamer, tx_streamer::sptr>(m, "tx_streamer", "See: uhd::tx_streamer")
// Methods
- .def("send" , &wrap_send, overload_wrap_send())
+ .def("send" , &wrap_send,
+ py::arg("np_array"),
+ py::arg("metadata"),
+ py::arg("timeout") = 0.1)
.def("get_num_channels" , &tx_streamer::get_num_channels )
.def("get_max_num_samps", &tx_streamer::get_max_num_samps )
.def("recv_async_msg" , &wrap_recv_async_msg,
- overload_wrap_recv_async_msg() )
+ py::arg("async_metadata"),
+ py::arg("timeout") = 0.1)
;
}
diff --git a/host/lib/types/filters_python.hpp b/host/lib/types/filters_python.hpp
index ff5785345..ad13eed1e 100644
--- a/host/lib/types/filters_python.hpp
+++ b/host/lib/types/filters_python.hpp
@@ -1,5 +1,6 @@
//
// Copyright 2017-2018 Ettus Research, a National Instruments Company
+// Copyright 2019 Ettus Research, a National Instruments Brand
//
// SPDX-License-Identifier: GPL-3.0-or-later
//
@@ -9,24 +10,22 @@
#include <uhd/types/filters.hpp>
-void export_filters()
+void export_filters(py::module& m)
{
using filter_info_base = uhd::filter_info_base;
using filter_info_type = filter_info_base::filter_type;
using analog_filter_base = uhd::analog_filter_base;
using analog_filter_lp = uhd::analog_filter_lp;
- bp::enum_<filter_info_type>("filter_type")
+ py::enum_<filter_info_type>(m, "filter_type")
.value("analog_low_pass" , filter_info_base::ANALOG_LOW_PASS )
.value("analog_band_pass", filter_info_base::ANALOG_BAND_PASS)
.value("digital_i16" , filter_info_base::DIGITAL_I16 )
.value("digital_fir_i16" , filter_info_base::DIGITAL_FIR_I16 )
;
- bp::class_<
- filter_info_base,
- boost::shared_ptr<filter_info_base> >
- ("filter_info_base", bp::init<filter_info_type, bool, size_t>())
+ py::class_<filter_info_base, filter_info_base::sptr>(m, "filter_info_base")
+ .def(py::init<filter_info_type, bool, size_t>())
// Methods
.def("is_bypassed", &filter_info_base::is_bypassed )
@@ -34,21 +33,15 @@ void export_filters()
.def("__str__" , &filter_info_base::to_pp_string)
;
- bp::class_<
- analog_filter_base,
- boost::shared_ptr<analog_filter_base>,
- bp::bases<filter_info_base> >
- ("analog_filter_base", bp::init<filter_info_type, bool, size_t, std::string>())
+ py::class_<analog_filter_base, analog_filter_base::sptr>(m, "analog_filter_base")
+ .def(py::init<filter_info_type, bool, size_t, std::string>())
// Methods
- .def("get_analog_type", &analog_filter_base::get_analog_type, bp::return_value_policy<bp::copy_const_reference>())
+ .def("get_analog_type", &analog_filter_base::get_analog_type)
;
- bp::class_<
- analog_filter_lp,
- boost::shared_ptr<analog_filter_lp>,
- bp::bases<analog_filter_base> >
- ("analog_filter_lp", bp::init<filter_info_type, bool, size_t, const std::string, double, double>())
+ py::class_<analog_filter_lp, boost::shared_ptr<analog_filter_lp>>(m, "analog_filter_lp")
+ .def(py::init<filter_info_type, bool, size_t, const std::string, double, double>())
// Methods
.def("get_cutoff" , &analog_filter_lp::get_cutoff )
diff --git a/host/lib/types/metadata_python.hpp b/host/lib/types/metadata_python.hpp
index 876756d73..f57d82dc9 100644
--- a/host/lib/types/metadata_python.hpp
+++ b/host/lib/types/metadata_python.hpp
@@ -1,5 +1,6 @@
//
// Copyright 2017-2018 Ettus Research, a National Instruments Company
+// Copyright 2019 Ettus Research, a National Instruments Brand
//
// SPDX-License-Identifier: GPL-3.0-or-later
//
@@ -9,7 +10,7 @@
#include <uhd/types/ranges.hpp>
-void export_metadata()
+void export_metadata(py::module& m)
{
using range_t = uhd::range_t;
using meta_range_t = uhd::meta_range_t;
@@ -19,7 +20,7 @@ void export_metadata()
using async_metadata_t = uhd::async_metadata_t;
using event_code_t = async_metadata_t::event_code_t;
- bp::enum_<error_code_t>("rx_metadata_error_code")
+ py::enum_<error_code_t>(m, "rx_metadata_error_code")
.value("none" , error_code_t::ERROR_CODE_NONE )
.value("timeout" , error_code_t::ERROR_CODE_TIMEOUT )
.value("late" , error_code_t::ERROR_CODE_LATE_COMMAND)
@@ -29,11 +30,11 @@ void export_metadata()
.value("bad_packet" , error_code_t::ERROR_CODE_BAD_PACKET )
;
- bp::class_<range_t>
- ("range", bp::init<double>())
-
+ py::class_<range_t>(m, "range")
// Constructors
- .def(bp::init<double, double, double>())
+ .def(py::init<double>())
+ .def(py::init<double, double>())
+ .def(py::init<double, double, double>())
// Methods
.def("start" , &range_t::start )
@@ -42,30 +43,28 @@ void export_metadata()
.def("__str__", &range_t::to_pp_string)
;
- bp::class_<std::vector<range_t> >("range_vector")
- .def(bp::vector_indexing_suite<std::vector<range_t> >());
-
- bp::class_<meta_range_t, bp::bases<std::vector<range_t> > >
- ("meta_range", bp::init<>())
-
+ py::class_<meta_range_t>(m, "meta_range_t")
// Constructors
- .def(bp::init<double, double, double>())
+ .def(py::init<>())
+ .def(py::init<double, double>())
+ .def(py::init<double, double, double>())
// Methods
.def("start" , &meta_range_t::start )
.def("stop" , &meta_range_t::stop )
.def("step" , &meta_range_t::step )
- .def("clip" , &meta_range_t::clip )
+ .def("clip" , &meta_range_t::clip, py::arg("value"), py::arg("clip_step") = false)
.def("__str__", &meta_range_t::to_pp_string)
;
- bp::class_<rx_metadata_t>("rx_metadata", bp::init<>())
+ py::class_<rx_metadata_t>(m, "rx_metadata")
+ .def(py::init<>())
// Methods
.def("reset" , &rx_metadata_t::reset )
.def("to_pp_string", &rx_metadata_t::to_pp_string)
.def("strerror" , &rx_metadata_t::strerror )
- .def("__str__" , &rx_metadata_t::to_pp_string, bp::args("compact") = false)
+ .def("__str__" , &rx_metadata_t::to_pp_string, py::arg("compact") = false)
// Properties
.def_readonly("has_time_spec" , &rx_metadata_t::has_time_spec )
@@ -77,7 +76,8 @@ void export_metadata()
.def_readonly("out_of_sequence", &rx_metadata_t::out_of_sequence)
;
- bp::class_<tx_metadata_t>("tx_metadata", bp::init<>())
+ py::class_<tx_metadata_t>(m, "tx_metadata")
+ .def(py::init<>())
// Properties
.def_readwrite("has_time_spec" , &tx_metadata_t::has_time_spec )
@@ -86,7 +86,7 @@ void export_metadata()
.def_readwrite("end_of_burst" , &tx_metadata_t::end_of_burst )
;
- bp::enum_<event_code_t>("tx_metadata_event_code")
+ py::enum_<event_code_t>(m, "tx_metadata_event_code")
.value("burst_ack" , event_code_t::EVENT_CODE_BURST_ACK )
.value("underflow" , event_code_t::EVENT_CODE_UNDERFLOW )
.value("seq_error" , event_code_t::EVENT_CODE_SEQ_ERROR )
@@ -96,15 +96,16 @@ void export_metadata()
.value("user_payload" , event_code_t::EVENT_CODE_USER_PAYLOAD )
;
- bp::class_<async_metadata_t>("async_metadata", bp::init<>())
+ py::class_<async_metadata_t>(m, "async_metadata")
+ .def(py::init<>())
// Properties
- .def_readwrite("channel" , &async_metadata_t::channel )
- .def_readwrite("has_time_spec", &async_metadata_t::has_time_spec)
- .def_readwrite("time_spec" , &async_metadata_t::time_spec )
- .def_readwrite("event_code" , &async_metadata_t::event_code )
+ .def_readonly("channel" , &async_metadata_t::channel )
+ .def_readonly("has_time_spec", &async_metadata_t::has_time_spec)
+ .def_readonly("time_spec" , &async_metadata_t::time_spec )
+ .def_readonly("event_code" , &async_metadata_t::event_code )
// TODO: Expose user payloads
- //.def_readwrite("user_payload" , &async_metadata_t::user_payload )
+ //.def_readonly("user_payload" , &async_metadata_t::user_payload )
;
}
diff --git a/host/lib/types/sensors_python.hpp b/host/lib/types/sensors_python.hpp
index 8fd9da4e3..e3937d117 100644
--- a/host/lib/types/sensors_python.hpp
+++ b/host/lib/types/sensors_python.hpp
@@ -1,5 +1,6 @@
//
// Copyright 2017-2018 Ettus Research, a National Instruments Company
+// Copyright 2019 Ettus Research, a National Instruments Brand
//
// SPDX-License-Identifier: GPL-3.0-or-later
//
@@ -9,25 +10,24 @@
#include <uhd/types/sensors.hpp>
-void export_sensors()
+void export_sensors(py::module& m)
{
using sensor_value_t = uhd::sensor_value_t;
using data_type_t = sensor_value_t::data_type_t;
- bp::enum_<data_type_t>("data_type")
+ py::enum_<data_type_t>(m, "data_type")
.value("b", data_type_t::BOOLEAN)
.value("i", data_type_t::INTEGER)
.value("r", data_type_t::REALNUM)
.value("s", data_type_t::STRING )
;
- bp::class_<sensor_value_t>
- ("sensor_value", bp::init<const std::string&, bool, const std::string&, const std::string&>())
-
+ py::class_<sensor_value_t>(m, "sensor_value")
// Constructors
- .def(bp::init<const std::string&, signed, const std::string&, const std::string&>())
- .def(bp::init<const std::string&, double, const std::string&, const std::string&>())
- .def(bp::init<const std::string&, const std::string& , const std::string&>())
+ .def(py::init<const std::string&, bool, const std::string&, const std::string&>())
+ .def(py::init<const std::string&, signed, const std::string&, const std::string&>())
+ .def(py::init<const std::string&, double, const std::string&, const std::string&>())
+ .def(py::init<const std::string&, const std::string& , const std::string&>())
// Methods
.def("to_bool", &sensor_value_t::to_bool )
@@ -36,10 +36,10 @@ void export_sensors()
.def("__str__", &sensor_value_t::to_pp_string)
// Properties
- .add_property("name", &sensor_value_t::name )
- .add_property("value", &sensor_value_t::value)
- .add_property("unit", &sensor_value_t::unit )
- .add_property("type", &sensor_value_t::type )
+ .def_readwrite("name", &sensor_value_t::name )
+ .def_readwrite("value", &sensor_value_t::value)
+ .def_readwrite("unit", &sensor_value_t::unit )
+ .def_readwrite("type", &sensor_value_t::type )
;
}
diff --git a/host/lib/types/serial_python.hpp b/host/lib/types/serial_python.hpp
index 441bcc4d7..eb52472a5 100644
--- a/host/lib/types/serial_python.hpp
+++ b/host/lib/types/serial_python.hpp
@@ -1,5 +1,6 @@
//
// Copyright 2017-2018 Ettus Research, a National Instruments Company
+// Copyright 2019 Ettus Research, a National Instruments Brand
//
// SPDX-License-Identifier: GPL-3.0-or-later
//
@@ -9,23 +10,24 @@
#include <uhd/types/serial.hpp>
-void export_spi_config()
+void export_spi_config(py::module& m)
{
using spi_config_t = uhd::spi_config_t;
using spi_edge_t = spi_config_t::edge_t;
- bp::enum_<spi_edge_t>("spi_edge")
+ py::enum_<spi_edge_t>(m, "spi_edge")
.value("EDGE_RISE" , spi_edge_t::EDGE_RISE)
.value("EDGE_FALL", spi_edge_t::EDGE_FALL)
;
- bp::class_<spi_config_t>("spi_config", bp::init<spi_edge_t>())
+ py::class_<spi_config_t>(m, "spi_config")
+ .def(py::init<spi_edge_t>())
// Properties
- .add_property("mosi_edge" , &spi_config_t::mosi_edge )
- .add_property("miso_edge" , &spi_config_t::miso_edge )
- .add_property("use_custom_divider", &spi_config_t::use_custom_divider)
- .add_property("divider" , &spi_config_t::divider )
+ .def_readwrite("mosi_edge" , &spi_config_t::mosi_edge )
+ .def_readwrite("miso_edge" , &spi_config_t::miso_edge )
+ .def_readwrite("use_custom_divider", &spi_config_t::use_custom_divider)
+ .def_readwrite("divider" , &spi_config_t::divider )
;
}
diff --git a/host/lib/types/time_spec_python.hpp b/host/lib/types/time_spec_python.hpp
index 219dd076b..12489fd44 100644
--- a/host/lib/types/time_spec_python.hpp
+++ b/host/lib/types/time_spec_python.hpp
@@ -1,5 +1,6 @@
//
// Copyright 2017-2018 Ettus Research, a National Instruments Company
+// Copyright 2019 Ettus Research, a National Instruments Brand
//
// SPDX-License-Identifier: GPL-3.0-or-later
//
@@ -8,30 +9,31 @@
#define INCLUDED_UHD_TIME_SPEC_PYTHON_HPP
#include <uhd/types/time_spec.hpp>
+#include <pybind11/operators.h>
-void export_time_spec()
+void export_time_spec(py::module& m)
{
using time_spec_t = uhd::time_spec_t;
- bp::class_<time_spec_t>("time_spec", bp::init<double>())
+ py::class_<time_spec_t>(m, "time_spec")
//Additional constructors
- .def(bp::init<int64_t, double>())
- .def(bp::init<int64_t, long, double>())
+ .def(py::init<double>())
+ .def(py::init<int64_t, double>())
+ .def(py::init<int64_t, long, double>())
// Methods
- .def("from_ticks" , &time_spec_t::from_ticks )
- .staticmethod("from_ticks" )
+ .def_static("from_ticks" , &time_spec_t::from_ticks)
.def("get_tick_count" , &time_spec_t::get_tick_count )
.def("to_ticks" , &time_spec_t::to_ticks )
.def("get_real_secs" , &time_spec_t::get_real_secs )
.def("get_frac_secs" , &time_spec_t::get_frac_secs )
- .def(bp::self += time_spec_t())
- .def(bp::self += double())
- .def(bp::self + double())
- .def(bp::self + time_spec_t())
- .def(bp::self -= time_spec_t())
+ .def(py::self += time_spec_t())
+ .def(py::self += double())
+ .def(py::self + double())
+ .def(py::self + time_spec_t())
+ .def(py::self -= time_spec_t())
;
}
diff --git a/host/lib/types/tune_python.hpp b/host/lib/types/tune_python.hpp
index 587c8cbea..6c3607908 100644
--- a/host/lib/types/tune_python.hpp
+++ b/host/lib/types/tune_python.hpp
@@ -1,5 +1,6 @@
//
// Copyright 2017-2018 Ettus Research, a National Instruments Company
+// Copyright 2019 Ettus Research, a National Instruments Brand
//
// SPDX-License-Identifier: GPL-3.0-or-later
//
@@ -10,20 +11,20 @@
#include <uhd/types/tune_result.hpp>
#include <uhd/types/tune_request.hpp>
-void export_tune()
+void export_tune(py::module& m)
{
using tune_request_t = uhd::tune_request_t;
using tune_result_t = uhd::tune_result_t;
using policy_t = tune_request_t::policy_t;
- bp::enum_<policy_t>("tune_request_policy")
+ py::enum_<policy_t>(m, "tune_request_policy")
.value("none", tune_request_t::POLICY_NONE )
.value("auto", tune_request_t::POLICY_AUTO )
.value("manual", tune_request_t::POLICY_MANUAL)
;
- bp::class_<tune_request_t>("tune_request", bp::init<double>())
- .def(bp::init<double, double>())
+ py::class_<tune_request_t>(m, "tune_request")
+ .def(py::init<double, double>())
.def_readwrite("target_freq" , &tune_request_t::target_freq )
.def_readwrite("rf_freq_policy" , &tune_request_t::rf_freq_policy )
.def_readwrite("dsp_freq_policy", &tune_request_t::dsp_freq_policy)
@@ -32,7 +33,8 @@ void export_tune()
.def_readwrite("args" , &tune_request_t::args )
;
- bp::class_<tune_result_t>("tune_result", bp::init<>())
+ py::class_<tune_result_t>(m, "tune_result")
+ .def(py::init<>())
.def_readwrite("clipped_rf_freq", &tune_result_t::clipped_rf_freq)
.def_readwrite("target_rf_freq" , &tune_result_t::target_rf_freq )
.def_readwrite("actual_rf_freq" , &tune_result_t::actual_rf_freq )
diff --git a/host/lib/types/types_python.hpp b/host/lib/types/types_python.hpp
index 434ae9171..b7003d7b0 100644
--- a/host/lib/types/types_python.hpp
+++ b/host/lib/types/types_python.hpp
@@ -1,5 +1,6 @@
//
// Copyright 2017-2018 Ettus Research, a National Instruments Company
+// Copyright 2019 Ettus Research, a National Instruments Brand
//
// SPDX-License-Identifier: GPL-3.0-or-later
//
@@ -7,59 +8,49 @@
#ifndef INCLUDED_UHD_TYPES_PYTHON_HPP
#define INCLUDED_UHD_TYPES_PYTHON_HPP
+#include <pybind11/stl.h>
#include <uhd/types/device_addr.hpp>
#include <uhd/types/stream_cmd.hpp>
-#include <boost/python.hpp>
#include <string>
#include <map>
-//! Make a device_addr_t from a Python dict of strings
-static uhd::device_addr_t make_device_addr(bp::dict& info) {
- // Manually extract each key and each value, copy them to a map of strings, and return that.
- std::map<std::string,std::string> info_map;
- auto keys = info.keys();
- for (int ii = 0; ii < bp::len(keys); ++ii) {
- std::string key = bp::extract<std::string>(keys[ii]);
- info_map[key] = bp::extract<std::string>(info[key]);
- }
- return uhd::device_addr_t(info_map);
-}
-
-void export_types()
+void export_types(py::module& m)
{
using stream_cmd_t = uhd::stream_cmd_t;
using stream_mode_t = stream_cmd_t::stream_mode_t;
using str_map = std::map<std::string, std::string>;
- bp::enum_<stream_mode_t>("stream_mode")
+ py::enum_<stream_mode_t>(m, "stream_mode")
.value("start_cont", stream_cmd_t::STREAM_MODE_START_CONTINUOUS )
.value("stop_cont" , stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS )
.value("num_done" , stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE)
.value("num_more" , stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_MORE)
;
- bp::class_<stream_cmd_t>("stream_cmd", bp::init<stream_cmd_t::stream_mode_t>())
-
+ py::class_<stream_cmd_t>(m, "stream_cmd")
+ .def(py::init<stream_cmd_t::stream_mode_t>())
// Properties
.def_readwrite("num_samps" , &stream_cmd_t::num_samps )
.def_readwrite("time_spec" , &stream_cmd_t::time_spec )
.def_readwrite("stream_now", &stream_cmd_t::stream_now)
;
- bp::class_<uhd::device_addr_t>("device_addr", bp::init<bp::optional<std::string> >())
+ py::class_<uhd::device_addr_t>(m, "device_addr")
// Constructors
- /* TODO: This calls the correct C++ constructor, but Python
- dictionaries != str_maps, so we get a signature error */
- .def(bp::init<str_map>())
+ .def(py::init<>())
+ .def(py::init<std::string>())
+ .def(py::init<str_map>())
// Methods
.def("__str__", &uhd::device_addr_t::to_pp_string)
.def("to_string", &uhd::device_addr_t::to_string)
.def("to_pp_string", &uhd::device_addr_t::to_pp_string)
;
+ // This will allow functions in Python that take a device_addr to also take
+ // a string:
+ py::implicitly_convertible<std::string, uhd::device_addr_t>();
- bp::def("make_device_addr", make_device_addr);
}
#endif /* INCLUDED_UHD_TYPES_PYTHON_HPP */
diff --git a/host/lib/usrp/dboard_iface_python.hpp b/host/lib/usrp/dboard_iface_python.hpp
index f43490e7d..96fcc1702 100644
--- a/host/lib/usrp/dboard_iface_python.hpp
+++ b/host/lib/usrp/dboard_iface_python.hpp
@@ -1,5 +1,6 @@
//
// Copyright 2017-2018 Ettus Research, a National Instruments Company
+// Copyright 2019 Ettus Research, a National Instruments Brand
//
// SPDX-License-Identifier: GPL-3.0-or-later
//
@@ -11,7 +12,7 @@
#include <uhd/usrp/gpio_defs.hpp>
#include "../include/uhdlib/usrp/gpio_defs.hpp"
-void export_dboard_iface()
+void export_dboard_iface(py::module& m)
{
using dboard_iface = uhd::usrp::dboard_iface;
using special_props_t = uhd::usrp::dboard_iface_special_props_t;
@@ -23,48 +24,43 @@ void export_dboard_iface()
using gpio_atr_reg_t = uhd::usrp::gpio_atr::gpio_atr_reg_t;
using gpio_atr_mode_t = uhd::usrp::gpio_atr::gpio_atr_mode_t;
- bp::enum_<gpio_atr_reg_t>("gpio_atr_reg")
+ py::enum_<gpio_atr_reg_t>(m, "gpio_atr_reg")
.value("ATR_REG_IDLE" , gpio_atr_reg_t::ATR_REG_IDLE )
.value("ATR_REG_TX_ONLY" , gpio_atr_reg_t::ATR_REG_TX_ONLY )
.value("ATR_REG_RX_ONLY" , gpio_atr_reg_t::ATR_REG_RX_ONLY )
.value("ATR_REG_FULL_DUPLEX", gpio_atr_reg_t::ATR_REG_FULL_DUPLEX)
;
- bp::enum_<gpio_atr_mode_t>("gpio_atr_mode")
+ py::enum_<gpio_atr_mode_t>(m, "gpio_atr_mode")
.value("MODE_ATR" , gpio_atr_mode_t::MODE_ATR )
.value("MODE_GPIO", gpio_atr_mode_t::MODE_GPIO)
;
- bp::enum_<unit_t>("unit")
+ py::enum_<unit_t>(m, "unit")
.value("UNIT_RX" , unit_t::UNIT_RX )
.value("UNIT_TX" , unit_t::UNIT_TX )
.value("UNIT_BOTH", unit_t::UNIT_BOTH)
;
- bp::enum_<aux_dac_t>("aux_dac")
+ py::enum_<aux_dac_t>(m, "aux_dac")
.value("AUX_DAC_A", aux_dac_t::AUX_DAC_A)
.value("AUX_DAC_B", aux_dac_t::AUX_DAC_B)
.value("AUX_DAC_C", aux_dac_t::AUX_DAC_C)
.value("AUX_DAC_D", aux_dac_t::AUX_DAC_D)
;
- bp::enum_<aux_adc_t>("aux_adc")
+ py::enum_<aux_adc_t>(m, "aux_adc")
.value("AUX_ADC_A", aux_adc_t::AUX_ADC_A)
.value("AUX_ADC_B", aux_adc_t::AUX_ADC_B)
;
- bp::class_<special_props_t>("special_props")
-
+ py::class_<special_props_t>(m, "special_props")
// Properties
- .add_property("soft_clock_divider", &special_props_t::soft_clock_divider)
- .add_property("mangle_i2c_addrs" , &special_props_t::mangle_i2c_addrs )
+ .def_readwrite("soft_clock_divider", &special_props_t::soft_clock_divider)
+ .def_readwrite("mangle_i2c_addrs" , &special_props_t::mangle_i2c_addrs )
;
- bp::class_<
- dboard_iface,
- boost::shared_ptr<dboard_iface>,
- uhd::noncopyable>("dboard_iface", bp::no_init)
-
+ py::class_<dboard_iface, dboard_iface::sptr>(m, "dboard_iface")
// Methods
.def("get_special_props", &dboard_iface::get_special_props)
.def("write_aux_dac" , &dboard_iface::write_aux_dac )
diff --git a/host/lib/usrp/fe_connection_python.hpp b/host/lib/usrp/fe_connection_python.hpp
index 29bba1746..d1304909e 100644
--- a/host/lib/usrp/fe_connection_python.hpp
+++ b/host/lib/usrp/fe_connection_python.hpp
@@ -1,5 +1,6 @@
//
// Copyright 2017-2018 Ettus Research, a National Instruments Company
+// Copyright 2019 Ettus Research, a National Instruments Brand
//
// SPDX-License-Identifier: GPL-3.0-or-later
//
@@ -9,22 +10,22 @@
#include <uhd/usrp/fe_connection.hpp>
-void export_fe_connection()
+void export_fe_connection(py::module& m)
{
using fe_connection_t = uhd::usrp::fe_connection_t;
using sampling_t = fe_connection_t::sampling_t;
- bp::enum_<sampling_t>("sampling")
+ py::enum_<sampling_t>(m, "sampling")
.value("QUADRATURE", sampling_t::QUADRATURE)
.value("HETERODYNE", sampling_t::HETERODYNE)
.value("REAL" , sampling_t::REAL )
;
- bp::class_<fe_connection_t>
- ("fe_connection", bp::init<sampling_t, bool, bool, bool, double>())
+ py::class_<fe_connection_t>(m, "fe_connection")
// Constructors
- .def(bp::init<const std::string&, double>())
+ .def(py::init<sampling_t, bool, bool, bool, double>())
+ .def(py::init<const std::string&, double>())
// Methods
.def("get_sampling_mode", &fe_connection_t::get_sampling_mode)
diff --git a/host/lib/usrp/multi_usrp_python.hpp b/host/lib/usrp/multi_usrp_python.hpp
index 6dc14f083..9bec4bb4f 100644
--- a/host/lib/usrp/multi_usrp_python.hpp
+++ b/host/lib/usrp/multi_usrp_python.hpp
@@ -1,5 +1,6 @@
//
// Copyright 2017-2018 Ettus Research, a National Instruments Company
+// Copyright 2019 Ettus Research, a National Instruments Brand
//
// SPDX-License-Identifier: GPL-3.0-or-later
//
@@ -10,495 +11,167 @@
#include <uhd/types/device_addr.hpp>
#include <uhd/usrp/multi_usrp.hpp>
-//
-// Boost.Python needs overloaded API calls to be defined
-//
-static void set_rx_gain_0(
- uhd::usrp::multi_usrp *multi_usrp, double gain, const std::string &name, size_t chan = 0)
-{
- multi_usrp->set_rx_gain(gain, name, chan);
-}
-
-static void set_rx_gain_1(
- uhd::usrp::multi_usrp *multi_usrp, double gain, size_t chan = 0)
-{
- multi_usrp->set_rx_gain(gain, chan);
-}
-
-BOOST_PYTHON_FUNCTION_OVERLOADS(overload_set_rx_gain_0, set_rx_gain_0, 3, 4);
-BOOST_PYTHON_FUNCTION_OVERLOADS(overload_set_rx_gain_1, set_rx_gain_1, 2, 3);
-
-static void set_tx_gain_0(
- uhd::usrp::multi_usrp *multi_usrp, double gain, const std::string &name, size_t chan = 0)
-{
- multi_usrp->set_tx_gain(gain, name, chan);
-}
-
-static void set_tx_gain_1(
- uhd::usrp::multi_usrp *multi_usrp, double gain, size_t chan = 0)
-{
- multi_usrp->set_tx_gain(gain, chan);
-}
-
-BOOST_PYTHON_FUNCTION_OVERLOADS(overload_set_tx_gain_0, set_tx_gain_0, 3, 4);
-BOOST_PYTHON_FUNCTION_OVERLOADS(overload_set_tx_gain_1, set_tx_gain_1, 2, 3);
-
-static double get_rx_gain_0(
- uhd::usrp::multi_usrp *multi_usrp, const std::string &name, size_t chan = 0)
-{
- return multi_usrp->get_rx_gain(name, chan);
-}
-
-static double get_rx_gain_1(
- uhd::usrp::multi_usrp *multi_usrp, size_t chan = 0)
-{
- return multi_usrp->get_rx_gain(chan);
-}
-
-BOOST_PYTHON_FUNCTION_OVERLOADS(overload_get_rx_gain_0, get_rx_gain_0, 2, 3);
-BOOST_PYTHON_FUNCTION_OVERLOADS(overload_get_rx_gain_1, get_rx_gain_1, 1, 2);
-
-static double get_tx_gain_0(
- uhd::usrp::multi_usrp *multi_usrp, const std::string &name, size_t chan = 0)
-{
- return multi_usrp->get_tx_gain(name, chan);
-}
-
-static double get_tx_gain_1(
- uhd::usrp::multi_usrp *multi_usrp, size_t chan = 0)
-{
- return multi_usrp->get_tx_gain(chan);
-}
-
-BOOST_PYTHON_FUNCTION_OVERLOADS(overload_get_tx_gain_0, get_tx_gain_0, 2, 3);
-BOOST_PYTHON_FUNCTION_OVERLOADS(overload_get_tx_gain_1, get_tx_gain_1, 1, 2);
-
-static uhd::gain_range_t get_rx_gain_range_0(
- uhd::usrp::multi_usrp *multi_usrp, const std::string &name, size_t chan = 0)
-{
- return multi_usrp->get_rx_gain_range(name, chan);
-}
-
-static uhd::gain_range_t get_rx_gain_range_1(
- uhd::usrp::multi_usrp *multi_usrp, size_t chan = 0)
-{
- return multi_usrp->get_rx_gain_range(chan);
-}
-
-BOOST_PYTHON_FUNCTION_OVERLOADS(overload_get_rx_gain_range_0, get_rx_gain_range_0, 2, 3);
-BOOST_PYTHON_FUNCTION_OVERLOADS(overload_get_rx_gain_range_1, get_rx_gain_range_1, 1, 2);
-
-static uhd::gain_range_t get_tx_gain_range_0(
- uhd::usrp::multi_usrp *multi_usrp, const std::string &name, size_t chan = 0)
-{
- return multi_usrp->get_tx_gain_range(name, chan);
-}
-
-static uhd::gain_range_t get_tx_gain_range_1(
- uhd::usrp::multi_usrp *multi_usrp, size_t chan = 0)
-{
- return multi_usrp->get_tx_gain_range(chan);
-}
-
-BOOST_PYTHON_FUNCTION_OVERLOADS(overload_get_tx_gain_range_0, get_tx_gain_range_0, 2, 3);
-BOOST_PYTHON_FUNCTION_OVERLOADS(overload_get_tx_gain_range_1, get_tx_gain_range_1, 1, 2);
-
-static void set_rx_dc_offset_0(
- uhd::usrp::multi_usrp *multi_usrp, const bool enb, size_t chan = 0)
-{
- multi_usrp->set_rx_dc_offset(enb, chan);
-}
-
-static void set_rx_dc_offset_1(
- uhd::usrp::multi_usrp *multi_usrp, const std::complex<double> &offset, size_t chan = 0)
-{
- multi_usrp->set_rx_dc_offset(offset, chan);
-}
-
-BOOST_PYTHON_FUNCTION_OVERLOADS(overload_set_rx_dc_offset_0, set_rx_dc_offset_0, 2, 3);
-BOOST_PYTHON_FUNCTION_OVERLOADS(overload_set_rx_dc_offset_1, set_rx_dc_offset_1, 2, 3);
-
-static void set_tx_dc_offset_0(
- uhd::usrp::multi_usrp *multi_usrp, const bool enb, size_t chan = 0)
-{
- multi_usrp->set_tx_dc_offset(enb, chan);
-}
-
-static void set_tx_dc_offset_1(
- uhd::usrp::multi_usrp *multi_usrp, const std::complex<double> &offset, size_t chan = 0)
-{
- multi_usrp->set_tx_dc_offset(offset, chan);
-}
-
-BOOST_PYTHON_FUNCTION_OVERLOADS(overload_set_tx_dc_offset_0, set_tx_dc_offset_0, 2, 3);
-BOOST_PYTHON_FUNCTION_OVERLOADS(overload_set_tx_dc_offset_1, set_tx_dc_offset_1, 2, 3);
-
-static void set_rx_iq_balance_0(
- uhd::usrp::multi_usrp *multi_usrp, const bool enb, size_t chan = 0)
-{
- multi_usrp->set_rx_iq_balance(enb, chan);
-}
-
-static void set_rx_iq_balance_1(
- uhd::usrp::multi_usrp *multi_usrp, const std::complex<double> &offset, size_t chan = 0)
-{
- multi_usrp->set_rx_iq_balance(offset, chan);
-}
-
-BOOST_PYTHON_FUNCTION_OVERLOADS(overload_set_rx_iq_balance_0, set_rx_iq_balance_0, 2, 3);
-BOOST_PYTHON_FUNCTION_OVERLOADS(overload_set_rx_iq_balance_1, set_rx_iq_balance_1, 2, 3);
-
-static void set_gpio_attr_0(uhd::usrp::multi_usrp *multi_usrp,
- const std::string &bank,
- const std::string &attr,
- const uint32_t value,
- const uint32_t mask = 0xffffffff,
- const size_t mboard = 0)
-{
- multi_usrp->set_gpio_attr(bank, attr, value, mask, mboard);
-}
-
-static void set_gpio_attr_1(uhd::usrp::multi_usrp *multi_usrp,
- const std::string &bank,
- const std::string &attr,
- const std::string &value,
- const uint32_t mask = 0xffffffff,
- const size_t mboard = 0)
-{
- multi_usrp->set_gpio_attr(bank, attr, value, mask, mboard);
-}
-
-BOOST_PYTHON_FUNCTION_OVERLOADS(overload_set_gpio_attr_0, set_gpio_attr_0, 4, 6);
-BOOST_PYTHON_FUNCTION_OVERLOADS(overload_set_gpio_attr_1, set_gpio_attr_1, 4, 6);
-
-static void set_sync_source_0(uhd::usrp::multi_usrp *multi_usrp,
- const std::string &clock_source,
- const std::string &time_source)
-{
- multi_usrp->set_sync_source(clock_source, time_source);
-}
-static void set_sync_source_1(uhd::usrp::multi_usrp *multi_usrp,
- const std::string &clock_source,
- const std::string &time_source,
- const size_t mboard)
-{
- multi_usrp->set_sync_source(clock_source, time_source, mboard);
-}
-static void set_sync_source_2(uhd::usrp::multi_usrp *multi_usrp,
- const uhd::device_addr_t& sync_source)
-{
- multi_usrp->set_sync_source(sync_source);
-}
-static void set_sync_source_3(uhd::usrp::multi_usrp *multi_usrp,
- const uhd::device_addr_t& sync_source,
- const size_t mboard)
-{
- multi_usrp->set_sync_source(sync_source, mboard);
-}
-
-//
-// Boost.Python needs to know about default argument overloads
-//
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_freq, get_rx_freq, 0, 1);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_rate, get_rx_rate, 0, 1);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_rx_freq, set_rx_freq, 1, 2);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_rx_rate, set_rx_rate, 1, 2);
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_freq, get_tx_freq, 0, 1);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_rate, get_tx_rate, 0, 1);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_tx_freq, set_tx_freq, 1, 2);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_tx_rate, set_tx_rate, 1, 2);
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_usrp_rx_info, get_usrp_rx_info, 0, 1);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_usrp_tx_info, get_usrp_tx_info, 0, 1);
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_master_clock_rate, set_master_clock_rate, 1, 2);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_master_clock_rate, get_master_clock_rate, 0, 1);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_master_clock_rate_range, get_master_clock_rate_range, 0, 1);
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_mboard_name, get_mboard_name, 0, 1);
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_time_now, get_time_now, 0, 1);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_time_last_pps, get_time_last_pps, 0, 1);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_time_now, set_time_now, 1, 2);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_time_next_pps, set_time_next_pps, 1, 2);
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_command_time, set_command_time, 1, 2);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_clear_command_time, clear_command_time, 0, 1);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_issue_stream_cmd, issue_stream_cmd, 1, 2);
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_clock_config, set_clock_config, 1, 2);
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_time_source, set_time_source, 1, 2);
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_clock_source, set_clock_source, 1, 2);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_clock_source_out, set_clock_source_out, 1, 2);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_time_source_out, set_time_source_out, 1, 2);
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_mboard_sensor, get_mboard_sensor, 1, 2);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_mboard_sensor_names, get_mboard_sensor_names, 0, 1);
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_user_register, set_user_register, 2, 3);
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_rx_subdev_spec, set_rx_subdev_spec, 1, 2);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_subdev_spec, get_rx_subdev_spec, 0, 1);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_subdev_name, get_rx_subdev_name, 0, 1);
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_rates, get_rx_rates, 0, 1);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_freq_range, get_rx_freq_range, 0, 1);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_fe_rx_freq_range, get_fe_rx_freq_range, 0, 1);
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_lo_names, get_rx_lo_names, 0, 1);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_lo_source, get_rx_lo_source, 0, 2);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_rx_lo_source, set_rx_lo_source, 1, 3);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_lo_sources, get_rx_lo_sources, 0, 2);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_rx_lo_export_enabled, set_rx_lo_export_enabled, 1, 3);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_lo_export_enabled, get_rx_lo_export_enabled, 0, 2);
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_rx_lo_freq, set_rx_lo_freq, 2, 3);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_lo_freq, get_rx_lo_freq, 1, 2);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_lo_freq_range, get_rx_lo_freq_range, 1, 2);
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_normalized_rx_gain, set_normalized_rx_gain, 1, 2);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_normalized_rx_gain, get_normalized_rx_gain, 0, 1);
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_rx_agc, set_rx_agc, 1, 2);
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_gain_names, get_rx_gain_names, 0, 1);
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_rx_antenna, set_rx_antenna, 1, 2);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_antenna, get_rx_antenna, 0, 1);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_antennas, get_rx_antennas, 0, 1);
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_rx_bandwidth, set_rx_bandwidth, 1, 2);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_bandwidth, get_rx_bandwidth, 0, 1);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_bandwidth_range, get_rx_bandwidth_range, 0, 1);
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_dboard_iface, get_rx_dboard_iface, 0, 1);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_sensor, get_rx_sensor, 1, 2);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_sensor_names, get_rx_sensor_names, 0, 1);
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_gain_profile, get_rx_gain_profile, 0, 1);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_rx_gain_profile, set_rx_gain_profile, 1, 2);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_rx_gain_profile_names, get_rx_gain_profile_names, 0, 1);
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_tx_subdev_spec, set_tx_subdev_spec, 1, 2);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_subdev_spec, get_tx_subdev_spec, 0, 1);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_subdev_name, get_tx_subdev_name, 0, 1);
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_rates, get_tx_rates, 0, 1);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_freq_range, get_tx_freq_range, 0, 1);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_fe_tx_freq_range, get_fe_tx_freq_range, 0, 1);
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_lo_names, get_tx_lo_names, 0, 1);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_lo_source, get_tx_lo_source, 0, 2);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_tx_lo_source, set_tx_lo_source, 1, 3);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_lo_sources, get_tx_lo_sources, 0, 2);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_tx_lo_export_enabled, set_tx_lo_export_enabled, 1, 3);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_lo_export_enabled, get_tx_lo_export_enabled, 0, 2);
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_tx_lo_freq, set_tx_lo_freq, 2, 3);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_lo_freq, get_tx_lo_freq, 1, 2);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_lo_freq_range, get_tx_lo_freq_range, 1, 2);
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_normalized_tx_gain, set_normalized_tx_gain, 1, 2);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_normalized_tx_gain, get_normalized_tx_gain, 0, 1);
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_gain_names, get_tx_gain_names, 0, 1);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_tx_antenna, set_tx_antenna, 1, 2);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_antenna, get_tx_antenna, 0, 1);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_antennas, get_tx_antennas, 0, 1);
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_tx_bandwidth, set_tx_bandwidth, 1, 2);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_bandwidth, get_tx_bandwidth, 0, 1);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_bandwidth_range, get_tx_bandwidth_range, 0, 1);
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_dboard_iface, get_tx_dboard_iface, 0, 1);
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_sensor, get_tx_sensor, 1, 2);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_sensor_names, get_tx_sensor_names, 0, 1);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_tx_iq_balance, set_tx_iq_balance, 1, 2);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_gain_profile, get_tx_gain_profile, 0, 1);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_set_tx_gain_profile, set_tx_gain_profile, 1, 2);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_tx_gain_profile_names, get_tx_gain_profile_names, 0, 1);
-
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_gpio_attr, get_gpio_attr, 2, 3);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_enumerate_registers, enumerate_registers, 0, 1);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_register_info, get_register_info, 1, 2);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_write_register, write_register, 3, 4);
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_read_register, read_register, 2, 3);
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(overload_get_filter_names, get_filter_names, 0, 1);
-
-void export_multi_usrp()
+void export_multi_usrp(py::module& m)
{
using multi_usrp = uhd::usrp::multi_usrp;
using register_info_t = multi_usrp::register_info_t;
- bp::class_<register_info_t>("register_info")
- .add_property("bitwidth", &register_info_t::bitwidth)
- .add_property("readable", &register_info_t::readable)
- .add_property("writable", &register_info_t::writable)
- ;
+ const auto ALL_MBOARDS = multi_usrp::ALL_MBOARDS;
+ const auto ALL_CHANS = multi_usrp::ALL_CHANS;
+ const auto ALL_LOS = multi_usrp::ALL_LOS;
- bp::class_<
- multi_usrp,
- boost::shared_ptr<multi_usrp>,
- uhd::noncopyable>("multi_usrp", bp::no_init)
+ py::class_<register_info_t>(m, "register_info")
+ .def_readwrite("bitwidth", &register_info_t::bitwidth)
+ .def_readwrite("readable", &register_info_t::readable)
+ .def_readwrite("writable", &register_info_t::writable)
+ ;
- .def("__init__", bp::make_constructor(&multi_usrp::make))
+ py::class_<multi_usrp, multi_usrp::sptr>(m, "multi_usrp")
- // Methods
- .def("make", &multi_usrp::make)
- .staticmethod("make")
+ // Factory
+ .def(py::init(&multi_usrp::make))
// General USRP methods
- .def("get_rx_freq" , &multi_usrp::get_rx_freq, overload_get_rx_freq())
+ .def("get_rx_freq" , &multi_usrp::get_rx_freq, py::arg("chan") = 0)
.def("get_rx_num_channels" , &multi_usrp::get_rx_num_channels)
- .def("get_rx_rate" , &multi_usrp::get_rx_rate, overload_get_rx_rate())
- .def("get_rx_stream" , &multi_usrp::get_rx_stream)
- .def("set_rx_freq" , &multi_usrp::set_rx_freq, overload_set_rx_freq())
- .def("set_rx_gain" , &set_rx_gain_0, overload_set_rx_gain_0())
- .def("set_rx_gain" , &set_rx_gain_1, overload_set_rx_gain_1())
- .def("set_rx_rate" , &multi_usrp::set_rx_rate, overload_set_rx_rate())
- .def("get_tx_freq" , &multi_usrp::get_tx_freq, overload_get_tx_freq())
+ .def("get_rx_rate" , &multi_usrp::get_rx_rate, py::arg("chan") = 0)
+ .def("get_rx_stream" , &multi_usrp::get_rx_stream)
+ .def("set_rx_freq" , &multi_usrp::set_rx_freq, py::arg("tune_request"), py::arg("chan") = 0)
+ .def("set_rx_gain" , (void (multi_usrp::*)(double, const std::string&, size_t)) &multi_usrp::set_rx_gain, py::arg("gain"), py::arg("name"), py::arg("chan") = 0)
+ .def("set_rx_gain" , (void (multi_usrp::*)(double, size_t)) &multi_usrp::set_rx_gain, py::arg("gain"), py::arg("chan") = 0)
+ .def("set_rx_rate" , &multi_usrp::set_rx_rate, py::arg("rate"), py::arg("chan") = ALL_CHANS)
+ .def("get_tx_freq" , &multi_usrp::get_tx_freq, py::arg("chan") = 0)
.def("get_tx_num_channels" , &multi_usrp::get_tx_num_channels)
- .def("get_tx_rate" , &multi_usrp::get_tx_rate, overload_get_tx_rate())
+ .def("get_tx_rate" , &multi_usrp::get_tx_rate, py::arg("chan") = 0)
.def("get_tx_stream" , &multi_usrp::get_tx_stream)
- .def("set_tx_freq" , &multi_usrp::set_tx_freq, overload_set_tx_freq())
- .def("set_tx_gain" , &set_tx_gain_0, overload_set_tx_gain_0())
- .def("set_tx_gain" , &set_tx_gain_1, overload_set_tx_gain_1())
- .def("set_tx_rate" , &multi_usrp::set_tx_rate, overload_set_tx_rate())
- .def("get_usrp_rx_info" , &multi_usrp::get_usrp_rx_info, overload_get_usrp_rx_info())
- .def("get_usrp_tx_info" , &multi_usrp::get_usrp_tx_info, overload_get_usrp_tx_info())
- .def("set_master_clock_rate" , &multi_usrp::set_master_clock_rate, overload_set_master_clock_rate())
- .def("get_master_clock_rate" , &multi_usrp::get_master_clock_rate, overload_get_master_clock_rate())
- .def("get_master_clock_rate_range", &multi_usrp::get_master_clock_rate_range, overload_get_master_clock_rate_range())
+ .def("set_tx_freq" , &multi_usrp::set_tx_freq, py::arg("tune_request"), py::arg("chan") = 0)
+ .def("set_tx_gain" , (void (multi_usrp::*)(double, const std::string&, size_t)) &multi_usrp::set_tx_gain, py::arg("gain"), py::arg("name"), py::arg("chan") = 0)
+ .def("set_tx_gain" , (void (multi_usrp::*)(double, size_t)) &multi_usrp::set_tx_gain, py::arg("gain"), py::arg("chan") = 0)
+ .def("set_tx_rate" , &multi_usrp::set_tx_rate, py::arg("rate"), py::arg("chan") = ALL_CHANS)
+ .def("get_usrp_rx_info" , &multi_usrp::get_usrp_rx_info, py::arg("chan") = 0)
+ .def("get_usrp_tx_info" , &multi_usrp::get_usrp_tx_info, py::arg("chan") = 0)
+ .def("set_master_clock_rate" , &multi_usrp::set_master_clock_rate, py::arg("rate"), py::arg("mboard") = ALL_MBOARDS)
+ .def("get_master_clock_rate" , &multi_usrp::get_master_clock_rate, py::arg("mboard") = 0)
+ .def("get_master_clock_rate_range", &multi_usrp::get_master_clock_rate_range, py::arg("mboard") = ALL_MBOARDS)
.def("get_pp_string" , &multi_usrp::get_pp_string)
- .def("get_mboard_name" , &multi_usrp::get_mboard_name, overload_get_mboard_name())
- .def("get_time_now" , &multi_usrp::get_time_now, overload_get_time_now())
- .def("get_time_last_pps" , &multi_usrp::get_time_last_pps, overload_get_time_last_pps())
- .def("set_time_now" , &multi_usrp::set_time_now, overload_set_time_now())
- .def("set_time_next_pps" , &multi_usrp::set_time_next_pps, overload_set_time_next_pps())
+ .def("get_mboard_name" , &multi_usrp::get_mboard_name, py::arg("mboard") = 0)
+ .def("get_time_now" , &multi_usrp::get_time_now, py::arg("mboard") = 0)
+ .def("get_time_last_pps" , &multi_usrp::get_time_last_pps, py::arg("mboard") = 0)
+ .def("set_time_now" , &multi_usrp::set_time_now, py::arg("time_spec"), py::arg("mboard") = ALL_MBOARDS)
+ .def("set_time_next_pps" , &multi_usrp::set_time_next_pps, py::arg("time_spec"), py::arg("mboard") = ALL_MBOARDS)
.def("set_time_unknown_pps" , &multi_usrp::set_time_unknown_pps)
.def("get_time_synchronized" , &multi_usrp::get_time_synchronized)
- .def("set_command_time" , &multi_usrp::set_command_time, overload_set_command_time())
- .def("clear_command_time" , &multi_usrp::clear_command_time, overload_clear_command_time())
- .def("issue_stream_cmd" , &multi_usrp::issue_stream_cmd, overload_issue_stream_cmd())
- .def("set_clock_config" , &multi_usrp::set_clock_config, overload_set_clock_config())
- .def("set_time_source" , &multi_usrp::set_time_source, overload_set_time_source())
+ .def("set_command_time" , &multi_usrp::set_command_time, py::arg("time_spec"), py::arg("mboard") = 0)
+ .def("clear_command_time" , &multi_usrp::clear_command_time, py::arg("mboard") = ALL_MBOARDS)
+ .def("issue_stream_cmd" , &multi_usrp::issue_stream_cmd, py::arg("rate"), py::arg("chan") = ALL_CHANS)
+ .def("set_time_source" , &multi_usrp::set_time_source, py::arg("source"), py::arg("mboard") = ALL_MBOARDS)
.def("get_time_source" , &multi_usrp::get_time_source)
.def("get_time_sources" , &multi_usrp::get_time_sources)
- .def("set_clock_source" , &multi_usrp::set_clock_source, overload_set_clock_source())
+ .def("set_clock_source" , &multi_usrp::set_clock_source, py::arg("source"), py::arg("mboard") = ALL_MBOARDS)
.def("get_clock_source" , &multi_usrp::get_clock_source)
.def("get_clock_sources" , &multi_usrp::get_clock_sources)
- .def("set_sync_source" , &set_sync_source_0)
- .def("set_sync_source" , &set_sync_source_1)
- .def("set_sync_source" , &set_sync_source_2)
- .def("set_sync_source" , &set_sync_source_3)
+ .def("set_sync_source" , (void (multi_usrp::*)(const std::string&, const std::string&, size_t)) &multi_usrp::set_sync_source, py::arg("clock_source"), py::arg("time_source"), py::arg("mboard") = ALL_MBOARDS)
+ .def("set_sync_source" , (void (multi_usrp::*)(const uhd::device_addr_t&, size_t)) &multi_usrp::set_sync_source, py::arg("sync_source"), py::arg("mboard") = ALL_MBOARDS)
.def("get_sync_source" , &multi_usrp::get_sync_source)
.def("get_sync_sources" , &multi_usrp::get_sync_sources)
- .def("set_clock_source_out" , &multi_usrp::set_clock_source_out, overload_set_clock_source_out())
- .def("set_time_source_out" , &multi_usrp::set_time_source_out, overload_set_time_source_out())
+ .def("set_clock_source_out" , &multi_usrp::set_clock_source_out, py::arg("enb"), py::arg("mboard") = ALL_MBOARDS)
+ .def("set_time_source_out" , &multi_usrp::set_time_source_out, py::arg("enb"), py::arg("mboard") = ALL_MBOARDS)
.def("get_num_mboards" , &multi_usrp::get_num_mboards)
- .def("get_mboard_sensor" , &multi_usrp::get_mboard_sensor, overload_get_mboard_sensor())
- .def("get_mboard_sensor_names" , &multi_usrp::get_mboard_sensor_names, overload_get_mboard_sensor_names())
- .def("set_user_register" , &multi_usrp::set_user_register, overload_set_user_register())
+ .def("get_mboard_sensor" , &multi_usrp::get_mboard_sensor, py::arg("name"), py::arg("mboard") = 0)
+ .def("get_mboard_sensor_names" , &multi_usrp::get_mboard_sensor_names, py::arg("mboard") = 0)
+ .def("set_user_register" , &multi_usrp::set_user_register, py::arg("addr"), py::arg("data"), py::arg("mboard") = ALL_MBOARDS)
// RX methods
- .def("set_rx_subdev_spec" , &multi_usrp::set_rx_subdev_spec, overload_set_rx_subdev_spec())
- .def("get_rx_subdev_spec" , &multi_usrp::get_rx_subdev_spec, overload_get_rx_subdev_spec())
- .def("get_rx_subdev_name" , &multi_usrp::get_rx_subdev_name, overload_get_rx_subdev_name())
- .def("get_rx_rates" , &multi_usrp::get_rx_rates, overload_get_rx_rates())
- .def("get_rx_freq_range" , &multi_usrp::get_rx_freq_range, overload_get_rx_freq_range())
- .def("get_fe_rx_freq_range" , &multi_usrp::get_fe_rx_freq_range, overload_get_fe_rx_freq_range())
- .def("get_rx_lo_names" , &multi_usrp::get_rx_lo_names, overload_get_rx_lo_names())
- .def("set_rx_lo_source" , &multi_usrp::set_rx_lo_source, overload_set_rx_lo_source())
- .def("get_rx_lo_source" , &multi_usrp::get_rx_lo_source, overload_get_rx_lo_source())
- .def("get_rx_lo_sources" , &multi_usrp::get_rx_lo_sources, overload_get_rx_lo_sources())
- .def("set_rx_lo_export_enabled", &multi_usrp::set_rx_lo_export_enabled, overload_set_rx_lo_export_enabled())
- .def("get_rx_lo_export_enabled", &multi_usrp::get_rx_lo_export_enabled, overload_get_rx_lo_export_enabled())
- .def("set_rx_lo_freq" , &multi_usrp::set_rx_lo_freq, overload_set_rx_lo_freq())
- .def("get_rx_lo_freq" , &multi_usrp::get_rx_lo_freq, overload_get_rx_lo_freq())
- .def("get_rx_lo_freq_range" , &multi_usrp::get_rx_lo_freq_range, overload_get_rx_lo_freq_range())
- .def("set_normalized_rx_gain" , &multi_usrp::set_normalized_rx_gain, overload_set_normalized_rx_gain())
- .def("get_normalized_rx_gain" , &multi_usrp::get_normalized_rx_gain, overload_get_normalized_rx_gain())
- .def("set_rx_agc" , &multi_usrp::set_rx_agc, overload_set_rx_agc())
- .def("get_rx_gain" , &get_rx_gain_0, overload_get_rx_gain_0())
- .def("get_rx_gain" , &get_rx_gain_1, overload_get_rx_gain_1())
- .def("get_rx_gain_range" , &get_rx_gain_range_0, overload_get_rx_gain_range_0())
- .def("get_rx_gain_range" , &get_rx_gain_range_1, overload_get_rx_gain_range_1())
- .def("get_rx_gain_names" , &multi_usrp::get_rx_gain_names, overload_get_rx_gain_names())
- .def("set_rx_antenna" , &multi_usrp::set_rx_antenna, overload_set_rx_antenna())
- .def("get_rx_antenna" , &multi_usrp::get_rx_antenna, overload_get_rx_antenna())
- .def("get_rx_antennas" , &multi_usrp::get_rx_antennas, overload_get_rx_antennas())
- .def("set_rx_bandwidth" , &multi_usrp::set_rx_bandwidth, overload_set_rx_bandwidth())
- .def("get_rx_bandwidth" , &multi_usrp::get_rx_bandwidth, overload_get_rx_bandwidth())
- .def("get_rx_bandwidth_range" , &multi_usrp::get_rx_bandwidth_range, overload_get_rx_bandwidth_range())
- .def("get_rx_dboard_iface" , &multi_usrp::get_rx_dboard_iface, overload_get_rx_dboard_iface())
- .def("get_rx_sensor" , &multi_usrp::get_rx_sensor, overload_get_rx_sensor())
- .def("get_rx_sensor_names" , &multi_usrp::get_rx_sensor_names, overload_get_rx_sensor_names())
- .def("set_rx_dc_offset" , &set_rx_dc_offset_0, overload_set_rx_dc_offset_0())
- .def("set_rx_dc_offset" , &set_rx_dc_offset_1, overload_set_rx_dc_offset_1())
- .def("set_rx_iq_balance" , &set_rx_iq_balance_0, overload_set_rx_iq_balance_0())
- .def("set_rx_iq_balance" , &set_rx_iq_balance_1, overload_set_rx_iq_balance_1())
- .def("get_rx_gain_profile" , &multi_usrp::get_rx_gain_profile, overload_get_rx_gain_profile())
- .def("set_rx_gain_profile" , &multi_usrp::set_rx_gain_profile, overload_set_rx_gain_profile())
- .def("get_rx_gain_profile_names", &multi_usrp::get_rx_gain_profile_names, overload_get_rx_gain_profile_names())
+ .def("set_rx_subdev_spec" , &multi_usrp::set_rx_subdev_spec, py::arg("spec"), py::arg("mboard") = ALL_MBOARDS)
+ .def("get_rx_subdev_spec" , &multi_usrp::get_rx_subdev_spec, py::arg("mboard") = 0)
+ .def("get_rx_subdev_name" , &multi_usrp::get_rx_subdev_name, py::arg("chan") = 0)
+ .def("get_rx_rates" , &multi_usrp::get_rx_rates, py::arg("chan") = 0)
+ .def("get_rx_freq_range" , &multi_usrp::get_rx_freq_range, py::arg("chan") = 0)
+ .def("get_fe_rx_freq_range" , &multi_usrp::get_fe_rx_freq_range, py::arg("chan") = 0)
+ .def("get_rx_lo_names" , &multi_usrp::get_rx_lo_names, py::arg("chan") = 0)
+ .def("set_rx_lo_source" , &multi_usrp::set_rx_lo_source, py::arg("src"), py::arg("name") = ALL_LOS, py::arg("chan") = 0)
+ .def("get_rx_lo_source" , &multi_usrp::get_rx_lo_source, py::arg("name") = ALL_LOS, py::arg("chan") = 0)
+ .def("get_rx_lo_sources" , &multi_usrp::get_rx_lo_sources, py::arg("name") = ALL_LOS, py::arg("chan") = 0)
+ .def("set_rx_lo_export_enabled", &multi_usrp::set_rx_lo_export_enabled, py::arg("enb"), py::arg("name") = ALL_LOS, py::arg("chan") = 0)
+ .def("get_rx_lo_export_enabled", &multi_usrp::get_rx_lo_export_enabled, py::arg("name") = ALL_LOS, py::arg("chan") = 0)
+ .def("set_rx_lo_freq" , &multi_usrp::set_rx_lo_freq, py::arg("freq"), py::arg("name"), py::arg("chan") = 0)
+ .def("get_rx_lo_freq" , &multi_usrp::get_rx_lo_freq, py::arg("name"), py::arg("chan") = 0)
+ .def("get_rx_lo_freq_range" , &multi_usrp::get_rx_lo_freq_range, py::arg("name"), py::arg("chan") = 0)
+ .def("set_normalized_rx_gain" , &multi_usrp::set_normalized_rx_gain, py::arg("gain"), py::arg("chan") = 0)
+ .def("get_normalized_rx_gain" , &multi_usrp::get_normalized_rx_gain, py::arg("chan") = 0)
+ .def("set_rx_agc" , &multi_usrp::set_rx_agc, py::arg("enable"), py::arg("chan") = 0)
+ .def("get_rx_gain" , (double (multi_usrp::*)(const std::string&, size_t)) &multi_usrp::get_rx_gain, py::arg("name"), py::arg("chan") = 0)
+ .def("get_rx_gain" , (double (multi_usrp::*)(size_t)) &multi_usrp::get_rx_gain, py::arg("chan") = 0)
+ .def("get_rx_gain_range" , (uhd::gain_range_t (multi_usrp::*)(const std::string&, size_t)) &multi_usrp::get_rx_gain_range, py::arg("name"), py::arg("chan") = 0)
+ .def("get_rx_gain_range" , (uhd::gain_range_t (multi_usrp::*)(size_t)) &multi_usrp::get_rx_gain_range, py::arg("chan") = 0)
+ .def("get_rx_gain_names" , &multi_usrp::get_rx_gain_names, py::arg("chan") = 0)
+ .def("set_rx_antenna" , &multi_usrp::set_rx_antenna, py::arg("ant"), py::arg("chan") = 0)
+ .def("get_rx_antenna" , &multi_usrp::get_rx_antenna, py::arg("chan") = 0)
+ .def("get_rx_antennas" , &multi_usrp::get_rx_antennas, py::arg("chan") = 0)
+ .def("set_rx_bandwidth" , &multi_usrp::set_rx_bandwidth, py::arg("bandwidth"), py::arg("chan") = 0)
+ .def("get_rx_bandwidth" , &multi_usrp::get_rx_bandwidth, py::arg("chan") = 0)
+ .def("get_rx_bandwidth_range" , &multi_usrp::get_rx_bandwidth_range, py::arg("chan") = 0)
+ .def("get_rx_dboard_iface" , &multi_usrp::get_rx_dboard_iface, py::arg("chan") = 0)
+ .def("get_rx_sensor" , &multi_usrp::get_rx_sensor, py::arg("name"), py::arg("chan") = 0)
+ .def("get_rx_sensor_names" , &multi_usrp::get_rx_sensor_names, py::arg("chan") = 0)
+ .def("set_rx_dc_offset" , (void (multi_usrp::*)(const std::complex<double>&, size_t)) &multi_usrp::set_rx_dc_offset, py::arg("offset"), py::arg("chan") = 0)
+ .def("set_rx_dc_offset" , (void (multi_usrp::*)(bool, size_t)) &multi_usrp::set_rx_dc_offset, py::arg("enb"), py::arg("chan") = 0)
+ .def("set_rx_iq_balance" , (void (multi_usrp::*)(const std::complex<double>&, size_t)) &multi_usrp::set_rx_iq_balance, py::arg("correction"), py::arg("chan") = 0)
+ .def("set_rx_iq_balance" , (void (multi_usrp::*)(bool, size_t)) &multi_usrp::set_rx_dc_offset, py::arg("enb"), py::arg("chan") = 0)
+ .def("get_rx_gain_profile" , &multi_usrp::get_rx_gain_profile, py::arg("chan") = 0)
+ .def("set_rx_gain_profile" , &multi_usrp::set_rx_gain_profile, py::arg("profile"), py::arg("chan") = 0)
+ .def("get_rx_gain_profile_names", &multi_usrp::get_rx_gain_profile_names, py::arg("chan") = 0)
// TX methods
- .def("set_tx_subdev_spec" , &multi_usrp::set_tx_subdev_spec, overload_set_tx_subdev_spec())
- .def("get_tx_subdev_spec" , &multi_usrp::get_tx_subdev_spec, overload_get_tx_subdev_spec())
- .def("get_tx_subdev_name" , &multi_usrp::get_tx_subdev_name, overload_get_tx_subdev_name())
- .def("get_tx_rates" , &multi_usrp::get_tx_rates, overload_get_rx_rates())
- .def("get_tx_freq_range" , &multi_usrp::get_tx_freq_range, overload_get_tx_freq_range())
- .def("get_fe_tx_freq_range" , &multi_usrp::get_fe_tx_freq_range, overload_get_fe_tx_freq_range())
- .def("get_tx_lo_names" , &multi_usrp::get_tx_lo_names, overload_get_tx_lo_names())
- .def("set_tx_lo_source" , &multi_usrp::set_tx_lo_source, overload_set_tx_lo_source())
- .def("get_tx_lo_source" , &multi_usrp::get_tx_lo_source, overload_get_tx_lo_source())
- .def("get_tx_lo_sources" , &multi_usrp::get_tx_lo_sources, overload_get_tx_lo_sources())
- .def("set_tx_lo_export_enabled", &multi_usrp::set_tx_lo_export_enabled, overload_set_tx_lo_export_enabled())
- .def("get_tx_lo_export_enabled", &multi_usrp::get_tx_lo_export_enabled, overload_get_tx_lo_export_enabled())
- .def("set_tx_lo_freq" , &multi_usrp::set_tx_lo_freq, overload_set_tx_lo_freq())
- .def("get_tx_lo_freq" , &multi_usrp::get_tx_lo_freq, overload_get_tx_lo_freq())
- .def("get_tx_lo_freq_range" , &multi_usrp::get_tx_lo_freq_range, overload_get_tx_lo_freq_range())
- .def("set_normalized_tx_gain" , &multi_usrp::set_normalized_tx_gain, overload_set_normalized_tx_gain())
- .def("get_normalized_tx_gain" , &multi_usrp::get_normalized_tx_gain, overload_get_normalized_tx_gain())
- .def("get_tx_gain" , &get_tx_gain_0, overload_get_tx_gain_0())
- .def("get_tx_gain" , &get_tx_gain_1, overload_get_tx_gain_1())
- .def("get_tx_gain_range" , &get_tx_gain_range_0, overload_get_tx_gain_range_0())
- .def("get_tx_gain_range" , &get_tx_gain_range_1, overload_get_tx_gain_range_1())
- .def("get_tx_gain_names" , &multi_usrp::get_tx_gain_names, overload_get_tx_gain_names())
- .def("set_tx_antenna" , &multi_usrp::set_tx_antenna, overload_set_tx_antenna())
- .def("get_tx_antenna" , &multi_usrp::get_tx_antenna, overload_get_tx_antenna())
- .def("get_tx_antennas" , &multi_usrp::get_tx_antennas, overload_get_tx_antennas())
- .def("set_tx_bandwidth" , &multi_usrp::set_tx_bandwidth, overload_set_tx_bandwidth())
- .def("get_tx_bandwidth" , &multi_usrp::get_tx_bandwidth, overload_get_tx_bandwidth())
- .def("get_tx_bandwidth_range" , &multi_usrp::get_tx_bandwidth_range, overload_get_tx_bandwidth_range())
- .def("get_tx_dboard_iface" , &multi_usrp::get_tx_dboard_iface, overload_get_tx_dboard_iface())
- .def("get_tx_sensor" , &multi_usrp::get_tx_sensor, overload_get_tx_sensor())
- .def("get_tx_sensor_names" , &multi_usrp::get_tx_sensor_names, overload_get_tx_sensor_names())
- .def("set_tx_dc_offset" , &set_tx_dc_offset_0, overload_set_tx_dc_offset_0())
- .def("set_tx_dc_offset" , &set_tx_dc_offset_1, overload_set_tx_dc_offset_1())
- .def("set_tx_iq_balance" , &multi_usrp::set_tx_iq_balance, overload_set_tx_iq_balance())
- .def("get_tx_gain_profile" , &multi_usrp::get_tx_gain_profile, overload_get_tx_gain_profile())
- .def("set_tx_gain_profile" , &multi_usrp::set_tx_gain_profile, overload_set_tx_gain_profile())
- .def("get_tx_gain_profile_names", &multi_usrp::get_tx_gain_profile_names, overload_get_tx_gain_profile_names())
+ .def("set_tx_subdev_spec" , &multi_usrp::set_tx_subdev_spec, py::arg("spec"), py::arg("mboard") = ALL_MBOARDS)
+ .def("get_tx_subdev_spec" , &multi_usrp::get_tx_subdev_spec, py::arg("mboard") = 0)
+ .def("get_tx_subdev_name" , &multi_usrp::get_tx_subdev_name, py::arg("chan") = 0)
+ .def("get_tx_rates" , &multi_usrp::get_tx_rates, py::arg("chan") = 0)
+ .def("get_tx_freq_range" , &multi_usrp::get_tx_freq_range, py::arg("chan") = 0)
+ .def("get_fe_tx_freq_range" , &multi_usrp::get_fe_tx_freq_range, py::arg("chan") = 0)
+ .def("get_tx_lo_names" , &multi_usrp::get_tx_lo_names, py::arg("chan") = 0)
+ .def("set_tx_lo_source" , &multi_usrp::set_tx_lo_source, py::arg("src"), py::arg("name") = ALL_LOS, py::arg("chan") = 0)
+ .def("get_tx_lo_source" , &multi_usrp::get_tx_lo_source, py::arg("name") = ALL_LOS, py::arg("chan") = 0)
+ .def("get_tx_lo_sources" , &multi_usrp::get_tx_lo_sources, py::arg("name") = ALL_LOS, py::arg("chan") = 0)
+ .def("set_tx_lo_export_enabled", &multi_usrp::set_tx_lo_export_enabled, py::arg("enb"), py::arg("name") = ALL_LOS, py::arg("chan") = 0)
+ .def("get_tx_lo_export_enabled", &multi_usrp::get_tx_lo_export_enabled, py::arg("name") = ALL_LOS, py::arg("chan") = 0)
+ .def("set_tx_lo_freq" , &multi_usrp::set_tx_lo_freq, py::arg("freq"), py::arg("name"), py::arg("chan") = 0)
+ .def("get_tx_lo_freq" , &multi_usrp::get_tx_lo_freq, py::arg("name"), py::arg("chan") = 0)
+ .def("get_tx_lo_freq_range" , &multi_usrp::get_tx_lo_freq_range, py::arg("name"), py::arg("chan") = 0)
+ .def("set_normalized_tx_gain" , &multi_usrp::set_normalized_tx_gain, py::arg("gain"), py::arg("chan") = 0)
+ .def("get_normalized_tx_gain" , &multi_usrp::get_normalized_tx_gain, py::arg("chan") = 0)
+ .def("get_tx_gain" , (double (multi_usrp::*)(const std::string&, size_t)) &multi_usrp::get_tx_gain, py::arg("name"), py::arg("chan") = 0)
+ .def("get_tx_gain" , (double (multi_usrp::*)(size_t)) &multi_usrp::get_tx_gain, py::arg("chan") = 0)
+ .def("get_tx_gain_range" , (uhd::gain_range_t (multi_usrp::*)(const std::string&, size_t)) &multi_usrp::get_tx_gain_range, py::arg("name"), py::arg("chan") = 0)
+ .def("get_tx_gain_range" , (uhd::gain_range_t (multi_usrp::*)(size_t)) &multi_usrp::get_tx_gain_range, py::arg("chan") = 0)
+ .def("get_tx_gain_names" , &multi_usrp::get_tx_gain_names, py::arg("chan") = 0)
+ .def("set_tx_antenna" , &multi_usrp::set_tx_antenna, py::arg("ant"), py::arg("chan") = 0)
+ .def("get_tx_antenna" , &multi_usrp::get_tx_antenna, py::arg("chan") = 0)
+ .def("get_tx_antennas" , &multi_usrp::get_tx_antennas, py::arg("chan") = 0)
+ .def("set_tx_bandwidth" , &multi_usrp::set_tx_bandwidth, py::arg("bandwidth"), py::arg("chan") = 0)
+ .def("get_tx_bandwidth" , &multi_usrp::get_tx_bandwidth, py::arg("chan") = 0)
+ .def("get_tx_bandwidth_range" , &multi_usrp::get_tx_bandwidth_range, py::arg("chan") = 0)
+ .def("get_tx_dboard_iface" , &multi_usrp::get_tx_dboard_iface, py::arg("chan") = 0)
+ .def("get_tx_sensor" , &multi_usrp::get_tx_sensor, py::arg("name"), py::arg("chan") = 0)
+ .def("get_tx_sensor_names" , &multi_usrp::get_tx_sensor_names, py::arg("chan") = 0)
+ .def("set_tx_dc_offset" , (void (multi_usrp::*)(const std::complex<double>&, size_t)) &multi_usrp::set_tx_dc_offset, py::arg("offset"), py::arg("chan") = 0)
+ .def("set_tx_iq_balance" , (void (multi_usrp::*)(const std::complex<double>&, size_t)) &multi_usrp::set_tx_iq_balance, py::arg("correction"), py::arg("chan") = 0)
+ .def("get_tx_gain_profile" , &multi_usrp::get_tx_gain_profile, py::arg("chan") = 0)
+ .def("set_tx_gain_profile" , &multi_usrp::set_tx_gain_profile, py::arg("profile"), py::arg("chan") = 0)
+ .def("get_tx_gain_profile_names", &multi_usrp::get_tx_gain_profile_names, py::arg("chan") = 0)
// GPIO methods
.def("get_gpio_banks" , &multi_usrp::get_gpio_banks)
- .def("set_gpio_attr" , &set_gpio_attr_0, overload_set_gpio_attr_0())
- .def("set_gpio_attr" , &set_gpio_attr_1, overload_set_gpio_attr_1())
- .def("get_gpio_attr" , &multi_usrp::get_gpio_attr, overload_get_gpio_attr())
- .def("enumerate_registers" , &multi_usrp::enumerate_registers, overload_enumerate_registers())
- .def("get_register_info" , &multi_usrp::get_register_info, overload_get_register_info())
- .def("write_register" , &multi_usrp::write_register, overload_write_register())
- .def("read_register" , &multi_usrp::read_register, overload_read_register())
+ .def("set_gpio_attr" , (void (multi_usrp::*)(const std::string&, const std::string&, const std::string&, const uint32_t, const size_t)) &multi_usrp::set_gpio_attr, py::arg("bank"), py::arg("attr"), py::arg("value"), py::arg("mask") = 0xffffffff, py::arg("mboard") = 0)
+ .def("set_gpio_attr" , (void (multi_usrp::*)(const std::string&, const std::string&, const uint32_t, const uint32_t, const size_t)) &multi_usrp::set_gpio_attr, py::arg("bank"), py::arg("attr"), py::arg("value"), py::arg("mask") = 0xffffffff, py::arg("mboard") = 0)
+ .def("get_gpio_attr" , &multi_usrp::get_gpio_attr, py::arg("bank"), py::arg("attr"), py::arg("mboard") = 0)
+ .def("enumerate_registers" , &multi_usrp::enumerate_registers, py::arg("mboard") = 0)
+ .def("get_register_info" , &multi_usrp::get_register_info, py::arg("path"), py::arg("mboard") = 0)
+ .def("write_register" , &multi_usrp::write_register, py::arg("path"), py::arg("field"), py::arg("value"), py::arg("mboard") = 0)
+ .def("read_register" , &multi_usrp::read_register, py::arg("path"), py::arg("field"), py::arg("mboard") = 0)
// Filter API methods
- .def("get_filter_names" , &multi_usrp::get_filter_names, overload_get_filter_names())
+ .def("get_filter_names" , &multi_usrp::get_filter_names, py::arg("search_mask") = "")
.def("get_filter" , &multi_usrp::get_filter)
.def("set_filter" , &multi_usrp::set_filter)
;
diff --git a/host/lib/usrp/subdev_spec_python.hpp b/host/lib/usrp/subdev_spec_python.hpp
index ed91099f9..61a517a6f 100644
--- a/host/lib/usrp/subdev_spec_python.hpp
+++ b/host/lib/usrp/subdev_spec_python.hpp
@@ -1,5 +1,6 @@
//
// Copyright 2017-2018 Ettus Research, a National Instruments Company
+// Copyright 2019 Ettus Research, a National Instruments Brand
//
// SPDX-License-Identifier: GPL-3.0-or-later
//
@@ -9,24 +10,20 @@
#include <uhd/usrp/subdev_spec.hpp>
-void export_subdev_spec()
+void export_subdev_spec(py::module& m)
{
using subdev_spec_pair_t = uhd::usrp::subdev_spec_pair_t;
using subdev_spec_t = uhd::usrp::subdev_spec_t;
- bp::class_<subdev_spec_pair_t>
- ("subdev_spec_pair", bp::init<const std::string&, const std::string &>())
-
+ py::class_<subdev_spec_pair_t> (m, "subdev_spec_pair")
+ .def(py::init<const std::string&, const std::string &>())
// Properties
- .add_property("db_name", &subdev_spec_pair_t::db_name)
- .add_property("sd_name", &subdev_spec_pair_t::sd_name)
+ .def_readwrite("db_name", &subdev_spec_pair_t::db_name)
+ .def_readwrite("sd_name", &subdev_spec_pair_t::sd_name)
;
- bp::class_<std::vector<subdev_spec_pair_t> >("subdev_spec_vector")
- .def(bp::vector_indexing_suite<std::vector<subdev_spec_pair_t> >());
-
- bp::class_<subdev_spec_t, bp::bases<std::vector<subdev_spec_pair_t> > >
- ("subdev_spec", bp::init<const std::string &>())
+ py::class_<subdev_spec_t>(m, "subdev_spec")
+ .def(py::init<const std::string &>())
// Methods
.def("__str__", &subdev_spec_t::to_pp_string)
diff --git a/host/lib/utils/gil_release_python.hpp b/host/lib/utils/gil_release_python.hpp
deleted file mode 100644
index 287ba240e..000000000
--- a/host/lib/utils/gil_release_python.hpp
+++ /dev/null
@@ -1,31 +0,0 @@
-//
-// Copyright 2018 Ettus Research, a National Instruments Company
-//
-// SPDX-License-Identifier: GPL-3.0-or-later
-//
-
-//! RAII-style GIL release method
-//
-// To release the GIL using this method, simply instantiate this class in the
-// scope that needs to release the GIL.
-//
-// Note that using this class assumes that threads have already been
-// initialized. See also https://docs.python.org/3.5/c-api/init.html for more
-// documentation on Python initialization and threads.
-class scoped_gil_release
-{
-public:
- inline scoped_gil_release()
- {
- _thread_state = PyEval_SaveThread();
- }
-
- inline ~scoped_gil_release()
- {
- PyEval_RestoreThread(_thread_state);
- _thread_state = nullptr;
- }
-
-private:
- PyThreadState* _thread_state;
-};
diff --git a/host/python/CMakeLists.txt b/host/python/CMakeLists.txt
index 07791de55..ec2c80fd4 100644
--- a/host/python/CMakeLists.txt
+++ b/host/python/CMakeLists.txt
@@ -16,6 +16,14 @@ PYTHON_CHECK_MODULE(
# Get include dirs
include_directories(${PYTHON_INCLUDE_DIRS})
+set(PYBIND11_INCLUDE_DIR
+ "${CMAKE_SOURCE_DIR}/lib/deps/pybind11/include"
+ CACHE
+ STRING
+ "Location of PyBind11 includes"
+)
+message(STATUS "${PYBIND11_INCLUDE_DIR}")
+include_directories(${PYBIND11_INCLUDE_DIR})
execute_process(
COMMAND "${PYTHON_EXECUTABLE}" -c
"from __future__ import print_function\ntry:\n import numpy\n import os\n inc_path = numpy.get_include()\n if os.path.exists(os.path.join(inc_path, 'numpy', 'arrayobject.h')):\n print(inc_path, end='')\nexcept:\n pass"
@@ -26,9 +34,10 @@ add_library(pyuhd SHARED pyuhd.cpp)
target_include_directories(pyuhd PUBLIC
${PYTHON_NUMPY_INCLUDE_DIR}
${CMAKE_SOURCE_DIR}/lib
+ ${PYBIND11_INCLUDE_DIR}
)
-target_link_libraries(pyuhd ${BOOST_PYTHON_LIBRARY} ${Boost_LIBRARIES} ${PYTHON_LIBRARY} uhd)
+target_link_libraries(pyuhd ${Boost_LIBRARIES} ${PYTHON_LIBRARY} uhd)
# Copy pyuhd library to the staging directory
if(WIN32)
set(PYUHD_LIBRARY_NAME libpyuhd.pyd)
diff --git a/host/python/pyuhd.cpp b/host/python/pyuhd.cpp
index e0f35d929..16badbe8c 100644
--- a/host/python/pyuhd.cpp
+++ b/host/python/pyuhd.cpp
@@ -1,29 +1,21 @@
//
// Copyright 2017-2018 Ettus Research, a National Instruments Company
+// Copyright 2019 Ettus Research, a National Instruments Brand
//
// SPDX-License-Identifier: GPL-3.0-or-later
//
-#include <boost/shared_ptr.hpp>
-#include <boost/python.hpp>
-#include <boost/python/stl_iterator.hpp>
-#include <boost/python/suite/indexing/vector_indexing_suite.hpp>
-
-/*
-This solution was adapted from an Issue posted to the Boost.Python Github.
-https://github.com/boostorg/python/pull/159/files
-*/
-#if (BOOST_VERSION >= 106400) && (BOOST_VERSION < 106600)
-#warning overriding broken boost python implementation of BOOST_PYTHON_MODULE_INIT
-# define BOOST_PYTHON_MODULE_INIT(name) \
- void BOOST_PP_CAT(init_module_,name)(); \
-extern "C" BOOST_SYMBOL_EXPORT _BOOST_PYTHON_MODULE_INIT(name)
-#endif
+#include <pybind11/pybind11.h>
#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
#include <numpy/arrayobject.h>
-namespace bp = boost::python;
+namespace py = pybind11;
+
+// Allow boost::shared_ptr<T> to be a holder class of an object (PyBind11
+// supports std::shared_ptr and std::unique_ptr out of the box)
+#include <boost/shared_ptr.hpp>
+PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr<T>);
#include "stream_python.hpp"
@@ -40,81 +32,6 @@ namespace bp = boost::python;
#include "usrp/subdev_spec_python.hpp"
#include "usrp/multi_usrp_python.hpp"
-// Converter for std::vector / std::list arguments from python iterables
-struct iterable_converter
-{
- template <typename Container>
- iterable_converter& from_python()
- {
- bp::converter::registry::push_back(
- &iterable_converter::convertible,
- &iterable_converter::construct<Container>,
- bp::type_id<Container>()
- );
- return *this;
- }
-
- static void* convertible(PyObject* object)
- {
- return PyObject_GetIter(object) ? object : NULL;
- }
-
- template <typename Container>
- static void construct(
- PyObject* object,
- bp::converter::rvalue_from_python_stage1_data* data)
- {
- // Object is a borrowed reference, so create a handle indicting it is
- // borrowed for proper reference counting.
- bp::handle<> handle(bp::borrowed(object));
-
- // Obtain a handle to the memory block that the converter has
- // allocated for the C++ type.
- typedef bp::converter::rvalue_from_python_storage<Container> storage_type;
-
- void* storage = reinterpret_cast<storage_type*>(data)->storage.bytes;
- typedef bp::stl_input_iterator<typename Container::value_type> iterator;
-
- // Allocate the C++ type into the converter's memory block, and assign
- // its handle to the converter's convertible variable. The C++
- // container is populated by passing the begin and end iterators of
- // the python object to the container's constructor.
- new (storage) Container(
- iterator(bp::object(handle)), // begin
- iterator() // end
- );
-
- data->convertible = storage;
- }
-};
-
-template<typename Dtype1, typename Dtype2>
-struct uhd_to_python_dict
-{
- static PyObject* convert(uhd::dict<Dtype1, Dtype2> const& input_dict)
- {
- bp::dict py_dict;
- for (const auto& key: input_dict.keys()){
- py_dict[key] = input_dict[key];
- }
- return bp::incref(py_dict.ptr());
- }
-
-};
-
-template<typename Container>
-struct iterable_to_python_list
-{
- static PyObject* convert(Container const& input)
- {
- bp::list py_list;
- for (const auto& element: input){
- py_list.append(element);
- }
- return bp::incref(py_list.ptr());
- }
-};
-
// We need this hack because import_array() returns NULL
// for newer Python versions.
// This function is also necessary because it ensures access to the C API
@@ -132,80 +49,32 @@ void init_numpy()
}
#endif
-BOOST_PYTHON_MODULE(libpyuhd)
+PYBIND11_MODULE(libpyuhd, m)
{
// Initialize the numpy C API
// (otherwise we will see segmentation faults)
init_numpy();
- bp::object package = bp::scope();
- package.attr("__path__") = "libpyuhd";
-
- // Declare converters
- iterable_converter()
- .from_python<std::vector<double> >()
- .from_python<std::vector<int> >()
- .from_python<std::vector<size_t> >()
- ;
-
- bp::to_python_converter<
- uhd::dict<std::string, std::string>,
- uhd_to_python_dict<std::string, std::string>, false >();
- bp::to_python_converter<
- std::vector<std::string>,
- iterable_to_python_list<std::vector<std::string> >, false >();
-
// Register types submodule
- {
- bp::object types_module(
- bp::handle<>(bp::borrowed(PyImport_AddModule("libpyuhd.types")))
- );
- bp::scope().attr("types") = types_module;
- bp::scope io_scope = types_module;
-
- bp::implicitly_convertible<std::string, uhd::device_addr_t>();
-
- export_types();
- export_time_spec();
- export_spi_config();
- export_metadata();
- export_sensors();
- export_tune();
+ auto types_module = m.def_submodule("types", "UHD Types");
- // Declare some more converters
- iterable_converter()
- .from_python<std::vector<uhd::device_addr_t>>()
- ;
-
- bp::to_python_converter<
- std::vector<uhd::device_addr_t>,
- iterable_to_python_list<std::vector<uhd::device_addr_t>>, false >();
- }
+ export_types(types_module);
+ export_time_spec(types_module);
+ export_spi_config(types_module);
+ export_metadata(types_module);
+ export_sensors(types_module);
+ export_tune(types_module);
// Register usrp submodule
- {
- bp::object usrp_module(
- bp::handle<>(bp::borrowed(PyImport_AddModule("libpyuhd.usrp")))
- );
- bp::scope().attr("usrp") = usrp_module;
- bp::scope io_scope = usrp_module;
-
- export_multi_usrp();
- export_subdev_spec();
- export_dboard_iface();
- export_fe_connection();
- export_stream();
- }
+ auto usrp_module = m.def_submodule("usrp", "USRP Objects");
+ export_multi_usrp(usrp_module);
+ export_subdev_spec(usrp_module);
+ export_dboard_iface(usrp_module);
+ export_fe_connection(usrp_module);
+ export_stream(usrp_module);
// Register filters submodule
- {
- bp::object filters_module(
- bp::handle<>(bp::borrowed(PyImport_AddModule("libpyuhd.filters")))
- );
- bp::scope().attr("filters") = filters_module;
- bp::scope io_scope = filters_module;
-
- export_filters();
- }
+ auto filters_module = m.def_submodule("filters", "Filter Submodule");
+ export_filters(filters_module);
}
diff --git a/host/python/types.py b/host/python/types.py
index 6b4ceefce..ad96076f3 100644
--- a/host/python/types.py
+++ b/host/python/types.py
@@ -18,8 +18,9 @@ SPIEdge = lib.types.spi_edge
SPIConfig = lib.types.spi_config
RXMetadataErrorCode = lib.types.rx_metadata_error_code
Range = lib.types.range
-RangeVector = lib.types.range_vector
-MetaRange = lib.types.meta_range
+MetaRange = lib.types.meta_range_t
+GainRange = lib.types.meta_range_t
+FreqRange = lib.types.meta_range_t
RXMetadata = lib.types.rx_metadata
TXMetadata = lib.types.tx_metadata
TXAsyncMetadata = lib.types.async_metadata
generated by cgit v1.2.3 (git 2.39.1) at 2025-03-28 16:47:52 +0000