diff options
Diffstat (limited to 'gr-uhd')
25 files changed, 1580 insertions, 394 deletions
diff --git a/gr-uhd/CMakeLists.txt b/gr-uhd/CMakeLists.txt index d79e309376..eb0b3958e1 100644 --- a/gr-uhd/CMakeLists.txt +++ b/gr-uhd/CMakeLists.txt @@ -46,7 +46,6 @@ add_subdirectory(lib) add_subdirectory(docs) add_subdirectory(examples/c++) if(ENABLE_PYTHON) - add_subdirectory(swig) add_subdirectory(python/uhd) add_subdirectory(apps) add_subdirectory(examples/grc) diff --git a/gr-uhd/apps/uhd_fft b/gr-uhd/apps/uhd_fft index 6e7e5deda0..13c34c0205 100755 --- a/gr-uhd/apps/uhd_fft +++ b/gr-uhd/apps/uhd_fft @@ -94,7 +94,7 @@ class uhd_fft(UHDApp, gr.top_block, Qt.QWidget): ################################################## # Variables ################################################## - self.chan0_lo_locked = chan0_lo_locked = uhd.sensor_value("", False, "") + self.chan0_lo_locked = chan0_lo_locked = uhd.sensor_value("", False, "", "") self.usrp_device_info = usrp_device_info = "[No USRP Device Info Found!]" self.uhd_version_info = uhd_version_info = uhd.get_version_string() self.lo_locked_probe = lo_locked_probe = chan0_lo_locked.to_bool() @@ -203,7 +203,8 @@ class uhd_fft(UHDApp, gr.top_block, Qt.QWidget): self.freq, #fc self.samp_rate, #bw "", #name - len(self.channels) #number of inputs + len(self.channels), #number of inputs + None # parent ) self.qtgui_waterfall_sink_x_0.set_update_time(self.update_rate) self.qtgui_waterfall_sink_x_0.enable_grid(False) @@ -220,7 +221,8 @@ class uhd_fft(UHDApp, gr.top_block, Qt.QWidget): 1024, #size self.samp_rate, #samp_rate "", #name - len(self.channels) #number of inputs + len(self.channels), #number of inputs + None # parent ) self.qtgui_time_sink_x_0.set_update_time(self.update_rate) self.qtgui_time_sink_x_0.set_y_axis(-1, 1) @@ -249,7 +251,8 @@ class uhd_fft(UHDApp, gr.top_block, Qt.QWidget): self.freq, #fc self.samp_rate, #bw "", #name - len(self.channels) #number of inputs + len(self.channels), #number of inputs + None #parent ) self.qtgui_freq_sink_x_0.set_update_time(self.update_rate) self.qtgui_freq_sink_x_0.set_y_axis(-100, 10) diff --git a/gr-uhd/examples/grc/uhd_fft.grc b/gr-uhd/examples/grc/uhd_fft.grc index f7808f4a99..2c7bfa4a25 100644 --- a/gr-uhd/examples/grc/uhd_fft.grc +++ b/gr-uhd/examples/grc/uhd_fft.grc @@ -70,7 +70,7 @@ blocks: function_args: '"''lo_locked''"' function_name: get_sensor poll_rate: '10' - value: uhd.sensor_value("", False, "") + value: uhd.sensor_value("", False, "", "") states: bus_sink: false bus_source: false diff --git a/gr-uhd/examples/grc/uhd_siggen_gui.grc b/gr-uhd/examples/grc/uhd_siggen_gui.grc index a3066633d8..aa3a03db15 100644 --- a/gr-uhd/examples/grc/uhd_siggen_gui.grc +++ b/gr-uhd/examples/grc/uhd_siggen_gui.grc @@ -92,7 +92,7 @@ blocks: function_args: '"''lo_locked''"' function_name: get_sensor poll_rate: '10' - value: uhd.sensor_value("", False, "") + value: uhd.sensor_value("", False, "", "") states: bus_sink: false bus_source: false diff --git a/gr-uhd/grc/gen_uhd_usrp_blocks.py b/gr-uhd/grc/gen_uhd_usrp_blocks.py index 0a83f6dd72..d49a427dc2 100644 --- a/gr-uhd/grc/gen_uhd_usrp_blocks.py +++ b/gr-uhd/grc/gen_uhd_usrp_blocks.py @@ -408,7 +408,7 @@ PARAMS_TMPL = """ - id: center_freq${n} label: 'Ch${n}: Center Freq (Hz)' category: RF Options - dtype: real + dtype: raw default: '0' hide: ${'$'}{ 'none' if (nchan > ${n}) else 'all' } % if sourk == 'source': diff --git a/gr-uhd/include/gnuradio/uhd/uhd_types.h b/gr-uhd/include/gnuradio/uhd/uhd_types.h new file mode 100644 index 0000000000..0179274540 --- /dev/null +++ b/gr-uhd/include/gnuradio/uhd/uhd_types.h @@ -0,0 +1,46 @@ +/* -*- c++ -*- */ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/* Wrappers for UHD types that exposed in the API of gr-uhd blocks */ +#ifndef INCLUDED_GR_UHD_TYPES_H +#define INCLUDED_GR_UHD_TYPES_H + +#include <uhd/stream.hpp> +#include <uhd/types/filters.hpp> +#include <uhd/types/ranges.hpp> +#include <uhd/types/sensors.hpp> +#include <uhd/types/stream_cmd.hpp> +#include <uhd/types/tune_request.hpp> +#include <uhd/types/tune_result.hpp> +#include <uhd/types/wb_iface.hpp> + +namespace gr { +namespace uhd { + +// typedef device_addr_t ::uhd::device_addr_t +class stream_args_t : public ::uhd::stream_args_t +{ + +public: + stream_args_t(const std::string& cpu = "", + const std::string& otw = "", + const ::uhd::device_addr_t& args = ::uhd::device_addr_t(), + const std::vector<size_t> channels = std::vector<size_t>()) + : ::uhd::stream_args_t(cpu, otw) + { + this->args = args; + this->channels = channels; + } +}; +} // namespace uhd +} // namespace gr + + +#endif
\ No newline at end of file diff --git a/gr-uhd/include/gnuradio/uhd/usrp_sink.h b/gr-uhd/include/gnuradio/uhd/usrp_sink.h index 504856c6e7..03002b9174 100644 --- a/gr-uhd/include/gnuradio/uhd/usrp_sink.h +++ b/gr-uhd/include/gnuradio/uhd/usrp_sink.h @@ -101,6 +101,14 @@ public: const ::uhd::stream_args_t& stream_args, const std::string& tsb_tag_name = ""); + // Also accept a string for the device_addr + static sptr make(const std::string& device_addr_str, + const ::uhd::stream_args_t& stream_args, + const std::string& tsb_tag_name = "") + { + return make(::uhd::device_addr_t(device_addr_str), stream_args, tsb_tag_name); + } + /*! * Set the start time for outgoing samples. * To control when samples are transmitted, diff --git a/gr-uhd/include/gnuradio/uhd/usrp_source.h b/gr-uhd/include/gnuradio/uhd/usrp_source.h index 8165a7edb9..bd08f08641 100644 --- a/gr-uhd/include/gnuradio/uhd/usrp_source.h +++ b/gr-uhd/include/gnuradio/uhd/usrp_source.h @@ -58,6 +58,16 @@ public: const ::uhd::stream_args_t& stream_args, const bool issue_stream_cmd_on_start = true); + static sptr make(const std::string& device_addr_str, + const ::uhd::stream_args_t& stream_args, + const bool issue_stream_cmd_on_start = true) + { + return make(::uhd::device_addr_t(device_addr_str), + stream_args, + issue_stream_cmd_on_start); + } + + /*! * Set the start time for incoming samples. * To control when samples are received, diff --git a/gr-uhd/lib/usrp_block_impl.cc b/gr-uhd/lib/usrp_block_impl.cc index 50edc82b5b..2ce7aa3b39 100644 --- a/gr-uhd/lib/usrp_block_impl.cc +++ b/gr-uhd/lib/usrp_block_impl.cc @@ -125,7 +125,7 @@ usrp_block_impl::usrp_block_impl(const ::uhd::device_addr_t& device_addr, // Set up message ports: message_port_register_in(pmt::mp("command")); set_msg_handler(pmt::mp("command"), - boost::bind(&usrp_block_impl::msg_handler_command, this, _1)); + [this](pmt::pmt_t msg) { this->msg_handler_command(msg); }); // cuz we lazy: #define REGISTER_CMD_HANDLER(key, _handler) \ diff --git a/gr-uhd/python/uhd/CMakeLists.txt b/gr-uhd/python/uhd/CMakeLists.txt index f73dc68524..e6d34d8d6c 100644 --- a/gr-uhd/python/uhd/CMakeLists.txt +++ b/gr-uhd/python/uhd/CMakeLists.txt @@ -37,3 +37,5 @@ foreach(py_qa_test_file ${py_qa_test_files}) GR_ADD_TEST(${py_qa_test_name} ${QA_PYTHON_EXECUTABLE} -B ${py_qa_test_file}) endforeach(py_qa_test_file) endif(ENABLE_TESTING) + +add_subdirectory(bindings) diff --git a/gr-uhd/python/uhd/__init__.py b/gr-uhd/python/uhd/__init__.py index 0fa188ae23..85a8f2c142 100644 --- a/gr-uhd/python/uhd/__init__.py +++ b/gr-uhd/python/uhd/__init__.py @@ -16,51 +16,43 @@ line. from __future__ import absolute_import from __future__ import unicode_literals +import uhd # TODO: verify uhd python is installed as a dependency for gr-uhd with python + ######################################################################## # Prepare uhd swig module to make it more pythonic ######################################################################## -def _prepare_uhd_swig(): +def _prepare_uhd_python(): try: - from . import uhd_swig + from . import uhd_python except ImportError: import os dirname, filename = os.path.split(os.path.abspath(__file__)) - __path__.append(os.path.join(dirname, "..", "..", "swig")) - from . import uhd_swig + __path__.append(os.path.join(dirname, "bindings")) + from . import uhd_python #some useful typedefs for the user - setattr(uhd_swig, 'freq_range_t', uhd_swig.meta_range_t) - setattr(uhd_swig, 'gain_range_t', uhd_swig.meta_range_t) + setattr(uhd_python, 'freq_range_t', uhd_python.meta_range_t) + setattr(uhd_python, 'gain_range_t', uhd_python.meta_range_t) #Make the python tune request object inherit from float #so that it can be passed in GRC as a frequency parameter. #The type checking in GRC will accept the tune request. #Also use kwargs to construct individual struct elements. - class tune_request_t(uhd_swig.tune_request_t, float): - def __new__(self, *args, **kwargs): return float.__new__(self) + class tune_request_t(uhd_python.tune_request_t): + # def __new__(self, *args, **kwargs): return float.__new__(self) def __float__(self): return self.target_freq def __init__(self, *args, **kwargs): - super(tune_request_t, self).__init__(*args) + super().__init__(*args) for key, val in list(kwargs.items()): setattr(self, key, val) - setattr(uhd_swig, 'tune_request_t', tune_request_t) - - #Make the python tune request object inherit from string - #so that it can be passed in GRC as a string parameter. - #The type checking in GRC will accept the device address. - #Define the set/get item special methods for dict access. - class device_addr_t(uhd_swig.device_addr_t, str): - def __new__(self, *args): return str.__new__(self) - def __getitem__(self, key): return self.get(key) - def __setitem__(self, key, val): self.set(key, val) - def __init__(self, *args, **kwargs): - super(device_addr_t, self).__init__(*args) - if args and isinstance(args[0], device_addr_t): - for key in list(args[0].keys()): self[key] = args[0][key] - setattr(uhd_swig, 'device_addr_t', device_addr_t) + setattr(uhd_python, 'tune_request_t', tune_request_t) #make the streamer args take **kwargs on init - class stream_args_t(uhd_swig.stream_args_t): + class stream_args_t(uhd_python.stream_args_t): def __init__(self, *args, **kwargs): + # UHD Python API doesn't have default args for stream_args_t + # If empty args, then append empty str's + while len(args) < 2: + args += ("",) super(stream_args_t, self).__init__(*args) for key, val in list(kwargs.items()): #for some reason, I can't assign a list in the constructor @@ -68,60 +60,35 @@ def _prepare_uhd_swig(): if key == 'channels': for v in val: self.channels.append(v) elif key == 'args': - self.args = device_addr_t(val) + self.args = uhd_python.device_addr_t(val) else: setattr(self, key, val) - setattr(uhd_swig, 'stream_args_t', stream_args_t) - #handle general things on all uhd_swig attributes + # FIXME: stream_args_t.channels.append does not work due to copy operation of STL vectors + setattr(uhd_python, 'stream_args_t', stream_args_t) + + #handle general things on all uhd_python attributes #Install the __str__ and __repr__ handlers if applicable #Create aliases for uhd swig attributes to avoid the "_t" - for attr in dir(uhd_swig): - myobj = getattr(uhd_swig, attr) + for attr in dir(uhd_python): + myobj = getattr(uhd_python, attr) if hasattr(myobj, 'to_string'): myobj.__repr__ = lambda o: o.to_string().strip() if hasattr(myobj, 'to_pp_string'): myobj.__str__ = lambda o: o.to_pp_string().strip() if hasattr(myobj, 'to_bool'): myobj.__nonzero__ = lambda o: o.to_bool() if hasattr(myobj, 'to_int'): myobj.__int__ = lambda o: o.to_int() if hasattr(myobj, 'to_real'): myobj.__float__ = lambda o: o.to_real() - if attr.endswith('_t'): setattr(uhd_swig, attr[:-2], myobj) + if attr.endswith('_t'): setattr(uhd_python, attr[:-2], myobj) #make a new find devices that casts everything with the pythonized device_addr_t which has __str__ def find_devices(*args, **kwargs): def to_pythonized_dev_addr(dev_addr): - new_dev_addr = uhd_swig.device_addr_t() + new_dev_addr = uhd_python.device_addr_t() for key in list(dev_addr.keys()): new_dev_addr[key] = dev_addr.get(key) return new_dev_addr - return __builtins__['map'](to_pythonized_dev_addr, uhd_swig.find_devices_raw(*args, **kwargs)) - setattr(uhd_swig, 'find_devices', find_devices) - - #Cast constructor args (FIXME swig handle overloads?) - for attr in ('usrp_source', 'usrp_sink', 'amsg_source'): - def constructor_factory(old_constructor): - def constructor_interceptor(*args, **kwargs): - args = list(args) - kwargs = dict(kwargs) - for index, key, cast in ( - (0, 'device_addr', device_addr), - ): - if len(args) > index: - args[index] = cast(args[index]) - if key in kwargs: - kwargs[key] = cast(kwargs[key]) - #don't pass kwargs, it confuses swig, map into args list: - for key in ('device_addr', 'stream_args', - 'issue_stream_cmd_on_start', 'tsb_tag_name', 'msgq'): - if key in kwargs: args.append(kwargs[key]) - return old_constructor(*args) - return constructor_interceptor - setattr(uhd_swig, attr, constructor_factory(getattr(uhd_swig, attr))) - - #Aliases for deprecated constructors - setattr(uhd_swig, 'single_usrp_source', uhd_swig.usrp_source) - setattr(uhd_swig, 'single_usrp_sink', uhd_swig.usrp_sink) - setattr(uhd_swig, 'multi_usrp_source', uhd_swig.usrp_source) - setattr(uhd_swig, 'multi_usrp_sink', uhd_swig.usrp_sink) + return __builtins__['map'](to_pythonized_dev_addr, uhd_python.find_devices_raw(*args, **kwargs)) + setattr(uhd_python, 'find_devices', find_devices) ######################################################################## -# Initialize this module with the contents of uhd swig +# Initialize this module with the contents of uhd pybind ######################################################################## -_prepare_uhd_swig() -from .uhd_swig import * +_prepare_uhd_python() +from .uhd_python import * diff --git a/gr-uhd/python/uhd/bindings/CMakeLists.txt b/gr-uhd/python/uhd/bindings/CMakeLists.txt new file mode 100644 index 0000000000..8d123da16c --- /dev/null +++ b/gr-uhd/python/uhd/bindings/CMakeLists.txt @@ -0,0 +1,20 @@ +include(GrPybind) + +######################################################################## +# Python Bindings +######################################################################## + +list(APPEND uhd_python_files + uhd_types_python.cc + amsg_source_python.cc + usrp_block_python.cc + usrp_sink_python.cc + usrp_source_python.cc + python_bindings.cc) + +GR_PYBIND_MAKE(uhd + ../../.. + gr::uhd + "${uhd_python_files}") + +install(TARGETS uhd_python DESTINATION ${GR_PYTHON_DIR}/gnuradio/uhd COMPONENT pythonapi) diff --git a/gr-uhd/python/uhd/bindings/amsg_source_python.cc b/gr-uhd/python/uhd/bindings/amsg_source_python.cc new file mode 100644 index 0000000000..2e3daacf2e --- /dev/null +++ b/gr-uhd/python/uhd/bindings/amsg_source_python.cc @@ -0,0 +1,43 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/* This file is automatically generated using bindtool */ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/uhd/amsg_source.h> +// pydoc.h is automatically generated in the build directory +#include <amsg_source_pydoc.h> + +void bind_amsg_source(py::module& m) +{ + + using amsg_source = ::gr::uhd::amsg_source; + + + py::class_<amsg_source, std::shared_ptr<amsg_source>>( + m, "amsg_source", D(amsg_source)) + + .def(py::init(&amsg_source::make), + py::arg("device_addr"), + py::arg("msgq"), + D(amsg_source, make)) + + + .def_static("msg_to_async_metadata_t", + &amsg_source::msg_to_async_metadata_t, + py::arg("msg"), + D(amsg_source, msg_to_async_metadata_t)) + + ; +} diff --git a/gr-uhd/python/uhd/bindings/docstrings/amsg_source_pydoc_template.h b/gr-uhd/python/uhd/bindings/docstrings/amsg_source_pydoc_template.h new file mode 100644 index 0000000000..275c38042e --- /dev/null +++ b/gr-uhd/python/uhd/bindings/docstrings/amsg_source_pydoc_template.h @@ -0,0 +1,30 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, uhd, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_uhd_amsg_source = R"doc()doc"; + + +static const char* __doc_gr_uhd_amsg_source_amsg_source_0 = R"doc()doc"; + + +static const char* __doc_gr_uhd_amsg_source_amsg_source_1 = R"doc()doc"; + + +static const char* __doc_gr_uhd_amsg_source_make = R"doc()doc"; + + +static const char* __doc_gr_uhd_amsg_source_msg_to_async_metadata_t = R"doc()doc"; diff --git a/gr-uhd/python/uhd/bindings/docstrings/usrp_block_pydoc_template.h b/gr-uhd/python/uhd/bindings/docstrings/usrp_block_pydoc_template.h new file mode 100644 index 0000000000..3ef0dd728b --- /dev/null +++ b/gr-uhd/python/uhd/bindings/docstrings/usrp_block_pydoc_template.h @@ -0,0 +1,234 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, uhd, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_uhd_usrp_block = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_set_subdev_spec = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_subdev_spec = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_num_mboards = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_set_samp_rate = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_samp_rate = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_samp_rates = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_set_center_freq_0 = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_set_center_freq_1 = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_center_freq = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_freq_range = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_set_gain_0 = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_set_gain_1 = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_set_normalized_gain = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_gain_0 = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_gain_1 = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_normalized_gain = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_gain_names = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_gain_range_0 = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_gain_range_1 = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_set_antenna = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_antenna = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_antennas = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_set_bandwidth = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_bandwidth = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_bandwidth_range = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_sensor = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_sensor_names = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_dboard_sensor = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_dboard_sensor_names = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_mboard_sensor = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_mboard_sensor_names = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_time_source = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_time_sources = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_set_clock_source = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_clock_source = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_clock_sources = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_clock_rate = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_set_clock_rate = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_time_now = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_time_last_pps = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_set_time_now = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_set_time_next_pps = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_set_time_unknown_pps = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_set_command_time = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_clear_command_time = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_dboard_iface = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_device = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_set_user_register = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_set_time_source = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_set_stream_args = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_gpio_banks = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_set_gpio_attr = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_gpio_attr = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_filter_names = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_set_filter = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_block_get_filter = R"doc()doc"; + + +static const char* __doc_gr_uhd_cmd_chan_key = R"doc()doc"; + + +static const char* __doc_gr_uhd_cmd_gain_key = R"doc()doc"; + + +static const char* __doc_gr_uhd_cmd_freq_key = R"doc()doc"; + + +static const char* __doc_gr_uhd_cmd_lo_offset_key = R"doc()doc"; + + +static const char* __doc_gr_uhd_cmd_tune_key = R"doc()doc"; + + +static const char* __doc_gr_uhd_cmd_lo_freq_key = R"doc()doc"; + + +static const char* __doc_gr_uhd_cmd_dsp_freq_key = R"doc()doc"; + + +static const char* __doc_gr_uhd_cmd_rate_key = R"doc()doc"; + + +static const char* __doc_gr_uhd_cmd_bandwidth_key = R"doc()doc"; + + +static const char* __doc_gr_uhd_cmd_time_key = R"doc()doc"; + + +static const char* __doc_gr_uhd_cmd_mboard_key = R"doc()doc"; + + +static const char* __doc_gr_uhd_cmd_antenna_key = R"doc()doc"; + + +static const char* __doc_gr_uhd_cmd_direction_key = R"doc()doc"; + + +static const char* __doc_gr_uhd_cmd_tag_key = R"doc()doc"; + + +static const char* __doc_gr_uhd_ant_direction_rx = R"doc()doc"; + + +static const char* __doc_gr_uhd_ant_direction_tx = R"doc()doc"; diff --git a/gr-uhd/python/uhd/bindings/docstrings/usrp_sink_pydoc_template.h b/gr-uhd/python/uhd/bindings/docstrings/usrp_sink_pydoc_template.h new file mode 100644 index 0000000000..233a1f4c3c --- /dev/null +++ b/gr-uhd/python/uhd/bindings/docstrings/usrp_sink_pydoc_template.h @@ -0,0 +1,66 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, uhd, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_uhd_usrp_sink = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_sink_usrp_sink_0 = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_sink_usrp_sink_1 = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_sink_make = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_sink_set_start_time = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_sink_get_usrp_info = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_sink_get_lo_names = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_sink_set_lo_source = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_sink_get_lo_source = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_sink_get_lo_sources = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_sink_set_lo_export_enabled = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_sink_get_lo_export_enabled = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_sink_set_lo_freq = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_sink_get_lo_freq = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_sink_get_lo_freq_range = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_sink_set_dc_offset = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_sink_set_iq_balance = R"doc()doc"; diff --git a/gr-uhd/python/uhd/bindings/docstrings/usrp_source_pydoc_template.h b/gr-uhd/python/uhd/bindings/docstrings/usrp_source_pydoc_template.h new file mode 100644 index 0000000000..f2d93f03a0 --- /dev/null +++ b/gr-uhd/python/uhd/bindings/docstrings/usrp_source_pydoc_template.h @@ -0,0 +1,87 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, uhd, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_uhd_usrp_source = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_source_usrp_source_0 = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_source_usrp_source_1 = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_source_make = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_source_set_start_time = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_source_issue_stream_cmd = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_source_set_recv_timeout = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_source_get_usrp_info = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_source_get_lo_names = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_source_set_lo_source = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_source_get_lo_source = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_source_get_lo_sources = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_source_set_lo_export_enabled = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_source_get_lo_export_enabled = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_source_set_lo_freq = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_source_get_lo_freq = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_source_get_lo_freq_range = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_source_set_auto_dc_offset = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_source_set_dc_offset = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_source_set_auto_iq_balance = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_source_set_iq_balance = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_source_set_rx_agc = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_source_finite_acquisition = R"doc()doc"; + + +static const char* __doc_gr_uhd_usrp_source_finite_acquisition_v = R"doc()doc"; diff --git a/gr-uhd/python/uhd/bindings/python_bindings.cc b/gr-uhd/python/uhd/bindings/python_bindings.cc new file mode 100644 index 0000000000..e32d1b48cc --- /dev/null +++ b/gr-uhd/python/uhd/bindings/python_bindings.cc @@ -0,0 +1,55 @@ + +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#include <pybind11/pybind11.h> + +#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION +#include <numpy/arrayobject.h> + +#include <uhd/version.hpp> + +namespace py = pybind11; + +void bind_uhd_types(py::module&); +void bind_amsg_source(py::module&); +void bind_usrp_block(py::module&); +void bind_usrp_sink(py::module&); +void bind_usrp_source(py::module&); + +// 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 +// and removes a warning. +void* init_numpy() +{ + import_array(); + return NULL; +} + +PYBIND11_MODULE(uhd_python, m) +{ + // Initialize the numpy C API + // (otherwise we will see segmentation faults) + init_numpy(); + + // Allow access to base block methods + py::module::import("gnuradio.gr"); + + bind_uhd_types(m); + bind_amsg_source(m); + bind_usrp_block(m); + bind_usrp_sink(m); + bind_usrp_source(m); + + m.def( + "get_version_string", + []() { return ::uhd::get_version_string(); }, + "Returns UHD Version String"); +} diff --git a/gr-uhd/python/uhd/bindings/uhd_types_python.cc b/gr-uhd/python/uhd/bindings/uhd_types_python.cc new file mode 100644 index 0000000000..45202c8395 --- /dev/null +++ b/gr-uhd/python/uhd/bindings/uhd_types_python.cc @@ -0,0 +1,158 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/* This file is automatically generated using bindtool */ + +#include <pybind11/complex.h> +#include <pybind11/operators.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/uhd/uhd_types.h> + +void bind_uhd_types(py::module& m) +{ + // Bindings copied from UHD + + // using str_map = std::map<std::string, std::string>; + + py::class_<::uhd::device_addr_t>(m, "device_addr_t") + // Constructors + .def(py::init<>()) + .def(py::init<std::string>()) + // Not defined for UHD < 3.11 + // .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>(); + + using stream_args_t = ::uhd::stream_args_t; + py::class_<stream_args_t>(m, "stream_args_t") + .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) + .def_readwrite("args", &stream_args_t::args) + .def_readwrite("channels", &stream_args_t::channels); + + + // ::uhd::time_spec_t + using time_spec_t = ::uhd::time_spec_t; + + py::class_<time_spec_t>(m, "time_spec_t") + // Additional constructors + .def(py::init<double>()) + .def(py::init<int64_t, double>()) + .def(py::init<int64_t, long, double>()) + + // Methods + .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_full_secs", &time_spec_t::get_full_secs) + .def("get_frac_secs", &time_spec_t::get_frac_secs) + + .def(py::self += time_spec_t()) + .def(py::self -= time_spec_t()) + .def(py::self + time_spec_t()) + .def(py::self - time_spec_t()) + .def(py::self += double()) + .def(py::self -= double()) + .def(py::self + double()) + .def(py::self - double()); + + // ::uhd::stream_cmd_t + using stream_cmd_t = ::uhd::stream_cmd_t; + py::class_<stream_cmd_t>(m, "stream_cmd_t") + .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); + + // ::uhd::meta_range_t + using meta_range_t = ::uhd::meta_range_t; + + py::class_<meta_range_t>(m, "meta_range_t") + // Constructors + .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, py::arg("value"), py::arg("clip_step") = false) + .def("__str__", &meta_range_t::to_pp_string); + + // ::uhd::tune_result_t + using tune_result_t = ::uhd::tune_result_t; + py::class_<tune_result_t>(m, "tune_result_t") + .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) + .def_readwrite("target_dsp_freq", &tune_result_t::target_dsp_freq) + .def_readwrite("actual_dsp_freq", &tune_result_t::actual_dsp_freq) + .def("__str__", &tune_result_t::to_pp_string); + + // ::uhd::tune_request_t + using tune_request_t = ::uhd::tune_request_t; + py::class_<tune_request_t>(m, "tune_request_t") + .def(py::init<double, double>()) + .def(py::init<double>(), py::arg("target_freq") = 0.0) + .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) + .def_readwrite("rf_freq", &tune_request_t::rf_freq) + .def_readwrite("dsp_freq", &tune_request_t::dsp_freq) + .def_readwrite("args", &tune_request_t::args); + + + // ::uhd::sensor_value_t + using sensor_value_t = uhd::sensor_value_t; + + py::class_<sensor_value_t>(m, "sensor_value_t") + // Constructors + .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) + .def("to_int", &sensor_value_t::to_int) + .def("to_real", &sensor_value_t::to_real) + .def("__str__", &sensor_value_t::to_pp_string); + + // NOTE: UHD 3.9 has these properties defined as const so they cannot be + // set in this manner. + // // Properties + // .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/gr-uhd/python/uhd/bindings/usrp_block_python.cc b/gr-uhd/python/uhd/bindings/usrp_block_python.cc new file mode 100644 index 0000000000..7d25ce1a34 --- /dev/null +++ b/gr-uhd/python/uhd/bindings/usrp_block_python.cc @@ -0,0 +1,441 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/* This file is automatically generated using bindtool */ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/uhd/usrp_block.h> +// pydoc.h is automatically generated in the build directory +#include <usrp_block_pydoc.h> + +void bind_usrp_block(py::module& m) +{ + + using usrp_block = ::gr::uhd::usrp_block; + + + py::class_<usrp_block, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<usrp_block>>(m, "usrp_block", D(usrp_block)) + + + .def("set_subdev_spec", + &usrp_block::set_subdev_spec, + py::arg("spec"), + py::arg("mboard") = 0, + D(usrp_block, set_subdev_spec)) + + + .def("get_subdev_spec", + &usrp_block::get_subdev_spec, + py::arg("mboard") = 0, + D(usrp_block, get_subdev_spec)) + + + .def("get_num_mboards", + &usrp_block::get_num_mboards, + D(usrp_block, get_num_mboards)) + + + .def("set_samp_rate", + &usrp_block::set_samp_rate, + py::arg("rate"), + D(usrp_block, set_samp_rate)) + + + .def("get_samp_rate", &usrp_block::get_samp_rate, D(usrp_block, get_samp_rate)) + + + .def("get_samp_rates", &usrp_block::get_samp_rates, D(usrp_block, get_samp_rates)) + + + .def("set_center_freq", + (uhd::tune_result_t(usrp_block::*)(uhd::tune_request_t const, size_t)) & + usrp_block::set_center_freq, + py::arg("tune_request"), + py::arg("chan") = 0, + D(usrp_block, set_center_freq, 0)) + + + .def("set_center_freq", + (uhd::tune_result_t(usrp_block::*)(double, size_t)) & + usrp_block::set_center_freq, + py::arg("freq"), + py::arg("chan") = 0, + D(usrp_block, set_center_freq, 1)) + + + .def("get_center_freq", + &usrp_block::get_center_freq, + py::arg("chan") = 0, + D(usrp_block, get_center_freq)) + + + .def("get_freq_range", + &usrp_block::get_freq_range, + py::arg("chan") = 0, + D(usrp_block, get_freq_range)) + + + .def("set_gain", + (void (usrp_block::*)(double, size_t)) & usrp_block::set_gain, + py::arg("gain"), + py::arg("chan") = 0, + D(usrp_block, set_gain, 0)) + + + .def("set_gain", + (void (usrp_block::*)(double, std::string const&, size_t)) & + usrp_block::set_gain, + py::arg("gain"), + py::arg("name"), + py::arg("chan") = 0, + D(usrp_block, set_gain, 1)) + + + .def("set_normalized_gain", + &usrp_block::set_normalized_gain, + py::arg("norm_gain"), + py::arg("chan") = 0, + D(usrp_block, set_normalized_gain)) + + + .def("get_gain", + (double (usrp_block::*)(size_t)) & usrp_block::get_gain, + py::arg("chan") = 0, + D(usrp_block, get_gain, 0)) + + + .def("get_gain", + (double (usrp_block::*)(std::string const&, size_t)) & usrp_block::get_gain, + py::arg("name"), + py::arg("chan") = 0, + D(usrp_block, get_gain, 1)) + + + .def("get_normalized_gain", + &usrp_block::get_normalized_gain, + py::arg("chan") = 0, + D(usrp_block, get_normalized_gain)) + + + .def("get_gain_names", + &usrp_block::get_gain_names, + py::arg("chan") = 0, + D(usrp_block, get_gain_names)) + + + .def("get_gain_range", + (uhd::gain_range_t(usrp_block::*)(size_t)) & usrp_block::get_gain_range, + py::arg("chan") = 0, + D(usrp_block, get_gain_range, 0)) + + + .def("get_gain_range", + (uhd::gain_range_t(usrp_block::*)(std::string const&, size_t)) & + usrp_block::get_gain_range, + py::arg("name"), + py::arg("chan") = 0, + D(usrp_block, get_gain_range, 1)) + + + .def("set_antenna", + &usrp_block::set_antenna, + py::arg("ant"), + py::arg("chan") = 0, + D(usrp_block, set_antenna)) + + + .def("get_antenna", + &usrp_block::get_antenna, + py::arg("chan") = 0, + D(usrp_block, get_antenna)) + + + .def("get_antennas", + &usrp_block::get_antennas, + py::arg("chan") = 0, + D(usrp_block, get_antennas)) + + + .def("set_bandwidth", + &usrp_block::set_bandwidth, + py::arg("bandwidth"), + py::arg("chan") = 0, + D(usrp_block, set_bandwidth)) + + + .def("get_bandwidth", + &usrp_block::get_bandwidth, + py::arg("chan") = 0, + D(usrp_block, get_bandwidth)) + + + .def("get_bandwidth_range", + &usrp_block::get_bandwidth_range, + py::arg("chan") = 0, + D(usrp_block, get_bandwidth_range)) + + + .def("get_sensor", + &usrp_block::get_sensor, + py::arg("name"), + py::arg("chan") = 0, + D(usrp_block, get_sensor)) + + + .def("get_sensor_names", + &usrp_block::get_sensor_names, + py::arg("chan") = 0, + D(usrp_block, get_sensor_names)) + + + .def("get_dboard_sensor", + &usrp_block::get_dboard_sensor, + py::arg("name"), + py::arg("chan") = 0, + D(usrp_block, get_dboard_sensor)) + + + .def("get_dboard_sensor_names", + &usrp_block::get_dboard_sensor_names, + py::arg("chan") = 0, + D(usrp_block, get_dboard_sensor_names)) + + + .def("get_mboard_sensor", + &usrp_block::get_mboard_sensor, + py::arg("name"), + py::arg("mboard") = 0, + D(usrp_block, get_mboard_sensor)) + + + .def("get_mboard_sensor_names", + &usrp_block::get_mboard_sensor_names, + py::arg("mboard") = 0, + D(usrp_block, get_mboard_sensor_names)) + + + .def("get_time_source", + &usrp_block::get_time_source, + py::arg("mboard"), + D(usrp_block, get_time_source)) + + + .def("get_time_sources", + &usrp_block::get_time_sources, + py::arg("mboard"), + D(usrp_block, get_time_sources)) + + + .def("set_clock_source", + &usrp_block::set_clock_source, + py::arg("source"), + py::arg("mboard") = 0, + D(usrp_block, set_clock_source)) + + + .def("get_clock_source", + &usrp_block::get_clock_source, + py::arg("mboard"), + D(usrp_block, get_clock_source)) + + + .def("get_clock_sources", + &usrp_block::get_clock_sources, + py::arg("mboard"), + D(usrp_block, get_clock_sources)) + + + .def("get_clock_rate", + &usrp_block::get_clock_rate, + py::arg("mboard") = 0, + D(usrp_block, get_clock_rate)) + + + .def("set_clock_rate", + &usrp_block::set_clock_rate, + py::arg("rate"), + py::arg("mboard") = 0, + D(usrp_block, set_clock_rate)) + + + .def("get_time_now", + &usrp_block::get_time_now, + py::arg("mboard") = 0, + D(usrp_block, get_time_now)) + + + .def("get_time_last_pps", + &usrp_block::get_time_last_pps, + py::arg("mboard") = 0, + D(usrp_block, get_time_last_pps)) + + + .def("set_time_now", + &usrp_block::set_time_now, + py::arg("time_spec"), + py::arg("mboard") = 0, + D(usrp_block, set_time_now)) + + + .def("set_time_next_pps", + &usrp_block::set_time_next_pps, + py::arg("time_spec"), + D(usrp_block, set_time_next_pps)) + + + .def("set_time_unknown_pps", + &usrp_block::set_time_unknown_pps, + py::arg("time_spec"), + D(usrp_block, set_time_unknown_pps)) + + + .def("set_command_time", + &usrp_block::set_command_time, + py::arg("time_spec"), + py::arg("mboard") = 0, + D(usrp_block, set_command_time)) + + + .def("clear_command_time", + &usrp_block::clear_command_time, + py::arg("mboard") = 0, + D(usrp_block, clear_command_time)) + + + .def("get_dboard_iface", + &usrp_block::get_dboard_iface, + py::arg("chan") = 0, + D(usrp_block, get_dboard_iface)) + + + .def("get_device", &usrp_block::get_device, D(usrp_block, get_device)) + + + .def("set_user_register", + &usrp_block::set_user_register, + py::arg("addr"), + py::arg("data"), + py::arg("mboard") = 0, + D(usrp_block, set_user_register)) + + + .def("set_time_source", + &usrp_block::set_time_source, + py::arg("source"), + py::arg("mboard") = 0, + D(usrp_block, set_time_source)) + + + .def("set_stream_args", + &usrp_block::set_stream_args, + py::arg("stream_args"), + D(usrp_block, set_stream_args)) + + + .def("get_gpio_banks", + &usrp_block::get_gpio_banks, + py::arg("mboard"), + D(usrp_block, get_gpio_banks)) + + + .def("set_gpio_attr", + &usrp_block::set_gpio_attr, + py::arg("bank"), + py::arg("attr"), + py::arg("value"), + py::arg("mask") = 4294967295U, + py::arg("mboard") = 0, + D(usrp_block, set_gpio_attr)) + + + .def("get_gpio_attr", + &usrp_block::get_gpio_attr, + py::arg("bank"), + py::arg("attr"), + py::arg("mboard") = 0, + D(usrp_block, get_gpio_attr)) + + + .def("get_filter_names", + &usrp_block::get_filter_names, + py::arg("search_mask") = "", + D(usrp_block, get_filter_names)) + + + .def("set_filter", + &usrp_block::set_filter, + py::arg("path"), + py::arg("filter"), + D(usrp_block, set_filter)) + + + .def("get_filter", + &usrp_block::get_filter, + py::arg("path"), + D(usrp_block, get_filter)) + + ; + + + m.def("cmd_chan_key", &::gr::uhd::cmd_chan_key, D(cmd_chan_key)); + + + m.def("cmd_gain_key", &::gr::uhd::cmd_gain_key, D(cmd_gain_key)); + + + m.def("cmd_freq_key", &::gr::uhd::cmd_freq_key, D(cmd_freq_key)); + + + m.def("cmd_lo_offset_key", &::gr::uhd::cmd_lo_offset_key, D(cmd_lo_offset_key)); + + + m.def("cmd_tune_key", &::gr::uhd::cmd_tune_key, D(cmd_tune_key)); + + + m.def("cmd_lo_freq_key", &::gr::uhd::cmd_lo_freq_key, D(cmd_lo_freq_key)); + + + m.def("cmd_dsp_freq_key", &::gr::uhd::cmd_dsp_freq_key, D(cmd_dsp_freq_key)); + + + m.def("cmd_rate_key", &::gr::uhd::cmd_rate_key, D(cmd_rate_key)); + + + m.def("cmd_bandwidth_key", &::gr::uhd::cmd_bandwidth_key, D(cmd_bandwidth_key)); + + + m.def("cmd_time_key", &::gr::uhd::cmd_time_key, D(cmd_time_key)); + + + m.def("cmd_mboard_key", &::gr::uhd::cmd_mboard_key, D(cmd_mboard_key)); + + + m.def("cmd_antenna_key", &::gr::uhd::cmd_antenna_key, D(cmd_antenna_key)); + + + m.def("cmd_direction_key", &::gr::uhd::cmd_direction_key, D(cmd_direction_key)); + + + m.def("cmd_tag_key", &::gr::uhd::cmd_tag_key, D(cmd_tag_key)); + + + m.def("ant_direction_rx", &::gr::uhd::ant_direction_rx, D(ant_direction_rx)); + + + m.def("ant_direction_tx", &::gr::uhd::ant_direction_tx, D(ant_direction_tx)); +} diff --git a/gr-uhd/python/uhd/bindings/usrp_sink_python.cc b/gr-uhd/python/uhd/bindings/usrp_sink_python.cc new file mode 100644 index 0000000000..d0a7dc482d --- /dev/null +++ b/gr-uhd/python/uhd/bindings/usrp_sink_python.cc @@ -0,0 +1,145 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/* This file is automatically generated using bindtool */ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/uhd/usrp_sink.h> +// pydoc.h is automatically generated in the build directory +#include <usrp_sink_pydoc.h> + +void bind_usrp_sink(py::module& m) +{ + + using usrp_sink = ::gr::uhd::usrp_sink; + + + py::class_<usrp_sink, + gr::uhd::usrp_block, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<usrp_sink>>(m, "usrp_sink", D(usrp_sink)) + + .def(py::init((std::shared_ptr<gr::uhd::usrp_sink>(*)(const ::uhd::device_addr_t&, + const ::uhd::stream_args_t&, + const std::string&)) & + usrp_sink::make), + py::arg("device_addr"), + py::arg("stream_args"), + py::arg("tsb_tag_name") = "", + D(usrp_sink, make)) + + .def(py::init((std::shared_ptr<gr::uhd::usrp_sink>(*)(const std::string&, + const ::uhd::stream_args_t&, + const std::string&)) & + usrp_sink::make), + py::arg("device_addr"), + py::arg("stream_args"), + py::arg("tsb_tag_name") = "", + D(usrp_sink, make)) + + + .def("set_start_time", + &usrp_sink::set_start_time, + py::arg("time"), + D(usrp_sink, set_start_time)) + + + .def("get_usrp_info", + &usrp_sink::get_usrp_info, + py::arg("chan") = 0, + D(usrp_sink, get_usrp_info)) + + + .def("get_lo_names", + &usrp_sink::get_lo_names, + py::arg("chan") = 0, + D(usrp_sink, get_lo_names)) + + + .def("set_lo_source", + &usrp_sink::set_lo_source, + py::arg("src"), + py::arg("name"), + py::arg("chan") = 0, + D(usrp_sink, set_lo_source)) + + + .def("get_lo_source", + &usrp_sink::get_lo_source, + py::arg("name"), + py::arg("chan") = 0, + D(usrp_sink, get_lo_source)) + + + .def("get_lo_sources", + &usrp_sink::get_lo_sources, + py::arg("name"), + py::arg("chan") = 0, + D(usrp_sink, get_lo_sources)) + + + .def("set_lo_export_enabled", + &usrp_sink::set_lo_export_enabled, + py::arg("enabled"), + py::arg("name"), + py::arg("chan") = 0, + D(usrp_sink, set_lo_export_enabled)) + + + .def("get_lo_export_enabled", + &usrp_sink::get_lo_export_enabled, + py::arg("name"), + py::arg("chan") = 0, + D(usrp_sink, get_lo_export_enabled)) + + + .def("set_lo_freq", + &usrp_sink::set_lo_freq, + py::arg("freq"), + py::arg("name"), + py::arg("chan") = 0, + D(usrp_sink, set_lo_freq)) + + + .def("get_lo_freq", + &usrp_sink::get_lo_freq, + py::arg("name"), + py::arg("chan") = 0, + D(usrp_sink, get_lo_freq)) + + + .def("get_lo_freq_range", + &usrp_sink::get_lo_freq_range, + py::arg("name"), + py::arg("chan") = 0, + D(usrp_sink, get_lo_freq_range)) + + + .def("set_dc_offset", + &usrp_sink::set_dc_offset, + py::arg("offset"), + py::arg("chan") = 0, + D(usrp_sink, set_dc_offset)) + + + .def("set_iq_balance", + &usrp_sink::set_iq_balance, + py::arg("correction"), + py::arg("chan") = 0, + D(usrp_sink, set_iq_balance)) + + ; +} diff --git a/gr-uhd/python/uhd/bindings/usrp_source_python.cc b/gr-uhd/python/uhd/bindings/usrp_source_python.cc new file mode 100644 index 0000000000..19f3d6017d --- /dev/null +++ b/gr-uhd/python/uhd/bindings/usrp_source_python.cc @@ -0,0 +1,191 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/* This file is automatically generated using bindtool */ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/uhd/usrp_source.h> +// pydoc.h is automatically generated in the build directory +#include <usrp_source_pydoc.h> + +void bind_usrp_source(py::module& m) +{ + + using usrp_source = ::gr::uhd::usrp_source; + + + py::class_<usrp_source, + gr::uhd::usrp_block, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<usrp_source>>(m, "usrp_source", D(usrp_source)) + + .def(py::init( + (std::shared_ptr<gr::uhd::usrp_source>(*)(const ::uhd::device_addr_t&, + const ::uhd::stream_args_t&, + const bool)) & + usrp_source::make), + py::arg("device_addr"), + py::arg("stream_args"), + py::arg("issue_stream_cmd_on_start") = true, + D(usrp_source, make)) + + .def(py::init((std::shared_ptr<gr::uhd::usrp_source>(*)( + const std::string&, const ::uhd::stream_args_t&, const bool)) & + usrp_source::make), + py::arg("device_addr"), + py::arg("stream_args"), + py::arg("issue_stream_cmd_on_start") = true, + D(usrp_source, make)) + + + .def("set_start_time", + &usrp_source::set_start_time, + py::arg("time"), + D(usrp_source, set_start_time)) + + + .def("issue_stream_cmd", + &usrp_source::issue_stream_cmd, + py::arg("cmd"), + D(usrp_source, issue_stream_cmd)) + + + .def("set_recv_timeout", + &usrp_source::set_recv_timeout, + py::arg("timeout"), + py::arg("one_packet") = true, + D(usrp_source, set_recv_timeout)) + + + .def("get_usrp_info", + &usrp_source::get_usrp_info, + py::arg("chan") = 0, + D(usrp_source, get_usrp_info)) + + + .def("get_lo_names", + &usrp_source::get_lo_names, + py::arg("chan") = 0, + D(usrp_source, get_lo_names)) + + + .def("set_lo_source", + &usrp_source::set_lo_source, + py::arg("src"), + py::arg("name"), + py::arg("chan") = 0, + D(usrp_source, set_lo_source)) + + + .def("get_lo_source", + &usrp_source::get_lo_source, + py::arg("name"), + py::arg("chan") = 0, + D(usrp_source, get_lo_source)) + + + .def("get_lo_sources", + &usrp_source::get_lo_sources, + py::arg("name"), + py::arg("chan") = 0, + D(usrp_source, get_lo_sources)) + + + .def("set_lo_export_enabled", + &usrp_source::set_lo_export_enabled, + py::arg("enabled"), + py::arg("name"), + py::arg("chan") = 0, + D(usrp_source, set_lo_export_enabled)) + + + .def("get_lo_export_enabled", + &usrp_source::get_lo_export_enabled, + py::arg("name"), + py::arg("chan") = 0, + D(usrp_source, get_lo_export_enabled)) + + + .def("set_lo_freq", + &usrp_source::set_lo_freq, + py::arg("freq"), + py::arg("name"), + py::arg("chan") = 0, + D(usrp_source, set_lo_freq)) + + + .def("get_lo_freq", + &usrp_source::get_lo_freq, + py::arg("name"), + py::arg("chan") = 0, + D(usrp_source, get_lo_freq)) + + + .def("get_lo_freq_range", + &usrp_source::get_lo_freq_range, + py::arg("name"), + py::arg("chan") = 0, + D(usrp_source, get_lo_freq_range)) + + + .def("set_auto_dc_offset", + &usrp_source::set_auto_dc_offset, + py::arg("enb"), + py::arg("chan") = 0, + D(usrp_source, set_auto_dc_offset)) + + + .def("set_dc_offset", + &usrp_source::set_dc_offset, + py::arg("offset"), + py::arg("chan") = 0, + D(usrp_source, set_dc_offset)) + + + .def("set_auto_iq_balance", + &usrp_source::set_auto_iq_balance, + py::arg("enb"), + py::arg("chan") = 0, + D(usrp_source, set_auto_iq_balance)) + + + .def("set_iq_balance", + &usrp_source::set_iq_balance, + py::arg("correction"), + py::arg("chan") = 0, + D(usrp_source, set_iq_balance)) + + + .def("set_rx_agc", + &usrp_source::set_rx_agc, + py::arg("enable"), + py::arg("chan") = 0, + D(usrp_source, set_rx_agc)) + + + .def("finite_acquisition", + &usrp_source::finite_acquisition, + py::arg("nsamps"), + D(usrp_source, finite_acquisition)) + + + .def("finite_acquisition_v", + &usrp_source::finite_acquisition_v, + py::arg("nsamps"), + D(usrp_source, finite_acquisition_v)) + + ; +} diff --git a/gr-uhd/python/uhd/qa_uhd.py b/gr-uhd/python/uhd/qa_uhd.py index f36a6e9f1d..a954a2233b 100644 --- a/gr-uhd/python/uhd/qa_uhd.py +++ b/gr-uhd/python/uhd/qa_uhd.py @@ -37,6 +37,8 @@ class test_uhd(gr_unittest.TestCase): """ Try to manipulate the stream args channels for proper swig'ing checks. """ + # FIXME: stream_args_t.channels.append does not work due to copy operation of STL vectors + # Needs to either change API, remove QA test, or somehow remap append() sa = uhd.stream_args_t() sa.channels.append(1) sa.channels.append(0) diff --git a/gr-uhd/swig/CMakeLists.txt b/gr-uhd/swig/CMakeLists.txt deleted file mode 100644 index e4decbdef1..0000000000 --- a/gr-uhd/swig/CMakeLists.txt +++ /dev/null @@ -1,40 +0,0 @@ -# Copyright 2011,2019 Free Software Foundation, Inc. -# -# This file is part of GNU Radio -# -# SPDX-License-Identifier: GPL-3.0-or-later -# - -######################################################################## -# Setup swig generation -######################################################################## -include(GrPython) -include(GrSwig) - -set(GR_SWIG_FLAGS -DGR_HAVE_UHD) #needed to parse uhd_swig.i -if(ENABLE_UHD_RFNOC) - set(GR_SWIG_FLAGS ${GR_SWIG_FLAGS} -DGR_HAVE_RFNOC) -endif(ENABLE_UHD_RFNOC) - -set(GR_SWIG_INCLUDE_DIRS $<TARGET_PROPERTY:runtime_swig,INCLUDE_DIRECTORIES>) -set(GR_SWIG_TARGET_DEPS runtime_swig) - -set(GR_SWIG_DOC_FILE ${CMAKE_CURRENT_BINARY_DIR}/uhd_swig_doc.i) -set(GR_SWIG_DOC_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/../include/gnuradio/uhd) -set(GR_SWIG_DOCS_TARGET_DEPS runtime_swig_swig_doc) - -link_directories(${UHD_LIBRARY_DIRS}) -set(GR_SWIG_LIBRARIES gnuradio-uhd ${UHD_LIBRARIES}) - -GR_SWIG_MAKE(uhd_swig uhd_swig.i) - -GR_SWIG_INSTALL( - TARGETS uhd_swig - DESTINATION ${GR_PYTHON_DIR}/gnuradio/uhd -) - -install( - FILES uhd_swig.i - ${CMAKE_CURRENT_BINARY_DIR}/uhd_swig_doc.i - DESTINATION ${GR_INCLUDE_DIR}/gnuradio/swig -) diff --git a/gr-uhd/swig/uhd_swig.i b/gr-uhd/swig/uhd_swig.i deleted file mode 100644 index c97512326d..0000000000 --- a/gr-uhd/swig/uhd_swig.i +++ /dev/null @@ -1,281 +0,0 @@ -/* -*- c++ -*- */ -/* - * Copyright 2010-2014 Free Software Foundation, Inc. - * - * This file is part of GNU Radio - * - * SPDX-License-Identifier: GPL-3.0-or-later - * - */ - -// Defined during configure; avoids trying to locate -// header files if UHD was not installed. -#ifdef GR_HAVE_UHD - -#define GR_UHD_API - -#include <uhd/version.hpp> - -//suppress 319. No access specifier given for base class name (ignored). -#pragma SWIG nowarn=319 - -//////////////////////////////////////////////////////////////////////// -// standard includes -//////////////////////////////////////////////////////////////////////// - -%include <std_vector.i> -%include "gnuradio.i" - -//load generated python docstrings -%include "uhd_swig_doc.i" - -//////////////////////////////////////////////////////////////////////// -// SWIG should not see the uhd::usrp::multi_usrp class -//////////////////////////////////////////////////////////////////////// -%ignore gr::uhd::usrp_sink::get_device; -%ignore gr::uhd::usrp_source::get_device; - -#ifdef GR_HAVE_RFNOC -%ignore gr::uhd::rfnoc_graph::create_rx_streamer; -%ignore gr::uhd::rfnoc_graph::create_tx_streamer; -%ignore gr::uhd::rfnoc_graph::get_block_ref; -%ignore gr::uhd::rfnoc_block::get_block_ref; -%ignore gr::uhd::rfnoc_block::make_block_ref; -#endif - -//////////////////////////////////////////////////////////////////////// -// block headers -//////////////////////////////////////////////////////////////////////// -%{ -#include <gnuradio/uhd/usrp_source.h> -#include <gnuradio/uhd/usrp_sink.h> -#include <gnuradio/uhd/amsg_source.h> -%} - -#ifdef GR_HAVE_RFNOC -%{ -#include <gnuradio/uhd/rfnoc_block.h> -#include <gnuradio/uhd/rfnoc_graph.h> -#include <gnuradio/uhd/rfnoc_tx_streamer.h> -#include <gnuradio/uhd/rfnoc_rx_streamer.h> -#include <gnuradio/uhd/rfnoc_block_generic.h> -#include <gnuradio/uhd/rfnoc_ddc.h> -#include <gnuradio/uhd/rfnoc_duc.h> -#include <gnuradio/uhd/rfnoc_rx_radio.h> -#include <gnuradio/uhd/rfnoc_tx_radio.h> -%} -#endif - -%include "gnuradio/uhd/usrp_block.h" - -//////////////////////////////////////////////////////////////////////// -// used types -//////////////////////////////////////////////////////////////////////// - -%template(uhd_string_vector_t) std::vector<std::string>; - -%template(uhd_size_vector_t) std::vector<size_t>; - -%include <uhd/config.hpp> - -%include <uhd/utils/pimpl.hpp> - -%ignore uhd::dict::operator[]; //ignore warnings about %extend -%include <uhd/types/dict.hpp> -%template(string_string_dict_t) uhd::dict<std::string, std::string>; //define after dict - -%extend uhd::dict<std::string, std::string>{ - std::string __getitem__(std::string key) {return (*self)[key];} - void __setitem__(std::string key, std::string val) {(*self)[key] = val;} -}; - -%include <uhd/types/device_addr.hpp> - -%template(range_vector_t) std::vector<uhd::range_t>; //define before range -%include <uhd/types/ranges.hpp> - -%include <uhd/types/tune_request.hpp> - -%include <uhd/types/tune_result.hpp> - -%include <uhd/types/time_spec.hpp> - -%extend uhd::time_spec_t{ - uhd::time_spec_t __add__(const uhd::time_spec_t &what) - { - uhd::time_spec_t temp = *self; - temp += what; - return temp; - } - uhd::time_spec_t __sub__(const uhd::time_spec_t &what) - { - uhd::time_spec_t temp = *self; - temp -= what; - return temp; - } - bool __eq__(const uhd::time_spec_t &what) - { - return (what == *self); - } -}; - -%include <uhd/types/stream_cmd.hpp> - -%include <uhd/types/metadata.hpp> - -%template(device_addr_vector_t) std::vector<uhd::device_addr_t>; - -%include <uhd/types/sensors.hpp> - -%include <uhd/stream.hpp> - -%include <uhd/types/filters.hpp> - -%include stdint.i - -// Used for lists of filter taps -%template(uhd_vector_int16_t) std::vector<int16_t>; - -//////////////////////////////////////////////////////////////////////// -// swig dboard_iface for python access -//////////////////////////////////////////////////////////////////////// -%include <uhd/types/serial.hpp> -%include <uhd/usrp/dboard_iface.hpp> - -#if UHD_VERSION < 4000000 - -%template(filter_info_base_sptr) std::shared_ptr<uhd::filter_info_base>; -%template(analog_filter_base_stpr) std::shared_ptr<uhd::analog_filter_base>; -%template(analog_filter_lp_stpr) std::shared_ptr<uhd::analog_filter_lp>; -%template(digital_filter_base_int16_t_sptr) std::shared_ptr<uhd::digital_filter_base<int16_t>>; -%template(digital_filter_fir_int16_t_sptr) std::shared_ptr<uhd::digital_filter_fir<int16_t>>; - -%extend uhd::filter_info_base{ - std::shared_ptr<uhd::analog_filter_base> to_analog_info_base(std::shared_ptr<uhd::filter_info_base> ptr) { - return std::dynamic_pointer_cast<uhd::analog_filter_base>(ptr); - } - - std::shared_ptr<uhd::analog_filter_lp> to_analog_filter_lp(std::shared_ptr<uhd::filter_info_base> ptr) { - return std::dynamic_pointer_cast<uhd::analog_filter_lp>(ptr); - } - - std::shared_ptr<uhd::digital_filter_base<int16_t>> to_digital_filter_base_int16(std::shared_ptr<uhd::filter_info_base> ptr) { - return std::dynamic_pointer_cast<uhd::digital_filter_base<int16_t>>(ptr); - } - - std::shared_ptr<uhd::digital_filter_fir<int16_t>> to_digital_filter_fir_int16(std::shared_ptr<uhd::filter_info_base> ptr) { - return std::dynamic_pointer_cast<uhd::digital_filter_fir<int16_t>>(ptr); - } -} - -%template(dboard_iface_sptr) std::shared_ptr<uhd::usrp::dboard_iface>; - -#else - -%template(filter_info_base_sptr) std::shared_ptr<uhd::filter_info_base>; -%template(analog_filter_base_stpr) std::shared_ptr<uhd::analog_filter_base>; -%template(analog_filter_lp_stpr) std::shared_ptr<uhd::analog_filter_lp>; -%template(digital_filter_base_int16_t_sptr) std::shared_ptr<uhd::digital_filter_base<int16_t>>; -%template(digital_filter_fir_int16_t_sptr) std::shared_ptr<uhd::digital_filter_fir<int16_t>>; - -%extend uhd::filter_info_base{ - std::shared_ptr<uhd::analog_filter_base> to_analog_info_base(std::shared_ptr<uhd::filter_info_base> ptr) { - return std::dynamic_pointer_cast<uhd::analog_filter_base>(ptr); - } - - std::shared_ptr<uhd::analog_filter_lp> to_analog_filter_lp(std::shared_ptr<uhd::filter_info_base> ptr) { - return std::dynamic_pointer_cast<uhd::analog_filter_lp>(ptr); - } - - std::shared_ptr<uhd::digital_filter_base<int16_t>> to_digital_filter_base_int16(std::shared_ptr<uhd::filter_info_base> ptr) { - return std::dynamic_pointer_cast<uhd::digital_filter_base<int16_t>>(ptr); - } - - std::shared_ptr<uhd::digital_filter_fir<int16_t>> to_digital_filter_fir_int16(std::shared_ptr<uhd::filter_info_base> ptr) { - return std::dynamic_pointer_cast<uhd::digital_filter_fir<int16_t>>(ptr); - } - -%template(dboard_iface_sptr) std::shared_ptr<uhd::usrp::dboard_iface>; - -} - -#endif - -//////////////////////////////////////////////////////////////////////// -// block magic -//////////////////////////////////////////////////////////////////////// -%include <gnuradio/uhd/usrp_source.h> -%include <gnuradio/uhd/usrp_sink.h> -%include <gnuradio/uhd/amsg_source.h> - -#ifdef GR_HAVE_RFNOC -%include <gnuradio/uhd/rfnoc_graph.h> -%include <gnuradio/uhd/rfnoc_block.h> -%include <gnuradio/uhd/rfnoc_tx_streamer.h> -%include <gnuradio/uhd/rfnoc_rx_streamer.h> -%include <gnuradio/uhd/rfnoc_block_generic.h> -%include <gnuradio/uhd/rfnoc_ddc.h> -%include <gnuradio/uhd/rfnoc_duc.h> -%include <gnuradio/uhd/rfnoc_rx_radio.h> -%include <gnuradio/uhd/rfnoc_tx_radio.h> -#endif - -GR_SWIG_BLOCK_MAGIC2(uhd, usrp_source) -GR_SWIG_BLOCK_MAGIC2(uhd, usrp_sink) -GR_SWIG_BLOCK_MAGIC2(uhd, amsg_source) - -#ifdef GR_HAVE_RFNOC -GR_SWIG_BLOCK_MAGIC2(uhd, rfnoc_graph) -GR_SWIG_BLOCK_MAGIC2(uhd, rfnoc_tx_streamer); -GR_SWIG_BLOCK_MAGIC2(uhd, rfnoc_rx_streamer); -GR_SWIG_BLOCK_MAGIC2(uhd, rfnoc_block_generic); -GR_SWIG_BLOCK_MAGIC2(uhd, rfnoc_ddc); -GR_SWIG_BLOCK_MAGIC2(uhd, rfnoc_duc); -GR_SWIG_BLOCK_MAGIC2(uhd, rfnoc_rx_radio); -GR_SWIG_BLOCK_MAGIC2(uhd, rfnoc_tx_radio); -#endif - - -//////////////////////////////////////////////////////////////////////// -// device discovery (no need to %include device.hpp) -//////////////////////////////////////////////////////////////////////// -%{ -static uhd::device_addrs_t find_devices_raw( - const uhd::device_addr_t &dev_addr = uhd::device_addr_t()) -{ - return uhd::device::find(dev_addr); -} -%} - -static uhd::device_addrs_t find_devices_raw( - const uhd::device_addr_t &dev_addr = uhd::device_addr_t()); - -//////////////////////////////////////////////////////////////////////// -// helpful constants -//////////////////////////////////////////////////////////////////////// -%{ -static const size_t ALL_MBOARDS = uhd::usrp::multi_usrp::ALL_MBOARDS; -static const size_t ALL_CHANS = uhd::usrp::multi_usrp::ALL_CHANS; -static const std::string ALL_GAINS = uhd::usrp::multi_usrp::ALL_GAINS; - -#ifdef UHD_USRP_MULTI_USRP_LO_CONFIG_API -static const std::string ALL_LOS = uhd::usrp::multi_usrp::ALL_LOS; -#else -static const std::string ALL_LOS; -#endif -%} - -static const size_t ALL_MBOARDS; -static const size_t ALL_CHANS; -static const std::string ALL_GAINS; -static const std::string ALL_LOS; - -%{ -#include <uhd/version.hpp> -std::string get_version_string(void){ - return uhd::get_version_string(); -} -%} -std::string get_version_string(void); - -#endif /* GR_HAVE_UHD */ |