diff options
187 files changed, 8447 insertions, 154 deletions
diff --git a/gr-digital/python/digital/CMakeLists.txt b/gr-digital/python/digital/CMakeLists.txt index 2391bbe83d..b425e4dc72 100644 --- a/gr-digital/python/digital/CMakeLists.txt +++ b/gr-digital/python/digital/CMakeLists.txt @@ -51,14 +51,7 @@ if(ENABLE_TESTING) set(GR_TEST_TARGET_DEPS "") set(GR_TEST_LIBRARY_DIRS "") set(GR_TEST_PYTHON_DIRS - ${CMAKE_BINARY_DIR}/gnuradio-runtime/python - ${CMAKE_BINARY_DIR}/gnuradio-runtime/swig - ${CMAKE_BINARY_DIR}/gr-blocks/swig - ${CMAKE_BINARY_DIR}/gr-filter/swig - ${CMAKE_BINARY_DIR}/gr-channels/swig - ${CMAKE_BINARY_DIR}/gr-digital/swig - ${CMAKE_BINARY_DIR}/gr-fft/swig - ${CMAKE_BINARY_DIR}/gr-analog/swig + ${CMAKE_BINARY_DIR}/gnuradio-runtime/python ) include(GrTest) @@ -68,3 +61,5 @@ if(ENABLE_TESTING) 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-digital/python/digital/__init__.py b/gr-digital/python/digital/__init__.py index 9c29fd9f93..32dd062824 100644 --- a/gr-digital/python/digital/__init__.py +++ b/gr-digital/python/digital/__init__.py @@ -18,11 +18,16 @@ from __future__ import unicode_literals import os try: - from .digital_swig import * + from .digital_python import * except ImportError: dirname, filename = os.path.split(os.path.abspath(__file__)) - __path__.append(os.path.join(dirname, "..", "..", "swig")) - from .digital_swig import * + __path__.append(os.path.join(dirname, "bindings")) + from .digital_python import * + +from gnuradio import analog # just need analog for the enum +class gmskmod_bc(cpmmod_bc): + def __init__(self, samples_per_sym = 2, L = 4, beta = 0.3): + cpmmod_bc.__init__(self, analog.cpm.GAUSSIAN, 0.5, samples_per_sym, L, beta) from .psk import * from .qam import * diff --git a/gr-digital/python/digital/bindings/CMakeLists.txt b/gr-digital/python/digital/bindings/CMakeLists.txt new file mode 100644 index 0000000000..1afdaecb66 --- /dev/null +++ b/gr-digital/python/digital/bindings/CMakeLists.txt @@ -0,0 +1,94 @@ +include(GrPybind) + +######################################################################## +# Python Bindings +######################################################################## + +list(APPEND digital_python_files + additive_scrambler_bb_python.cc + binary_slicer_fb_python.cc + burst_shaper_python.cc + chunks_to_symbols_python.cc + clock_recovery_mm_cc_python.cc + clock_recovery_mm_ff_python.cc + cma_equalizer_cc_python.cc + constellation_python.cc + constellation_decoder_cb_python.cc + constellation_receiver_cb_python.cc + constellation_soft_decoder_cf_python.cc + corr_est_cc_python.cc + correlate_access_code_bb_python.cc + correlate_access_code_bb_ts_python.cc + correlate_access_code_ff_ts_python.cc + correlate_access_code_tag_bb_python.cc + correlate_access_code_tag_ff_python.cc + costas_loop_cc_python.cc + cpmmod_bc_python.cc + crc32_python.cc + crc32_async_bb_python.cc + crc32_bb_python.cc + descrambler_bb_python.cc + diff_decoder_bb_python.cc + diff_encoder_bb_python.cc + diff_phasor_cc_python.cc + fll_band_edge_cc_python.cc + framer_sink_1_python.cc + glfsr_python.cc + glfsr_source_b_python.cc + glfsr_source_f_python.cc + hdlc_deframer_bp_python.cc + hdlc_framer_pb_python.cc + header_buffer_python.cc + header_format_base_python.cc + header_format_counter_python.cc + header_format_crc_python.cc + header_format_default_python.cc + header_format_ofdm_python.cc + header_payload_demux_python.cc + interpolating_resampler_type_python.cc + kurtotic_equalizer_cc_python.cc + lfsr_python.cc + lms_dd_equalizer_cc_python.cc + map_bb_python.cc + metric_type_python.cc + # modulate_vector_python.cc + mpsk_snr_est_python.cc + mpsk_snr_est_cc_python.cc + msk_timing_recovery_cc_python.cc + ofdm_carrier_allocator_cvc_python.cc + ofdm_chanest_vcvc_python.cc + ofdm_cyclic_prefixer_python.cc + ofdm_equalizer_base_python.cc + ofdm_equalizer_simpledfe_python.cc + ofdm_equalizer_static_python.cc + ofdm_frame_equalizer_vcvc_python.cc + ofdm_serializer_vcc_python.cc + ofdm_sync_sc_cfb_python.cc + packet_header_default_python.cc + packet_header_ofdm_python.cc + packet_headergenerator_bb_python.cc + packet_headerparser_b_python.cc + packet_sink_python.cc + pfb_clock_sync_ccf_python.cc + pfb_clock_sync_fff_python.cc + pn_correlator_cc_python.cc + probe_density_b_python.cc + probe_mpsk_snr_est_c_python.cc + protocol_formatter_async_python.cc + protocol_formatter_bb_python.cc + protocol_parser_b_python.cc + scrambler_bb_python.cc + simple_correlator_python.cc + simple_framer_python.cc + simple_framer_sync_python.cc + symbol_sync_cc_python.cc + symbol_sync_ff_python.cc + timing_error_detector_type_python.cc + python_bindings.cc) + +GR_PYBIND_MAKE(digital + ../../.. + gr::digital + "${digital_python_files}") + +install(TARGETS digital_python DESTINATION ${GR_PYTHON_DIR}/gnuradio/digital COMPONENT pythonapi) diff --git a/gr-digital/python/digital/bindings/additive_scrambler_bb_python.cc b/gr-digital/python/digital/bindings/additive_scrambler_bb_python.cc new file mode 100644 index 0000000000..8af93a7f66 --- /dev/null +++ b/gr-digital/python/digital/bindings/additive_scrambler_bb_python.cc @@ -0,0 +1,62 @@ +/* + * 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/digital/additive_scrambler_bb.h> +// pydoc.h is automatically generated in the build directory +#include <additive_scrambler_bb_pydoc.h> + +void bind_additive_scrambler_bb(py::module& m) +{ + + using additive_scrambler_bb = ::gr::digital::additive_scrambler_bb; + + + py::class_<additive_scrambler_bb, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<additive_scrambler_bb>>( + m, "additive_scrambler_bb", D(additive_scrambler_bb)) + + .def(py::init(&additive_scrambler_bb::make), + py::arg("mask"), + py::arg("seed"), + py::arg("len"), + py::arg("count") = 0, + py::arg("bits_per_byte") = 1, + py::arg("reset_tag_key") = "", + D(additive_scrambler_bb, make)) + + + .def("mask", &additive_scrambler_bb::mask, D(additive_scrambler_bb, mask)) + + + .def("seed", &additive_scrambler_bb::seed, D(additive_scrambler_bb, seed)) + + + .def("len", &additive_scrambler_bb::len, D(additive_scrambler_bb, len)) + + + .def("count", &additive_scrambler_bb::count, D(additive_scrambler_bb, count)) + + + .def("bits_per_byte", + &additive_scrambler_bb::bits_per_byte, + D(additive_scrambler_bb, bits_per_byte)) + + ; +} diff --git a/gr-digital/python/digital/bindings/binary_slicer_fb_python.cc b/gr-digital/python/digital/bindings/binary_slicer_fb_python.cc new file mode 100644 index 0000000000..72e691eca4 --- /dev/null +++ b/gr-digital/python/digital/bindings/binary_slicer_fb_python.cc @@ -0,0 +1,39 @@ +/* + * 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/digital/binary_slicer_fb.h> +// pydoc.h is automatically generated in the build directory +#include <binary_slicer_fb_pydoc.h> + +void bind_binary_slicer_fb(py::module& m) +{ + + using binary_slicer_fb = ::gr::digital::binary_slicer_fb; + + + py::class_<binary_slicer_fb, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<binary_slicer_fb>>( + m, "binary_slicer_fb", D(binary_slicer_fb)) + + .def(py::init(&binary_slicer_fb::make), D(binary_slicer_fb, make)) + + + ; +} diff --git a/gr-digital/python/digital/bindings/burst_shaper_python.cc b/gr-digital/python/digital/bindings/burst_shaper_python.cc new file mode 100644 index 0000000000..c514c85f3b --- /dev/null +++ b/gr-digital/python/digital/bindings/burst_shaper_python.cc @@ -0,0 +1,44 @@ +/* + * 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/digital/burst_shaper.h> + +template <typename T> +void bind_burst_shaper_template(py::module& m, const char* classname) +{ + using burst_shaper = gr::digital::burst_shaper<T>; + + py::class_<burst_shaper, gr::block, gr::basic_block, std::shared_ptr<burst_shaper>>( + m, classname) + .def(py::init(&gr::digital::burst_shaper<T>::make), + py::arg("taps"), + py::arg("pre_padding") = 0, + py::arg("post_padding") = 0, + py::arg("insert_phasing") = false, + py::arg("length_tag_name") = "packet_len") + + .def("pre_padding", &burst_shaper::pre_padding) + .def("post_padding", &burst_shaper::post_padding) + .def("prefix_length", &burst_shaper::prefix_length) + .def("suffix_length", &burst_shaper::suffix_length); +} + +void bind_burst_shaper(py::module& m) +{ + bind_burst_shaper_template<float>(m, "burst_shaper_ff"); + bind_burst_shaper_template<gr_complex>(m, "burst_shaper_cc"); +} diff --git a/gr-digital/python/digital/bindings/chunks_to_symbols_python.cc b/gr-digital/python/digital/bindings/chunks_to_symbols_python.cc new file mode 100644 index 0000000000..9d01a9dfac --- /dev/null +++ b/gr-digital/python/digital/bindings/chunks_to_symbols_python.cc @@ -0,0 +1,50 @@ +/* + * 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/digital/chunks_to_symbols.h> + +template <class IN_T, class OUT_T> +void bind_chunks_to_symbols_template(py::module& m, const char* classname) +{ + using chunks_to_symbols = gr::digital::chunks_to_symbols<IN_T, OUT_T>; + + py::class_<chunks_to_symbols, + gr::sync_interpolator, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<chunks_to_symbols>>(m, classname) + .def(py::init(&gr::digital::chunks_to_symbols<IN_T, OUT_T>::make), + py::arg("symbol_table"), + py::arg("D") = 1) + + .def("set_symbol_table", + &chunks_to_symbols::set_symbol_table, + py::arg("symbol_table")) + .def("symbol_table", &chunks_to_symbols::symbol_table) + .def("D", &chunks_to_symbols::D); +} + +void bind_chunks_to_symbols(py::module& m) +{ + bind_chunks_to_symbols_template<std::uint8_t, float>(m, "chunks_to_symbols_bf"); + bind_chunks_to_symbols_template<std::uint8_t, gr_complex>(m, "chunks_to_symbols_bc"); + bind_chunks_to_symbols_template<std::int16_t, float>(m, "chunks_to_symbols_sf"); + bind_chunks_to_symbols_template<std::int16_t, gr_complex>(m, "chunks_to_symbols_sc"); + bind_chunks_to_symbols_template<std::int32_t, float>(m, "chunks_to_symbols_if"); + bind_chunks_to_symbols_template<std::int32_t, gr_complex>(m, "chunks_to_symbols_ic"); +} diff --git a/gr-digital/python/digital/bindings/clock_recovery_mm_cc_python.cc b/gr-digital/python/digital/bindings/clock_recovery_mm_cc_python.cc new file mode 100644 index 0000000000..7be3501c57 --- /dev/null +++ b/gr-digital/python/digital/bindings/clock_recovery_mm_cc_python.cc @@ -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 + * + */ + +/* This file is automatically generated using bindtool */ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/digital/clock_recovery_mm_cc.h> +// pydoc.h is automatically generated in the build directory +#include <clock_recovery_mm_cc_pydoc.h> + +void bind_clock_recovery_mm_cc(py::module& m) +{ + + using clock_recovery_mm_cc = ::gr::digital::clock_recovery_mm_cc; + + + py::class_<clock_recovery_mm_cc, + gr::block, + gr::basic_block, + std::shared_ptr<clock_recovery_mm_cc>>( + m, "clock_recovery_mm_cc", D(clock_recovery_mm_cc)) + + .def(py::init(&clock_recovery_mm_cc::make), + py::arg("omega"), + py::arg("gain_omega"), + py::arg("mu"), + py::arg("gain_mu"), + py::arg("omega_relative_limit"), + D(clock_recovery_mm_cc, make)) + + + .def("mu", &clock_recovery_mm_cc::mu, D(clock_recovery_mm_cc, mu)) + + + .def("omega", &clock_recovery_mm_cc::omega, D(clock_recovery_mm_cc, omega)) + + + .def("gain_mu", &clock_recovery_mm_cc::gain_mu, D(clock_recovery_mm_cc, gain_mu)) + + + .def("gain_omega", + &clock_recovery_mm_cc::gain_omega, + D(clock_recovery_mm_cc, gain_omega)) + + + .def("set_verbose", + &clock_recovery_mm_cc::set_verbose, + py::arg("verbose"), + D(clock_recovery_mm_cc, set_verbose)) + + + .def("set_gain_mu", + &clock_recovery_mm_cc::set_gain_mu, + py::arg("gain_mu"), + D(clock_recovery_mm_cc, set_gain_mu)) + + + .def("set_gain_omega", + &clock_recovery_mm_cc::set_gain_omega, + py::arg("gain_omega"), + D(clock_recovery_mm_cc, set_gain_omega)) + + + .def("set_mu", + &clock_recovery_mm_cc::set_mu, + py::arg("mu"), + D(clock_recovery_mm_cc, set_mu)) + + + .def("set_omega", + &clock_recovery_mm_cc::set_omega, + py::arg("omega"), + D(clock_recovery_mm_cc, set_omega)) + + ; +} diff --git a/gr-digital/python/digital/bindings/clock_recovery_mm_ff_python.cc b/gr-digital/python/digital/bindings/clock_recovery_mm_ff_python.cc new file mode 100644 index 0000000000..ea0e80db4a --- /dev/null +++ b/gr-digital/python/digital/bindings/clock_recovery_mm_ff_python.cc @@ -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 + * + */ + +/* This file is automatically generated using bindtool */ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/digital/clock_recovery_mm_ff.h> +// pydoc.h is automatically generated in the build directory +#include <clock_recovery_mm_ff_pydoc.h> + +void bind_clock_recovery_mm_ff(py::module& m) +{ + + using clock_recovery_mm_ff = ::gr::digital::clock_recovery_mm_ff; + + + py::class_<clock_recovery_mm_ff, + gr::block, + gr::basic_block, + std::shared_ptr<clock_recovery_mm_ff>>( + m, "clock_recovery_mm_ff", D(clock_recovery_mm_ff)) + + .def(py::init(&clock_recovery_mm_ff::make), + py::arg("omega"), + py::arg("gain_omega"), + py::arg("mu"), + py::arg("gain_mu"), + py::arg("omega_relative_limit"), + D(clock_recovery_mm_ff, make)) + + + .def("mu", &clock_recovery_mm_ff::mu, D(clock_recovery_mm_ff, mu)) + + + .def("omega", &clock_recovery_mm_ff::omega, D(clock_recovery_mm_ff, omega)) + + + .def("gain_mu", &clock_recovery_mm_ff::gain_mu, D(clock_recovery_mm_ff, gain_mu)) + + + .def("gain_omega", + &clock_recovery_mm_ff::gain_omega, + D(clock_recovery_mm_ff, gain_omega)) + + + .def("set_verbose", + &clock_recovery_mm_ff::set_verbose, + py::arg("verbose"), + D(clock_recovery_mm_ff, set_verbose)) + + + .def("set_gain_mu", + &clock_recovery_mm_ff::set_gain_mu, + py::arg("gain_mu"), + D(clock_recovery_mm_ff, set_gain_mu)) + + + .def("set_gain_omega", + &clock_recovery_mm_ff::set_gain_omega, + py::arg("gain_omega"), + D(clock_recovery_mm_ff, set_gain_omega)) + + + .def("set_mu", + &clock_recovery_mm_ff::set_mu, + py::arg("mu"), + D(clock_recovery_mm_ff, set_mu)) + + + .def("set_omega", + &clock_recovery_mm_ff::set_omega, + py::arg("omega"), + D(clock_recovery_mm_ff, set_omega)) + + ; +} diff --git a/gr-digital/python/digital/bindings/cma_equalizer_cc_python.cc b/gr-digital/python/digital/bindings/cma_equalizer_cc_python.cc new file mode 100644 index 0000000000..025329c417 --- /dev/null +++ b/gr-digital/python/digital/bindings/cma_equalizer_cc_python.cc @@ -0,0 +1,71 @@ +/* + * 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/digital/cma_equalizer_cc.h> +// pydoc.h is automatically generated in the build directory +#include <cma_equalizer_cc_pydoc.h> + +void bind_cma_equalizer_cc(py::module& m) +{ + + using cma_equalizer_cc = ::gr::digital::cma_equalizer_cc; + + + py::class_<cma_equalizer_cc, + gr::sync_decimator, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<cma_equalizer_cc>>( + m, "cma_equalizer_cc", D(cma_equalizer_cc)) + + .def(py::init(&cma_equalizer_cc::make), + py::arg("num_taps"), + py::arg("modulus"), + py::arg("mu"), + py::arg("sps"), + D(cma_equalizer_cc, make)) + + + .def("set_taps", + &cma_equalizer_cc::set_taps, + py::arg("taps"), + D(cma_equalizer_cc, set_taps)) + + + .def("taps", &cma_equalizer_cc::taps, D(cma_equalizer_cc, taps)) + + + .def("gain", &cma_equalizer_cc::gain, D(cma_equalizer_cc, gain)) + + + .def("set_gain", + &cma_equalizer_cc::set_gain, + py::arg("mu"), + D(cma_equalizer_cc, set_gain)) + + + .def("modulus", &cma_equalizer_cc::modulus, D(cma_equalizer_cc, modulus)) + + + .def("set_modulus", + &cma_equalizer_cc::set_modulus, + py::arg("mod"), + D(cma_equalizer_cc, set_modulus)) + + ; +} diff --git a/gr-digital/python/digital/bindings/constellation_decoder_cb_python.cc b/gr-digital/python/digital/bindings/constellation_decoder_cb_python.cc new file mode 100644 index 0000000000..0fa1b0dd2d --- /dev/null +++ b/gr-digital/python/digital/bindings/constellation_decoder_cb_python.cc @@ -0,0 +1,40 @@ +/* + * 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/digital/constellation_decoder_cb.h> +// pydoc.h is automatically generated in the build directory +#include <constellation_decoder_cb_pydoc.h> + +void bind_constellation_decoder_cb(py::module& m) +{ + + using constellation_decoder_cb = ::gr::digital::constellation_decoder_cb; + + + py::class_<constellation_decoder_cb, + gr::block, + gr::basic_block, + std::shared_ptr<constellation_decoder_cb>>( + m, "constellation_decoder_cb", D(constellation_decoder_cb)) + + .def(py::init(&constellation_decoder_cb::make), + py::arg("constellation"), + D(constellation_decoder_cb, make)) + + + ; +} diff --git a/gr-digital/python/digital/bindings/constellation_python.cc b/gr-digital/python/digital/bindings/constellation_python.cc new file mode 100644 index 0000000000..c85c45950f --- /dev/null +++ b/gr-digital/python/digital/bindings/constellation_python.cc @@ -0,0 +1,395 @@ +/* + * 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/digital/constellation.h> +// pydoc.h is automatically generated in the build directory +#include <constellation_pydoc.h> + +void bind_constellation(py::module& m) +{ + + using constellation = ::gr::digital::constellation; + using constellation_calcdist = ::gr::digital::constellation_calcdist; + using constellation_sector = ::gr::digital::constellation_sector; + using constellation_rect = ::gr::digital::constellation_rect; + using constellation_expl_rect = ::gr::digital::constellation_expl_rect; + using constellation_psk = ::gr::digital::constellation_psk; + using constellation_bpsk = ::gr::digital::constellation_bpsk; + using constellation_qpsk = ::gr::digital::constellation_qpsk; + using constellation_dqpsk = ::gr::digital::constellation_dqpsk; + using constellation_8psk = ::gr::digital::constellation_8psk; + using constellation_8psk_natural = ::gr::digital::constellation_8psk_natural; + using constellation_16qam = ::gr::digital::constellation_16qam; + + + py::class_<constellation, std::shared_ptr<constellation>>( + m, "constellation", D(constellation)) + + // .def(py::init<std::vector<std::complex<float>, + // std::allocator<std::complex<float> > >,std::vector<int, std::allocator<int> + // >,unsigned int,unsigned int,bool>(), py::arg("constell"), + // py::arg("pre_diff_code"), + // py::arg("rotational_symmetry"), + // py::arg("dimensionality"), + // py::arg("normalize_points") = true, + // D(constellation,constellation,0) + // ) + // .def(py::init<>(),D(constellation,constellation,1)) + // .def(py::init<gr::digital::constellation const &>(), py::arg("arg0"), + // D(constellation,constellation,2) + // ) + + + .def("map_to_points", + &constellation::map_to_points, + py::arg("value"), + py::arg("points"), + D(constellation, map_to_points)) + + + .def("map_to_points_v", + &constellation::map_to_points_v, + py::arg("value"), + D(constellation, map_to_points_v)) + + + .def("decision_maker", + &constellation::decision_maker, + py::arg("sample"), + D(constellation, decision_maker)) + + + .def("decision_maker_v", + &constellation::decision_maker_v, + py::arg("sample"), + D(constellation, decision_maker_v)) + + + .def("decision_maker_pe", + &constellation::decision_maker_pe, + py::arg("sample"), + py::arg("phase_error"), + D(constellation, decision_maker_pe)) + + + .def("calc_metric", + &constellation::calc_metric, + py::arg("sample"), + py::arg("metric"), + py::arg("type"), + D(constellation, calc_metric)) + + + .def("calc_euclidean_metric", + &constellation::calc_euclidean_metric, + py::arg("sample"), + py::arg("metric"), + D(constellation, calc_euclidean_metric)) + + + .def("calc_hard_symbol_metric", + &constellation::calc_hard_symbol_metric, + py::arg("sample"), + py::arg("metric"), + D(constellation, calc_hard_symbol_metric)) + + + .def("points", &constellation::points, D(constellation, points)) + + + .def("s_points", &constellation::s_points, D(constellation, s_points)) + + + .def("v_points", &constellation::v_points, D(constellation, v_points)) + + + .def("apply_pre_diff_code", + &constellation::apply_pre_diff_code, + D(constellation, apply_pre_diff_code)) + + + .def("set_pre_diff_code", + &constellation::set_pre_diff_code, + py::arg("a"), + D(constellation, set_pre_diff_code)) + + + .def("pre_diff_code", + &constellation::pre_diff_code, + D(constellation, pre_diff_code)) + + + .def("rotational_symmetry", + &constellation::rotational_symmetry, + D(constellation, rotational_symmetry)) + + + .def("dimensionality", + &constellation::dimensionality, + D(constellation, dimensionality)) + + + .def("bits_per_symbol", + &constellation::bits_per_symbol, + D(constellation, bits_per_symbol)) + + + .def("arity", &constellation::arity, D(constellation, arity)) + + + .def("base", &constellation::base, D(constellation, base)) + + + .def("as_pmt", &constellation::as_pmt, D(constellation, as_pmt)) + + + .def("gen_soft_dec_lut", + &constellation::gen_soft_dec_lut, + py::arg("precision"), + py::arg("npwr") = 1., + D(constellation, gen_soft_dec_lut)) + + + .def("calc_soft_dec", + &constellation::calc_soft_dec, + py::arg("sample"), + py::arg("npwr") = 1., + D(constellation, calc_soft_dec)) + + + .def("set_soft_dec_lut", + &constellation::set_soft_dec_lut, + py::arg("soft_dec_lut"), + py::arg("precision"), + D(constellation, set_soft_dec_lut)) + + + .def("has_soft_dec_lut", + &constellation::has_soft_dec_lut, + D(constellation, has_soft_dec_lut)) + + + .def("soft_dec_lut", &constellation::soft_dec_lut, D(constellation, soft_dec_lut)) + + + .def("soft_decision_maker", + &constellation::soft_decision_maker, + py::arg("sample"), + D(constellation, soft_decision_maker)) + + ; + + + py::class_<constellation_calcdist, + gr::digital::constellation, + std::shared_ptr<constellation_calcdist>>( + m, "constellation_calcdist", D(constellation_calcdist)) + + .def(py::init(&constellation_calcdist::make), + py::arg("constell"), + py::arg("pre_diff_code"), + py::arg("rotational_symmetry"), + py::arg("dimensionality"), + py::arg("normalize_points") = true, + D(constellation_calcdist, make)) + + + .def("decision_maker", + &constellation_calcdist::decision_maker, + py::arg("sample"), + D(constellation_calcdist, decision_maker)) + + ; + + + py::class_<constellation_sector, + gr::digital::constellation, + std::shared_ptr<constellation_sector>>( + m, "constellation_sector", D(constellation_sector)) + + // .def(py::init<std::vector<std::complex<float>, + // std::allocator<std::complex<float> > >,std::vector<int, std::allocator<int> + // >,unsigned int,unsigned int,unsigned int>(), py::arg("constell"), + // py::arg("pre_diff_code"), + // py::arg("rotational_symmetry"), + // py::arg("dimensionality"), + // py::arg("n_sectors"), + // D(constellation_sector,constellation_sector,0) + // ) + // .def(py::init<gr::digital::constellation_sector const &>(), py::arg("arg0"), + // D(constellation_sector,constellation_sector,1) + // ) + + + .def("decision_maker", + &constellation_sector::decision_maker, + py::arg("sample"), + D(constellation_sector, decision_maker)) + + ; + + + py::class_<constellation_rect, + gr::digital::constellation_sector, + std::shared_ptr<constellation_rect>>( + m, "constellation_rect", D(constellation_rect)) + + .def(py::init(&constellation_rect::make), + py::arg("constell"), + py::arg("pre_diff_code"), + py::arg("rotational_symmetry"), + py::arg("real_sectors"), + py::arg("imag_sectors"), + py::arg("width_real_sectors"), + py::arg("width_imag_sectors"), + D(constellation_rect, make)) + + + ; + + + py::class_<constellation_expl_rect, + gr::digital::constellation_rect, + std::shared_ptr<constellation_expl_rect>>( + m, "constellation_expl_rect", D(constellation_expl_rect)) + + .def(py::init(&constellation_expl_rect::make), + py::arg("constellation"), + py::arg("pre_diff_code"), + py::arg("rotational_symmetry"), + py::arg("real_sectors"), + py::arg("imag_sectors"), + py::arg("width_real_sectors"), + py::arg("width_imag_sectors"), + py::arg("sector_values"), + D(constellation_expl_rect, make)) + + + ; + + + py::class_<constellation_psk, + gr::digital::constellation_sector, + std::shared_ptr<constellation_psk>>( + m, "constellation_psk", D(constellation_psk)) + + .def(py::init(&constellation_psk::make), + py::arg("constell"), + py::arg("pre_diff_code"), + py::arg("n_sectors"), + D(constellation_psk, make)) + + + ; + + + py::class_<constellation_bpsk, + gr::digital::constellation, + std::shared_ptr<constellation_bpsk>>( + m, "constellation_bpsk", D(constellation_bpsk)) + + .def(py::init(&constellation_bpsk::make), D(constellation_bpsk, make)) + + + .def("decision_maker", + &constellation_bpsk::decision_maker, + py::arg("sample"), + D(constellation_bpsk, decision_maker)) + + ; + + + py::class_<constellation_qpsk, + gr::digital::constellation, + std::shared_ptr<constellation_qpsk>>( + m, "constellation_qpsk", D(constellation_qpsk)) + + .def(py::init(&constellation_qpsk::make), D(constellation_qpsk, make)) + + + .def("decision_maker", + &constellation_qpsk::decision_maker, + py::arg("sample"), + D(constellation_qpsk, decision_maker)) + + ; + + + py::class_<constellation_dqpsk, + gr::digital::constellation, + std::shared_ptr<constellation_dqpsk>>( + m, "constellation_dqpsk", D(constellation_dqpsk)) + + .def(py::init(&constellation_dqpsk::make), D(constellation_dqpsk, make)) + + + .def("decision_maker", + &constellation_dqpsk::decision_maker, + py::arg("sample"), + D(constellation_dqpsk, decision_maker)) + + ; + + + py::class_<constellation_8psk, + gr::digital::constellation, + std::shared_ptr<constellation_8psk>>( + m, "constellation_8psk", D(constellation_8psk)) + + .def(py::init(&constellation_8psk::make), D(constellation_8psk, make)) + + + .def("decision_maker", + &constellation_8psk::decision_maker, + py::arg("sample"), + D(constellation_8psk, decision_maker)) + + ; + + + py::class_<constellation_8psk_natural, + gr::digital::constellation, + std::shared_ptr<constellation_8psk_natural>>( + m, "constellation_8psk_natural", D(constellation_8psk_natural)) + + .def(py::init(&constellation_8psk_natural::make), + D(constellation_8psk_natural, make)) + + + .def("decision_maker", + &constellation_8psk_natural::decision_maker, + py::arg("sample"), + D(constellation_8psk_natural, decision_maker)) + + ; + + + py::class_<constellation_16qam, + gr::digital::constellation, + std::shared_ptr<constellation_16qam>>( + m, "constellation_16qam", D(constellation_16qam)) + + .def(py::init(&constellation_16qam::make), D(constellation_16qam, make)) + + + .def("decision_maker", + &constellation_16qam::decision_maker, + py::arg("sample"), + D(constellation_16qam, decision_maker)) + + ; +} diff --git a/gr-digital/python/digital/bindings/constellation_receiver_cb_python.cc b/gr-digital/python/digital/bindings/constellation_receiver_cb_python.cc new file mode 100644 index 0000000000..f33d31e04e --- /dev/null +++ b/gr-digital/python/digital/bindings/constellation_receiver_cb_python.cc @@ -0,0 +1,48 @@ +/* + * 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/digital/constellation_receiver_cb.h> +// pydoc.h is automatically generated in the build directory +#include <constellation_receiver_cb_pydoc.h> + +void bind_constellation_receiver_cb(py::module& m) +{ + + using constellation_receiver_cb = ::gr::digital::constellation_receiver_cb; + + + py::class_<constellation_receiver_cb, + gr::block, + gr::basic_block, + std::shared_ptr<constellation_receiver_cb>>( + m, "constellation_receiver_cb", D(constellation_receiver_cb)) + + .def(py::init(&constellation_receiver_cb::make), + py::arg("constellation"), + py::arg("loop_bw"), + py::arg("fmin"), + py::arg("fmax"), + D(constellation_receiver_cb, make)) + + + .def("phase_error_tracking", + &constellation_receiver_cb::phase_error_tracking, + py::arg("phase_error"), + D(constellation_receiver_cb, phase_error_tracking)) + + ; +} diff --git a/gr-digital/python/digital/bindings/constellation_soft_decoder_cf_python.cc b/gr-digital/python/digital/bindings/constellation_soft_decoder_cf_python.cc new file mode 100644 index 0000000000..3b086ee80d --- /dev/null +++ b/gr-digital/python/digital/bindings/constellation_soft_decoder_cf_python.cc @@ -0,0 +1,42 @@ +/* + * 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/digital/constellation_soft_decoder_cf.h> +// pydoc.h is automatically generated in the build directory +#include <constellation_soft_decoder_cf_pydoc.h> + +void bind_constellation_soft_decoder_cf(py::module& m) +{ + + using constellation_soft_decoder_cf = ::gr::digital::constellation_soft_decoder_cf; + + + py::class_<constellation_soft_decoder_cf, + gr::sync_interpolator, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<constellation_soft_decoder_cf>>( + m, "constellation_soft_decoder_cf", D(constellation_soft_decoder_cf)) + + .def(py::init(&constellation_soft_decoder_cf::make), + py::arg("constellation"), + D(constellation_soft_decoder_cf, make)) + + + ; +} diff --git a/gr-digital/python/digital/bindings/corr_est_cc_python.cc b/gr-digital/python/digital/bindings/corr_est_cc_python.cc new file mode 100644 index 0000000000..2f01f31e5d --- /dev/null +++ b/gr-digital/python/digital/bindings/corr_est_cc_python.cc @@ -0,0 +1,72 @@ +/* + * 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/digital/corr_est_cc.h> +// pydoc.h is automatically generated in the build directory +#include <corr_est_cc_pydoc.h> + +void bind_corr_est_cc(py::module& m) +{ + + using corr_est_cc = ::gr::digital::corr_est_cc; + + py::enum_<gr::digital::tm_type>(m, "tm_type") + .value("THRESHOLD_DYNAMIC", gr::digital::THRESHOLD_DYNAMIC) // 0 + .value("THRESHOLD_ABSOLUTE", gr::digital::THRESHOLD_ABSOLUTE) // 1 + .export_values(); + + py::class_<corr_est_cc, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<corr_est_cc>>(m, "corr_est_cc", D(corr_est_cc)) + + .def(py::init(&corr_est_cc::make), + py::arg("symbols"), + py::arg("sps"), + py::arg("mark_delay"), + py::arg("threshold") = 0.90000000000000002, + py::arg("threshold_method") = ::gr::digital::tm_type::THRESHOLD_ABSOLUTE, + D(corr_est_cc, make)) + + + .def("symbols", &corr_est_cc::symbols, D(corr_est_cc, symbols)) + + + .def("set_symbols", + &corr_est_cc::set_symbols, + py::arg("symbols"), + D(corr_est_cc, set_symbols)) + + + .def("mark_delay", &corr_est_cc::mark_delay, D(corr_est_cc, mark_delay)) + + + .def("set_mark_delay", + &corr_est_cc::set_mark_delay, + py::arg("mark_delay"), + D(corr_est_cc, set_mark_delay)) + + + .def("threshold", &corr_est_cc::threshold, D(corr_est_cc, threshold)) + + + .def("set_threshold", + &corr_est_cc::set_threshold, + py::arg("threshold"), + D(corr_est_cc, set_threshold)); +} diff --git a/gr-digital/python/digital/bindings/correlate_access_code_bb_python.cc b/gr-digital/python/digital/bindings/correlate_access_code_bb_python.cc new file mode 100644 index 0000000000..f0e776671e --- /dev/null +++ b/gr-digital/python/digital/bindings/correlate_access_code_bb_python.cc @@ -0,0 +1,47 @@ +/* + * 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/digital/correlate_access_code_bb.h> +// pydoc.h is automatically generated in the build directory +#include <correlate_access_code_bb_pydoc.h> + +void bind_correlate_access_code_bb(py::module& m) +{ + + using correlate_access_code_bb = ::gr::digital::correlate_access_code_bb; + + + py::class_<correlate_access_code_bb, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<correlate_access_code_bb>>( + m, "correlate_access_code_bb", D(correlate_access_code_bb)) + + .def(py::init(&correlate_access_code_bb::make), + py::arg("access_code"), + py::arg("threshold"), + D(correlate_access_code_bb, make)) + + + .def("set_access_code", + &correlate_access_code_bb::set_access_code, + py::arg("access_code"), + D(correlate_access_code_bb, set_access_code)) + + ; +} diff --git a/gr-digital/python/digital/bindings/correlate_access_code_bb_ts_python.cc b/gr-digital/python/digital/bindings/correlate_access_code_bb_ts_python.cc new file mode 100644 index 0000000000..da21cea4a8 --- /dev/null +++ b/gr-digital/python/digital/bindings/correlate_access_code_bb_ts_python.cc @@ -0,0 +1,52 @@ +/* + * 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/digital/correlate_access_code_bb_ts.h> +// pydoc.h is automatically generated in the build directory +#include <correlate_access_code_bb_ts_pydoc.h> + +void bind_correlate_access_code_bb_ts(py::module& m) +{ + + using correlate_access_code_bb_ts = ::gr::digital::correlate_access_code_bb_ts; + + + py::class_<correlate_access_code_bb_ts, + gr::block, + gr::basic_block, + std::shared_ptr<correlate_access_code_bb_ts>>( + m, "correlate_access_code_bb_ts", D(correlate_access_code_bb_ts)) + + .def(py::init(&correlate_access_code_bb_ts::make), + py::arg("access_code"), + py::arg("threshold"), + py::arg("tag_name"), + D(correlate_access_code_bb_ts, make)) + + + .def("set_access_code", + &correlate_access_code_bb_ts::set_access_code, + py::arg("access_code"), + D(correlate_access_code_bb_ts, set_access_code)) + + + .def("access_code", + &correlate_access_code_bb_ts::access_code, + D(correlate_access_code_bb_ts, access_code)) + + ; +} diff --git a/gr-digital/python/digital/bindings/correlate_access_code_ff_ts_python.cc b/gr-digital/python/digital/bindings/correlate_access_code_ff_ts_python.cc new file mode 100644 index 0000000000..8f86abe2fe --- /dev/null +++ b/gr-digital/python/digital/bindings/correlate_access_code_ff_ts_python.cc @@ -0,0 +1,52 @@ +/* + * 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/digital/correlate_access_code_ff_ts.h> +// pydoc.h is automatically generated in the build directory +#include <correlate_access_code_ff_ts_pydoc.h> + +void bind_correlate_access_code_ff_ts(py::module& m) +{ + + using correlate_access_code_ff_ts = ::gr::digital::correlate_access_code_ff_ts; + + + py::class_<correlate_access_code_ff_ts, + gr::block, + gr::basic_block, + std::shared_ptr<correlate_access_code_ff_ts>>( + m, "correlate_access_code_ff_ts", D(correlate_access_code_ff_ts)) + + .def(py::init(&correlate_access_code_ff_ts::make), + py::arg("access_code"), + py::arg("threshold"), + py::arg("tag_name"), + D(correlate_access_code_ff_ts, make)) + + + .def("set_access_code", + &correlate_access_code_ff_ts::set_access_code, + py::arg("access_code"), + D(correlate_access_code_ff_ts, set_access_code)) + + + .def("access_code", + &correlate_access_code_ff_ts::access_code, + D(correlate_access_code_ff_ts, access_code)) + + ; +} diff --git a/gr-digital/python/digital/bindings/correlate_access_code_tag_bb_python.cc b/gr-digital/python/digital/bindings/correlate_access_code_tag_bb_python.cc new file mode 100644 index 0000000000..eff03d15a3 --- /dev/null +++ b/gr-digital/python/digital/bindings/correlate_access_code_tag_bb_python.cc @@ -0,0 +1,60 @@ +/* + * 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/digital/correlate_access_code_tag_bb.h> +// pydoc.h is automatically generated in the build directory +#include <correlate_access_code_tag_bb_pydoc.h> + +void bind_correlate_access_code_tag_bb(py::module& m) +{ + + using correlate_access_code_tag_bb = ::gr::digital::correlate_access_code_tag_bb; + + + py::class_<correlate_access_code_tag_bb, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<correlate_access_code_tag_bb>>( + m, "correlate_access_code_tag_bb", D(correlate_access_code_tag_bb)) + + .def(py::init(&correlate_access_code_tag_bb::make), + py::arg("access_code"), + py::arg("threshold"), + py::arg("tag_name"), + D(correlate_access_code_tag_bb, make)) + + + .def("set_access_code", + &correlate_access_code_tag_bb::set_access_code, + py::arg("access_code"), + D(correlate_access_code_tag_bb, set_access_code)) + + + .def("set_threshold", + &correlate_access_code_tag_bb::set_threshold, + py::arg("threshold"), + D(correlate_access_code_tag_bb, set_threshold)) + + + .def("set_tagname", + &correlate_access_code_tag_bb::set_tagname, + py::arg("tagname"), + D(correlate_access_code_tag_bb, set_tagname)) + + ; +} diff --git a/gr-digital/python/digital/bindings/correlate_access_code_tag_ff_python.cc b/gr-digital/python/digital/bindings/correlate_access_code_tag_ff_python.cc new file mode 100644 index 0000000000..b6f85b914e --- /dev/null +++ b/gr-digital/python/digital/bindings/correlate_access_code_tag_ff_python.cc @@ -0,0 +1,60 @@ +/* + * 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/digital/correlate_access_code_tag_ff.h> +// pydoc.h is automatically generated in the build directory +#include <correlate_access_code_tag_ff_pydoc.h> + +void bind_correlate_access_code_tag_ff(py::module& m) +{ + + using correlate_access_code_tag_ff = ::gr::digital::correlate_access_code_tag_ff; + + + py::class_<correlate_access_code_tag_ff, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<correlate_access_code_tag_ff>>( + m, "correlate_access_code_tag_ff", D(correlate_access_code_tag_ff)) + + .def(py::init(&correlate_access_code_tag_ff::make), + py::arg("access_code"), + py::arg("threshold"), + py::arg("tag_name"), + D(correlate_access_code_tag_ff, make)) + + + .def("set_access_code", + &correlate_access_code_tag_ff::set_access_code, + py::arg("access_code"), + D(correlate_access_code_tag_ff, set_access_code)) + + + .def("set_threshold", + &correlate_access_code_tag_ff::set_threshold, + py::arg("threshold"), + D(correlate_access_code_tag_ff, set_threshold)) + + + .def("set_tagname", + &correlate_access_code_tag_ff::set_tagname, + py::arg("tagname"), + D(correlate_access_code_tag_ff, set_tagname)) + + ; +} diff --git a/gr-digital/python/digital/bindings/costas_loop_cc_python.cc b/gr-digital/python/digital/bindings/costas_loop_cc_python.cc new file mode 100644 index 0000000000..d08446c976 --- /dev/null +++ b/gr-digital/python/digital/bindings/costas_loop_cc_python.cc @@ -0,0 +1,44 @@ +/* + * 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/digital/costas_loop_cc.h> +// pydoc.h is automatically generated in the build directory +#include <costas_loop_cc_pydoc.h> + +void bind_costas_loop_cc(py::module& m) +{ + + using costas_loop_cc = ::gr::digital::costas_loop_cc; + + + py::class_<costas_loop_cc, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<costas_loop_cc>>(m, "costas_loop_cc", D(costas_loop_cc)) + + .def(py::init(&costas_loop_cc::make), + py::arg("loop_bw"), + py::arg("order"), + py::arg("use_snr") = false, + D(costas_loop_cc, make)) + + + .def("error", &costas_loop_cc::error, D(costas_loop_cc, error)) + + ; +} diff --git a/gr-digital/python/digital/bindings/cpmmod_bc_python.cc b/gr-digital/python/digital/bindings/cpmmod_bc_python.cc new file mode 100644 index 0000000000..65ebaea5f3 --- /dev/null +++ b/gr-digital/python/digital/bindings/cpmmod_bc_python.cc @@ -0,0 +1,64 @@ +/* + * 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/digital/cpmmod_bc.h> +// pydoc.h is automatically generated in the build directory +#include <cpmmod_bc_pydoc.h> + +void bind_cpmmod_bc(py::module& m) +{ + + using cpmmod_bc = ::gr::digital::cpmmod_bc; + + + py::class_<cpmmod_bc, gr::hier_block2, gr::basic_block, std::shared_ptr<cpmmod_bc>>( + m, "cpmmod_bc", D(cpmmod_bc)) + + .def(py::init(&cpmmod_bc::make), + py::arg("type"), + py::arg("h"), + py::arg("samples_per_sym"), + py::arg("L"), + py::arg("beta") = 0.3, + D(cpmmod_bc, make)) + + + .def_static("make_gmskmod_bc", + &cpmmod_bc::make_gmskmod_bc, + py::arg("samples_per_sym") = 2, + py::arg("L") = 4, + py::arg("beta") = 0.3, + D(cpmmod_bc, make_gmskmod_bc)) + + + .def("taps", &cpmmod_bc::taps, D(cpmmod_bc, taps)) + + + .def("type", &cpmmod_bc::type, D(cpmmod_bc, type)) + + + .def("index", &cpmmod_bc::index, D(cpmmod_bc, index)) + + + .def( + "samples_per_sym", &cpmmod_bc::samples_per_sym, D(cpmmod_bc, samples_per_sym)) + + + .def("beta", &cpmmod_bc::beta, D(cpmmod_bc, beta)) + + ; +} diff --git a/gr-digital/python/digital/bindings/crc32_async_bb_python.cc b/gr-digital/python/digital/bindings/crc32_async_bb_python.cc new file mode 100644 index 0000000000..68ff45686b --- /dev/null +++ b/gr-digital/python/digital/bindings/crc32_async_bb_python.cc @@ -0,0 +1,39 @@ +/* + * 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/digital/crc32_async_bb.h> +// pydoc.h is automatically generated in the build directory +#include <crc32_async_bb_pydoc.h> + +void bind_crc32_async_bb(py::module& m) +{ + + using crc32_async_bb = ::gr::digital::crc32_async_bb; + + + py::class_<crc32_async_bb, + gr::block, + gr::basic_block, + std::shared_ptr<crc32_async_bb>>(m, "crc32_async_bb", D(crc32_async_bb)) + + .def(py::init(&crc32_async_bb::make), + py::arg("check") = false, + D(crc32_async_bb, make)) + + + ; +} diff --git a/gr-digital/python/digital/bindings/crc32_bb_python.cc b/gr-digital/python/digital/bindings/crc32_bb_python.cc new file mode 100644 index 0000000000..d0c0be23ca --- /dev/null +++ b/gr-digital/python/digital/bindings/crc32_bb_python.cc @@ -0,0 +1,42 @@ +/* + * 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/digital/crc32_bb.h> +// pydoc.h is automatically generated in the build directory +#include <crc32_bb_pydoc.h> + +void bind_crc32_bb(py::module& m) +{ + + using crc32_bb = ::gr::digital::crc32_bb; + + + py::class_<crc32_bb, + gr::tagged_stream_block, + gr::block, + gr::basic_block, + std::shared_ptr<crc32_bb>>(m, "crc32_bb", D(crc32_bb)) + + .def(py::init(&crc32_bb::make), + py::arg("check") = false, + py::arg("lengthtagname") = "packet_len", + py::arg("packed") = true, + D(crc32_bb, make)) + + + ; +} diff --git a/gr-digital/python/digital/bindings/crc32_python.cc b/gr-digital/python/digital/bindings/crc32_python.cc new file mode 100644 index 0000000000..31e52d647c --- /dev/null +++ b/gr-digital/python/digital/bindings/crc32_python.cc @@ -0,0 +1,54 @@ +/* + * 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/digital/crc32.h> +// pydoc.h is automatically generated in the build directory +#include <crc32_pydoc.h> + +void bind_crc32(py::module& m) +{ + + + m.def("update_crc32", + (unsigned int (*)(unsigned int, unsigned char const*, size_t)) & + ::gr::digital::update_crc32, + py::arg("crc"), + py::arg("buf"), + py::arg("len"), + D(update_crc32, 0)); + + + m.def("update_crc32", + (unsigned int (*)(unsigned int, std::string const)) & + ::gr::digital::update_crc32, + py::arg("crc"), + py::arg("buf"), + D(update_crc32, 1)); + + + m.def("crc32", + (unsigned int (*)(unsigned char const*, size_t)) & ::gr::digital::crc32, + py::arg("buf"), + py::arg("len"), + D(crc32, 0)); + + + m.def("crc32", + (unsigned int (*)(std::string const)) & ::gr::digital::crc32, + py::arg("buf"), + D(crc32, 1)); +} diff --git a/gr-digital/python/digital/bindings/descrambler_bb_python.cc b/gr-digital/python/digital/bindings/descrambler_bb_python.cc new file mode 100644 index 0000000000..2f65ced126 --- /dev/null +++ b/gr-digital/python/digital/bindings/descrambler_bb_python.cc @@ -0,0 +1,42 @@ +/* + * 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/digital/descrambler_bb.h> +// pydoc.h is automatically generated in the build directory +#include <descrambler_bb_pydoc.h> + +void bind_descrambler_bb(py::module& m) +{ + + using descrambler_bb = ::gr::digital::descrambler_bb; + + + py::class_<descrambler_bb, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<descrambler_bb>>(m, "descrambler_bb", D(descrambler_bb)) + + .def(py::init(&descrambler_bb::make), + py::arg("mask"), + py::arg("seed"), + py::arg("len"), + D(descrambler_bb, make)) + + + ; +} diff --git a/gr-digital/python/digital/bindings/diff_decoder_bb_python.cc b/gr-digital/python/digital/bindings/diff_decoder_bb_python.cc new file mode 100644 index 0000000000..903de92dad --- /dev/null +++ b/gr-digital/python/digital/bindings/diff_decoder_bb_python.cc @@ -0,0 +1,40 @@ +/* + * 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/digital/diff_decoder_bb.h> +// pydoc.h is automatically generated in the build directory +#include <diff_decoder_bb_pydoc.h> + +void bind_diff_decoder_bb(py::module& m) +{ + + using diff_decoder_bb = ::gr::digital::diff_decoder_bb; + + + py::class_<diff_decoder_bb, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<diff_decoder_bb>>(m, "diff_decoder_bb", D(diff_decoder_bb)) + + .def(py::init(&diff_decoder_bb::make), + py::arg("modulus"), + D(diff_decoder_bb, make)) + + + ; +} diff --git a/gr-digital/python/digital/bindings/diff_encoder_bb_python.cc b/gr-digital/python/digital/bindings/diff_encoder_bb_python.cc new file mode 100644 index 0000000000..40b0e8f006 --- /dev/null +++ b/gr-digital/python/digital/bindings/diff_encoder_bb_python.cc @@ -0,0 +1,40 @@ +/* + * 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/digital/diff_encoder_bb.h> +// pydoc.h is automatically generated in the build directory +#include <diff_encoder_bb_pydoc.h> + +void bind_diff_encoder_bb(py::module& m) +{ + + using diff_encoder_bb = ::gr::digital::diff_encoder_bb; + + + py::class_<diff_encoder_bb, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<diff_encoder_bb>>(m, "diff_encoder_bb", D(diff_encoder_bb)) + + .def(py::init(&diff_encoder_bb::make), + py::arg("modulus"), + D(diff_encoder_bb, make)) + + + ; +} diff --git a/gr-digital/python/digital/bindings/diff_phasor_cc_python.cc b/gr-digital/python/digital/bindings/diff_phasor_cc_python.cc new file mode 100644 index 0000000000..ca7544e115 --- /dev/null +++ b/gr-digital/python/digital/bindings/diff_phasor_cc_python.cc @@ -0,0 +1,38 @@ +/* + * 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/digital/diff_phasor_cc.h> +// pydoc.h is automatically generated in the build directory +#include <diff_phasor_cc_pydoc.h> + +void bind_diff_phasor_cc(py::module& m) +{ + + using diff_phasor_cc = ::gr::digital::diff_phasor_cc; + + + py::class_<diff_phasor_cc, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<diff_phasor_cc>>(m, "diff_phasor_cc", D(diff_phasor_cc)) + + .def(py::init(&diff_phasor_cc::make), D(diff_phasor_cc, make)) + + + ; +} diff --git a/gr-digital/python/digital/bindings/docstrings/additive_scrambler_bb_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/additive_scrambler_bb_pydoc_template.h new file mode 100644 index 0000000000..372e6a7404 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/additive_scrambler_bb_pydoc_template.h @@ -0,0 +1,44 @@ +/* + * 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, digital, __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_digital_additive_scrambler_bb = R"doc()doc"; + + +static const char* __doc_gr_digital_additive_scrambler_bb_additive_scrambler_bb_0 = + R"doc()doc"; + + +static const char* __doc_gr_digital_additive_scrambler_bb_additive_scrambler_bb_1 = + R"doc()doc"; + + +static const char* __doc_gr_digital_additive_scrambler_bb_make = R"doc()doc"; + + +static const char* __doc_gr_digital_additive_scrambler_bb_mask = R"doc()doc"; + + +static const char* __doc_gr_digital_additive_scrambler_bb_seed = R"doc()doc"; + + +static const char* __doc_gr_digital_additive_scrambler_bb_len = R"doc()doc"; + + +static const char* __doc_gr_digital_additive_scrambler_bb_count = R"doc()doc"; + + +static const char* __doc_gr_digital_additive_scrambler_bb_bits_per_byte = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/binary_slicer_fb_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/binary_slicer_fb_pydoc_template.h new file mode 100644 index 0000000000..cddfd77a00 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/binary_slicer_fb_pydoc_template.h @@ -0,0 +1,24 @@ +/* + * 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, digital, __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_digital_binary_slicer_fb = R"doc()doc"; + + +static const char* __doc_gr_digital_binary_slicer_fb_binary_slicer_fb = R"doc()doc"; + + +static const char* __doc_gr_digital_binary_slicer_fb_make = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/burst_shaper_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/burst_shaper_pydoc_template.h new file mode 100644 index 0000000000..84c1cb8104 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/burst_shaper_pydoc_template.h @@ -0,0 +1,15 @@ +/* + * 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, digital, __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 + */ diff --git a/gr-digital/python/digital/bindings/docstrings/chunks_to_symbols_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/chunks_to_symbols_pydoc_template.h new file mode 100644 index 0000000000..84c1cb8104 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/chunks_to_symbols_pydoc_template.h @@ -0,0 +1,15 @@ +/* + * 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, digital, __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 + */ diff --git a/gr-digital/python/digital/bindings/docstrings/clock_recovery_mm_cc_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/clock_recovery_mm_cc_pydoc_template.h new file mode 100644 index 0000000000..b793fde9a6 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/clock_recovery_mm_cc_pydoc_template.h @@ -0,0 +1,56 @@ +/* + * 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, digital, __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_digital_clock_recovery_mm_cc = R"doc()doc"; + + +static const char* __doc_gr_digital_clock_recovery_mm_cc_clock_recovery_mm_cc_0 = + R"doc()doc"; + + +static const char* __doc_gr_digital_clock_recovery_mm_cc_clock_recovery_mm_cc_1 = + R"doc()doc"; + + +static const char* __doc_gr_digital_clock_recovery_mm_cc_make = R"doc()doc"; + + +static const char* __doc_gr_digital_clock_recovery_mm_cc_mu = R"doc()doc"; + + +static const char* __doc_gr_digital_clock_recovery_mm_cc_omega = R"doc()doc"; + + +static const char* __doc_gr_digital_clock_recovery_mm_cc_gain_mu = R"doc()doc"; + + +static const char* __doc_gr_digital_clock_recovery_mm_cc_gain_omega = R"doc()doc"; + + +static const char* __doc_gr_digital_clock_recovery_mm_cc_set_verbose = R"doc()doc"; + + +static const char* __doc_gr_digital_clock_recovery_mm_cc_set_gain_mu = R"doc()doc"; + + +static const char* __doc_gr_digital_clock_recovery_mm_cc_set_gain_omega = R"doc()doc"; + + +static const char* __doc_gr_digital_clock_recovery_mm_cc_set_mu = R"doc()doc"; + + +static const char* __doc_gr_digital_clock_recovery_mm_cc_set_omega = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/clock_recovery_mm_ff_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/clock_recovery_mm_ff_pydoc_template.h new file mode 100644 index 0000000000..ac1581770c --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/clock_recovery_mm_ff_pydoc_template.h @@ -0,0 +1,56 @@ +/* + * 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, digital, __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_digital_clock_recovery_mm_ff = R"doc()doc"; + + +static const char* __doc_gr_digital_clock_recovery_mm_ff_clock_recovery_mm_ff_0 = + R"doc()doc"; + + +static const char* __doc_gr_digital_clock_recovery_mm_ff_clock_recovery_mm_ff_1 = + R"doc()doc"; + + +static const char* __doc_gr_digital_clock_recovery_mm_ff_make = R"doc()doc"; + + +static const char* __doc_gr_digital_clock_recovery_mm_ff_mu = R"doc()doc"; + + +static const char* __doc_gr_digital_clock_recovery_mm_ff_omega = R"doc()doc"; + + +static const char* __doc_gr_digital_clock_recovery_mm_ff_gain_mu = R"doc()doc"; + + +static const char* __doc_gr_digital_clock_recovery_mm_ff_gain_omega = R"doc()doc"; + + +static const char* __doc_gr_digital_clock_recovery_mm_ff_set_verbose = R"doc()doc"; + + +static const char* __doc_gr_digital_clock_recovery_mm_ff_set_gain_mu = R"doc()doc"; + + +static const char* __doc_gr_digital_clock_recovery_mm_ff_set_gain_omega = R"doc()doc"; + + +static const char* __doc_gr_digital_clock_recovery_mm_ff_set_mu = R"doc()doc"; + + +static const char* __doc_gr_digital_clock_recovery_mm_ff_set_omega = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/cma_equalizer_cc_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/cma_equalizer_cc_pydoc_template.h new file mode 100644 index 0000000000..ae3a5c5df9 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/cma_equalizer_cc_pydoc_template.h @@ -0,0 +1,45 @@ +/* + * 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, digital, __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_digital_cma_equalizer_cc = R"doc()doc"; + + +static const char* __doc_gr_digital_cma_equalizer_cc_cma_equalizer_cc_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_cma_equalizer_cc_cma_equalizer_cc_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_cma_equalizer_cc_make = R"doc()doc"; + + +static const char* __doc_gr_digital_cma_equalizer_cc_set_taps = R"doc()doc"; + + +static const char* __doc_gr_digital_cma_equalizer_cc_taps = R"doc()doc"; + + +static const char* __doc_gr_digital_cma_equalizer_cc_gain = R"doc()doc"; + + +static const char* __doc_gr_digital_cma_equalizer_cc_set_gain = R"doc()doc"; + + +static const char* __doc_gr_digital_cma_equalizer_cc_modulus = R"doc()doc"; + + +static const char* __doc_gr_digital_cma_equalizer_cc_set_modulus = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/constellation_decoder_cb_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/constellation_decoder_cb_pydoc_template.h new file mode 100644 index 0000000000..46b9ee9cb7 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/constellation_decoder_cb_pydoc_template.h @@ -0,0 +1,25 @@ +/* + * 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, digital, __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_digital_constellation_decoder_cb = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_decoder_cb_constellation_decoder_cb = + R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_decoder_cb_make = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/constellation_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/constellation_pydoc_template.h new file mode 100644 index 0000000000..8ae7467263 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/constellation_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, digital, __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_digital_constellation = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_constellation_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_constellation_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_constellation_2 = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_map_to_points = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_map_to_points_v = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_decision_maker = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_decision_maker_v = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_decision_maker_pe = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_calc_metric = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_calc_euclidean_metric = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_calc_hard_symbol_metric = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_points = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_s_points = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_v_points = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_apply_pre_diff_code = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_set_pre_diff_code = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_pre_diff_code = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_rotational_symmetry = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_dimensionality = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_bits_per_symbol = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_arity = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_base = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_as_pmt = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_gen_soft_dec_lut = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_calc_soft_dec = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_set_soft_dec_lut = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_has_soft_dec_lut = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_soft_dec_lut = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_soft_decision_maker = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_calcdist = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_calcdist_constellation_calcdist = + R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_calcdist_make = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_calcdist_decision_maker = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_sector = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_sector_constellation_sector_0 = + R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_sector_constellation_sector_1 = + R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_sector_decision_maker = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_rect = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_rect_constellation_rect = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_rect_make = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_expl_rect = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_expl_rect_constellation_expl_rect = + R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_expl_rect_make = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_psk = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_psk_constellation_psk = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_psk_make = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_bpsk = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_bpsk_constellation_bpsk = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_bpsk_make = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_bpsk_decision_maker = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_qpsk = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_qpsk_constellation_qpsk = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_qpsk_make = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_qpsk_decision_maker = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_dqpsk = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_dqpsk_constellation_dqpsk = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_dqpsk_make = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_dqpsk_decision_maker = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_8psk = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_8psk_constellation_8psk = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_8psk_make = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_8psk_decision_maker = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_8psk_natural = R"doc()doc"; + + +static const char* + __doc_gr_digital_constellation_8psk_natural_constellation_8psk_natural = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_8psk_natural_make = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_8psk_natural_decision_maker = + R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_16qam = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_16qam_constellation_16qam = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_16qam_make = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_16qam_decision_maker = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/constellation_receiver_cb_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/constellation_receiver_cb_pydoc_template.h new file mode 100644 index 0000000000..a0892220e9 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/constellation_receiver_cb_pydoc_template.h @@ -0,0 +1,33 @@ +/* + * 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, digital, __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_digital_constellation_receiver_cb = R"doc()doc"; + + +static const char* + __doc_gr_digital_constellation_receiver_cb_constellation_receiver_cb_0 = R"doc()doc"; + + +static const char* + __doc_gr_digital_constellation_receiver_cb_constellation_receiver_cb_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_receiver_cb_make = R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_receiver_cb_phase_error_tracking = + R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/constellation_soft_decoder_cf_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/constellation_soft_decoder_cf_pydoc_template.h new file mode 100644 index 0000000000..fee74ee55c --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/constellation_soft_decoder_cf_pydoc_template.h @@ -0,0 +1,26 @@ +/* + * 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, digital, __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_digital_constellation_soft_decoder_cf = R"doc()doc"; + + +static const char* + __doc_gr_digital_constellation_soft_decoder_cf_constellation_soft_decoder_cf = + R"doc()doc"; + + +static const char* __doc_gr_digital_constellation_soft_decoder_cf_make = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/corr_est_cc_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/corr_est_cc_pydoc_template.h new file mode 100644 index 0000000000..a2ff9bde4d --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/corr_est_cc_pydoc_template.h @@ -0,0 +1,45 @@ +/* + * 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, digital, __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_digital_corr_est_cc = R"doc()doc"; + + +static const char* __doc_gr_digital_corr_est_cc_corr_est_cc_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_corr_est_cc_corr_est_cc_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_corr_est_cc_make = R"doc()doc"; + + +static const char* __doc_gr_digital_corr_est_cc_symbols = R"doc()doc"; + + +static const char* __doc_gr_digital_corr_est_cc_set_symbols = R"doc()doc"; + + +static const char* __doc_gr_digital_corr_est_cc_mark_delay = R"doc()doc"; + + +static const char* __doc_gr_digital_corr_est_cc_set_mark_delay = R"doc()doc"; + + +static const char* __doc_gr_digital_corr_est_cc_threshold = R"doc()doc"; + + +static const char* __doc_gr_digital_corr_est_cc_set_threshold = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/correlate_access_code_bb_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/correlate_access_code_bb_pydoc_template.h new file mode 100644 index 0000000000..d6de7c050b --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/correlate_access_code_bb_pydoc_template.h @@ -0,0 +1,33 @@ +/* + * 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, digital, __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_digital_correlate_access_code_bb = R"doc()doc"; + + +static const char* __doc_gr_digital_correlate_access_code_bb_correlate_access_code_bb_0 = + R"doc()doc"; + + +static const char* __doc_gr_digital_correlate_access_code_bb_correlate_access_code_bb_1 = + R"doc()doc"; + + +static const char* __doc_gr_digital_correlate_access_code_bb_make = R"doc()doc"; + + +static const char* __doc_gr_digital_correlate_access_code_bb_set_access_code = + R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/correlate_access_code_bb_ts_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/correlate_access_code_bb_ts_pydoc_template.h new file mode 100644 index 0000000000..606fd38438 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/correlate_access_code_bb_ts_pydoc_template.h @@ -0,0 +1,38 @@ +/* + * 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, digital, __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_digital_correlate_access_code_bb_ts = R"doc()doc"; + + +static const char* + __doc_gr_digital_correlate_access_code_bb_ts_correlate_access_code_bb_ts_0 = + R"doc()doc"; + + +static const char* + __doc_gr_digital_correlate_access_code_bb_ts_correlate_access_code_bb_ts_1 = + R"doc()doc"; + + +static const char* __doc_gr_digital_correlate_access_code_bb_ts_make = R"doc()doc"; + + +static const char* __doc_gr_digital_correlate_access_code_bb_ts_set_access_code = + R"doc()doc"; + + +static const char* __doc_gr_digital_correlate_access_code_bb_ts_access_code = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/correlate_access_code_ff_ts_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/correlate_access_code_ff_ts_pydoc_template.h new file mode 100644 index 0000000000..edfa7c6e8d --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/correlate_access_code_ff_ts_pydoc_template.h @@ -0,0 +1,38 @@ +/* + * 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, digital, __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_digital_correlate_access_code_ff_ts = R"doc()doc"; + + +static const char* + __doc_gr_digital_correlate_access_code_ff_ts_correlate_access_code_ff_ts_0 = + R"doc()doc"; + + +static const char* + __doc_gr_digital_correlate_access_code_ff_ts_correlate_access_code_ff_ts_1 = + R"doc()doc"; + + +static const char* __doc_gr_digital_correlate_access_code_ff_ts_make = R"doc()doc"; + + +static const char* __doc_gr_digital_correlate_access_code_ff_ts_set_access_code = + R"doc()doc"; + + +static const char* __doc_gr_digital_correlate_access_code_ff_ts_access_code = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/correlate_access_code_tag_bb_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/correlate_access_code_tag_bb_pydoc_template.h new file mode 100644 index 0000000000..9baa5d1a27 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/correlate_access_code_tag_bb_pydoc_template.h @@ -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 + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, digital, __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_digital_correlate_access_code_tag_bb = R"doc()doc"; + + +static const char* + __doc_gr_digital_correlate_access_code_tag_bb_correlate_access_code_tag_bb_0 = + R"doc()doc"; + + +static const char* + __doc_gr_digital_correlate_access_code_tag_bb_correlate_access_code_tag_bb_1 = + R"doc()doc"; + + +static const char* __doc_gr_digital_correlate_access_code_tag_bb_make = R"doc()doc"; + + +static const char* __doc_gr_digital_correlate_access_code_tag_bb_set_access_code = + R"doc()doc"; + + +static const char* __doc_gr_digital_correlate_access_code_tag_bb_set_threshold = + R"doc()doc"; + + +static const char* __doc_gr_digital_correlate_access_code_tag_bb_set_tagname = + R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/correlate_access_code_tag_ff_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/correlate_access_code_tag_ff_pydoc_template.h new file mode 100644 index 0000000000..14397907e9 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/correlate_access_code_tag_ff_pydoc_template.h @@ -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 + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, digital, __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_digital_correlate_access_code_tag_ff = R"doc()doc"; + + +static const char* + __doc_gr_digital_correlate_access_code_tag_ff_correlate_access_code_tag_ff_0 = + R"doc()doc"; + + +static const char* + __doc_gr_digital_correlate_access_code_tag_ff_correlate_access_code_tag_ff_1 = + R"doc()doc"; + + +static const char* __doc_gr_digital_correlate_access_code_tag_ff_make = R"doc()doc"; + + +static const char* __doc_gr_digital_correlate_access_code_tag_ff_set_access_code = + R"doc()doc"; + + +static const char* __doc_gr_digital_correlate_access_code_tag_ff_set_threshold = + R"doc()doc"; + + +static const char* __doc_gr_digital_correlate_access_code_tag_ff_set_tagname = + R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/costas_loop_cc_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/costas_loop_cc_pydoc_template.h new file mode 100644 index 0000000000..f4dbe267ec --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/costas_loop_cc_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, digital, __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_digital_costas_loop_cc = R"doc()doc"; + + +static const char* __doc_gr_digital_costas_loop_cc_costas_loop_cc_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_costas_loop_cc_costas_loop_cc_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_costas_loop_cc_make = R"doc()doc"; + + +static const char* __doc_gr_digital_costas_loop_cc_error = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/cpmmod_bc_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/cpmmod_bc_pydoc_template.h new file mode 100644 index 0000000000..8db03b103c --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/cpmmod_bc_pydoc_template.h @@ -0,0 +1,45 @@ +/* + * 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, digital, __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_digital_cpmmod_bc = R"doc()doc"; + + +static const char* __doc_gr_digital_cpmmod_bc_cpmmod_bc_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_cpmmod_bc_cpmmod_bc_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_cpmmod_bc_make = R"doc()doc"; + + +static const char* __doc_gr_digital_cpmmod_bc_make_gmskmod_bc = R"doc()doc"; + + +static const char* __doc_gr_digital_cpmmod_bc_taps = R"doc()doc"; + + +static const char* __doc_gr_digital_cpmmod_bc_type = R"doc()doc"; + + +static const char* __doc_gr_digital_cpmmod_bc_index = R"doc()doc"; + + +static const char* __doc_gr_digital_cpmmod_bc_samples_per_sym = R"doc()doc"; + + +static const char* __doc_gr_digital_cpmmod_bc_beta = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/crc32_async_bb_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/crc32_async_bb_pydoc_template.h new file mode 100644 index 0000000000..e62629dd9b --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/crc32_async_bb_pydoc_template.h @@ -0,0 +1,24 @@ +/* + * 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, digital, __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_digital_crc32_async_bb = R"doc()doc"; + + +static const char* __doc_gr_digital_crc32_async_bb_crc32_async_bb = R"doc()doc"; + + +static const char* __doc_gr_digital_crc32_async_bb_make = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/crc32_bb_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/crc32_bb_pydoc_template.h new file mode 100644 index 0000000000..e08936a44c --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/crc32_bb_pydoc_template.h @@ -0,0 +1,24 @@ +/* + * 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, digital, __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_digital_crc32_bb = R"doc()doc"; + + +static const char* __doc_gr_digital_crc32_bb_crc32_bb = R"doc()doc"; + + +static const char* __doc_gr_digital_crc32_bb_make = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/crc32_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/crc32_pydoc_template.h new file mode 100644 index 0000000000..75ae8d3814 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/crc32_pydoc_template.h @@ -0,0 +1,27 @@ +/* + * 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, digital, __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_digital_update_crc32_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_update_crc32_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_crc32_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_crc32_1 = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/descrambler_bb_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/descrambler_bb_pydoc_template.h new file mode 100644 index 0000000000..2693349a90 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/descrambler_bb_pydoc_template.h @@ -0,0 +1,24 @@ +/* + * 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, digital, __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_digital_descrambler_bb = R"doc()doc"; + + +static const char* __doc_gr_digital_descrambler_bb_descrambler_bb = R"doc()doc"; + + +static const char* __doc_gr_digital_descrambler_bb_make = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/diff_decoder_bb_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/diff_decoder_bb_pydoc_template.h new file mode 100644 index 0000000000..79ab4b8d3f --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/diff_decoder_bb_pydoc_template.h @@ -0,0 +1,24 @@ +/* + * 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, digital, __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_digital_diff_decoder_bb = R"doc()doc"; + + +static const char* __doc_gr_digital_diff_decoder_bb_diff_decoder_bb = R"doc()doc"; + + +static const char* __doc_gr_digital_diff_decoder_bb_make = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/diff_encoder_bb_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/diff_encoder_bb_pydoc_template.h new file mode 100644 index 0000000000..73fa449974 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/diff_encoder_bb_pydoc_template.h @@ -0,0 +1,24 @@ +/* + * 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, digital, __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_digital_diff_encoder_bb = R"doc()doc"; + + +static const char* __doc_gr_digital_diff_encoder_bb_diff_encoder_bb = R"doc()doc"; + + +static const char* __doc_gr_digital_diff_encoder_bb_make = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/diff_phasor_cc_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/diff_phasor_cc_pydoc_template.h new file mode 100644 index 0000000000..7078c93226 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/diff_phasor_cc_pydoc_template.h @@ -0,0 +1,24 @@ +/* + * 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, digital, __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_digital_diff_phasor_cc = R"doc()doc"; + + +static const char* __doc_gr_digital_diff_phasor_cc_diff_phasor_cc = R"doc()doc"; + + +static const char* __doc_gr_digital_diff_phasor_cc_make = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/fll_band_edge_cc_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/fll_band_edge_cc_pydoc_template.h new file mode 100644 index 0000000000..a339cdd4c1 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/fll_band_edge_cc_pydoc_template.h @@ -0,0 +1,48 @@ +/* + * 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, digital, __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_digital_fll_band_edge_cc = R"doc()doc"; + + +static const char* __doc_gr_digital_fll_band_edge_cc_fll_band_edge_cc_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_fll_band_edge_cc_fll_band_edge_cc_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_fll_band_edge_cc_make = R"doc()doc"; + + +static const char* __doc_gr_digital_fll_band_edge_cc_set_samples_per_symbol = R"doc()doc"; + + +static const char* __doc_gr_digital_fll_band_edge_cc_set_rolloff = R"doc()doc"; + + +static const char* __doc_gr_digital_fll_band_edge_cc_set_filter_size = R"doc()doc"; + + +static const char* __doc_gr_digital_fll_band_edge_cc_samples_per_symbol = R"doc()doc"; + + +static const char* __doc_gr_digital_fll_band_edge_cc_rolloff = R"doc()doc"; + + +static const char* __doc_gr_digital_fll_band_edge_cc_filter_size = R"doc()doc"; + + +static const char* __doc_gr_digital_fll_band_edge_cc_print_taps = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/framer_sink_1_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/framer_sink_1_pydoc_template.h new file mode 100644 index 0000000000..13d7aa8d25 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/framer_sink_1_pydoc_template.h @@ -0,0 +1,24 @@ +/* + * 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, digital, __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_digital_framer_sink_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_framer_sink_1_framer_sink_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_framer_sink_1_make = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/glfsr_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/glfsr_pydoc_template.h new file mode 100644 index 0000000000..b6c929710c --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/glfsr_pydoc_template.h @@ -0,0 +1,33 @@ +/* + * 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, digital, __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_digital_glfsr = R"doc()doc"; + + +static const char* __doc_gr_digital_glfsr_glfsr_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_glfsr_glfsr_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_glfsr_glfsr_mask = R"doc()doc"; + + +static const char* __doc_gr_digital_glfsr_next_bit = R"doc()doc"; + + +static const char* __doc_gr_digital_glfsr_mask = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/glfsr_source_b_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/glfsr_source_b_pydoc_template.h new file mode 100644 index 0000000000..bd99865675 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/glfsr_source_b_pydoc_template.h @@ -0,0 +1,33 @@ +/* + * 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, digital, __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_digital_glfsr_source_b = R"doc()doc"; + + +static const char* __doc_gr_digital_glfsr_source_b_glfsr_source_b_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_glfsr_source_b_glfsr_source_b_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_glfsr_source_b_make = R"doc()doc"; + + +static const char* __doc_gr_digital_glfsr_source_b_period = R"doc()doc"; + + +static const char* __doc_gr_digital_glfsr_source_b_mask = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/glfsr_source_f_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/glfsr_source_f_pydoc_template.h new file mode 100644 index 0000000000..2e94e71b02 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/glfsr_source_f_pydoc_template.h @@ -0,0 +1,33 @@ +/* + * 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, digital, __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_digital_glfsr_source_f = R"doc()doc"; + + +static const char* __doc_gr_digital_glfsr_source_f_glfsr_source_f_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_glfsr_source_f_glfsr_source_f_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_glfsr_source_f_make = R"doc()doc"; + + +static const char* __doc_gr_digital_glfsr_source_f_period = R"doc()doc"; + + +static const char* __doc_gr_digital_glfsr_source_f_mask = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/hdlc_deframer_bp_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/hdlc_deframer_bp_pydoc_template.h new file mode 100644 index 0000000000..d8b8eb6573 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/hdlc_deframer_bp_pydoc_template.h @@ -0,0 +1,24 @@ +/* + * 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, digital, __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_digital_hdlc_deframer_bp = R"doc()doc"; + + +static const char* __doc_gr_digital_hdlc_deframer_bp_hdlc_deframer_bp = R"doc()doc"; + + +static const char* __doc_gr_digital_hdlc_deframer_bp_make = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/hdlc_framer_pb_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/hdlc_framer_pb_pydoc_template.h new file mode 100644 index 0000000000..5207c4ecd6 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/hdlc_framer_pb_pydoc_template.h @@ -0,0 +1,24 @@ +/* + * 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, digital, __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_digital_hdlc_framer_pb = R"doc()doc"; + + +static const char* __doc_gr_digital_hdlc_framer_pb_hdlc_framer_pb = R"doc()doc"; + + +static const char* __doc_gr_digital_hdlc_framer_pb_make = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/header_buffer_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/header_buffer_pydoc_template.h new file mode 100644 index 0000000000..9f184da149 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/header_buffer_pydoc_template.h @@ -0,0 +1,57 @@ +/* + * 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, digital, __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_digital_header_buffer = R"doc()doc"; + + +static const char* __doc_gr_digital_header_buffer_header_buffer_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_header_buffer_header_buffer_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_header_buffer_clear = R"doc()doc"; + + +static const char* __doc_gr_digital_header_buffer_header = R"doc()doc"; + + +static const char* __doc_gr_digital_header_buffer_add_field8 = R"doc()doc"; + + +static const char* __doc_gr_digital_header_buffer_add_field16 = R"doc()doc"; + + +static const char* __doc_gr_digital_header_buffer_add_field32 = R"doc()doc"; + + +static const char* __doc_gr_digital_header_buffer_add_field64 = R"doc()doc"; + + +static const char* __doc_gr_digital_header_buffer_insert_bit = R"doc()doc"; + + +static const char* __doc_gr_digital_header_buffer_extract_field8 = R"doc()doc"; + + +static const char* __doc_gr_digital_header_buffer_extract_field16 = R"doc()doc"; + + +static const char* __doc_gr_digital_header_buffer_extract_field32 = R"doc()doc"; + + +static const char* __doc_gr_digital_header_buffer_extract_field64 = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/header_format_base_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/header_format_base_pydoc_template.h new file mode 100644 index 0000000000..5adad00747 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/header_format_base_pydoc_template.h @@ -0,0 +1,42 @@ +/* + * 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, digital, __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_digital_header_format_base = R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_base_header_format_base_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_base_header_format_base_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_base_base = R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_base_formatter = R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_base_format = R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_base_parse = R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_base_header_nbits = R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_base_header_nbytes = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/header_format_counter_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/header_format_counter_pydoc_template.h new file mode 100644 index 0000000000..bea92c11eb --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/header_format_counter_pydoc_template.h @@ -0,0 +1,35 @@ +/* + * 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, digital, __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_digital_header_format_counter = R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_counter_header_format_counter_0 = + R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_counter_header_format_counter_1 = + R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_counter_format = R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_counter_header_nbits = R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_counter_make = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/header_format_crc_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/header_format_crc_pydoc_template.h new file mode 100644 index 0000000000..50115eaa39 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/header_format_crc_pydoc_template.h @@ -0,0 +1,39 @@ +/* + * 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, digital, __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_digital_header_format_crc = R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_crc_header_format_crc_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_crc_header_format_crc_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_crc_set_header_num = R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_crc_format = R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_crc_parse = R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_crc_header_nbits = R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_crc_make = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/header_format_default_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/header_format_default_pydoc_template.h new file mode 100644 index 0000000000..387c1d8228 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/header_format_default_pydoc_template.h @@ -0,0 +1,50 @@ +/* + * 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, digital, __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_digital_header_format_default = R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_default_header_format_default_0 = + R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_default_header_format_default_1 = + R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_default_format = R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_default_parse = R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_default_header_nbits = R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_default_set_access_code = R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_default_access_code = R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_default_set_threshold = R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_default_threshold = R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_default_make = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/header_format_ofdm_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/header_format_ofdm_pydoc_template.h new file mode 100644 index 0000000000..69aa49d984 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/header_format_ofdm_pydoc_template.h @@ -0,0 +1,36 @@ +/* + * 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, digital, __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_digital_header_format_ofdm = R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_ofdm_header_format_ofdm_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_ofdm_header_format_ofdm_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_ofdm_format = R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_ofdm_parse = R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_ofdm_header_nbits = R"doc()doc"; + + +static const char* __doc_gr_digital_header_format_ofdm_make = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/header_payload_demux_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/header_payload_demux_pydoc_template.h new file mode 100644 index 0000000000..c7e6d36bd0 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/header_payload_demux_pydoc_template.h @@ -0,0 +1,25 @@ +/* + * 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, digital, __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_digital_header_payload_demux = R"doc()doc"; + + +static const char* __doc_gr_digital_header_payload_demux_header_payload_demux = + R"doc()doc"; + + +static const char* __doc_gr_digital_header_payload_demux_make = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/interpolating_resampler_type_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/interpolating_resampler_type_pydoc_template.h new file mode 100644 index 0000000000..84c1cb8104 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/interpolating_resampler_type_pydoc_template.h @@ -0,0 +1,15 @@ +/* + * 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, digital, __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 + */ diff --git a/gr-digital/python/digital/bindings/docstrings/kurtotic_equalizer_cc_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/kurtotic_equalizer_cc_pydoc_template.h new file mode 100644 index 0000000000..135c9699e8 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/kurtotic_equalizer_cc_pydoc_template.h @@ -0,0 +1,35 @@ +/* + * 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, digital, __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_digital_kurtotic_equalizer_cc = R"doc()doc"; + + +static const char* __doc_gr_digital_kurtotic_equalizer_cc_kurtotic_equalizer_cc_0 = + R"doc()doc"; + + +static const char* __doc_gr_digital_kurtotic_equalizer_cc_kurtotic_equalizer_cc_1 = + R"doc()doc"; + + +static const char* __doc_gr_digital_kurtotic_equalizer_cc_make = R"doc()doc"; + + +static const char* __doc_gr_digital_kurtotic_equalizer_cc_gain = R"doc()doc"; + + +static const char* __doc_gr_digital_kurtotic_equalizer_cc_set_gain = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/lfsr_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/lfsr_pydoc_template.h new file mode 100644 index 0000000000..4e8da40aa3 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/lfsr_pydoc_template.h @@ -0,0 +1,42 @@ +/* + * 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, digital, __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_digital_lfsr = R"doc()doc"; + + +static const char* __doc_gr_digital_lfsr_lfsr_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_lfsr_lfsr_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_lfsr_next_bit = R"doc()doc"; + + +static const char* __doc_gr_digital_lfsr_next_bit_scramble = R"doc()doc"; + + +static const char* __doc_gr_digital_lfsr_next_bit_descramble = R"doc()doc"; + + +static const char* __doc_gr_digital_lfsr_reset = R"doc()doc"; + + +static const char* __doc_gr_digital_lfsr_pre_shift = R"doc()doc"; + + +static const char* __doc_gr_digital_lfsr_mask = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/lms_dd_equalizer_cc_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/lms_dd_equalizer_cc_pydoc_template.h new file mode 100644 index 0000000000..88b45955a9 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/lms_dd_equalizer_cc_pydoc_template.h @@ -0,0 +1,41 @@ +/* + * 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, digital, __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_digital_lms_dd_equalizer_cc = R"doc()doc"; + + +static const char* __doc_gr_digital_lms_dd_equalizer_cc_lms_dd_equalizer_cc_0 = + R"doc()doc"; + + +static const char* __doc_gr_digital_lms_dd_equalizer_cc_lms_dd_equalizer_cc_1 = + R"doc()doc"; + + +static const char* __doc_gr_digital_lms_dd_equalizer_cc_make = R"doc()doc"; + + +static const char* __doc_gr_digital_lms_dd_equalizer_cc_set_taps = R"doc()doc"; + + +static const char* __doc_gr_digital_lms_dd_equalizer_cc_taps = R"doc()doc"; + + +static const char* __doc_gr_digital_lms_dd_equalizer_cc_gain = R"doc()doc"; + + +static const char* __doc_gr_digital_lms_dd_equalizer_cc_set_gain = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/map_bb_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/map_bb_pydoc_template.h new file mode 100644 index 0000000000..0c8aa5e0a6 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/map_bb_pydoc_template.h @@ -0,0 +1,33 @@ +/* + * 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, digital, __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_digital_map_bb = R"doc()doc"; + + +static const char* __doc_gr_digital_map_bb_map_bb_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_map_bb_map_bb_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_map_bb_make = R"doc()doc"; + + +static const char* __doc_gr_digital_map_bb_set_map = R"doc()doc"; + + +static const char* __doc_gr_digital_map_bb_map = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/metric_type_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/metric_type_pydoc_template.h new file mode 100644 index 0000000000..84c1cb8104 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/metric_type_pydoc_template.h @@ -0,0 +1,15 @@ +/* + * 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, digital, __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 + */ diff --git a/gr-digital/python/digital/bindings/docstrings/mpsk_snr_est_cc_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/mpsk_snr_est_cc_pydoc_template.h new file mode 100644 index 0000000000..da08e783c8 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/mpsk_snr_est_cc_pydoc_template.h @@ -0,0 +1,48 @@ +/* + * 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, digital, __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_digital_mpsk_snr_est_cc = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_cc_mpsk_snr_est_cc_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_cc_mpsk_snr_est_cc_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_cc_make = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_cc_snr = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_cc_type = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_cc_tag_nsample = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_cc_alpha = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_cc_set_type = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_cc_set_tag_nsample = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_cc_set_alpha = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/mpsk_snr_est_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/mpsk_snr_est_pydoc_template.h new file mode 100644 index 0000000000..a1fd593bbe --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/mpsk_snr_est_pydoc_template.h @@ -0,0 +1,119 @@ +/* + * 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, digital, __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_digital_mpsk_snr_est = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_mpsk_snr_est_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_mpsk_snr_est_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_alpha = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_set_alpha = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_update = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_snr = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_signal = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_noise = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_simple = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_simple_mpsk_snr_est_simple_0 = + R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_simple_mpsk_snr_est_simple_1 = + R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_simple_update = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_simple_snr = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_skew = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_skew_mpsk_snr_est_skew_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_skew_mpsk_snr_est_skew_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_skew_update = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_skew_snr = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_m2m4 = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_m2m4_mpsk_snr_est_m2m4_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_m2m4_mpsk_snr_est_m2m4_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_m2m4_update = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_m2m4_snr = R"doc()doc"; + + +static const char* __doc_gr_digital_snr_est_m2m4 = R"doc()doc"; + + +static const char* __doc_gr_digital_snr_est_m2m4_snr_est_m2m4_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_snr_est_m2m4_snr_est_m2m4_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_snr_est_m2m4_update = R"doc()doc"; + + +static const char* __doc_gr_digital_snr_est_m2m4_snr = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_svr = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_svr_mpsk_snr_est_svr_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_svr_mpsk_snr_est_svr_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_svr_update = R"doc()doc"; + + +static const char* __doc_gr_digital_mpsk_snr_est_svr_snr = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/msk_timing_recovery_cc_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/msk_timing_recovery_cc_pydoc_template.h new file mode 100644 index 0000000000..0c059f9829 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/msk_timing_recovery_cc_pydoc_template.h @@ -0,0 +1,47 @@ +/* + * 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, digital, __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_digital_msk_timing_recovery_cc = R"doc()doc"; + + +static const char* __doc_gr_digital_msk_timing_recovery_cc_msk_timing_recovery_cc_0 = + R"doc()doc"; + + +static const char* __doc_gr_digital_msk_timing_recovery_cc_msk_timing_recovery_cc_1 = + R"doc()doc"; + + +static const char* __doc_gr_digital_msk_timing_recovery_cc_make = R"doc()doc"; + + +static const char* __doc_gr_digital_msk_timing_recovery_cc_set_gain = R"doc()doc"; + + +static const char* __doc_gr_digital_msk_timing_recovery_cc_get_gain = R"doc()doc"; + + +static const char* __doc_gr_digital_msk_timing_recovery_cc_set_limit = R"doc()doc"; + + +static const char* __doc_gr_digital_msk_timing_recovery_cc_get_limit = R"doc()doc"; + + +static const char* __doc_gr_digital_msk_timing_recovery_cc_set_sps = R"doc()doc"; + + +static const char* __doc_gr_digital_msk_timing_recovery_cc_get_sps = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/ofdm_carrier_allocator_cvc_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/ofdm_carrier_allocator_cvc_pydoc_template.h new file mode 100644 index 0000000000..fee2989a5b --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/ofdm_carrier_allocator_cvc_pydoc_template.h @@ -0,0 +1,41 @@ +/* + * 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, digital, __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_digital_ofdm_carrier_allocator_cvc = R"doc()doc"; + + +static const char* + __doc_gr_digital_ofdm_carrier_allocator_cvc_ofdm_carrier_allocator_cvc_0 = + R"doc()doc"; + + +static const char* + __doc_gr_digital_ofdm_carrier_allocator_cvc_ofdm_carrier_allocator_cvc_1 = + R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_carrier_allocator_cvc_len_tag_key = R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_carrier_allocator_cvc_fft_len = R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_carrier_allocator_cvc_occupied_carriers = + R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_carrier_allocator_cvc_make = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/ofdm_chanest_vcvc_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/ofdm_chanest_vcvc_pydoc_template.h new file mode 100644 index 0000000000..915a03250b --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/ofdm_chanest_vcvc_pydoc_template.h @@ -0,0 +1,24 @@ +/* + * 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, digital, __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_digital_ofdm_chanest_vcvc = R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_chanest_vcvc_ofdm_chanest_vcvc = R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_chanest_vcvc_make = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/ofdm_cyclic_prefixer_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/ofdm_cyclic_prefixer_pydoc_template.h new file mode 100644 index 0000000000..e4d6e9cd4d --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/ofdm_cyclic_prefixer_pydoc_template.h @@ -0,0 +1,28 @@ +/* + * 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, digital, __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_digital_ofdm_cyclic_prefixer = R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_cyclic_prefixer_ofdm_cyclic_prefixer = + R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_cyclic_prefixer_make_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_cyclic_prefixer_make_1 = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/ofdm_equalizer_base_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/ofdm_equalizer_base_pydoc_template.h new file mode 100644 index 0000000000..6174568d51 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/ofdm_equalizer_base_pydoc_template.h @@ -0,0 +1,59 @@ +/* + * 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, digital, __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_digital_ofdm_equalizer_base = R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_equalizer_base_ofdm_equalizer_base_0 = + R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_equalizer_base_ofdm_equalizer_base_1 = + R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_equalizer_base_reset = R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_equalizer_base_equalize = R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_equalizer_base_get_channel_state = R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_equalizer_base_fft_len = R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_equalizer_base_base = R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_equalizer_1d_pilots = R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_equalizer_1d_pilots_ofdm_equalizer_1d_pilots_0 = + R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_equalizer_1d_pilots_ofdm_equalizer_1d_pilots_1 = + R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_equalizer_1d_pilots_reset = R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_equalizer_1d_pilots_get_channel_state = + R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/ofdm_equalizer_simpledfe_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/ofdm_equalizer_simpledfe_pydoc_template.h new file mode 100644 index 0000000000..9f9832814c --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/ofdm_equalizer_simpledfe_pydoc_template.h @@ -0,0 +1,32 @@ +/* + * 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, digital, __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_digital_ofdm_equalizer_simpledfe = R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_equalizer_simpledfe_ofdm_equalizer_simpledfe_0 = + R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_equalizer_simpledfe_ofdm_equalizer_simpledfe_1 = + R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_equalizer_simpledfe_equalize = R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_equalizer_simpledfe_make = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/ofdm_equalizer_static_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/ofdm_equalizer_static_pydoc_template.h new file mode 100644 index 0000000000..1c2b19cc7f --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/ofdm_equalizer_static_pydoc_template.h @@ -0,0 +1,32 @@ +/* + * 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, digital, __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_digital_ofdm_equalizer_static = R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_equalizer_static_ofdm_equalizer_static_0 = + R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_equalizer_static_ofdm_equalizer_static_1 = + R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_equalizer_static_equalize = R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_equalizer_static_make = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/ofdm_frame_equalizer_vcvc_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/ofdm_frame_equalizer_vcvc_pydoc_template.h new file mode 100644 index 0000000000..85528aac9e --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/ofdm_frame_equalizer_vcvc_pydoc_template.h @@ -0,0 +1,25 @@ +/* + * 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, digital, __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_digital_ofdm_frame_equalizer_vcvc = R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_frame_equalizer_vcvc_ofdm_frame_equalizer_vcvc = + R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_frame_equalizer_vcvc_make = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/ofdm_serializer_vcc_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/ofdm_serializer_vcc_pydoc_template.h new file mode 100644 index 0000000000..4743256877 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/ofdm_serializer_vcc_pydoc_template.h @@ -0,0 +1,27 @@ +/* + * 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, digital, __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_digital_ofdm_serializer_vcc = R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_serializer_vcc_ofdm_serializer_vcc = R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_serializer_vcc_make_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_serializer_vcc_make_1 = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/ofdm_sync_sc_cfb_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/ofdm_sync_sc_cfb_pydoc_template.h new file mode 100644 index 0000000000..e198236885 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/ofdm_sync_sc_cfb_pydoc_template.h @@ -0,0 +1,33 @@ +/* + * 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, digital, __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_digital_ofdm_sync_sc_cfb = R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_sync_sc_cfb_ofdm_sync_sc_cfb_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_sync_sc_cfb_ofdm_sync_sc_cfb_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_sync_sc_cfb_make = R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_sync_sc_cfb_set_threshold = R"doc()doc"; + + +static const char* __doc_gr_digital_ofdm_sync_sc_cfb_threshold = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/packet_header_default_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/packet_header_default_pydoc_template.h new file mode 100644 index 0000000000..4d161f9ef8 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/packet_header_default_pydoc_template.h @@ -0,0 +1,50 @@ +/* + * 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, digital, __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_digital_packet_header_default = R"doc()doc"; + + +static const char* __doc_gr_digital_packet_header_default_packet_header_default_0 = + R"doc()doc"; + + +static const char* __doc_gr_digital_packet_header_default_packet_header_default_1 = + R"doc()doc"; + + +static const char* __doc_gr_digital_packet_header_default_base = R"doc()doc"; + + +static const char* __doc_gr_digital_packet_header_default_formatter = R"doc()doc"; + + +static const char* __doc_gr_digital_packet_header_default_set_header_num = R"doc()doc"; + + +static const char* __doc_gr_digital_packet_header_default_header_len = R"doc()doc"; + + +static const char* __doc_gr_digital_packet_header_default_len_tag_key = R"doc()doc"; + + +static const char* __doc_gr_digital_packet_header_default_header_formatter = R"doc()doc"; + + +static const char* __doc_gr_digital_packet_header_default_header_parser = R"doc()doc"; + + +static const char* __doc_gr_digital_packet_header_default_make = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/packet_header_ofdm_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/packet_header_ofdm_pydoc_template.h new file mode 100644 index 0000000000..538b2da887 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/packet_header_ofdm_pydoc_template.h @@ -0,0 +1,33 @@ +/* + * 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, digital, __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_digital_packet_header_ofdm = R"doc()doc"; + + +static const char* __doc_gr_digital_packet_header_ofdm_packet_header_ofdm_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_packet_header_ofdm_packet_header_ofdm_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_packet_header_ofdm_header_formatter = R"doc()doc"; + + +static const char* __doc_gr_digital_packet_header_ofdm_header_parser = R"doc()doc"; + + +static const char* __doc_gr_digital_packet_header_ofdm_make = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/packet_headergenerator_bb_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/packet_headergenerator_bb_pydoc_template.h new file mode 100644 index 0000000000..15fefeca98 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/packet_headergenerator_bb_pydoc_template.h @@ -0,0 +1,36 @@ +/* + * 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, digital, __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_digital_packet_headergenerator_bb = R"doc()doc"; + + +static const char* + __doc_gr_digital_packet_headergenerator_bb_packet_headergenerator_bb_0 = R"doc()doc"; + + +static const char* + __doc_gr_digital_packet_headergenerator_bb_packet_headergenerator_bb_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_packet_headergenerator_bb_make_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_packet_headergenerator_bb_make_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_packet_headergenerator_bb_set_header_formatter = + R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/packet_headerparser_b_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/packet_headerparser_b_pydoc_template.h new file mode 100644 index 0000000000..d2baf9bb4c --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/packet_headerparser_b_pydoc_template.h @@ -0,0 +1,28 @@ +/* + * 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, digital, __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_digital_packet_headerparser_b = R"doc()doc"; + + +static const char* __doc_gr_digital_packet_headerparser_b_packet_headerparser_b = + R"doc()doc"; + + +static const char* __doc_gr_digital_packet_headerparser_b_make_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_packet_headerparser_b_make_1 = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/packet_sink_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/packet_sink_pydoc_template.h new file mode 100644 index 0000000000..78ef39f4da --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/packet_sink_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, digital, __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_digital_packet_sink = R"doc()doc"; + + +static const char* __doc_gr_digital_packet_sink_packet_sink_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_packet_sink_packet_sink_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_packet_sink_make = R"doc()doc"; + + +static const char* __doc_gr_digital_packet_sink_carrier_sensed = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/pfb_clock_sync_ccf_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/pfb_clock_sync_ccf_pydoc_template.h new file mode 100644 index 0000000000..115db55981 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/pfb_clock_sync_ccf_pydoc_template.h @@ -0,0 +1,91 @@ +/* + * 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, digital, __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_digital_pfb_clock_sync_ccf = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_ccf_pfb_clock_sync_ccf_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_ccf_pfb_clock_sync_ccf_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_ccf_make = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_ccf_update_gains = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_ccf_update_taps = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_ccf_taps = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_ccf_diff_taps = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_ccf_channel_taps = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_ccf_diff_channel_taps = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_ccf_taps_as_string = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_ccf_diff_taps_as_string = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_ccf_set_loop_bandwidth = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_ccf_set_damping_factor = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_ccf_set_alpha = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_ccf_set_beta = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_ccf_set_max_rate_deviation = + R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_ccf_loop_bandwidth = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_ccf_damping_factor = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_ccf_alpha = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_ccf_beta = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_ccf_clock_rate = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_ccf_error = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_ccf_rate = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_ccf_phase = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/pfb_clock_sync_fff_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/pfb_clock_sync_fff_pydoc_template.h new file mode 100644 index 0000000000..2a51dcd472 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/pfb_clock_sync_fff_pydoc_template.h @@ -0,0 +1,82 @@ +/* + * 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, digital, __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_digital_pfb_clock_sync_fff = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_fff_pfb_clock_sync_fff_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_fff_pfb_clock_sync_fff_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_fff_make = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_fff_update_gains = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_fff_update_taps = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_fff_taps = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_fff_diff_taps = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_fff_channel_taps = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_fff_diff_channel_taps = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_fff_taps_as_string = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_fff_diff_taps_as_string = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_fff_set_loop_bandwidth = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_fff_set_damping_factor = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_fff_set_alpha = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_fff_set_beta = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_fff_set_max_rate_deviation = + R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_fff_loop_bandwidth = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_fff_damping_factor = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_fff_alpha = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_fff_beta = R"doc()doc"; + + +static const char* __doc_gr_digital_pfb_clock_sync_fff_clock_rate = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/pn_correlator_cc_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/pn_correlator_cc_pydoc_template.h new file mode 100644 index 0000000000..739032d070 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/pn_correlator_cc_pydoc_template.h @@ -0,0 +1,24 @@ +/* + * 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, digital, __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_digital_pn_correlator_cc = R"doc()doc"; + + +static const char* __doc_gr_digital_pn_correlator_cc_pn_correlator_cc = R"doc()doc"; + + +static const char* __doc_gr_digital_pn_correlator_cc_make = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/probe_density_b_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/probe_density_b_pydoc_template.h new file mode 100644 index 0000000000..9834f76e34 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/probe_density_b_pydoc_template.h @@ -0,0 +1,33 @@ +/* + * 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, digital, __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_digital_probe_density_b = R"doc()doc"; + + +static const char* __doc_gr_digital_probe_density_b_probe_density_b_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_probe_density_b_probe_density_b_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_probe_density_b_make = R"doc()doc"; + + +static const char* __doc_gr_digital_probe_density_b_density = R"doc()doc"; + + +static const char* __doc_gr_digital_probe_density_b_set_alpha = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/probe_mpsk_snr_est_c_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/probe_mpsk_snr_est_c_pydoc_template.h new file mode 100644 index 0000000000..ca38a46af4 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/probe_mpsk_snr_est_c_pydoc_template.h @@ -0,0 +1,56 @@ +/* + * 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, digital, __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_digital_probe_mpsk_snr_est_c = R"doc()doc"; + + +static const char* __doc_gr_digital_probe_mpsk_snr_est_c_probe_mpsk_snr_est_c_0 = + R"doc()doc"; + + +static const char* __doc_gr_digital_probe_mpsk_snr_est_c_probe_mpsk_snr_est_c_1 = + R"doc()doc"; + + +static const char* __doc_gr_digital_probe_mpsk_snr_est_c_make = R"doc()doc"; + + +static const char* __doc_gr_digital_probe_mpsk_snr_est_c_snr = R"doc()doc"; + + +static const char* __doc_gr_digital_probe_mpsk_snr_est_c_signal = R"doc()doc"; + + +static const char* __doc_gr_digital_probe_mpsk_snr_est_c_noise = R"doc()doc"; + + +static const char* __doc_gr_digital_probe_mpsk_snr_est_c_type = R"doc()doc"; + + +static const char* __doc_gr_digital_probe_mpsk_snr_est_c_msg_nsample = R"doc()doc"; + + +static const char* __doc_gr_digital_probe_mpsk_snr_est_c_alpha = R"doc()doc"; + + +static const char* __doc_gr_digital_probe_mpsk_snr_est_c_set_type = R"doc()doc"; + + +static const char* __doc_gr_digital_probe_mpsk_snr_est_c_set_msg_nsample = R"doc()doc"; + + +static const char* __doc_gr_digital_probe_mpsk_snr_est_c_set_alpha = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/protocol_formatter_async_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/protocol_formatter_async_pydoc_template.h new file mode 100644 index 0000000000..4485bf0e52 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/protocol_formatter_async_pydoc_template.h @@ -0,0 +1,25 @@ +/* + * 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, digital, __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_digital_protocol_formatter_async = R"doc()doc"; + + +static const char* __doc_gr_digital_protocol_formatter_async_protocol_formatter_async = + R"doc()doc"; + + +static const char* __doc_gr_digital_protocol_formatter_async_make = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/protocol_formatter_bb_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/protocol_formatter_bb_pydoc_template.h new file mode 100644 index 0000000000..410eb6060f --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/protocol_formatter_bb_pydoc_template.h @@ -0,0 +1,32 @@ +/* + * 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, digital, __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_digital_protocol_formatter_bb = R"doc()doc"; + + +static const char* __doc_gr_digital_protocol_formatter_bb_protocol_formatter_bb_0 = + R"doc()doc"; + + +static const char* __doc_gr_digital_protocol_formatter_bb_protocol_formatter_bb_1 = + R"doc()doc"; + + +static const char* __doc_gr_digital_protocol_formatter_bb_make = R"doc()doc"; + + +static const char* __doc_gr_digital_protocol_formatter_bb_set_header_format = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/protocol_parser_b_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/protocol_parser_b_pydoc_template.h new file mode 100644 index 0000000000..842bcc44de --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/protocol_parser_b_pydoc_template.h @@ -0,0 +1,24 @@ +/* + * 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, digital, __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_digital_protocol_parser_b = R"doc()doc"; + + +static const char* __doc_gr_digital_protocol_parser_b_protocol_parser_b = R"doc()doc"; + + +static const char* __doc_gr_digital_protocol_parser_b_make = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/scrambler_bb_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/scrambler_bb_pydoc_template.h new file mode 100644 index 0000000000..296b7d351a --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/scrambler_bb_pydoc_template.h @@ -0,0 +1,24 @@ +/* + * 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, digital, __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_digital_scrambler_bb = R"doc()doc"; + + +static const char* __doc_gr_digital_scrambler_bb_scrambler_bb = R"doc()doc"; + + +static const char* __doc_gr_digital_scrambler_bb_make = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/simple_correlator_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/simple_correlator_pydoc_template.h new file mode 100644 index 0000000000..31ce13f096 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/simple_correlator_pydoc_template.h @@ -0,0 +1,24 @@ +/* + * 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, digital, __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_digital_simple_correlator = R"doc()doc"; + + +static const char* __doc_gr_digital_simple_correlator_simple_correlator = R"doc()doc"; + + +static const char* __doc_gr_digital_simple_correlator_make = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/simple_framer_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/simple_framer_pydoc_template.h new file mode 100644 index 0000000000..bd6f2f10c5 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/simple_framer_pydoc_template.h @@ -0,0 +1,24 @@ +/* + * 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, digital, __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_digital_simple_framer = R"doc()doc"; + + +static const char* __doc_gr_digital_simple_framer_simple_framer = R"doc()doc"; + + +static const char* __doc_gr_digital_simple_framer_make = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/simple_framer_sync_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/simple_framer_sync_pydoc_template.h new file mode 100644 index 0000000000..84c1cb8104 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/simple_framer_sync_pydoc_template.h @@ -0,0 +1,15 @@ +/* + * 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, digital, __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 + */ diff --git a/gr-digital/python/digital/bindings/docstrings/symbol_sync_cc_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/symbol_sync_cc_pydoc_template.h new file mode 100644 index 0000000000..1984fa55f9 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/symbol_sync_cc_pydoc_template.h @@ -0,0 +1,57 @@ +/* + * 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, digital, __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_digital_symbol_sync_cc = R"doc()doc"; + + +static const char* __doc_gr_digital_symbol_sync_cc_symbol_sync_cc_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_symbol_sync_cc_symbol_sync_cc_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_symbol_sync_cc_make = R"doc()doc"; + + +static const char* __doc_gr_digital_symbol_sync_cc_loop_bandwidth = R"doc()doc"; + + +static const char* __doc_gr_digital_symbol_sync_cc_damping_factor = R"doc()doc"; + + +static const char* __doc_gr_digital_symbol_sync_cc_ted_gain = R"doc()doc"; + + +static const char* __doc_gr_digital_symbol_sync_cc_alpha = R"doc()doc"; + + +static const char* __doc_gr_digital_symbol_sync_cc_beta = R"doc()doc"; + + +static const char* __doc_gr_digital_symbol_sync_cc_set_loop_bandwidth = R"doc()doc"; + + +static const char* __doc_gr_digital_symbol_sync_cc_set_damping_factor = R"doc()doc"; + + +static const char* __doc_gr_digital_symbol_sync_cc_set_ted_gain = R"doc()doc"; + + +static const char* __doc_gr_digital_symbol_sync_cc_set_alpha = R"doc()doc"; + + +static const char* __doc_gr_digital_symbol_sync_cc_set_beta = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/symbol_sync_ff_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/symbol_sync_ff_pydoc_template.h new file mode 100644 index 0000000000..0bfdaf5610 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/symbol_sync_ff_pydoc_template.h @@ -0,0 +1,57 @@ +/* + * 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, digital, __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_digital_symbol_sync_ff = R"doc()doc"; + + +static const char* __doc_gr_digital_symbol_sync_ff_symbol_sync_ff_0 = R"doc()doc"; + + +static const char* __doc_gr_digital_symbol_sync_ff_symbol_sync_ff_1 = R"doc()doc"; + + +static const char* __doc_gr_digital_symbol_sync_ff_make = R"doc()doc"; + + +static const char* __doc_gr_digital_symbol_sync_ff_loop_bandwidth = R"doc()doc"; + + +static const char* __doc_gr_digital_symbol_sync_ff_damping_factor = R"doc()doc"; + + +static const char* __doc_gr_digital_symbol_sync_ff_ted_gain = R"doc()doc"; + + +static const char* __doc_gr_digital_symbol_sync_ff_alpha = R"doc()doc"; + + +static const char* __doc_gr_digital_symbol_sync_ff_beta = R"doc()doc"; + + +static const char* __doc_gr_digital_symbol_sync_ff_set_loop_bandwidth = R"doc()doc"; + + +static const char* __doc_gr_digital_symbol_sync_ff_set_damping_factor = R"doc()doc"; + + +static const char* __doc_gr_digital_symbol_sync_ff_set_ted_gain = R"doc()doc"; + + +static const char* __doc_gr_digital_symbol_sync_ff_set_alpha = R"doc()doc"; + + +static const char* __doc_gr_digital_symbol_sync_ff_set_beta = R"doc()doc"; diff --git a/gr-digital/python/digital/bindings/docstrings/timing_error_detector_type_pydoc_template.h b/gr-digital/python/digital/bindings/docstrings/timing_error_detector_type_pydoc_template.h new file mode 100644 index 0000000000..84c1cb8104 --- /dev/null +++ b/gr-digital/python/digital/bindings/docstrings/timing_error_detector_type_pydoc_template.h @@ -0,0 +1,15 @@ +/* + * 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, digital, __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 + */ diff --git a/gr-digital/python/digital/bindings/fll_band_edge_cc_python.cc b/gr-digital/python/digital/bindings/fll_band_edge_cc_python.cc new file mode 100644 index 0000000000..afc5e0d7f9 --- /dev/null +++ b/gr-digital/python/digital/bindings/fll_band_edge_cc_python.cc @@ -0,0 +1,77 @@ +/* + * 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/digital/fll_band_edge_cc.h> +// pydoc.h is automatically generated in the build directory +#include <fll_band_edge_cc_pydoc.h> + +void bind_fll_band_edge_cc(py::module& m) +{ + + using fll_band_edge_cc = ::gr::digital::fll_band_edge_cc; + + + py::class_<fll_band_edge_cc, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<fll_band_edge_cc>>( + m, "fll_band_edge_cc", D(fll_band_edge_cc)) + + .def(py::init(&fll_band_edge_cc::make), + py::arg("samps_per_sym"), + py::arg("rolloff"), + py::arg("filter_size"), + py::arg("bandwidth"), + D(fll_band_edge_cc, make)) + + + .def("set_samples_per_symbol", + &fll_band_edge_cc::set_samples_per_symbol, + py::arg("sps"), + D(fll_band_edge_cc, set_samples_per_symbol)) + + + .def("set_rolloff", + &fll_band_edge_cc::set_rolloff, + py::arg("rolloff"), + D(fll_band_edge_cc, set_rolloff)) + + + .def("set_filter_size", + &fll_band_edge_cc::set_filter_size, + py::arg("filter_size"), + D(fll_band_edge_cc, set_filter_size)) + + + .def("samples_per_symbol", + &fll_band_edge_cc::samples_per_symbol, + D(fll_band_edge_cc, samples_per_symbol)) + + + .def("rolloff", &fll_band_edge_cc::rolloff, D(fll_band_edge_cc, rolloff)) + + + .def("filter_size", + &fll_band_edge_cc::filter_size, + D(fll_band_edge_cc, filter_size)) + + + .def("print_taps", &fll_band_edge_cc::print_taps, D(fll_band_edge_cc, print_taps)) + + ; +} diff --git a/gr-digital/python/digital/bindings/framer_sink_1_python.cc b/gr-digital/python/digital/bindings/framer_sink_1_python.cc new file mode 100644 index 0000000000..f80260a333 --- /dev/null +++ b/gr-digital/python/digital/bindings/framer_sink_1_python.cc @@ -0,0 +1,40 @@ +/* + * 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/digital/framer_sink_1.h> +// pydoc.h is automatically generated in the build directory +#include <framer_sink_1_pydoc.h> + +void bind_framer_sink_1(py::module& m) +{ + + using framer_sink_1 = ::gr::digital::framer_sink_1; + + + py::class_<framer_sink_1, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<framer_sink_1>>(m, "framer_sink_1", D(framer_sink_1)) + + .def(py::init(&framer_sink_1::make), + py::arg("target_queue"), + D(framer_sink_1, make)) + + + ; +} diff --git a/gr-digital/python/digital/bindings/glfsr_python.cc b/gr-digital/python/digital/bindings/glfsr_python.cc new file mode 100644 index 0000000000..79e3f3f6a9 --- /dev/null +++ b/gr-digital/python/digital/bindings/glfsr_python.cc @@ -0,0 +1,47 @@ +/* + * 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/digital/glfsr.h> +// pydoc.h is automatically generated in the build directory +#include <glfsr_pydoc.h> + +void bind_glfsr(py::module& m) +{ + + using glfsr = ::gr::digital::glfsr; + + + py::class_<glfsr, std::shared_ptr<glfsr>>(m, "glfsr", D(glfsr)) + + .def(py::init<uint32_t, uint32_t>(), + py::arg("mask"), + py::arg("seed"), + D(glfsr, glfsr, 0)) + .def(py::init<gr::digital::glfsr const&>(), py::arg("arg0"), D(glfsr, glfsr, 1)) + + + .def_static( + "glfsr_mask", &glfsr::glfsr_mask, py::arg("degree"), D(glfsr, glfsr_mask)) + + + .def("next_bit", &glfsr::next_bit, D(glfsr, next_bit)) + + + .def("mask", &glfsr::mask, D(glfsr, mask)) + + ; +} diff --git a/gr-digital/python/digital/bindings/glfsr_source_b_python.cc b/gr-digital/python/digital/bindings/glfsr_source_b_python.cc new file mode 100644 index 0000000000..bc3733d32e --- /dev/null +++ b/gr-digital/python/digital/bindings/glfsr_source_b_python.cc @@ -0,0 +1,48 @@ +/* + * 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/digital/glfsr_source_b.h> +// pydoc.h is automatically generated in the build directory +#include <glfsr_source_b_pydoc.h> + +void bind_glfsr_source_b(py::module& m) +{ + + using glfsr_source_b = ::gr::digital::glfsr_source_b; + + + py::class_<glfsr_source_b, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<glfsr_source_b>>(m, "glfsr_source_b", D(glfsr_source_b)) + + .def(py::init(&glfsr_source_b::make), + py::arg("degree"), + py::arg("repeat") = true, + py::arg("mask") = 0, + py::arg("seed") = 1, + D(glfsr_source_b, make)) + + + .def("period", &glfsr_source_b::period, D(glfsr_source_b, period)) + + + .def("mask", &glfsr_source_b::mask, D(glfsr_source_b, mask)) + + ; +} diff --git a/gr-digital/python/digital/bindings/glfsr_source_f_python.cc b/gr-digital/python/digital/bindings/glfsr_source_f_python.cc new file mode 100644 index 0000000000..7ecb53ae86 --- /dev/null +++ b/gr-digital/python/digital/bindings/glfsr_source_f_python.cc @@ -0,0 +1,48 @@ +/* + * 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/digital/glfsr_source_f.h> +// pydoc.h is automatically generated in the build directory +#include <glfsr_source_f_pydoc.h> + +void bind_glfsr_source_f(py::module& m) +{ + + using glfsr_source_f = ::gr::digital::glfsr_source_f; + + + py::class_<glfsr_source_f, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<glfsr_source_f>>(m, "glfsr_source_f", D(glfsr_source_f)) + + .def(py::init(&glfsr_source_f::make), + py::arg("degree"), + py::arg("repeat") = true, + py::arg("mask") = 0, + py::arg("seed") = 1, + D(glfsr_source_f, make)) + + + .def("period", &glfsr_source_f::period, D(glfsr_source_f, period)) + + + .def("mask", &glfsr_source_f::mask, D(glfsr_source_f, mask)) + + ; +} diff --git a/gr-digital/python/digital/bindings/hdlc_deframer_bp_python.cc b/gr-digital/python/digital/bindings/hdlc_deframer_bp_python.cc new file mode 100644 index 0000000000..0aa30ad5f3 --- /dev/null +++ b/gr-digital/python/digital/bindings/hdlc_deframer_bp_python.cc @@ -0,0 +1,42 @@ +/* + * 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/digital/hdlc_deframer_bp.h> +// pydoc.h is automatically generated in the build directory +#include <hdlc_deframer_bp_pydoc.h> + +void bind_hdlc_deframer_bp(py::module& m) +{ + + using hdlc_deframer_bp = ::gr::digital::hdlc_deframer_bp; + + + py::class_<hdlc_deframer_bp, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<hdlc_deframer_bp>>( + m, "hdlc_deframer_bp", D(hdlc_deframer_bp)) + + .def(py::init(&hdlc_deframer_bp::make), + py::arg("length_min"), + py::arg("length_max"), + D(hdlc_deframer_bp, make)) + + + ; +} diff --git a/gr-digital/python/digital/bindings/hdlc_framer_pb_python.cc b/gr-digital/python/digital/bindings/hdlc_framer_pb_python.cc new file mode 100644 index 0000000000..2f1d25d537 --- /dev/null +++ b/gr-digital/python/digital/bindings/hdlc_framer_pb_python.cc @@ -0,0 +1,40 @@ +/* + * 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/digital/hdlc_framer_pb.h> +// pydoc.h is automatically generated in the build directory +#include <hdlc_framer_pb_pydoc.h> + +void bind_hdlc_framer_pb(py::module& m) +{ + + using hdlc_framer_pb = ::gr::digital::hdlc_framer_pb; + + + py::class_<hdlc_framer_pb, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<hdlc_framer_pb>>(m, "hdlc_framer_pb", D(hdlc_framer_pb)) + + .def(py::init(&hdlc_framer_pb::make), + py::arg("frame_tag_name"), + D(hdlc_framer_pb, make)) + + + ; +} diff --git a/gr-digital/python/digital/bindings/header_buffer_python.cc b/gr-digital/python/digital/bindings/header_buffer_python.cc new file mode 100644 index 0000000000..4079277d62 --- /dev/null +++ b/gr-digital/python/digital/bindings/header_buffer_python.cc @@ -0,0 +1,115 @@ +/* + * 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/digital/header_buffer.h> +// pydoc.h is automatically generated in the build directory +#include <header_buffer_pydoc.h> + +void bind_header_buffer(py::module& m) +{ + + using header_buffer = ::gr::digital::header_buffer; + + + py::class_<header_buffer, std::shared_ptr<header_buffer>>( + m, "header_buffer", D(header_buffer)) + + .def(py::init<uint8_t*>(), + py::arg("buffer") = __null, + D(header_buffer, header_buffer, 0)) + .def(py::init<gr::digital::header_buffer const&>(), + py::arg("arg0"), + D(header_buffer, header_buffer, 1)) + + + .def("clear", &header_buffer::clear, D(header_buffer, clear)) + + + .def("header", &header_buffer::header, D(header_buffer, header)) + + + .def("add_field8", + &header_buffer::add_field8, + py::arg("data"), + py::arg("len") = 8, + py::arg("bs") = false, + D(header_buffer, add_field8)) + + + .def("add_field16", + &header_buffer::add_field16, + py::arg("data"), + py::arg("len") = 16, + py::arg("bs") = false, + D(header_buffer, add_field16)) + + + .def("add_field32", + &header_buffer::add_field32, + py::arg("data"), + py::arg("len") = 32, + py::arg("bs") = false, + D(header_buffer, add_field32)) + + + .def("add_field64", + &header_buffer::add_field64, + py::arg("data"), + py::arg("len") = 64, + py::arg("bs") = false, + D(header_buffer, add_field64)) + + + .def("insert_bit", + &header_buffer::insert_bit, + py::arg("bit"), + D(header_buffer, insert_bit)) + + + .def("extract_field8", + &header_buffer::extract_field8, + py::arg("pos"), + py::arg("len") = 8, + py::arg("bs") = false, + D(header_buffer, extract_field8)) + + + .def("extract_field16", + &header_buffer::extract_field16, + py::arg("pos"), + py::arg("len") = 16, + py::arg("bs") = false, + D(header_buffer, extract_field16)) + + + .def("extract_field32", + &header_buffer::extract_field32, + py::arg("pos"), + py::arg("len") = 32, + py::arg("bs") = false, + D(header_buffer, extract_field32)) + + + .def("extract_field64", + &header_buffer::extract_field64, + py::arg("pos"), + py::arg("len") = 64, + py::arg("bs") = false, + D(header_buffer, extract_field64)) + + ; +} diff --git a/gr-digital/python/digital/bindings/header_format_base_python.cc b/gr-digital/python/digital/bindings/header_format_base_python.cc new file mode 100644 index 0000000000..3cdca0c109 --- /dev/null +++ b/gr-digital/python/digital/bindings/header_format_base_python.cc @@ -0,0 +1,70 @@ +/* + * 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/digital/header_format_base.h> +// pydoc.h is automatically generated in the build directory +#include <header_format_base_pydoc.h> + +void bind_header_format_base(py::module& m) +{ + + using header_format_base = ::gr::digital::header_format_base; + + + py::class_<header_format_base, std::shared_ptr<header_format_base>>( + m, "header_format_base", D(header_format_base)) + + //.def(py::init<>(),D(header_format_base,header_format_base,0)) + //.def(py::init<gr::digital::header_format_base const &>(), py::arg("arg0"), + // D(header_format_base,header_format_base,1) + //) + + + .def("base", &header_format_base::base, D(header_format_base, base)) + + + .def( + "formatter", &header_format_base::formatter, D(header_format_base, formatter)) + + + .def("format", + &header_format_base::format, + py::arg("nbytes_in"), + py::arg("input"), + py::arg("output"), + py::arg("info"), + D(header_format_base, format)) + .def("parse", + &header_format_base::parse, + py::arg("nbits_in"), + py::arg("input"), + py::arg("info"), + py::arg("nbits_processed"), + D(header_format_base, parse)) + + + .def("header_nbits", + &header_format_base::header_nbits, + D(header_format_base, header_nbits)) + + + .def("header_nbytes", + &header_format_base::header_nbytes, + D(header_format_base, header_nbytes)) + + ; +} diff --git a/gr-digital/python/digital/bindings/header_format_counter_python.cc b/gr-digital/python/digital/bindings/header_format_counter_python.cc new file mode 100644 index 0000000000..cea5228698 --- /dev/null +++ b/gr-digital/python/digital/bindings/header_format_counter_python.cc @@ -0,0 +1,63 @@ +/* + * 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/digital/header_format_counter.h> +// pydoc.h is automatically generated in the build directory +#include <header_format_counter_pydoc.h> + +void bind_header_format_counter(py::module& m) +{ + + using header_format_counter = ::gr::digital::header_format_counter; + + py::class_<header_format_counter, + gr::digital::header_format_default, + std::shared_ptr<header_format_counter>>( + m, "header_format_counter", D(header_format_counter)) + + // The make function returns a _base pointer, which is incompatible according to + // pybind11 + .def(py::init(&header_format_counter::make), + py::arg("access_code"), + py::arg("threshold"), + py::arg("bps"), + D(header_format_counter, make)) + + .def_static("make", + &header_format_counter::make, + py::arg("access_code"), + py::arg("threshold"), + py::arg("bps"), + D(header_format_counter, make)) + + + .def("format", + &header_format_counter::format, + py::arg("nbytes_in"), + py::arg("input"), + py::arg("output"), + py::arg("info"), + D(header_format_counter, format)) + + + .def("header_nbits", + &header_format_counter::header_nbits, + D(header_format_counter, header_nbits)) + + + ; +} diff --git a/gr-digital/python/digital/bindings/header_format_crc_python.cc b/gr-digital/python/digital/bindings/header_format_crc_python.cc new file mode 100644 index 0000000000..4c7ff42f71 --- /dev/null +++ b/gr-digital/python/digital/bindings/header_format_crc_python.cc @@ -0,0 +1,70 @@ +/* + * 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/digital/header_format_crc.h> +// pydoc.h is automatically generated in the build directory +#include <header_format_crc_pydoc.h> + +void bind_header_format_crc(py::module& m) +{ + + using header_format_crc = ::gr::digital::header_format_crc; + + py::class_<header_format_crc, + gr::digital::header_format_base, + std::shared_ptr<header_format_crc>>( + m, "header_format_crc", D(header_format_crc)) + + + .def(py::init(&header_format_crc::make), + py::arg("len_key_name") = "packet_len", + py::arg("num_key_name") = "packet_num", + D(header_format_crc, make)) + .def_static("make", + &header_format_crc::make, + py::arg("len_key_name") = "packet_len", + py::arg("num_key_name") = "packet_num", + D(header_format_crc, make)) + + + .def("set_header_num", + &header_format_crc::set_header_num, + py::arg("header_num"), + D(header_format_crc, set_header_num)) + .def("format", + &header_format_crc::format, + py::arg("nbytes_in"), + py::arg("input"), + py::arg("output"), + py::arg("info"), + D(header_format_crc, format)) + .def("parse", + &header_format_crc::parse, + py::arg("nbits_in"), + py::arg("input"), + py::arg("info"), + py::arg("nbits_processed"), + D(header_format_crc, parse)) + + + .def("header_nbits", + &header_format_crc::header_nbits, + D(header_format_crc, header_nbits)) + + + ; +} diff --git a/gr-digital/python/digital/bindings/header_format_default_python.cc b/gr-digital/python/digital/bindings/header_format_default_python.cc new file mode 100644 index 0000000000..8bbcd501f5 --- /dev/null +++ b/gr-digital/python/digital/bindings/header_format_default_python.cc @@ -0,0 +1,89 @@ +/* + * 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/digital/header_format_default.h> +// pydoc.h is automatically generated in the build directory +#include <header_format_default_pydoc.h> + +void bind_header_format_default(py::module& m) +{ + + using header_format_default = ::gr::digital::header_format_default; + + py::class_<header_format_default, + gr::digital::header_format_base, + std::shared_ptr<header_format_default>>( + m, "header_format_default", D(header_format_default)) + + .def(py::init(&header_format_default::make), + py::arg("access_code"), + py::arg("threshold"), + py::arg("bps") = 1, + D(header_format_default, make)) + .def_static("make", + &header_format_default::make, + py::arg("access_code"), + py::arg("threshold"), + py::arg("bps") = 1, + D(header_format_default, make)) + + + .def("format", + &header_format_default::format, + py::arg("nbytes_in"), + py::arg("input"), + py::arg("output"), + py::arg("info"), + D(header_format_default, format)) + .def("parse", + &header_format_default::parse, + py::arg("nbits_in"), + py::arg("input"), + py::arg("info"), + py::arg("nbits_processed"), + D(header_format_default, parse)) + + + .def("header_nbits", + &header_format_default::header_nbits, + D(header_format_default, header_nbits)) + + + .def("set_access_code", + &header_format_default::set_access_code, + py::arg("access_code"), + D(header_format_default, set_access_code)) + + + .def("access_code", + &header_format_default::access_code, + D(header_format_default, access_code)) + + + .def("set_threshold", + &header_format_default::set_threshold, + py::arg("thresh") = 0, + D(header_format_default, set_threshold)) + + + .def("threshold", + &header_format_default::threshold, + D(header_format_default, threshold)) + + + ; +} diff --git a/gr-digital/python/digital/bindings/header_format_ofdm_python.cc b/gr-digital/python/digital/bindings/header_format_ofdm_python.cc new file mode 100644 index 0000000000..565ecf100e --- /dev/null +++ b/gr-digital/python/digital/bindings/header_format_ofdm_python.cc @@ -0,0 +1,78 @@ +/* + * 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/digital/header_format_ofdm.h> +// pydoc.h is automatically generated in the build directory +#include <header_format_ofdm_pydoc.h> + +void bind_header_format_ofdm(py::module& m) +{ + + using header_format_ofdm = ::gr::digital::header_format_ofdm; + + py::class_<header_format_ofdm, + gr::digital::header_format_crc, + std::shared_ptr<header_format_ofdm>>( + m, "header_format_ofdm", D(header_format_ofdm)) + + + .def(py::init(&header_format_ofdm::make), + py::arg("occupied_carriers"), + py::arg("n_syms"), + py::arg("len_key_name") = "packet_len", + py::arg("frame_key_name") = "frame_len", + py::arg("num_key_name") = "packet_num", + py::arg("bits_per_header_sym") = 1, + py::arg("bits_per_payload_sym") = 1, + py::arg("scramble_header") = false, + D(header_format_ofdm, make)) + .def_static("make", + &header_format_ofdm::make, + py::arg("occupied_carriers"), + py::arg("n_syms"), + py::arg("len_key_name") = "packet_len", + py::arg("frame_key_name") = "frame_len", + py::arg("num_key_name") = "packet_num", + py::arg("bits_per_header_sym") = 1, + py::arg("bits_per_payload_sym") = 1, + py::arg("scramble_header") = false, + D(header_format_ofdm, make)) + + + .def("format", + &header_format_ofdm::format, + py::arg("nbytes_in"), + py::arg("input"), + py::arg("output"), + py::arg("info"), + D(header_format_ofdm, format)) + .def("parse", + &header_format_ofdm::parse, + py::arg("nbits_in"), + py::arg("input"), + py::arg("info"), + py::arg("nbits_processed"), + D(header_format_ofdm, parse)) + + + .def("header_nbits", + &header_format_ofdm::header_nbits, + D(header_format_ofdm, header_nbits)) + + + ; +} diff --git a/gr-digital/python/digital/bindings/header_payload_demux_python.cc b/gr-digital/python/digital/bindings/header_payload_demux_python.cc new file mode 100644 index 0000000000..f643fd22a5 --- /dev/null +++ b/gr-digital/python/digital/bindings/header_payload_demux_python.cc @@ -0,0 +1,47 @@ +/* + * 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/digital/header_payload_demux.h> +// pydoc.h is automatically generated in the build directory +#include <header_payload_demux_pydoc.h> + +void bind_header_payload_demux(py::module& m) +{ + + using header_payload_demux = ::gr::digital::header_payload_demux; + + + py::class_<header_payload_demux, + gr::block, + gr::basic_block, + std::shared_ptr<header_payload_demux>>( + m, "header_payload_demux", D(header_payload_demux)) + + .def(py::init(&header_payload_demux::make), + py::arg("header_len"), + py::arg("items_per_symbol") = 1, + py::arg("guard_interval") = 0, + py::arg("length_tag_key") = "frame_len", + py::arg("trigger_tag_key") = "", + py::arg("output_symbols") = false, + py::arg("itemsize") = sizeof(gr_complex), + py::arg("timing_tag_key") = "", + py::arg("samp_rate") = 1., + py::arg("special_tags") = std::vector<std::string>(), + py::arg("header_padding") = 0, + D(header_payload_demux, make)); +} diff --git a/gr-digital/python/digital/bindings/interpolating_resampler_type_python.cc b/gr-digital/python/digital/bindings/interpolating_resampler_type_python.cc new file mode 100644 index 0000000000..6da07d105d --- /dev/null +++ b/gr-digital/python/digital/bindings/interpolating_resampler_type_python.cc @@ -0,0 +1,31 @@ +/* + * 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/digital/interpolating_resampler_type.h> +// pydoc.h is automatically generated in the build directory +#include <interpolating_resampler_type_pydoc.h> + +void bind_interpolating_resampler_type(py::module& m) +{ + + py::enum_<gr::digital::ir_type>(m, "ir_type") + .value("IR_NONE", gr::digital::IR_NONE) // -1 + .value("IR_MMSE_8TAP", gr::digital::IR_MMSE_8TAP) // 0 + .value("IR_PFB_NO_MF", gr::digital::IR_PFB_NO_MF) // 1 + .value("IR_PFB_MF", gr::digital::IR_PFB_MF) // 2 + .export_values(); +} diff --git a/gr-digital/python/digital/bindings/kurtotic_equalizer_cc_python.cc b/gr-digital/python/digital/bindings/kurtotic_equalizer_cc_python.cc new file mode 100644 index 0000000000..6b1faefdbb --- /dev/null +++ b/gr-digital/python/digital/bindings/kurtotic_equalizer_cc_python.cc @@ -0,0 +1,51 @@ +/* + * 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/digital/kurtotic_equalizer_cc.h> +// pydoc.h is automatically generated in the build directory +#include <kurtotic_equalizer_cc_pydoc.h> + +void bind_kurtotic_equalizer_cc(py::module& m) +{ + + using kurtotic_equalizer_cc = ::gr::digital::kurtotic_equalizer_cc; + + + py::class_<kurtotic_equalizer_cc, + gr::sync_decimator, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<kurtotic_equalizer_cc>>( + m, "kurtotic_equalizer_cc", D(kurtotic_equalizer_cc)) + + .def(py::init(&kurtotic_equalizer_cc::make), + py::arg("num_taps"), + py::arg("mu"), + D(kurtotic_equalizer_cc, make)) + + + .def("gain", &kurtotic_equalizer_cc::gain, D(kurtotic_equalizer_cc, gain)) + + + .def("set_gain", + &kurtotic_equalizer_cc::set_gain, + py::arg("mu"), + D(kurtotic_equalizer_cc, set_gain)) + + ; +} diff --git a/gr-digital/python/digital/bindings/lfsr_python.cc b/gr-digital/python/digital/bindings/lfsr_python.cc new file mode 100644 index 0000000000..f6b4fe0b92 --- /dev/null +++ b/gr-digital/python/digital/bindings/lfsr_python.cc @@ -0,0 +1,62 @@ +/* + * 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/digital/lfsr.h> +// pydoc.h is automatically generated in the build directory +#include <lfsr_pydoc.h> + +void bind_lfsr(py::module& m) +{ + + using lfsr = ::gr::digital::lfsr; + + + py::class_<lfsr, std::shared_ptr<lfsr>>(m, "lfsr", D(lfsr)) + + .def(py::init<uint32_t, uint32_t, uint32_t>(), + py::arg("mask"), + py::arg("seed"), + py::arg("reg_len"), + D(lfsr, lfsr, 0)) + .def(py::init<gr::digital::lfsr const&>(), py::arg("arg0"), D(lfsr, lfsr, 1)) + + + .def("next_bit", &lfsr::next_bit, D(lfsr, next_bit)) + + + .def("next_bit_scramble", + &lfsr::next_bit_scramble, + py::arg("input"), + D(lfsr, next_bit_scramble)) + + + .def("next_bit_descramble", + &lfsr::next_bit_descramble, + py::arg("input"), + D(lfsr, next_bit_descramble)) + + + .def("reset", &lfsr::reset, D(lfsr, reset)) + + + .def("pre_shift", &lfsr::pre_shift, py::arg("num"), D(lfsr, pre_shift)) + + + .def("mask", &lfsr::mask, D(lfsr, mask)) + + ; +} diff --git a/gr-digital/python/digital/bindings/lms_dd_equalizer_cc_python.cc b/gr-digital/python/digital/bindings/lms_dd_equalizer_cc_python.cc new file mode 100644 index 0000000000..7300dbd93c --- /dev/null +++ b/gr-digital/python/digital/bindings/lms_dd_equalizer_cc_python.cc @@ -0,0 +1,62 @@ +/* + * 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/digital/lms_dd_equalizer_cc.h> +// pydoc.h is automatically generated in the build directory +#include <lms_dd_equalizer_cc_pydoc.h> + +void bind_lms_dd_equalizer_cc(py::module& m) +{ + + using lms_dd_equalizer_cc = ::gr::digital::lms_dd_equalizer_cc; + + + py::class_<lms_dd_equalizer_cc, + gr::sync_decimator, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<lms_dd_equalizer_cc>>( + m, "lms_dd_equalizer_cc", D(lms_dd_equalizer_cc)) + + .def(py::init(&lms_dd_equalizer_cc::make), + py::arg("num_taps"), + py::arg("mu"), + py::arg("sps"), + py::arg("cnst"), + D(lms_dd_equalizer_cc, make)) + + + .def("set_taps", + &lms_dd_equalizer_cc::set_taps, + py::arg("taps"), + D(lms_dd_equalizer_cc, set_taps)) + + + .def("taps", &lms_dd_equalizer_cc::taps, D(lms_dd_equalizer_cc, taps)) + + + .def("gain", &lms_dd_equalizer_cc::gain, D(lms_dd_equalizer_cc, gain)) + + + .def("set_gain", + &lms_dd_equalizer_cc::set_gain, + py::arg("mu"), + D(lms_dd_equalizer_cc, set_gain)) + + ; +} diff --git a/gr-digital/python/digital/bindings/map_bb_python.cc b/gr-digital/python/digital/bindings/map_bb_python.cc new file mode 100644 index 0000000000..1fb694a41c --- /dev/null +++ b/gr-digital/python/digital/bindings/map_bb_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/digital/map_bb.h> +// pydoc.h is automatically generated in the build directory +#include <map_bb_pydoc.h> + +void bind_map_bb(py::module& m) +{ + + using map_bb = ::gr::digital::map_bb; + + + py::class_<map_bb, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<map_bb>>(m, "map_bb", D(map_bb)) + + .def(py::init(&map_bb::make), py::arg("map"), D(map_bb, make)) + + + .def("set_map", &map_bb::set_map, py::arg("map"), D(map_bb, set_map)) + + + .def("map", &map_bb::map, D(map_bb, map)) + + ; +} diff --git a/gr-digital/python/digital/bindings/metric_type_python.cc b/gr-digital/python/digital/bindings/metric_type_python.cc new file mode 100644 index 0000000000..908e5279f0 --- /dev/null +++ b/gr-digital/python/digital/bindings/metric_type_python.cc @@ -0,0 +1,31 @@ +/* + * 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/digital/metric_type.h> +// pydoc.h is automatically generated in the build directory +#include <metric_type_pydoc.h> + +void bind_metric_type(py::module& m) +{ + + + py::enum_<::gr::digital::trellis_metric_type_t>(m, "trellis_metric_type_t") + .value("TRELLIS_EUCLIDEAN", ::gr::digital::TRELLIS_EUCLIDEAN) // 200 + .value("TRELLIS_HARD_SYMBOL", ::gr::digital::TRELLIS_HARD_SYMBOL) // 201 + .value("TRELLIS_HARD_BIT", ::gr::digital::TRELLIS_HARD_BIT) // 202 + .export_values(); +} diff --git a/gr-digital/python/digital/bindings/mpsk_snr_est_cc_python.cc b/gr-digital/python/digital/bindings/mpsk_snr_est_cc_python.cc new file mode 100644 index 0000000000..68a42e814d --- /dev/null +++ b/gr-digital/python/digital/bindings/mpsk_snr_est_cc_python.cc @@ -0,0 +1,72 @@ +/* + * 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/digital/mpsk_snr_est_cc.h> +// pydoc.h is automatically generated in the build directory +#include <mpsk_snr_est_cc_pydoc.h> + +void bind_mpsk_snr_est_cc(py::module& m) +{ + + using mpsk_snr_est_cc = ::gr::digital::mpsk_snr_est_cc; + + + py::class_<mpsk_snr_est_cc, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<mpsk_snr_est_cc>>(m, "mpsk_snr_est_cc", D(mpsk_snr_est_cc)) + + .def(py::init(&mpsk_snr_est_cc::make), + py::arg("type"), + py::arg("tag_nsamples") = 10000, + py::arg("alpha") = 0.001, + D(mpsk_snr_est_cc, make)) + + + .def("snr", &mpsk_snr_est_cc::snr, D(mpsk_snr_est_cc, snr)) + + + .def("type", &mpsk_snr_est_cc::type, D(mpsk_snr_est_cc, type)) + + + .def( + "tag_nsample", &mpsk_snr_est_cc::tag_nsample, D(mpsk_snr_est_cc, tag_nsample)) + + + .def("alpha", &mpsk_snr_est_cc::alpha, D(mpsk_snr_est_cc, alpha)) + + + .def("set_type", + &mpsk_snr_est_cc::set_type, + py::arg("t"), + D(mpsk_snr_est_cc, set_type)) + + + .def("set_tag_nsample", + &mpsk_snr_est_cc::set_tag_nsample, + py::arg("n"), + D(mpsk_snr_est_cc, set_tag_nsample)) + + + .def("set_alpha", + &mpsk_snr_est_cc::set_alpha, + py::arg("alpha"), + D(mpsk_snr_est_cc, set_alpha)) + + ; +} diff --git a/gr-digital/python/digital/bindings/mpsk_snr_est_python.cc b/gr-digital/python/digital/bindings/mpsk_snr_est_python.cc new file mode 100644 index 0000000000..57e70b019c --- /dev/null +++ b/gr-digital/python/digital/bindings/mpsk_snr_est_python.cc @@ -0,0 +1,199 @@ +/* + * 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/digital/mpsk_snr_est.h> +// pydoc.h is automatically generated in the build directory +#include <mpsk_snr_est_pydoc.h> + +void bind_mpsk_snr_est(py::module& m) +{ + + using mpsk_snr_est = ::gr::digital::mpsk_snr_est; + using mpsk_snr_est_simple = ::gr::digital::mpsk_snr_est_simple; + using mpsk_snr_est_skew = ::gr::digital::mpsk_snr_est_skew; + using mpsk_snr_est_m2m4 = ::gr::digital::mpsk_snr_est_m2m4; + using snr_est_m2m4 = ::gr::digital::snr_est_m2m4; + using mpsk_snr_est_svr = ::gr::digital::mpsk_snr_est_svr; + + + py::class_<mpsk_snr_est, std::shared_ptr<mpsk_snr_est>>( + m, "mpsk_snr_est", D(mpsk_snr_est)) + + .def(py::init<double>(), py::arg("alpha"), D(mpsk_snr_est, mpsk_snr_est, 0)) + .def(py::init<gr::digital::mpsk_snr_est const&>(), + py::arg("arg0"), + D(mpsk_snr_est, mpsk_snr_est, 1)) + + + .def("alpha", &mpsk_snr_est::alpha, D(mpsk_snr_est, alpha)) + + + .def("set_alpha", + &mpsk_snr_est::set_alpha, + py::arg("alpha"), + D(mpsk_snr_est, set_alpha)) + + + .def("update", + &mpsk_snr_est::update, + py::arg("noutput_items"), + py::arg("input"), + D(mpsk_snr_est, update)) + + + .def("snr", &mpsk_snr_est::snr, D(mpsk_snr_est, snr)) + + + .def("signal", &mpsk_snr_est::signal, D(mpsk_snr_est, signal)) + + + .def("noise", &mpsk_snr_est::noise, D(mpsk_snr_est, noise)) + + ; + + + py::class_<mpsk_snr_est_simple, + gr::digital::mpsk_snr_est, + std::shared_ptr<mpsk_snr_est_simple>>( + m, "mpsk_snr_est_simple", D(mpsk_snr_est_simple)) + + .def(py::init<double>(), + py::arg("alpha"), + D(mpsk_snr_est_simple, mpsk_snr_est_simple, 0)) + .def(py::init<gr::digital::mpsk_snr_est_simple const&>(), + py::arg("arg0"), + D(mpsk_snr_est_simple, mpsk_snr_est_simple, 1)) + + + .def("update", + &mpsk_snr_est_simple::update, + py::arg("noutput_items"), + py::arg("input"), + D(mpsk_snr_est_simple, update)) + + + .def("snr", &mpsk_snr_est_simple::snr, D(mpsk_snr_est_simple, snr)) + + ; + + + py::class_<mpsk_snr_est_skew, + gr::digital::mpsk_snr_est, + std::shared_ptr<mpsk_snr_est_skew>>( + m, "mpsk_snr_est_skew", D(mpsk_snr_est_skew)) + + .def(py::init<double>(), + py::arg("alpha"), + D(mpsk_snr_est_skew, mpsk_snr_est_skew, 0)) + .def(py::init<gr::digital::mpsk_snr_est_skew const&>(), + py::arg("arg0"), + D(mpsk_snr_est_skew, mpsk_snr_est_skew, 1)) + + + .def("update", + &mpsk_snr_est_skew::update, + py::arg("noutput_items"), + py::arg("input"), + D(mpsk_snr_est_skew, update)) + + + .def("snr", &mpsk_snr_est_skew::snr, D(mpsk_snr_est_skew, snr)) + + ; + + + py::class_<mpsk_snr_est_m2m4, + gr::digital::mpsk_snr_est, + std::shared_ptr<mpsk_snr_est_m2m4>>( + m, "mpsk_snr_est_m2m4", D(mpsk_snr_est_m2m4)) + + .def(py::init<double>(), + py::arg("alpha"), + D(mpsk_snr_est_m2m4, mpsk_snr_est_m2m4, 0)) + .def(py::init<gr::digital::mpsk_snr_est_m2m4 const&>(), + py::arg("arg0"), + D(mpsk_snr_est_m2m4, mpsk_snr_est_m2m4, 1)) + + + .def("update", + &mpsk_snr_est_m2m4::update, + py::arg("noutput_items"), + py::arg("input"), + D(mpsk_snr_est_m2m4, update)) + + + .def("snr", &mpsk_snr_est_m2m4::snr, D(mpsk_snr_est_m2m4, snr)) + + ; + + + py::class_<snr_est_m2m4, gr::digital::mpsk_snr_est, std::shared_ptr<snr_est_m2m4>>( + m, "snr_est_m2m4", D(snr_est_m2m4)) + + .def(py::init<double, double, double>(), + py::arg("alpha"), + py::arg("ka"), + py::arg("kw"), + D(snr_est_m2m4, snr_est_m2m4, 0)) + .def(py::init<gr::digital::snr_est_m2m4 const&>(), + py::arg("arg0"), + D(snr_est_m2m4, snr_est_m2m4, 1)) + + + .def("update", + &snr_est_m2m4::update, + py::arg("noutput_items"), + py::arg("input"), + D(snr_est_m2m4, update)) + + + .def("snr", &snr_est_m2m4::snr, D(snr_est_m2m4, snr)) + + ; + + + py::class_<mpsk_snr_est_svr, + gr::digital::mpsk_snr_est, + std::shared_ptr<mpsk_snr_est_svr>>( + m, "mpsk_snr_est_svr", D(mpsk_snr_est_svr)) + + .def(py::init<double>(), + py::arg("alpha"), + D(mpsk_snr_est_svr, mpsk_snr_est_svr, 0)) + .def(py::init<gr::digital::mpsk_snr_est_svr const&>(), + py::arg("arg0"), + D(mpsk_snr_est_svr, mpsk_snr_est_svr, 1)) + + + .def("update", + &mpsk_snr_est_svr::update, + py::arg("noutput_items"), + py::arg("input"), + D(mpsk_snr_est_svr, update)) + + + .def("snr", &mpsk_snr_est_svr::snr, D(mpsk_snr_est_svr, snr)) + + ; + + py::enum_<::gr::digital::snr_est_type_t>(m, "snr_est_type_t") + .value("SNR_EST_SIMPLE", ::gr::digital::SNR_EST_SIMPLE) // 0 + .value("SNR_EST_SKEW", ::gr::digital::SNR_EST_SKEW) // 1 + .value("SNR_EST_M2M4", ::gr::digital::SNR_EST_M2M4) // 2 + .value("SNR_EST_SVR", ::gr::digital::SNR_EST_SVR) // 3 + .export_values(); +} diff --git a/gr-digital/python/digital/bindings/msk_timing_recovery_cc_python.cc b/gr-digital/python/digital/bindings/msk_timing_recovery_cc_python.cc new file mode 100644 index 0000000000..7273ded0d6 --- /dev/null +++ b/gr-digital/python/digital/bindings/msk_timing_recovery_cc_python.cc @@ -0,0 +1,75 @@ +/* + * 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/digital/msk_timing_recovery_cc.h> +// pydoc.h is automatically generated in the build directory +#include <msk_timing_recovery_cc_pydoc.h> + +void bind_msk_timing_recovery_cc(py::module& m) +{ + + using msk_timing_recovery_cc = ::gr::digital::msk_timing_recovery_cc; + + + py::class_<msk_timing_recovery_cc, + gr::block, + gr::basic_block, + std::shared_ptr<msk_timing_recovery_cc>>( + m, "msk_timing_recovery_cc", D(msk_timing_recovery_cc)) + + .def(py::init(&msk_timing_recovery_cc::make), + py::arg("sps"), + py::arg("gain"), + py::arg("limit"), + py::arg("osps"), + D(msk_timing_recovery_cc, make)) + + + .def("set_gain", + &msk_timing_recovery_cc::set_gain, + py::arg("gain"), + D(msk_timing_recovery_cc, set_gain)) + + + .def("get_gain", + &msk_timing_recovery_cc::get_gain, + D(msk_timing_recovery_cc, get_gain)) + + + .def("set_limit", + &msk_timing_recovery_cc::set_limit, + py::arg("limit"), + D(msk_timing_recovery_cc, set_limit)) + + + .def("get_limit", + &msk_timing_recovery_cc::get_limit, + D(msk_timing_recovery_cc, get_limit)) + + + .def("set_sps", + &msk_timing_recovery_cc::set_sps, + py::arg("sps"), + D(msk_timing_recovery_cc, set_sps)) + + + .def("get_sps", + &msk_timing_recovery_cc::get_sps, + D(msk_timing_recovery_cc, get_sps)) + + ; +} diff --git a/gr-digital/python/digital/bindings/ofdm_carrier_allocator_cvc_python.cc b/gr-digital/python/digital/bindings/ofdm_carrier_allocator_cvc_python.cc new file mode 100644 index 0000000000..1fdce234d8 --- /dev/null +++ b/gr-digital/python/digital/bindings/ofdm_carrier_allocator_cvc_python.cc @@ -0,0 +1,62 @@ +/* + * 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/digital/ofdm_carrier_allocator_cvc.h> +// pydoc.h is automatically generated in the build directory +#include <ofdm_carrier_allocator_cvc_pydoc.h> + +void bind_ofdm_carrier_allocator_cvc(py::module& m) +{ + + using ofdm_carrier_allocator_cvc = ::gr::digital::ofdm_carrier_allocator_cvc; + + + py::class_<ofdm_carrier_allocator_cvc, + gr::tagged_stream_block, + gr::block, + gr::basic_block, + std::shared_ptr<ofdm_carrier_allocator_cvc>>( + m, "ofdm_carrier_allocator_cvc", D(ofdm_carrier_allocator_cvc)) + + .def(py::init(&ofdm_carrier_allocator_cvc::make), + py::arg("fft_len"), + py::arg("occupied_carriers"), + py::arg("pilot_carriers"), + py::arg("pilot_symbols"), + py::arg("sync_words"), + py::arg("len_tag_key") = "packet_len", + py::arg("output_is_shifted") = true, + D(ofdm_carrier_allocator_cvc, make)) + + + .def("len_tag_key", + &ofdm_carrier_allocator_cvc::len_tag_key, + D(ofdm_carrier_allocator_cvc, len_tag_key)) + + + .def("fft_len", + &ofdm_carrier_allocator_cvc::fft_len, + D(ofdm_carrier_allocator_cvc, fft_len)) + + + .def("occupied_carriers", + &ofdm_carrier_allocator_cvc::occupied_carriers, + D(ofdm_carrier_allocator_cvc, occupied_carriers)) + + + ; +} diff --git a/gr-digital/python/digital/bindings/ofdm_chanest_vcvc_python.cc b/gr-digital/python/digital/bindings/ofdm_chanest_vcvc_python.cc new file mode 100644 index 0000000000..b1f7c651b9 --- /dev/null +++ b/gr-digital/python/digital/bindings/ofdm_chanest_vcvc_python.cc @@ -0,0 +1,45 @@ +/* + * 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/digital/ofdm_chanest_vcvc.h> +// pydoc.h is automatically generated in the build directory +#include <ofdm_chanest_vcvc_pydoc.h> + +void bind_ofdm_chanest_vcvc(py::module& m) +{ + + using ofdm_chanest_vcvc = ::gr::digital::ofdm_chanest_vcvc; + + + py::class_<ofdm_chanest_vcvc, + gr::block, + gr::basic_block, + std::shared_ptr<ofdm_chanest_vcvc>>( + m, "ofdm_chanest_vcvc", D(ofdm_chanest_vcvc)) + + .def(py::init(&ofdm_chanest_vcvc::make), + py::arg("sync_symbol1"), + py::arg("sync_symbol2"), + py::arg("n_data_symbols"), + py::arg("eq_noise_red_len") = 0, + py::arg("max_carr_offset") = -1, + py::arg("force_one_sync_symbol") = false, + D(ofdm_chanest_vcvc, make)) + + + ; +} diff --git a/gr-digital/python/digital/bindings/ofdm_cyclic_prefixer_python.cc b/gr-digital/python/digital/bindings/ofdm_cyclic_prefixer_python.cc new file mode 100644 index 0000000000..b904d7f060 --- /dev/null +++ b/gr-digital/python/digital/bindings/ofdm_cyclic_prefixer_python.cc @@ -0,0 +1,50 @@ +/* + * 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/digital/ofdm_cyclic_prefixer.h> +// pydoc.h is automatically generated in the build directory +#include <ofdm_cyclic_prefixer_pydoc.h> + +void bind_ofdm_cyclic_prefixer(py::module& m) +{ + using ofdm_cyclic_prefixer = gr::digital::ofdm_cyclic_prefixer; + + + py::class_<ofdm_cyclic_prefixer, + gr::tagged_stream_block, + gr::block, + gr::basic_block, + std::shared_ptr<ofdm_cyclic_prefixer>>(m, "ofdm_cyclic_prefixer") + + .def(py::init((std::shared_ptr<ofdm_cyclic_prefixer>(*)( + size_t, size_t, int, const std::string&)) & + ofdm_cyclic_prefixer::make), + py::arg("input_size"), + py::arg("output_size"), + py::arg("rolloff_len") = 0, + py::arg("len_tag_key") = "", + D(ofdm_cyclic_prefixer, make, 0)) + + .def(py::init((std::shared_ptr<ofdm_cyclic_prefixer>(*)( + int, const std::vector<int>&, int, const std::string&)) & + ofdm_cyclic_prefixer::make), + py::arg("input_size"), + py::arg("output_size"), + py::arg("rolloff_len") = 0, + py::arg("len_tag_key") = "", + D(ofdm_cyclic_prefixer, make, 1)); +} diff --git a/gr-digital/python/digital/bindings/ofdm_equalizer_base_python.cc b/gr-digital/python/digital/bindings/ofdm_equalizer_base_python.cc new file mode 100644 index 0000000000..483c3b8071 --- /dev/null +++ b/gr-digital/python/digital/bindings/ofdm_equalizer_base_python.cc @@ -0,0 +1,103 @@ +/* + * 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/digital/ofdm_equalizer_base.h> +// pydoc.h is automatically generated in the build directory +#include <ofdm_equalizer_base_pydoc.h> + +void bind_ofdm_equalizer_base(py::module& m) +{ + + using ofdm_equalizer_base = ::gr::digital::ofdm_equalizer_base; + using ofdm_equalizer_1d_pilots = ::gr::digital::ofdm_equalizer_1d_pilots; + + + py::class_<ofdm_equalizer_base, std::shared_ptr<ofdm_equalizer_base>>( + m, "ofdm_equalizer_base", D(ofdm_equalizer_base)) + + // .def(py::init<int>(), py::arg("fft_len"), + // D(ofdm_equalizer_base,ofdm_equalizer_base,0) + // ) + // .def(py::init<gr::digital::ofdm_equalizer_base const &>(), py::arg("arg0"), + // D(ofdm_equalizer_base,ofdm_equalizer_base,1) + // ) + + + .def("reset", &ofdm_equalizer_base::reset, D(ofdm_equalizer_base, reset)) + + + .def("equalize", + &ofdm_equalizer_base::equalize, + py::arg("frame"), + py::arg("n_sym"), + py::arg("initial_taps") = std::vector<gr_complex>(), + py::arg("tags") = std::vector<gr::tag_t>(), + D(ofdm_equalizer_base, equalize)) + + + .def("get_channel_state", + &ofdm_equalizer_base::get_channel_state, + py::arg("taps"), + D(ofdm_equalizer_base, get_channel_state)) + + + .def("fft_len", &ofdm_equalizer_base::fft_len, D(ofdm_equalizer_base, fft_len)) + + + .def("base", &ofdm_equalizer_base::base, D(ofdm_equalizer_base, base)) + + ; + + + py::class_<ofdm_equalizer_1d_pilots, + gr::digital::ofdm_equalizer_base, + std::shared_ptr<ofdm_equalizer_1d_pilots>>( + m, "ofdm_equalizer_1d_pilots", D(ofdm_equalizer_1d_pilots)) + + // .def(py::init<int,std::vector<std::vector<int, std::allocator<int> >, + // std::allocator<std::vector<int, std::allocator<int> > > > const + // &,std::vector<std::vector<int, std::allocator<int> >, + // std::allocator<std::vector<int, std::allocator<int> > > > const + // &,std::vector<std::vector<std::complex<float>, + // std::allocator<std::complex<float> > >, + // std::allocator<std::vector<std::complex<float>, + // std::allocator<std::complex<float> > > > > const &,int,bool>(), + // py::arg("fft_len"), + // py::arg("occupied_carriers"), + // py::arg("pilot_carriers"), + // py::arg("pilot_symbols"), + // py::arg("symbols_skipped"), + // py::arg("input_is_shifted"), + // D(ofdm_equalizer_1d_pilots,ofdm_equalizer_1d_pilots,0) + // ) + // .def(py::init<gr::digital::ofdm_equalizer_1d_pilots const &>(), + // py::arg("arg0"), + // D(ofdm_equalizer_1d_pilots,ofdm_equalizer_1d_pilots,1) + // ) + + + .def( + "reset", &ofdm_equalizer_1d_pilots::reset, D(ofdm_equalizer_1d_pilots, reset)) + + + .def("get_channel_state", + &ofdm_equalizer_1d_pilots::get_channel_state, + py::arg("taps"), + D(ofdm_equalizer_1d_pilots, get_channel_state)) + + ; +} diff --git a/gr-digital/python/digital/bindings/ofdm_equalizer_simpledfe_python.cc b/gr-digital/python/digital/bindings/ofdm_equalizer_simpledfe_python.cc new file mode 100644 index 0000000000..77c3b0e13f --- /dev/null +++ b/gr-digital/python/digital/bindings/ofdm_equalizer_simpledfe_python.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 + * + */ + +/* This file is automatically generated using bindtool */ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/digital/ofdm_equalizer_simpledfe.h> +// pydoc.h is automatically generated in the build directory +#include <ofdm_equalizer_simpledfe_pydoc.h> + +void bind_ofdm_equalizer_simpledfe(py::module& m) +{ + + using ofdm_equalizer_simpledfe = ::gr::digital::ofdm_equalizer_simpledfe; + + + py::class_<ofdm_equalizer_simpledfe, + gr::digital::ofdm_equalizer_1d_pilots, + std::shared_ptr<ofdm_equalizer_simpledfe>>( + m, "ofdm_equalizer_simpledfe", D(ofdm_equalizer_simpledfe)) + + .def(py::init(&ofdm_equalizer_simpledfe::make), + py::arg("fft_len"), + py::arg("constellation"), + py::arg("occupied_carriers") = std::vector<std::vector<int>>(), + py::arg("pilot_carriers") = std::vector<std::vector<int>>(), + py::arg("pilot_symbols") = std::vector<std::vector<gr_complex>>(), + py::arg("symbols_skipped") = 0, + py::arg("alpha") = 0.10000000000000001, + py::arg("input_is_shifted") = true, + D(ofdm_equalizer_simpledfe, make)) + + + .def("equalize", + &ofdm_equalizer_simpledfe::equalize, + py::arg("frame"), + py::arg("n_sym"), + py::arg("initial_taps") = std::vector<gr_complex>(), + py::arg("tags") = std::vector<gr::tag_t>(), + D(ofdm_equalizer_simpledfe, equalize)) + + + ; +} diff --git a/gr-digital/python/digital/bindings/ofdm_equalizer_static_python.cc b/gr-digital/python/digital/bindings/ofdm_equalizer_static_python.cc new file mode 100644 index 0000000000..b96987b842 --- /dev/null +++ b/gr-digital/python/digital/bindings/ofdm_equalizer_static_python.cc @@ -0,0 +1,53 @@ +/* + * 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/digital/ofdm_equalizer_static.h> +// pydoc.h is automatically generated in the build directory +#include <ofdm_equalizer_static_pydoc.h> + +void bind_ofdm_equalizer_static(py::module& m) +{ + + using ofdm_equalizer_static = ::gr::digital::ofdm_equalizer_static; + + + py::class_<ofdm_equalizer_static, + gr::digital::ofdm_equalizer_1d_pilots, + std::shared_ptr<ofdm_equalizer_static>>( + m, "ofdm_equalizer_static", D(ofdm_equalizer_static)) + + .def(py::init(&ofdm_equalizer_static::make), + py::arg("fft_len"), + py::arg("occupied_carriers") = std::vector<std::vector<int>>(), + py::arg("pilot_carriers") = std::vector<std::vector<int>>(), + py::arg("pilot_symbols") = std::vector<std::vector<gr_complex>>(), + py::arg("symbols_skipped") = 0, + py::arg("input_is_shifted") = true, + D(ofdm_equalizer_static, make)) + + + .def("equalize", + &ofdm_equalizer_static::equalize, + py::arg("frame"), + py::arg("n_sym"), + py::arg("initial_taps") = std::vector<gr_complex>(), + py::arg("tags") = std::vector<gr::tag_t>(), + D(ofdm_equalizer_static, equalize)) + + + ; +} diff --git a/gr-digital/python/digital/bindings/ofdm_frame_equalizer_vcvc_python.cc b/gr-digital/python/digital/bindings/ofdm_frame_equalizer_vcvc_python.cc new file mode 100644 index 0000000000..c698d8487f --- /dev/null +++ b/gr-digital/python/digital/bindings/ofdm_frame_equalizer_vcvc_python.cc @@ -0,0 +1,45 @@ +/* + * 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/digital/ofdm_frame_equalizer_vcvc.h> +// pydoc.h is automatically generated in the build directory +#include <ofdm_frame_equalizer_vcvc_pydoc.h> + +void bind_ofdm_frame_equalizer_vcvc(py::module& m) +{ + + using ofdm_frame_equalizer_vcvc = ::gr::digital::ofdm_frame_equalizer_vcvc; + + + py::class_<ofdm_frame_equalizer_vcvc, + gr::tagged_stream_block, + gr::block, + gr::basic_block, + std::shared_ptr<ofdm_frame_equalizer_vcvc>>( + m, "ofdm_frame_equalizer_vcvc", D(ofdm_frame_equalizer_vcvc)) + + .def(py::init(&ofdm_frame_equalizer_vcvc::make), + py::arg("equalizer"), + py::arg("cp_len"), + py::arg("tsb_key") = "frame_len", + py::arg("propagate_channel_state") = false, + py::arg("fixed_frame_len") = 0, + D(ofdm_frame_equalizer_vcvc, make)) + + + ; +} diff --git a/gr-digital/python/digital/bindings/ofdm_serializer_vcc_python.cc b/gr-digital/python/digital/bindings/ofdm_serializer_vcc_python.cc new file mode 100644 index 0000000000..4a9df91a8e --- /dev/null +++ b/gr-digital/python/digital/bindings/ofdm_serializer_vcc_python.cc @@ -0,0 +1,64 @@ +/* + * 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/digital/ofdm_serializer_vcc.h> +// pydoc.h is automatically generated in the build directory +#include <ofdm_serializer_vcc_pydoc.h> + +void bind_ofdm_serializer_vcc(py::module& m) +{ + using ofdm_serializer_vcc = gr::digital::ofdm_serializer_vcc; + + + py::class_<ofdm_serializer_vcc, + gr::tagged_stream_block, + std::shared_ptr<ofdm_serializer_vcc>>(m, "ofdm_serializer_vcc") + + .def(py::init((std::shared_ptr<ofdm_serializer_vcc>(*)( + int, + const std::vector<std::vector<int>>&, + const std::string&, + const std::string&, + int, + const std::string&, + bool)) & + ofdm_serializer_vcc::make), + py::arg("fft_len"), + py::arg("occupied_carriers"), + py::arg("len_tag_key") = "frame_len", + py::arg("packet_len_tag_key") = "", + py::arg("symbols_skipped") = 0, + py::arg("carr_offset_key") = "", + py::arg("input_is_shifted") = true, + D(ofdm_serializer_vcc, make, 0)) + + .def(py::init((std::shared_ptr<ofdm_serializer_vcc>(*)( + const gr::digital::ofdm_carrier_allocator_cvc::sptr&, + const std::string&, + int, + const std::string&, + bool)) & + ofdm_serializer_vcc::make), + py::arg("allocator"), + py::arg("packet_len_tag_key") = "", + py::arg("symbols_skipped") = 0, + py::arg("carr_offset_key") = "", + py::arg("input_is_shifted") = true, + D(ofdm_serializer_vcc, make, 1)) + + ; +} diff --git a/gr-digital/python/digital/bindings/ofdm_sync_sc_cfb_python.cc b/gr-digital/python/digital/bindings/ofdm_sync_sc_cfb_python.cc new file mode 100644 index 0000000000..f1aa734919 --- /dev/null +++ b/gr-digital/python/digital/bindings/ofdm_sync_sc_cfb_python.cc @@ -0,0 +1,51 @@ +/* + * 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/digital/ofdm_sync_sc_cfb.h> +// pydoc.h is automatically generated in the build directory +#include <ofdm_sync_sc_cfb_pydoc.h> + +void bind_ofdm_sync_sc_cfb(py::module& m) +{ + + using ofdm_sync_sc_cfb = ::gr::digital::ofdm_sync_sc_cfb; + + + py::class_<ofdm_sync_sc_cfb, + gr::hier_block2, + gr::basic_block, + std::shared_ptr<ofdm_sync_sc_cfb>>( + m, "ofdm_sync_sc_cfb", D(ofdm_sync_sc_cfb)) + + .def(py::init(&ofdm_sync_sc_cfb::make), + py::arg("fft_len"), + py::arg("cp_len"), + py::arg("use_even_carriers") = false, + py::arg("threshold") = 0.90000000000000002, + D(ofdm_sync_sc_cfb, make)) + + + .def("set_threshold", + &ofdm_sync_sc_cfb::set_threshold, + py::arg("threshold"), + D(ofdm_sync_sc_cfb, set_threshold)) + + + .def("threshold", &ofdm_sync_sc_cfb::threshold, D(ofdm_sync_sc_cfb, threshold)) + + ; +} diff --git a/gr-digital/python/digital/bindings/packet_header_default_python.cc b/gr-digital/python/digital/bindings/packet_header_default_python.cc new file mode 100644 index 0000000000..68c832d175 --- /dev/null +++ b/gr-digital/python/digital/bindings/packet_header_default_python.cc @@ -0,0 +1,79 @@ +/* + * 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/digital/packet_header_default.h> +// pydoc.h is automatically generated in the build directory +#include <packet_header_default_pydoc.h> + +void bind_packet_header_default(py::module& m) +{ + + using packet_header_default = ::gr::digital::packet_header_default; + + + py::class_<packet_header_default, std::shared_ptr<packet_header_default>>( + m, "packet_header_default", D(packet_header_default)) + + .def(py::init(&packet_header_default::make), + py::arg("header_len"), + py::arg("len_tag_key") = "packet_len", + py::arg("num_tag_key") = "packet_num", + py::arg("bits_per_byte") = 1, + D(packet_header_default, make)) + + + .def("base", &packet_header_default::base, D(packet_header_default, base)) + + + .def("formatter", + &packet_header_default::formatter, + D(packet_header_default, formatter)) + + + .def("set_header_num", + &packet_header_default::set_header_num, + py::arg("header_num"), + D(packet_header_default, set_header_num)) + + + .def("header_len", + &packet_header_default::header_len, + D(packet_header_default, header_len)) + + + .def("len_tag_key", + &packet_header_default::len_tag_key, + D(packet_header_default, len_tag_key)) + + + .def("header_formatter", + &packet_header_default::header_formatter, + py::arg("packet_len"), + py::arg("out"), + py::arg("tags") = std::vector<gr::tag_t>(), + D(packet_header_default, header_formatter)) + + + .def("header_parser", + &packet_header_default::header_parser, + py::arg("header"), + py::arg("tags"), + D(packet_header_default, header_parser)) + + + ; +} diff --git a/gr-digital/python/digital/bindings/packet_header_ofdm_python.cc b/gr-digital/python/digital/bindings/packet_header_ofdm_python.cc new file mode 100644 index 0000000000..90cf49fb22 --- /dev/null +++ b/gr-digital/python/digital/bindings/packet_header_ofdm_python.cc @@ -0,0 +1,61 @@ +/* + * 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/digital/packet_header_ofdm.h> +// pydoc.h is automatically generated in the build directory +#include <packet_header_ofdm_pydoc.h> + +void bind_packet_header_ofdm(py::module& m) +{ + + using packet_header_ofdm = ::gr::digital::packet_header_ofdm; + + + py::class_<packet_header_ofdm, + gr::digital::packet_header_default, + std::shared_ptr<packet_header_ofdm>>( + m, "packet_header_ofdm", D(packet_header_ofdm)) + + .def(py::init(&packet_header_ofdm::make), + py::arg("occupied_carriers"), + py::arg("n_syms"), + py::arg("len_tag_key") = "packet_len", + py::arg("frame_len_tag_key") = "frame_len", + py::arg("num_tag_key") = "packet_num", + py::arg("bits_per_header_sym") = 1, + py::arg("bits_per_payload_sym") = 1, + py::arg("scramble_header") = false, + D(packet_header_ofdm, make)) + + + .def("header_formatter", + &packet_header_ofdm::header_formatter, + py::arg("packet_len"), + py::arg("out"), + py::arg("tags"), + D(packet_header_ofdm, header_formatter)) + + + .def("header_parser", + &packet_header_ofdm::header_parser, + py::arg("header"), + py::arg("tags"), + D(packet_header_ofdm, header_parser)) + + + ; +} diff --git a/gr-digital/python/digital/bindings/packet_headergenerator_bb_python.cc b/gr-digital/python/digital/bindings/packet_headergenerator_bb_python.cc new file mode 100644 index 0000000000..e9431d0a78 --- /dev/null +++ b/gr-digital/python/digital/bindings/packet_headergenerator_bb_python.cc @@ -0,0 +1,50 @@ +/* + * 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/digital/packet_headergenerator_bb.h> +// pydoc.h is automatically generated in the build directory +#include <packet_headergenerator_bb_pydoc.h> + +void bind_packet_headergenerator_bb(py::module& m) +{ + using packet_headergenerator_bb = gr::digital::packet_headergenerator_bb; + + + py::class_<packet_headergenerator_bb, + gr::tagged_stream_block, + std::shared_ptr<packet_headergenerator_bb>>(m, "packet_headergenerator_bb") + + .def(py::init((std::shared_ptr<packet_headergenerator_bb>(*)( + const gr::digital::packet_header_default::sptr&, + const std::string&)) & + packet_headergenerator_bb::make), + py::arg("header_formatter"), + py::arg("len_tag_key") = "packet_len", + D(packet_headergenerator_bb, make, 0)) + + .def(py::init((std::shared_ptr<packet_headergenerator_bb>(*)( + long, const std::string&)) & + packet_headergenerator_bb::make), + py::arg("header_len"), + py::arg("len_tag_key") = "packet_len", + D(packet_headergenerator_bb, make, 1)) + + .def("set_header_formatter", + &packet_headergenerator_bb::set_header_formatter, + py::arg("header_formatter"), + D(packet_headergenerator_bb, set_header_formatter)); +} diff --git a/gr-digital/python/digital/bindings/packet_headerparser_b_python.cc b/gr-digital/python/digital/bindings/packet_headerparser_b_python.cc new file mode 100644 index 0000000000..f71db562a8 --- /dev/null +++ b/gr-digital/python/digital/bindings/packet_headerparser_b_python.cc @@ -0,0 +1,44 @@ +/* + * 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/digital/packet_headerparser_b.h> +// pydoc.h is automatically generated in the build directory +#include <packet_headerparser_b_pydoc.h> + +void bind_packet_headerparser_b(py::module& m) +{ + using packet_headerparser_b = gr::digital::packet_headerparser_b; + + + py::class_<packet_headerparser_b, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<packet_headerparser_b>>(m, "packet_headerparser_b") + + .def(py::init((std::shared_ptr<packet_headerparser_b>(*)( + const gr::digital::packet_header_default::sptr&)) & + packet_headerparser_b::make), + py::arg("header_formatter"), + D(packet_headerparser_b, make, 0)) + .def(py::init( + (std::shared_ptr<packet_headerparser_b>(*)(long, const std::string&)) & + packet_headerparser_b::make), + py::arg("header_len"), + py::arg("len_tag_key"), + D(packet_headerparser_b, make, 1)); +} diff --git a/gr-digital/python/digital/bindings/packet_sink_python.cc b/gr-digital/python/digital/bindings/packet_sink_python.cc new file mode 100644 index 0000000000..98486f006c --- /dev/null +++ b/gr-digital/python/digital/bindings/packet_sink_python.cc @@ -0,0 +1,46 @@ +/* + * 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/digital/packet_sink.h> +// pydoc.h is automatically generated in the build directory +#include <packet_sink_pydoc.h> + +void bind_packet_sink(py::module& m) +{ + + using packet_sink = ::gr::digital::packet_sink; + + + py::class_<packet_sink, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<packet_sink>>(m, "packet_sink", D(packet_sink)) + + .def(py::init(&packet_sink::make), + py::arg("sync_vector"), + py::arg("target_queue"), + py::arg("threshold") = -1, + D(packet_sink, make)) + + + .def("carrier_sensed", + &packet_sink::carrier_sensed, + D(packet_sink, carrier_sensed)) + + ; +} diff --git a/gr-digital/python/digital/bindings/pfb_clock_sync_ccf_python.cc b/gr-digital/python/digital/bindings/pfb_clock_sync_ccf_python.cc new file mode 100644 index 0000000000..9d7506765f --- /dev/null +++ b/gr-digital/python/digital/bindings/pfb_clock_sync_ccf_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/digital/pfb_clock_sync_ccf.h> +// pydoc.h is automatically generated in the build directory +#include <pfb_clock_sync_ccf_pydoc.h> + +void bind_pfb_clock_sync_ccf(py::module& m) +{ + + using pfb_clock_sync_ccf = ::gr::digital::pfb_clock_sync_ccf; + + + py::class_<pfb_clock_sync_ccf, + gr::block, + gr::basic_block, + std::shared_ptr<pfb_clock_sync_ccf>>( + m, "pfb_clock_sync_ccf", D(pfb_clock_sync_ccf)) + + .def(py::init(&pfb_clock_sync_ccf::make), + py::arg("sps"), + py::arg("loop_bw"), + py::arg("taps"), + py::arg("filter_size") = 32, + py::arg("init_phase") = 0, + py::arg("max_rate_deviation") = 1.5, + py::arg("osps") = 1, + D(pfb_clock_sync_ccf, make)) + + + .def("update_gains", + &pfb_clock_sync_ccf::update_gains, + D(pfb_clock_sync_ccf, update_gains)) + + + .def("update_taps", + &pfb_clock_sync_ccf::update_taps, + py::arg("taps"), + D(pfb_clock_sync_ccf, update_taps)) + + + .def("taps", &pfb_clock_sync_ccf::taps, D(pfb_clock_sync_ccf, taps)) + + + .def( + "diff_taps", &pfb_clock_sync_ccf::diff_taps, D(pfb_clock_sync_ccf, diff_taps)) + + + .def("channel_taps", + &pfb_clock_sync_ccf::channel_taps, + py::arg("channel"), + D(pfb_clock_sync_ccf, channel_taps)) + + + .def("diff_channel_taps", + &pfb_clock_sync_ccf::diff_channel_taps, + py::arg("channel"), + D(pfb_clock_sync_ccf, diff_channel_taps)) + + + .def("taps_as_string", + &pfb_clock_sync_ccf::taps_as_string, + D(pfb_clock_sync_ccf, taps_as_string)) + + + .def("diff_taps_as_string", + &pfb_clock_sync_ccf::diff_taps_as_string, + D(pfb_clock_sync_ccf, diff_taps_as_string)) + + + .def("set_loop_bandwidth", + &pfb_clock_sync_ccf::set_loop_bandwidth, + py::arg("bw"), + D(pfb_clock_sync_ccf, set_loop_bandwidth)) + + + .def("set_damping_factor", + &pfb_clock_sync_ccf::set_damping_factor, + py::arg("df"), + D(pfb_clock_sync_ccf, set_damping_factor)) + + + .def("set_alpha", + &pfb_clock_sync_ccf::set_alpha, + py::arg("alpha"), + D(pfb_clock_sync_ccf, set_alpha)) + + + .def("set_beta", + &pfb_clock_sync_ccf::set_beta, + py::arg("beta"), + D(pfb_clock_sync_ccf, set_beta)) + + + .def("set_max_rate_deviation", + &pfb_clock_sync_ccf::set_max_rate_deviation, + py::arg("m"), + D(pfb_clock_sync_ccf, set_max_rate_deviation)) + + + .def("loop_bandwidth", + &pfb_clock_sync_ccf::loop_bandwidth, + D(pfb_clock_sync_ccf, loop_bandwidth)) + + + .def("damping_factor", + &pfb_clock_sync_ccf::damping_factor, + D(pfb_clock_sync_ccf, damping_factor)) + + + .def("alpha", &pfb_clock_sync_ccf::alpha, D(pfb_clock_sync_ccf, alpha)) + + + .def("beta", &pfb_clock_sync_ccf::beta, D(pfb_clock_sync_ccf, beta)) + + + .def("clock_rate", + &pfb_clock_sync_ccf::clock_rate, + D(pfb_clock_sync_ccf, clock_rate)) + + + .def("error", &pfb_clock_sync_ccf::error, D(pfb_clock_sync_ccf, error)) + + + .def("rate", &pfb_clock_sync_ccf::rate, D(pfb_clock_sync_ccf, rate)) + + + .def("phase", &pfb_clock_sync_ccf::phase, D(pfb_clock_sync_ccf, phase)) + + ; +} diff --git a/gr-digital/python/digital/bindings/pfb_clock_sync_fff_python.cc b/gr-digital/python/digital/bindings/pfb_clock_sync_fff_python.cc new file mode 100644 index 0000000000..99076ef68e --- /dev/null +++ b/gr-digital/python/digital/bindings/pfb_clock_sync_fff_python.cc @@ -0,0 +1,136 @@ +/* + * 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/digital/pfb_clock_sync_fff.h> +// pydoc.h is automatically generated in the build directory +#include <pfb_clock_sync_fff_pydoc.h> + +void bind_pfb_clock_sync_fff(py::module& m) +{ + + using pfb_clock_sync_fff = ::gr::digital::pfb_clock_sync_fff; + + + py::class_<pfb_clock_sync_fff, + gr::block, + gr::basic_block, + std::shared_ptr<pfb_clock_sync_fff>>( + m, "pfb_clock_sync_fff", D(pfb_clock_sync_fff)) + + .def(py::init(&pfb_clock_sync_fff::make), + py::arg("sps"), + py::arg("gain"), + py::arg("taps"), + py::arg("filter_size") = 32, + py::arg("init_phase") = 0, + py::arg("max_rate_deviation") = 1.5, + py::arg("osps") = 1, + D(pfb_clock_sync_fff, make)) + + + .def("update_gains", + &pfb_clock_sync_fff::update_gains, + D(pfb_clock_sync_fff, update_gains)) + + + .def("update_taps", + &pfb_clock_sync_fff::update_taps, + py::arg("taps"), + D(pfb_clock_sync_fff, update_taps)) + + + .def("taps", &pfb_clock_sync_fff::taps, D(pfb_clock_sync_fff, taps)) + + + .def( + "diff_taps", &pfb_clock_sync_fff::diff_taps, D(pfb_clock_sync_fff, diff_taps)) + + + .def("channel_taps", + &pfb_clock_sync_fff::channel_taps, + py::arg("channel"), + D(pfb_clock_sync_fff, channel_taps)) + + + .def("diff_channel_taps", + &pfb_clock_sync_fff::diff_channel_taps, + py::arg("channel"), + D(pfb_clock_sync_fff, diff_channel_taps)) + + + .def("taps_as_string", + &pfb_clock_sync_fff::taps_as_string, + D(pfb_clock_sync_fff, taps_as_string)) + + + .def("diff_taps_as_string", + &pfb_clock_sync_fff::diff_taps_as_string, + D(pfb_clock_sync_fff, diff_taps_as_string)) + + + .def("set_loop_bandwidth", + &pfb_clock_sync_fff::set_loop_bandwidth, + py::arg("bw"), + D(pfb_clock_sync_fff, set_loop_bandwidth)) + + + .def("set_damping_factor", + &pfb_clock_sync_fff::set_damping_factor, + py::arg("df"), + D(pfb_clock_sync_fff, set_damping_factor)) + + + .def("set_alpha", + &pfb_clock_sync_fff::set_alpha, + py::arg("alpha"), + D(pfb_clock_sync_fff, set_alpha)) + + + .def("set_beta", + &pfb_clock_sync_fff::set_beta, + py::arg("beta"), + D(pfb_clock_sync_fff, set_beta)) + + + .def("set_max_rate_deviation", + &pfb_clock_sync_fff::set_max_rate_deviation, + py::arg("m"), + D(pfb_clock_sync_fff, set_max_rate_deviation)) + + + .def("loop_bandwidth", + &pfb_clock_sync_fff::loop_bandwidth, + D(pfb_clock_sync_fff, loop_bandwidth)) + + + .def("damping_factor", + &pfb_clock_sync_fff::damping_factor, + D(pfb_clock_sync_fff, damping_factor)) + + + .def("alpha", &pfb_clock_sync_fff::alpha, D(pfb_clock_sync_fff, alpha)) + + + .def("beta", &pfb_clock_sync_fff::beta, D(pfb_clock_sync_fff, beta)) + + + .def("clock_rate", + &pfb_clock_sync_fff::clock_rate, + D(pfb_clock_sync_fff, clock_rate)) + + ; +} diff --git a/gr-digital/python/digital/bindings/pn_correlator_cc_python.cc b/gr-digital/python/digital/bindings/pn_correlator_cc_python.cc new file mode 100644 index 0000000000..1f6f840e57 --- /dev/null +++ b/gr-digital/python/digital/bindings/pn_correlator_cc_python.cc @@ -0,0 +1,44 @@ +/* + * 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/digital/pn_correlator_cc.h> +// pydoc.h is automatically generated in the build directory +#include <pn_correlator_cc_pydoc.h> + +void bind_pn_correlator_cc(py::module& m) +{ + + using pn_correlator_cc = ::gr::digital::pn_correlator_cc; + + + py::class_<pn_correlator_cc, + gr::sync_decimator, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<pn_correlator_cc>>( + m, "pn_correlator_cc", D(pn_correlator_cc)) + + .def(py::init(&pn_correlator_cc::make), + py::arg("degree"), + py::arg("mask") = 0, + py::arg("seed") = 1, + D(pn_correlator_cc, make)) + + + ; +} diff --git a/gr-digital/python/digital/bindings/probe_density_b_python.cc b/gr-digital/python/digital/bindings/probe_density_b_python.cc new file mode 100644 index 0000000000..a133c64aaa --- /dev/null +++ b/gr-digital/python/digital/bindings/probe_density_b_python.cc @@ -0,0 +1,46 @@ +/* + * 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/digital/probe_density_b.h> +// pydoc.h is automatically generated in the build directory +#include <probe_density_b_pydoc.h> + +void bind_probe_density_b(py::module& m) +{ + + using probe_density_b = ::gr::digital::probe_density_b; + + + py::class_<probe_density_b, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<probe_density_b>>(m, "probe_density_b", D(probe_density_b)) + + .def(py::init(&probe_density_b::make), py::arg("alpha"), D(probe_density_b, make)) + + + .def("density", &probe_density_b::density, D(probe_density_b, density)) + + + .def("set_alpha", + &probe_density_b::set_alpha, + py::arg("alpha"), + D(probe_density_b, set_alpha)) + + ; +} diff --git a/gr-digital/python/digital/bindings/probe_mpsk_snr_est_c_python.cc b/gr-digital/python/digital/bindings/probe_mpsk_snr_est_c_python.cc new file mode 100644 index 0000000000..9d18bcb859 --- /dev/null +++ b/gr-digital/python/digital/bindings/probe_mpsk_snr_est_c_python.cc @@ -0,0 +1,80 @@ +/* + * 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/digital/probe_mpsk_snr_est_c.h> +// pydoc.h is automatically generated in the build directory +#include <probe_mpsk_snr_est_c_pydoc.h> + +void bind_probe_mpsk_snr_est_c(py::module& m) +{ + + using probe_mpsk_snr_est_c = ::gr::digital::probe_mpsk_snr_est_c; + + + py::class_<probe_mpsk_snr_est_c, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<probe_mpsk_snr_est_c>>( + m, "probe_mpsk_snr_est_c", D(probe_mpsk_snr_est_c)) + + .def(py::init(&probe_mpsk_snr_est_c::make), + py::arg("type"), + py::arg("msg_nsamples") = 10000, + py::arg("alpha") = 0.001, + D(probe_mpsk_snr_est_c, make)) + + + .def("snr", &probe_mpsk_snr_est_c::snr, D(probe_mpsk_snr_est_c, snr)) + + + .def("signal", &probe_mpsk_snr_est_c::signal, D(probe_mpsk_snr_est_c, signal)) + + + .def("noise", &probe_mpsk_snr_est_c::noise, D(probe_mpsk_snr_est_c, noise)) + + + .def("type", &probe_mpsk_snr_est_c::type, D(probe_mpsk_snr_est_c, type)) + + + .def("msg_nsample", + &probe_mpsk_snr_est_c::msg_nsample, + D(probe_mpsk_snr_est_c, msg_nsample)) + + + .def("alpha", &probe_mpsk_snr_est_c::alpha, D(probe_mpsk_snr_est_c, alpha)) + + + .def("set_type", + &probe_mpsk_snr_est_c::set_type, + py::arg("t"), + D(probe_mpsk_snr_est_c, set_type)) + + + .def("set_msg_nsample", + &probe_mpsk_snr_est_c::set_msg_nsample, + py::arg("n"), + D(probe_mpsk_snr_est_c, set_msg_nsample)) + + + .def("set_alpha", + &probe_mpsk_snr_est_c::set_alpha, + py::arg("alpha"), + D(probe_mpsk_snr_est_c, set_alpha)) + + ; +} diff --git a/gr-digital/python/digital/bindings/protocol_formatter_async_python.cc b/gr-digital/python/digital/bindings/protocol_formatter_async_python.cc new file mode 100644 index 0000000000..5cffc28eef --- /dev/null +++ b/gr-digital/python/digital/bindings/protocol_formatter_async_python.cc @@ -0,0 +1,40 @@ +/* + * 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/digital/protocol_formatter_async.h> +// pydoc.h is automatically generated in the build directory +#include <protocol_formatter_async_pydoc.h> + +void bind_protocol_formatter_async(py::module& m) +{ + + using protocol_formatter_async = ::gr::digital::protocol_formatter_async; + + + py::class_<protocol_formatter_async, + gr::block, + gr::basic_block, + std::shared_ptr<protocol_formatter_async>>( + m, "protocol_formatter_async", D(protocol_formatter_async)) + + .def(py::init(&protocol_formatter_async::make), + py::arg("format"), + D(protocol_formatter_async, make)) + + + ; +} diff --git a/gr-digital/python/digital/bindings/protocol_formatter_bb_python.cc b/gr-digital/python/digital/bindings/protocol_formatter_bb_python.cc new file mode 100644 index 0000000000..fe26d3a991 --- /dev/null +++ b/gr-digital/python/digital/bindings/protocol_formatter_bb_python.cc @@ -0,0 +1,47 @@ +/* + * 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/digital/protocol_formatter_bb.h> +// pydoc.h is automatically generated in the build directory +#include <protocol_formatter_bb_pydoc.h> + +void bind_protocol_formatter_bb(py::module& m) +{ + + using protocol_formatter_bb = ::gr::digital::protocol_formatter_bb; + + + py::class_<protocol_formatter_bb, + gr::tagged_stream_block, + gr::block, + gr::basic_block, + std::shared_ptr<protocol_formatter_bb>>( + m, "protocol_formatter_bb", D(protocol_formatter_bb)) + + .def(py::init(&protocol_formatter_bb::make), + py::arg("format"), + py::arg("len_tag_key") = "packet_len", + D(protocol_formatter_bb, make)) + + + .def("set_header_format", + &protocol_formatter_bb::set_header_format, + py::arg("format"), + D(protocol_formatter_bb, set_header_format)) + + ; +} diff --git a/gr-digital/python/digital/bindings/protocol_parser_b_python.cc b/gr-digital/python/digital/bindings/protocol_parser_b_python.cc new file mode 100644 index 0000000000..a4bd8bd380 --- /dev/null +++ b/gr-digital/python/digital/bindings/protocol_parser_b_python.cc @@ -0,0 +1,41 @@ +/* + * 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/digital/protocol_parser_b.h> +// pydoc.h is automatically generated in the build directory +#include <protocol_parser_b_pydoc.h> + +void bind_protocol_parser_b(py::module& m) +{ + + using protocol_parser_b = ::gr::digital::protocol_parser_b; + + + py::class_<protocol_parser_b, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<protocol_parser_b>>( + m, "protocol_parser_b", D(protocol_parser_b)) + + .def(py::init(&protocol_parser_b::make), + py::arg("format"), + D(protocol_parser_b, make)) + + + ; +} diff --git a/gr-digital/python/digital/bindings/python_bindings.cc b/gr-digital/python/digital/bindings/python_bindings.cc new file mode 100644 index 0000000000..fddd0e7d90 --- /dev/null +++ b/gr-digital/python/digital/bindings/python_bindings.cc @@ -0,0 +1,196 @@ + +/* + * 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> + +namespace py = pybind11; + +void bind_additive_scrambler_bb(py::module&); +void bind_binary_slicer_fb(py::module&); +void bind_burst_shaper(py::module&); +void bind_chunks_to_symbols(py::module&); +void bind_clock_recovery_mm_cc(py::module&); +void bind_clock_recovery_mm_ff(py::module&); +void bind_cma_equalizer_cc(py::module&); +void bind_constellation(py::module&); +void bind_constellation_decoder_cb(py::module&); +void bind_constellation_receiver_cb(py::module&); +void bind_constellation_soft_decoder_cf(py::module&); +void bind_corr_est_cc(py::module&); +void bind_correlate_access_code_bb(py::module&); +void bind_correlate_access_code_bb_ts(py::module&); +void bind_correlate_access_code_ff_ts(py::module&); +void bind_correlate_access_code_tag_bb(py::module&); +void bind_correlate_access_code_tag_ff(py::module&); +void bind_costas_loop_cc(py::module&); +void bind_cpmmod_bc(py::module&); +void bind_crc32(py::module&); +void bind_crc32_async_bb(py::module&); +void bind_crc32_bb(py::module&); +void bind_descrambler_bb(py::module&); +void bind_diff_decoder_bb(py::module&); +void bind_diff_encoder_bb(py::module&); +void bind_diff_phasor_cc(py::module&); +void bind_fll_band_edge_cc(py::module&); +void bind_framer_sink_1(py::module&); +void bind_glfsr(py::module&); +void bind_glfsr_source_b(py::module&); +void bind_glfsr_source_f(py::module&); +void bind_hdlc_deframer_bp(py::module&); +void bind_hdlc_framer_pb(py::module&); +void bind_header_buffer(py::module&); +void bind_header_format_base(py::module&); +void bind_header_format_counter(py::module&); +void bind_header_format_crc(py::module&); +void bind_header_format_default(py::module&); +void bind_header_format_ofdm(py::module&); +void bind_header_payload_demux(py::module&); +void bind_interpolating_resampler_type(py::module&); +void bind_kurtotic_equalizer_cc(py::module&); +void bind_lfsr(py::module&); +void bind_lms_dd_equalizer_cc(py::module&); +void bind_map_bb(py::module&); +void bind_metric_type(py::module&); +// void bind_modulate_vector(py::module&); +void bind_mpsk_snr_est(py::module&); +void bind_mpsk_snr_est_cc(py::module&); +void bind_msk_timing_recovery_cc(py::module&); +void bind_ofdm_carrier_allocator_cvc(py::module&); +void bind_ofdm_chanest_vcvc(py::module&); +void bind_ofdm_cyclic_prefixer(py::module&); +void bind_ofdm_equalizer_base(py::module&); +void bind_ofdm_equalizer_simpledfe(py::module&); +void bind_ofdm_equalizer_static(py::module&); +void bind_ofdm_frame_equalizer_vcvc(py::module&); +void bind_ofdm_serializer_vcc(py::module&); +void bind_ofdm_sync_sc_cfb(py::module&); +void bind_packet_header_default(py::module&); +void bind_packet_header_ofdm(py::module&); +void bind_packet_headergenerator_bb(py::module&); +void bind_packet_headerparser_b(py::module&); +void bind_packet_sink(py::module&); +void bind_pfb_clock_sync_ccf(py::module&); +void bind_pfb_clock_sync_fff(py::module&); +void bind_pn_correlator_cc(py::module&); +void bind_probe_density_b(py::module&); +void bind_probe_mpsk_snr_est_c(py::module&); +void bind_protocol_formatter_async(py::module&); +void bind_protocol_formatter_bb(py::module&); +void bind_protocol_parser_b(py::module&); +void bind_scrambler_bb(py::module&); +void bind_simple_correlator(py::module&); +void bind_simple_framer(py::module&); +void bind_simple_framer_sync(py::module&); +void bind_symbol_sync_cc(py::module&); +void bind_symbol_sync_ff(py::module&); +void bind_timing_error_detector_type(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(digital_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_additive_scrambler_bb(m); + bind_binary_slicer_fb(m); + bind_burst_shaper(m); + bind_chunks_to_symbols(m); + bind_clock_recovery_mm_cc(m); + bind_clock_recovery_mm_ff(m); + bind_cma_equalizer_cc(m); + bind_constellation(m); + bind_constellation_decoder_cb(m); + bind_constellation_receiver_cb(m); + bind_constellation_soft_decoder_cf(m); + bind_corr_est_cc(m); + bind_correlate_access_code_bb(m); + bind_correlate_access_code_bb_ts(m); + bind_correlate_access_code_ff_ts(m); + bind_correlate_access_code_tag_bb(m); + bind_correlate_access_code_tag_ff(m); + bind_costas_loop_cc(m); + bind_cpmmod_bc(m); + bind_crc32(m); + bind_crc32_async_bb(m); + bind_crc32_bb(m); + bind_descrambler_bb(m); + bind_diff_decoder_bb(m); + bind_diff_encoder_bb(m); + bind_diff_phasor_cc(m); + bind_fll_band_edge_cc(m); + bind_framer_sink_1(m); + bind_glfsr(m); + bind_glfsr_source_b(m); + bind_glfsr_source_f(m); + bind_hdlc_deframer_bp(m); + bind_hdlc_framer_pb(m); + bind_header_buffer(m); + bind_header_format_base(m); + bind_header_format_default(m); + bind_header_format_counter(m); + bind_header_format_crc(m); + bind_header_format_ofdm(m); + bind_header_payload_demux(m); + bind_interpolating_resampler_type(m); + bind_kurtotic_equalizer_cc(m); + bind_lfsr(m); + bind_lms_dd_equalizer_cc(m); + bind_map_bb(m); + bind_metric_type(m); + // bind_modulate_vector(m); + bind_mpsk_snr_est(m); + bind_mpsk_snr_est_cc(m); + bind_msk_timing_recovery_cc(m); + bind_ofdm_carrier_allocator_cvc(m); + bind_ofdm_chanest_vcvc(m); + bind_ofdm_cyclic_prefixer(m); + bind_ofdm_equalizer_base(m); + bind_ofdm_equalizer_simpledfe(m); + bind_ofdm_equalizer_static(m); + bind_ofdm_frame_equalizer_vcvc(m); + bind_ofdm_serializer_vcc(m); + bind_ofdm_sync_sc_cfb(m); + bind_packet_header_default(m); + bind_packet_header_ofdm(m); + bind_packet_headergenerator_bb(m); + bind_packet_headerparser_b(m); + bind_packet_sink(m); + bind_pfb_clock_sync_ccf(m); + bind_pfb_clock_sync_fff(m); + bind_pn_correlator_cc(m); + bind_probe_density_b(m); + bind_probe_mpsk_snr_est_c(m); + bind_protocol_formatter_async(m); + bind_protocol_formatter_bb(m); + bind_protocol_parser_b(m); + bind_scrambler_bb(m); + bind_simple_correlator(m); + bind_simple_framer(m); + bind_simple_framer_sync(m); + bind_symbol_sync_cc(m); + bind_symbol_sync_ff(m); + bind_timing_error_detector_type(m); +} diff --git a/gr-digital/python/digital/bindings/scrambler_bb_python.cc b/gr-digital/python/digital/bindings/scrambler_bb_python.cc new file mode 100644 index 0000000000..a11e86c4d9 --- /dev/null +++ b/gr-digital/python/digital/bindings/scrambler_bb_python.cc @@ -0,0 +1,42 @@ +/* + * 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/digital/scrambler_bb.h> +// pydoc.h is automatically generated in the build directory +#include <scrambler_bb_pydoc.h> + +void bind_scrambler_bb(py::module& m) +{ + + using scrambler_bb = ::gr::digital::scrambler_bb; + + + py::class_<scrambler_bb, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<scrambler_bb>>(m, "scrambler_bb", D(scrambler_bb)) + + .def(py::init(&scrambler_bb::make), + py::arg("mask"), + py::arg("seed"), + py::arg("len"), + D(scrambler_bb, make)) + + + ; +} diff --git a/gr-digital/python/digital/bindings/simple_correlator_python.cc b/gr-digital/python/digital/bindings/simple_correlator_python.cc new file mode 100644 index 0000000000..6d264971fd --- /dev/null +++ b/gr-digital/python/digital/bindings/simple_correlator_python.cc @@ -0,0 +1,40 @@ +/* + * 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/digital/simple_correlator.h> +// pydoc.h is automatically generated in the build directory +#include <simple_correlator_pydoc.h> + +void bind_simple_correlator(py::module& m) +{ + + using simple_correlator = ::gr::digital::simple_correlator; + + + py::class_<simple_correlator, + gr::block, + gr::basic_block, + std::shared_ptr<simple_correlator>>( + m, "simple_correlator", D(simple_correlator)) + + .def(py::init(&simple_correlator::make), + py::arg("payload_bytesize"), + D(simple_correlator, make)) + + + ; +} diff --git a/gr-digital/python/digital/bindings/simple_framer_python.cc b/gr-digital/python/digital/bindings/simple_framer_python.cc new file mode 100644 index 0000000000..70911bc0e4 --- /dev/null +++ b/gr-digital/python/digital/bindings/simple_framer_python.cc @@ -0,0 +1,37 @@ +/* + * 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/digital/simple_framer.h> +// pydoc.h is automatically generated in the build directory +#include <simple_framer_pydoc.h> + +void bind_simple_framer(py::module& m) +{ + + using simple_framer = ::gr::digital::simple_framer; + + + py::class_<simple_framer, gr::block, gr::basic_block, std::shared_ptr<simple_framer>>( + m, "simple_framer", D(simple_framer)) + + .def(py::init(&simple_framer::make), + py::arg("payload_bytesize"), + D(simple_framer, make)) + + + ; +} diff --git a/gr-digital/python/digital/bindings/simple_framer_sync_python.cc b/gr-digital/python/digital/bindings/simple_framer_sync_python.cc new file mode 100644 index 0000000000..1e28f394dd --- /dev/null +++ b/gr-digital/python/digital/bindings/simple_framer_sync_python.cc @@ -0,0 +1,25 @@ +/* + * 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/digital/simple_framer_sync.h> +// pydoc.h is automatically generated in the build directory +#include <simple_framer_sync_pydoc.h> + +void bind_simple_framer_sync(py::module& m) +{ + // TODO: Add the constexprs here +} diff --git a/gr-digital/python/digital/bindings/symbol_sync_cc_python.cc b/gr-digital/python/digital/bindings/symbol_sync_cc_python.cc new file mode 100644 index 0000000000..4150b6096d --- /dev/null +++ b/gr-digital/python/digital/bindings/symbol_sync_cc_python.cc @@ -0,0 +1,97 @@ +/* + * 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/digital/symbol_sync_cc.h> +// pydoc.h is automatically generated in the build directory +#include <symbol_sync_cc_pydoc.h> + +void bind_symbol_sync_cc(py::module& m) +{ + + using symbol_sync_cc = ::gr::digital::symbol_sync_cc; + + + py::class_<symbol_sync_cc, + gr::block, + gr::basic_block, + std::shared_ptr<symbol_sync_cc>>(m, "symbol_sync_cc", D(symbol_sync_cc)) + + .def(py::init(&symbol_sync_cc::make), + py::arg("detector_type"), + py::arg("sps"), + py::arg("loop_bw"), + py::arg("damping_factor") = 1.F, + py::arg("ted_gain") = 1.F, + py::arg("max_deviation") = 1.5F, + py::arg("osps") = 1, + py::arg("slicer") = gr::digital::constellation_sptr(), + py::arg("interp_type") = ::gr::digital::ir_type::IR_MMSE_8TAP, + py::arg("n_filters") = 128, + py::arg("taps") = std::vector<float>(), + D(symbol_sync_cc, make)) + + + .def("loop_bandwidth", + &symbol_sync_cc::loop_bandwidth, + D(symbol_sync_cc, loop_bandwidth)) + + + .def("damping_factor", + &symbol_sync_cc::damping_factor, + D(symbol_sync_cc, damping_factor)) + + + .def("ted_gain", &symbol_sync_cc::ted_gain, D(symbol_sync_cc, ted_gain)) + + + .def("alpha", &symbol_sync_cc::alpha, D(symbol_sync_cc, alpha)) + + + .def("beta", &symbol_sync_cc::beta, D(symbol_sync_cc, beta)) + + + .def("set_loop_bandwidth", + &symbol_sync_cc::set_loop_bandwidth, + py::arg("omega_n_norm"), + D(symbol_sync_cc, set_loop_bandwidth)) + + + .def("set_damping_factor", + &symbol_sync_cc::set_damping_factor, + py::arg("zeta"), + D(symbol_sync_cc, set_damping_factor)) + + + .def("set_ted_gain", + &symbol_sync_cc::set_ted_gain, + py::arg("ted_gain"), + D(symbol_sync_cc, set_ted_gain)) + + + .def("set_alpha", + &symbol_sync_cc::set_alpha, + py::arg("alpha"), + D(symbol_sync_cc, set_alpha)) + + + .def("set_beta", + &symbol_sync_cc::set_beta, + py::arg("beta"), + D(symbol_sync_cc, set_beta)) + + ; +} diff --git a/gr-digital/python/digital/bindings/symbol_sync_ff_python.cc b/gr-digital/python/digital/bindings/symbol_sync_ff_python.cc new file mode 100644 index 0000000000..ad92f447a4 --- /dev/null +++ b/gr-digital/python/digital/bindings/symbol_sync_ff_python.cc @@ -0,0 +1,97 @@ +/* + * 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/digital/symbol_sync_ff.h> +// pydoc.h is automatically generated in the build directory +#include <symbol_sync_ff_pydoc.h> + +void bind_symbol_sync_ff(py::module& m) +{ + + using symbol_sync_ff = ::gr::digital::symbol_sync_ff; + + + py::class_<symbol_sync_ff, + gr::block, + gr::basic_block, + std::shared_ptr<symbol_sync_ff>>(m, "symbol_sync_ff", D(symbol_sync_ff)) + + .def(py::init(&symbol_sync_ff::make), + py::arg("detector_type"), + py::arg("sps"), + py::arg("loop_bw"), + py::arg("damping_factor") = 1.F, + py::arg("ted_gain") = 1.F, + py::arg("max_deviation") = 1.5F, + py::arg("osps") = 1, + py::arg("slicer") = gr::digital::constellation_sptr(), + py::arg("interp_type") = ::gr::digital::ir_type::IR_MMSE_8TAP, + py::arg("n_filters") = 128, + py::arg("taps") = std::vector<float>(), + D(symbol_sync_ff, make)) + + + .def("loop_bandwidth", + &symbol_sync_ff::loop_bandwidth, + D(symbol_sync_ff, loop_bandwidth)) + + + .def("damping_factor", + &symbol_sync_ff::damping_factor, + D(symbol_sync_ff, damping_factor)) + + + .def("ted_gain", &symbol_sync_ff::ted_gain, D(symbol_sync_ff, ted_gain)) + + + .def("alpha", &symbol_sync_ff::alpha, D(symbol_sync_ff, alpha)) + + + .def("beta", &symbol_sync_ff::beta, D(symbol_sync_ff, beta)) + + + .def("set_loop_bandwidth", + &symbol_sync_ff::set_loop_bandwidth, + py::arg("omega_n_norm"), + D(symbol_sync_ff, set_loop_bandwidth)) + + + .def("set_damping_factor", + &symbol_sync_ff::set_damping_factor, + py::arg("zeta"), + D(symbol_sync_ff, set_damping_factor)) + + + .def("set_ted_gain", + &symbol_sync_ff::set_ted_gain, + py::arg("ted_gain"), + D(symbol_sync_ff, set_ted_gain)) + + + .def("set_alpha", + &symbol_sync_ff::set_alpha, + py::arg("alpha"), + D(symbol_sync_ff, set_alpha)) + + + .def("set_beta", + &symbol_sync_ff::set_beta, + py::arg("beta"), + D(symbol_sync_ff, set_beta)) + + ; +} diff --git a/gr-digital/python/digital/bindings/timing_error_detector_type_python.cc b/gr-digital/python/digital/bindings/timing_error_detector_type_python.cc new file mode 100644 index 0000000000..44ea6e3e6f --- /dev/null +++ b/gr-digital/python/digital/bindings/timing_error_detector_type_python.cc @@ -0,0 +1,41 @@ +/* + * 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/digital/timing_error_detector_type.h> +// pydoc.h is automatically generated in the build directory +#include <timing_error_detector_type_pydoc.h> + +void bind_timing_error_detector_type(py::module& m) +{ + + + py::enum_<::gr::digital::ted_type>(m, "ted_type") + .value("TED_NONE", ::gr::digital::TED_NONE) // -1 + .value("TED_MUELLER_AND_MULLER", ::gr::digital::TED_MUELLER_AND_MULLER) // 0 + .value("TED_MOD_MUELLER_AND_MULLER", + ::gr::digital::TED_MOD_MUELLER_AND_MULLER) // 1 + .value("TED_ZERO_CROSSING", ::gr::digital::TED_ZERO_CROSSING) // 2 + .value("TED_GARDNER", ::gr::digital::TED_GARDNER) // 4 + .value("TED_EARLY_LATE", ::gr::digital::TED_EARLY_LATE) // 5 + .value("TED_DANDREA_AND_MENGALI_GEN_MSK", + ::gr::digital::TED_DANDREA_AND_MENGALI_GEN_MSK) // 6 + .value("TED_SIGNAL_TIMES_SLOPE_ML", ::gr::digital::TED_SIGNAL_TIMES_SLOPE_ML) // 7 + .value("TED_SIGNUM_TIMES_SLOPE_ML", ::gr::digital::TED_SIGNUM_TIMES_SLOPE_ML) // 8 + .value("TED_MENGALI_AND_DANDREA_GMSK", + ::gr::digital::TED_MENGALI_AND_DANDREA_GMSK) // 9 + .export_values(); +} diff --git a/gr-digital/python/digital/bpsk.py b/gr-digital/python/digital/bpsk.py index 30b4c028f8..c8bd25d61a 100644 --- a/gr-digital/python/digital/bpsk.py +++ b/gr-digital/python/digital/bpsk.py @@ -20,7 +20,7 @@ from cmath import exp from gnuradio import gr from gnuradio.digital.generic_mod_demod import generic_mod, generic_demod from gnuradio.digital.generic_mod_demod import shared_mod_args, shared_demod_args -from . import digital_swig +from . import digital_python from . import modulation_utils # ///////////////////////////////////////////////////////////////////////////// @@ -28,14 +28,14 @@ from . import modulation_utils # ///////////////////////////////////////////////////////////////////////////// def bpsk_constellation(): - return digital_swig.constellation_bpsk() + return digital_python.constellation_bpsk() # ///////////////////////////////////////////////////////////////////////////// # DBPSK constellation # ///////////////////////////////////////////////////////////////////////////// def dbpsk_constellation(): - return digital_swig.constellation_dbpsk() + return digital_python.constellation_dbpsk() # diff --git a/gr-digital/python/digital/cpm.py b/gr-digital/python/digital/cpm.py index f18b509c91..6fd16f0c6d 100644 --- a/gr-digital/python/digital/cpm.py +++ b/gr-digital/python/digital/cpm.py @@ -24,7 +24,7 @@ import numpy from gnuradio import gr, filter from gnuradio import analog from gnuradio import blocks -from . import digital_swig +from . import digital_python from . import modulation_utils @@ -117,7 +117,7 @@ class cpm_mod(gr.hier_block2): # Turn it into symmetric PAM data. - self.pam = digital_swig.chunks_to_symbols_bf(self.sym_alphabet,1) + self.pam = digital_python.chunks_to_symbols_bf(self.sym_alphabet,1) # Generate pulse (sum of taps = samples_per_symbol/2) if cpm_type == 0: # CPFSK diff --git a/gr-digital/python/digital/crc.py b/gr-digital/python/digital/crc.py index 7f6b3fcbd2..dae4e8537f 100644 --- a/gr-digital/python/digital/crc.py +++ b/gr-digital/python/digital/crc.py @@ -9,7 +9,7 @@ from __future__ import unicode_literals # from gnuradio import gru -from . import digital_swig as digital +from . import digital_python as digital import struct def gen_and_append_crc32(s): diff --git a/gr-digital/python/digital/generic_mod_demod.py b/gr-digital/python/digital/generic_mod_demod.py index 9801848de0..938adfeb8a 100644 --- a/gr-digital/python/digital/generic_mod_demod.py +++ b/gr-digital/python/digital/generic_mod_demod.py @@ -20,7 +20,7 @@ from __future__ import unicode_literals from gnuradio import gr, blocks, filter, analog from .modulation_utils import extract_kwargs_from_options_for_class from .utils import mod_codes -from . import digital_swig as digital +from . import digital_python as digital import math diff --git a/gr-digital/python/digital/gfsk.py b/gr-digital/python/digital/gfsk.py index ac93e39ba1..9c70940ff1 100644 --- a/gr-digital/python/digital/gfsk.py +++ b/gr-digital/python/digital/gfsk.py @@ -23,7 +23,7 @@ from gnuradio import gr from gnuradio import analog from gnuradio import blocks, filter from . import modulation_utils -from . import digital_swig as digital +from . import digital_python as digital # default values (used in __init__ and add_options) diff --git a/gr-digital/python/digital/gmsk.py b/gr-digital/python/digital/gmsk.py index 0e00a3fc46..08823d0827 100644 --- a/gr-digital/python/digital/gmsk.py +++ b/gr-digital/python/digital/gmsk.py @@ -25,7 +25,7 @@ import numpy from gnuradio import gr, blocks, analog, filter from . import modulation_utils -from . import digital_swig as digital +from . import digital_python as digital # default values (used in __init__ and add_options) _def_samples_per_symbol = 2 diff --git a/gr-digital/python/digital/ofdm_txrx.py b/gr-digital/python/digital/ofdm_txrx.py index 770ea26c6d..62073d3280 100644 --- a/gr-digital/python/digital/ofdm_txrx.py +++ b/gr-digital/python/digital/ofdm_txrx.py @@ -26,7 +26,7 @@ import numpy from gnuradio import gr, blocks, fft, analog -from . import digital_swig as digital +from . import digital_python as digital _def_fft_len = 64 diff --git a/gr-digital/python/digital/psk.py b/gr-digital/python/digital/psk.py index c55607bd8e..60bdaab4d0 100644 --- a/gr-digital/python/digital/psk.py +++ b/gr-digital/python/digital/psk.py @@ -18,7 +18,7 @@ from __future__ import unicode_literals from math import pi, log from cmath import exp -from . import digital_swig +from . import digital_python from . import modulation_utils from .utils import mod_codes, gray_code from .generic_mod_demod import generic_mod, generic_demod @@ -66,7 +66,7 @@ def psk_constellation(m=_def_constellation_points, mod_code=_def_mod_code, if post_diff_code is not None: inverse_post_diff_code = mod_codes.invert_code(post_diff_code) points = [points[x] for x in inverse_post_diff_code] - constellation = digital_swig.constellation_psk(points, pre_diff_code, m) + constellation = digital_python.constellation_psk(points, pre_diff_code, m) return constellation # ///////////////////////////////////////////////////////////////////////////// diff --git a/gr-digital/python/digital/qa_chunks_to_symbols.py b/gr-digital/python/digital/qa_chunks_to_symbols.py index 8cb7371a84..0fbbc679ca 100644 --- a/gr-digital/python/digital/qa_chunks_to_symbols.py +++ b/gr-digital/python/digital/qa_chunks_to_symbols.py @@ -24,8 +24,8 @@ class test_chunks_to_symbols(gr_unittest.TestCase): const = [ 1+0j, 0+1j, -1+0j, 0-1j] src_data = (0, 1, 2, 3, 3, 2, 1, 0) - expected_result = (1+0j, 0+1j, -1+0j, 0-1j, - 0-1j, -1+0j, 0+1j, 1+0j) + expected_result = [1+0j, 0+1j, -1+0j, 0-1j, + 0-1j, -1+0j, 0+1j, 1+0j] src = blocks.vector_source_b(src_data) op = digital.chunks_to_symbols_bc(const) @@ -41,8 +41,8 @@ class test_chunks_to_symbols(gr_unittest.TestCase): def test_bf_002(self): const = [-3, -1, 1, 3] src_data = (0, 1, 2, 3, 3, 2, 1, 0) - expected_result = (-3, -1, 1, 3, - 3, 1, -1, -3) + expected_result = [-3, -1, 1, 3, + 3, 1, -1, -3] src = blocks.vector_source_b(src_data) op = digital.chunks_to_symbols_bf(const) @@ -59,8 +59,8 @@ class test_chunks_to_symbols(gr_unittest.TestCase): const = [ 1+0j, 0+1j, -1+0j, 0-1j] src_data = (0, 1, 2, 3, 3, 2, 1, 0) - expected_result = (1+0j, 0+1j, -1+0j, 0-1j, - 0-1j, -1+0j, 0+1j, 1+0j) + expected_result = [1+0j, 0+1j, -1+0j, 0-1j, + 0-1j, -1+0j, 0+1j, 1+0j] src = blocks.vector_source_i(src_data) op = digital.chunks_to_symbols_ic(const) @@ -76,8 +76,8 @@ class test_chunks_to_symbols(gr_unittest.TestCase): def test_if_004(self): const = [-3, -1, 1, 3] src_data = (0, 1, 2, 3, 3, 2, 1, 0) - expected_result = (-3, -1, 1, 3, - 3, 1, -1, -3) + expected_result = [-3, -1, 1, 3, + 3, 1, -1, -3] src = blocks.vector_source_i(src_data) op = digital.chunks_to_symbols_if(const) @@ -94,8 +94,8 @@ class test_chunks_to_symbols(gr_unittest.TestCase): const = [ 1+0j, 0+1j, -1+0j, 0-1j] src_data = (0, 1, 2, 3, 3, 2, 1, 0) - expected_result = (1+0j, 0+1j, -1+0j, 0-1j, - 0-1j, -1+0j, 0+1j, 1+0j) + expected_result = [1+0j, 0+1j, -1+0j, 0-1j, + 0-1j, -1+0j, 0+1j, 1+0j] src = blocks.vector_source_s(src_data) op = digital.chunks_to_symbols_sc(const) @@ -111,8 +111,8 @@ class test_chunks_to_symbols(gr_unittest.TestCase): def test_sf_006(self): const = [-3, -1, 1, 3] src_data = (0, 1, 2, 3, 3, 2, 1, 0) - expected_result = (-3, -1, 1, 3, - 3, 1, -1, -3) + expected_result = [-3, -1, 1, 3, + 3, 1, -1, -3] src = blocks.vector_source_s(src_data) op = digital.chunks_to_symbols_sf(const) @@ -129,10 +129,10 @@ class test_chunks_to_symbols(gr_unittest.TestCase): def test_sf_callback(self): constA = [-3, -1, 1, 3] constB = [12, -12, 6, -6] - src_data = (0, 1, 2, 3, 3, 2, 1, 0) - expected_result=(12, -12, 6, -6, -6, 6, -12, 12) + src_data = [0, 1, 2, 3, 3, 2, 1, 0] + expected_result=[12, -12, 6, -6, -6, 6, -12, 12] - src = blocks.vector_source_s(src_data, False, 1, "") + src = blocks.vector_source_s(src_data, False, 1, []) op = digital.chunks_to_symbols_sf(constA) op.set_symbol_table(constB) dst = blocks.vector_sink_f() @@ -145,10 +145,10 @@ class test_chunks_to_symbols(gr_unittest.TestCase): def test_sc_callback(self): constA = [-3.0+1j, -1.0-1j, 1.0+1j, 3-1j] constB = [12.0+1j, -12.0-1j, 6.0+1j, -6-1j] - src_data = (0, 1, 2, 3, 3, 2, 1, 0) - expected_result=(12.0+1j, -12.0-1j, 6.0+1j, -6-1j, -6-1j, 6+1j, -12-1j, 12+1j) + src_data = [0, 1, 2, 3, 3, 2, 1, 0] + expected_result=[12.0+1j, -12.0-1j, 6.0+1j, -6-1j, -6-1j, 6+1j, -12-1j, 12+1j] - src = blocks.vector_source_s(src_data, False, 1, "") + src = blocks.vector_source_s(src_data, False, 1, []) op = digital.chunks_to_symbols_sc(constA) op.set_symbol_table(constB) dst = blocks.vector_sink_c() @@ -162,8 +162,8 @@ class test_chunks_to_symbols(gr_unittest.TestCase): constA = [-3.0, -1.0, 1.0, 3] constB = [12.0, -12.0, 6.0, -6] src_data = (0, 1, 2, 3, 3, 2, 1, 0) - expected_result = (-3, -1, 1, 3, - -6, 6, -12, 12) + expected_result = [-3, -1, 1, 3, + -6, 6, -12, 12] first_tag = gr.tag_t() first_tag.key = pmt.intern("set_symbol_table") first_tag.value = pmt.init_f32vector(len(constA), constA) @@ -188,8 +188,8 @@ class test_chunks_to_symbols(gr_unittest.TestCase): constA = [-3.0+1j, -1.0-1j, 1.0+1j, 3-1j] constB = [12.0+1j, -12.0-1j, 6.0+1j, -6-1j] src_data = (0, 1, 2, 3, 3, 2, 1, 0) - expected_result = (-3+1j, -1-1j, 1+1j, 3-1j, - -6-1j, 6+1j, -12-1j, 12+1j) + expected_result = [-3+1j, -1-1j, 1+1j, 3-1j, + -6-1j, 6+1j, -12-1j, 12+1j] first_tag = gr.tag_t() first_tag.key = pmt.intern("set_symbol_table") first_tag.value = pmt.init_c32vector(len(constA), constA) diff --git a/gr-digital/python/digital/qa_constellation.py b/gr-digital/python/digital/qa_constellation.py index 9269089ca5..f6acb6ace1 100644 --- a/gr-digital/python/digital/qa_constellation.py +++ b/gr-digital/python/digital/qa_constellation.py @@ -161,7 +161,7 @@ class test_constellation(gr_unittest.TestCase): def setUp(self): random.seed(0) # Generate a list of random bits. - self.src_data = tuple([random.randint(0,1) for i in range(0, self.src_length)]) + self.src_data = [random.randint(0,1) for i in range(0, self.src_length)] def tearDown(self): pass diff --git a/gr-digital/python/digital/qa_correlate_access_code.py b/gr-digital/python/digital/qa_correlate_access_code.py index ede1395bb1..c68ac036fb 100644 --- a/gr-digital/python/digital/qa_correlate_access_code.py +++ b/gr-digital/python/digital/qa_correlate_access_code.py @@ -35,10 +35,10 @@ class test_correlate_access_code(gr_unittest.TestCase): self.tb = None def test_001(self): - pad = (0,) * 64 + pad = [0,] * 64 # 0 0 0 1 0 0 0 1 - src_data = (1, 0, 1, 1, 1, 1, 0, 1, 1) + pad + (0,) * 7 - expected_result = pad + (1, 0, 1, 1, 3, 1, 0, 1, 1, 2) + (0,) * 6 + src_data = [1, 0, 1, 1, 1, 1, 0, 1, 1] + pad + [0,] * 7 + expected_result = pad + [1, 0, 1, 1, 3, 1, 0, 1, 1, 2] + [0,] * 6 src = blocks.vector_source_b(src_data) op = digital.correlate_access_code_bb("1011", 0) dst = blocks.vector_sink_b() @@ -49,13 +49,13 @@ class test_correlate_access_code(gr_unittest.TestCase): def test_002(self): - code = tuple(string_to_1_0_list(default_access_code)) + code = list(string_to_1_0_list(default_access_code)) access_code = to_1_0_string(code) - pad = (0,) * 64 + pad = [0,] * 64 #print code #print access_code - src_data = code + (1, 0, 1, 1) + pad - expected_result = pad + code + (3, 0, 1, 1) + src_data = code + [1, 0, 1, 1] + pad + expected_result = pad + code + [3, 0, 1, 1] src = blocks.vector_source_b(src_data) op = digital.correlate_access_code_bb(access_code, 0) dst = blocks.vector_sink_b() @@ -65,13 +65,13 @@ class test_correlate_access_code(gr_unittest.TestCase): self.assertEqual(expected_result, result_data) def test_003(self): - code = tuple(string_to_1_0_list(default_access_code)) + code = list(string_to_1_0_list(default_access_code)) access_code = to_1_0_string(code) - pad = (0,) * 64 + pad = [0,] * 64 #print code #print access_code - src_data = code + (1, 0, 1, 1) + pad - expected_result = code + (1, 0, 1, 1) + pad + src_data = code + [1, 0, 1, 1] + pad + expected_result = code + [1, 0, 1, 1] + pad src = blocks.vector_source_b(src_data) op = digital.correlate_access_code_tag_bb(access_code, 0, "test") dst = blocks.vector_sink_b() @@ -81,14 +81,14 @@ class test_correlate_access_code(gr_unittest.TestCase): self.assertEqual(expected_result, result_data) def test_004(self): - code = tuple(string_to_1_0_list(default_access_code)) + code = list(string_to_1_0_list(default_access_code)) access_code = to_1_0_string(code) - pad = (0,) * 64 + pad = [0,] * 64 #print code #print access_code - src_bits = code + (1, 0, 1, 1) + pad + src_bits = code + [1, 0, 1, 1] + pad src_data = [2.0*x - 1.0 for x in src_bits] - expected_result_bits = code + (1, 0, 1, 1) + pad + expected_result_bits = code + [1, 0, 1, 1] + pad expected_result = [2.0*x - 1.0 for x in expected_result_bits] src = blocks.vector_source_f(src_data) op = digital.correlate_access_code_tag_ff(access_code, 0, "test") diff --git a/gr-digital/python/digital/qa_correlate_access_code_XX_ts.py b/gr-digital/python/digital/qa_correlate_access_code_XX_ts.py index c7f1fdfd92..4d9693b6c1 100644 --- a/gr-digital/python/digital/qa_correlate_access_code_XX_ts.py +++ b/gr-digital/python/digital/qa_correlate_access_code_XX_ts.py @@ -40,7 +40,7 @@ class test_correlate_access_code_XX_ts(gr_unittest.TestCase): packet = header + payload pad = (0,) * 64 src_data = (0, 0, 1, 1, 1, 1, 0, 1, 1) + tuple(string_to_1_0_list(packet)) + pad - expected = tuple(map(int, src_data[9+32:-len(pad)])) + expected = list(map(int, src_data[9+32:-len(pad)])) src = blocks.vector_source_b(src_data) op = digital.correlate_access_code_bb_ts("1011", 0, "sync") dst = blocks.vector_sink_b() diff --git a/gr-digital/python/digital/qa_crc32_bb.py b/gr-digital/python/digital/qa_crc32_bb.py index b28f9521ba..e41fa04bc5 100644 --- a/gr-digital/python/digital/qa_crc32_bb.py +++ b/gr-digital/python/digital/qa_crc32_bb.py @@ -37,7 +37,7 @@ class qa_crc32_bb(gr_unittest.TestCase): def test_002_crc_equal(self): """ Go through CRC set / CRC check and make sure the output is the same as the input. """ - data = (0, 1, 2, 3, 4, 5, 6, 7, 8) + data = [0, 1, 2, 3, 4, 5, 6, 7, 8] src = blocks.vector_source_b(data) crc = digital.crc32_bb(False, self.tsb_key) crc_check = digital.crc32_bb(True, self.tsb_key) @@ -97,7 +97,7 @@ class qa_crc32_bb(gr_unittest.TestCase): def test_004_fail(self): """ Corrupt the data and make sure it fails CRC test. """ - data = (0, 1, 2, 3, 4, 5, 6, 7) + data = [0, 1, 2, 3, 4, 5, 6, 7] src = blocks.vector_source_b(data) crc = digital.crc32_bb(False, self.tsb_key) crc_check = digital.crc32_bb(True, self.tsb_key) @@ -114,7 +114,7 @@ class qa_crc32_bb(gr_unittest.TestCase): def test_005_tag_propagation(self): """ Make sure tags on the CRC aren't lost. """ # Data with precalculated CRC - data = (0, 1, 2, 3, 4, 5, 6, 7, 8, 2, 67, 225, 188) + data = [0, 1, 2, 3, 4, 5, 6, 7, 8, 2, 67, 225, 188] testtag = gr.tag_t() testtag.offset = len(data) - 1 testtag.key = pmt.string_to_symbol('tag1') @@ -151,7 +151,7 @@ class qa_crc32_bb(gr_unittest.TestCase): def test_007_crc_equal(self): """ Go through CRC set / CRC check and make sure the output is the same as the input. """ - data = (0, 1, 2, 3, 4, 5, 6, 7, 8) + data = [0, 1, 2, 3, 4, 5, 6, 7, 8] src = blocks.vector_source_b(data) crc = digital.crc32_bb(False, self.tsb_key, False) crc_check = digital.crc32_bb(True, self.tsb_key, False) @@ -167,7 +167,7 @@ class qa_crc32_bb(gr_unittest.TestCase): def test_002_crc_equal_unpacked (self): """ Test unpacked operation with packed operation """ - data = (0, 1, 2, 3, 4, 5, 6, 7, 8) + data = [0, 1, 2, 3, 4, 5, 6, 7, 8] src = blocks.vector_source_b(data) unpack1 = blocks.repack_bits_bb(8, 1, self.tsb_key, False, gr.GR_LSB_FIRST) unpack2 = blocks.repack_bits_bb(8, 1, self.tsb_key, False, gr.GR_LSB_FIRST) @@ -190,7 +190,7 @@ class qa_crc32_bb(gr_unittest.TestCase): def test_003_crc_equal_unpacked(self): """ Test unpacked operation with packed operation """ - data = range(35) + data = list(range(35)) src = blocks.vector_source_b(data) unpack1 = blocks.repack_bits_bb(8, 1, self.tsb_key, False, gr.GR_LSB_FIRST) diff --git a/gr-digital/python/digital/qa_diff_encoder.py b/gr-digital/python/digital/qa_diff_encoder.py index 8c4ea7c1ce..95be7d267f 100644 --- a/gr-digital/python/digital/qa_diff_encoder.py +++ b/gr-digital/python/digital/qa_diff_encoder.py @@ -13,11 +13,11 @@ import random from gnuradio import gr, gr_unittest, digital, blocks -def make_random_int_tuple(L, min, max): +def make_random_int_list(L, min, max): result = [] for x in range(L): result.append(random.randint(min, max)) - return tuple(result) + return list(result) class test_diff_encoder(gr_unittest.TestCase): @@ -32,7 +32,7 @@ class test_diff_encoder(gr_unittest.TestCase): def test_diff_encdec_000(self): random.seed(0) modulus = 2 - src_data = make_random_int_tuple(1000, 0, modulus-1) + src_data = make_random_int_list(1000, 0, modulus-1) expected_result = src_data src = blocks.vector_source_b(src_data) enc = digital.diff_encoder_bb(modulus) @@ -46,7 +46,7 @@ class test_diff_encoder(gr_unittest.TestCase): def test_diff_encdec_001(self): random.seed(0) modulus = 4 - src_data = make_random_int_tuple(1000, 0, modulus-1) + src_data = make_random_int_list(1000, 0, modulus-1) expected_result = src_data src = blocks.vector_source_b(src_data) enc = digital.diff_encoder_bb(modulus) @@ -60,7 +60,7 @@ class test_diff_encoder(gr_unittest.TestCase): def test_diff_encdec_002(self): random.seed(0) modulus = 8 - src_data = make_random_int_tuple(40000, 0, modulus-1) + src_data = make_random_int_list(40000, 0, modulus-1) expected_result = src_data src = blocks.vector_source_b(src_data) enc = digital.diff_encoder_bb(modulus) diff --git a/gr-digital/python/digital/qa_ofdm_carrier_allocator_cvc.py b/gr-digital/python/digital/qa_ofdm_carrier_allocator_cvc.py index e6671965c9..44115b237b 100644 --- a/gr-digital/python/digital/qa_ofdm_carrier_allocator_cvc.py +++ b/gr-digital/python/digital/qa_ofdm_carrier_allocator_cvc.py @@ -30,7 +30,7 @@ class qa_digital_carrier_allocator_cvc (gr_unittest.TestCase): occupied_carriers = ((0, 1, 2),) pilot_carriers = ((3,),) sync_word = (list(range(fft_len)),) - expected_result = tuple(sync_word[0] + [1j, 0, 0, 1, 2, 3]) + expected_result = sync_word[0] + [1j, 0, 0, 1, 2, 3] # ^ DC carrier src = blocks.vector_source_c(tx_symbols, False, 1) alloc = digital.ofdm_carrier_allocator_cvc(fft_len, @@ -58,7 +58,7 @@ class qa_digital_carrier_allocator_cvc (gr_unittest.TestCase): occupied_carriers = ((0, 1, 2),) pilot_carriers = ((-2,),) pilot_symbols = ((1j,),) - expected_result = (1j, 0, 1, 2, 3) + expected_result = [1j, 0, 1, 2, 3] # ^ DC carrier src = blocks.vector_source_c(tx_symbols, False, 1) alloc = digital.ofdm_carrier_allocator_cvc( @@ -82,7 +82,7 @@ class qa_digital_carrier_allocator_cvc (gr_unittest.TestCase): pilot_symbols = ((1j,),) occupied_carriers = ((-1, 1, 2),) pilot_carriers = ((3,),) - expected_result = (1j, 0, 1, 0, 2, 3) + expected_result = [1j, 0, 1, 0, 2, 3] src = blocks.vector_source_c(tx_symbols, False, 1) alloc = digital.ofdm_carrier_allocator_cvc(fft_len, occupied_carriers, @@ -99,7 +99,7 @@ class qa_digital_carrier_allocator_cvc (gr_unittest.TestCase): self.tb.run () self.assertEqual(sink.data()[0], expected_result) - def test_002_t (self): + def test_002_tb (self): """ once again, but this time add a sync word """ @@ -109,7 +109,7 @@ class qa_digital_carrier_allocator_cvc (gr_unittest.TestCase): pilot_symbols = ((1j,),) occupied_carriers = ((-1, 1, 2),) pilot_carriers = ((3,),) - expected_result = sync_word + (1j, 0, 1, 0, 2, 3) + (1j, 0, 4, 0, 5, 6) + expected_result = list(sync_word + (1j, 0, 1, 0, 2, 3) + (1j, 0, 4, 0, 5, 6)) special_tag1 = gr.tag_t() special_tag1.offset = 0 special_tag1.key = pmt.string_to_symbol("spam") @@ -156,9 +156,9 @@ class qa_digital_carrier_allocator_cvc (gr_unittest.TestCase): pilot_symbols = ((1j, 2j), (3j, 4j)) occupied_carriers = ((1, 3, 4, 11, 12, 14), (1, 2, 4, 11, 13, 14),) pilot_carriers = ((2, 13), (3, 12)) - expected_result = (0, 1, 1j, 2, 3, 0, 0, 0, 0, 0, 0, 4, 5, 2j, 6, 0, + expected_result = list((0, 1, 1j, 2, 3, 0, 0, 0, 0, 0, 0, 4, 5, 2j, 6, 0, 0, 7, 8, 3j, 9, 0, 0, 0, 0, 0, 0, 10, 4j, 11, 12, 0, - 0, 13, 1j, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 2j, 0, 0) + 0, 13, 1j, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 2j, 0, 0)) fft_len = 16 testtag1 = gr.tag_t() testtag1.offset = 0 @@ -203,30 +203,34 @@ class qa_digital_carrier_allocator_cvc (gr_unittest.TestCase): fft_len = 6 # Occupied carriers - with self.assertRaises(TypeError) as oc: + #with self.assertRaises(TypeError) as oc: + #Pybind11 raises this as a ValueError + with self.assertRaises(ValueError) as oc: alloc = digital.ofdm_carrier_allocator_cvc(fft_len, - (), - ((),), - ((),), - (), + [], + [[],], + [[],], + [], self.tsb_key) # Pilot carriers - with self.assertRaises(TypeError) as pc: + #Pybind11 raises this as a ValueError + with self.assertRaises(ValueError) as pc: alloc = digital.ofdm_carrier_allocator_cvc(fft_len, - ((),), - (), - ((),), - (), + [[],], + [], + [[],], + [], self.tsb_key) # Pilot carrier symbols - with self.assertRaises(TypeError) as ps: + #Pybind11 raises this as a ValueError + with self.assertRaises(ValueError) as ps: alloc = digital.ofdm_carrier_allocator_cvc(fft_len, - ((),), - ((),), - (), - (), + [[],], + [[],], + [], + [], self.tsb_key) diff --git a/gr-digital/python/digital/qa_ofdm_chanest_vcvc.py b/gr-digital/python/digital/qa_ofdm_chanest_vcvc.py index afef9c941f..5cdd133da4 100644 --- a/gr-digital/python/digital/qa_ofdm_chanest_vcvc.py +++ b/gr-digital/python/digital/qa_ofdm_chanest_vcvc.py @@ -113,7 +113,7 @@ class qa_ofdm_chanest_vcvc (gr_unittest.TestCase): sync_symbol2 = (0, 0, 0, 1j, -1, 1, -1j, 1j, 0, 1, -1j, -1, -1j, 1, 0, 0) data_symbol = (0, 0, 0, 1, -1, 1, -1, 1, 0, 1, -1, -1, -1, 1, 0, 0) tx_data = sync_symbol1 + sync_symbol2 + data_symbol - channel = (0, 0, 0, 2, -2, 2, 3j, 2, 0, 2, 2, 2, 2, 3, 0, 0) + channel = [0, 0, 0, 2, -2, 2, 3j, 2, 0, 2, 2, 2, 2, 3, 0, 0] src = blocks.vector_source_c(tx_data, False, fft_len) chan = blocks.multiply_const_vcc(channel) chanest = digital.ofdm_chanest_vcvc(sync_symbol1, sync_symbol2, 1) @@ -139,7 +139,7 @@ class qa_ofdm_chanest_vcvc (gr_unittest.TestCase): sync_symbol = (0, 0, 0, 1, 0, 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, 0) data_symbol = (0, 0, 0, 1, -1, 1, -1, 1, 0, 1, -1, -1, -1, 1, 0, 0) tx_data = sync_symbol + data_symbol - channel = (0, 0, 0, 2, 2, 2, 2, 3, 3, 2.5, 2.5, -3, -3, 1j, 1j, 0) + channel = [0, 0, 0, 2, 2, 2, 2, 3, 3, 2.5, 2.5, -3, -3, 1j, 1j, 0] #channel = (0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0) src = blocks.vector_source_c(tx_data, False, fft_len) chan = blocks.multiply_const_vcc(channel) @@ -166,7 +166,7 @@ class qa_ofdm_chanest_vcvc (gr_unittest.TestCase): ref_symbol = (0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0) data_symbol = (0, 0, 0, 1, -1, 1, -1, 1, 0, 1, -1, -1, -1, 1, 0, 0) tx_data = sync_symbol + data_symbol - channel = (0, 0, 0, 2, 2, 2, 2.5, 3, 2.5, 2, 2.5, 3, 2, 1, 1, 0) + channel = [0, 0, 0, 2, 2, 2, 2.5, 3, 2.5, 2, 2.5, 3, 2, 1, 1, 0] src = blocks.vector_source_c(tx_data, False, fft_len) chan = blocks.multiply_const_vcc(channel) chanest = digital.ofdm_chanest_vcvc(sync_symbol, ref_symbol, 1) @@ -190,7 +190,7 @@ class qa_ofdm_chanest_vcvc (gr_unittest.TestCase): data_symbol = (0, 0, 0, 1, -1, 1, -1, 1, 0, 1, -1, -1, -1, 1, 0, 0) # Channel 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 # Shifted (0, 0, 0, 0, 0, 1j, -1, 1, -1j, 1j, 0, 1, -1j, -1, -1j, 1) - chanest_exp = (0, 0, 0, 5, 6, 7, 8, 9, 0, 11, 12, 13, 14, 15, 0, 0) + chanest_exp = [0, 0, 0, 5, 6, 7, 8, 9, 0, 11, 12, 13, 14, 15, 0, 0] tx_data = shift_tuple(sync_symbol1, carr_offset) + \ shift_tuple(sync_symbol2, carr_offset) + \ shift_tuple(data_symbol, carr_offset) @@ -209,7 +209,7 @@ class qa_ofdm_chanest_vcvc (gr_unittest.TestCase): if pmt.symbol_to_string(tag.key) == 'ofdm_sync_chan_taps': chan_est = pmt.c32vector_elements(tag.value) self.assertEqual(chan_est, chanest_exp) - self.assertEqual(sink.data(), tuple(numpy.multiply(shift_tuple(data_symbol, carr_offset), channel))) + self.assertEqual(sink.data(), list(numpy.multiply(shift_tuple(data_symbol, carr_offset), channel))) def test_999_all_at_once(self): diff --git a/gr-digital/python/digital/qa_ofdm_cyclic_prefixer.py b/gr-digital/python/digital/qa_ofdm_cyclic_prefixer.py index 68c6e371d5..0d4d4f0fbe 100644 --- a/gr-digital/python/digital/qa_ofdm_cyclic_prefixer.py +++ b/gr-digital/python/digital/qa_ofdm_cyclic_prefixer.py @@ -26,8 +26,8 @@ class test_ofdm_cyclic_prefixer (gr_unittest.TestCase): " The easiest test: make sure the CP is added correctly. " fft_len = 8 cp_len = 2 - expected_result = (6, 7, 0, 1, 2, 3, 4, 5, 6, 7, - 6, 7, 0, 1, 2, 3, 4, 5, 6, 7) + expected_result = [6, 7, 0, 1, 2, 3, 4, 5, 6, 7, + 6, 7, 0, 1, 2, 3, 4, 5, 6, 7] src = blocks.vector_source_c(list(range(fft_len)) * 2, False, fft_len) cp = digital.ofdm_cyclic_prefixer(fft_len, fft_len + cp_len) sink = blocks.vector_sink_c() @@ -40,8 +40,8 @@ class test_ofdm_cyclic_prefixer (gr_unittest.TestCase): fft_len = 8 cp_len = 2 rolloff = 2 - expected_result = (7.0 / 2, 8, 1, 2, 3, 4, 5, 6, 7, 8, # 1.0/2 - 7.0 / 2+1.0 / 2, 8, 1, 2, 3, 4, 5, 6, 7, 8) + expected_result = [7.0 / 2, 8, 1, 2, 3, 4, 5, 6, 7, 8, # 1.0/2 + 7.0 / 2+1.0 / 2, 8, 1, 2, 3, 4, 5, 6, 7, 8] src = blocks.vector_source_c(list(range(1, fft_len+1)) * 2, False, fft_len) cp = digital.ofdm_cyclic_prefixer(fft_len, fft_len + cp_len, rolloff) sink = blocks.vector_sink_c() @@ -54,8 +54,8 @@ class test_ofdm_cyclic_prefixer (gr_unittest.TestCase): fft_len = 8 cp_len = 2 tag_name = "ts_last" - expected_result = (7.0 / 2, 8, 1, 2, 3, 4, 5, 6, 7, 8, # 1.0/2 - 7.0 / 2+1.0 / 2, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1.0 / 2) + expected_result = [7.0 / 2, 8, 1, 2, 3, 4, 5, 6, 7, 8, # 1.0/2 + 7.0 / 2+1.0 / 2, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1.0 / 2] tag2 = gr.tag_t() tag2.offset = 1 tag2.key = pmt.string_to_symbol("random_tag") @@ -77,12 +77,12 @@ class test_ofdm_cyclic_prefixer (gr_unittest.TestCase): "Two CP lengths, no rolloff and no tags." fft_len = 8 cp_lengths = (3, 2, 2) - expected_result = (5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, # 1 + expected_result = [5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, # 1 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, # 2 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, # 3 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, # 4 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, # 5 - ) + ] src = blocks.vector_source_c(list(range(fft_len))*5, False, fft_len) cp = digital.ofdm_cyclic_prefixer(fft_len, cp_lengths) sink = blocks.vector_sink_c() @@ -95,12 +95,12 @@ class test_ofdm_cyclic_prefixer (gr_unittest.TestCase): fft_len = 8 cp_lengths = (3, 2, 2) rolloff = 2 - expected_result = (6.0/2,7,8,1,2,3,4,5,6,7,8, #1 + expected_result = [6.0/2,7,8,1,2,3,4,5,6,7,8, #1 7.0/2 + 1.0/2,8,1,2,3,4,5,6,7,8, #2 7.0/2 + 1.0/2,8,1,2,3,4,5,6,7,8, #3 6.0/2 + 1.0/2,7,8,1,2,3,4,5,6,7,8,#4 7.0/2 + 1.0/2,8,1,2,3,4,5,6,7,8 #5 - ) + ] src = blocks.vector_source_c(list(range(1, fft_len+1))*5, False, fft_len) cp = digital.ofdm_cyclic_prefixer(fft_len, cp_lengths, rolloff) sink = blocks.vector_sink_c() @@ -114,10 +114,10 @@ class test_ofdm_cyclic_prefixer (gr_unittest.TestCase): cp_lengths = (3, 2, 2) rolloff = 2 tag_name = "ts_last" - expected_result = ( + expected_result = [ 6.0/2, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8, #1 7.0/2+1.0/2, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1.0/2 #Last tail - ) + ] # First test tag tag0 = gr.tag_t() tag0.offset = 0 diff --git a/gr-digital/python/digital/qa_ofdm_frame_equalizer_vcvc.py b/gr-digital/python/digital/qa_ofdm_frame_equalizer_vcvc.py index a3395ceb9b..2a83915681 100644 --- a/gr-digital/python/digital/qa_ofdm_frame_equalizer_vcvc.py +++ b/gr-digital/python/digital/qa_ofdm_frame_equalizer_vcvc.py @@ -35,7 +35,7 @@ class qa_ofdm_frame_equalizer_vcvc (gr_unittest.TestCase): fft_len = 8 equalizer = digital.ofdm_equalizer_static(fft_len) n_syms = 3 - tx_data = (1,) * fft_len * n_syms + tx_data = [1,] * fft_len * n_syms chan_tag = gr.tag_t() chan_tag.offset = 0 chan_tag.key = pmt.string_to_symbol("ofdm_sync_chan_taps") @@ -73,7 +73,7 @@ class qa_ofdm_frame_equalizer_vcvc (gr_unittest.TestCase): fft_len = 8 equalizer = digital.ofdm_equalizer_static(fft_len, symbols_skipped=1) n_syms = 3 - tx_data = (1,) * fft_len * n_syms + tx_data = [1,] * fft_len * n_syms chan_tag = gr.tag_t() chan_tag.offset = 0 chan_tag.key = pmt.string_to_symbol("ofdm_sync_chan_taps") diff --git a/gr-digital/python/digital/qa_ofdm_serializer_vcc.py b/gr-digital/python/digital/qa_ofdm_serializer_vcc.py index 0a1befe5b7..8dd1ba7efa 100644 --- a/gr-digital/python/digital/qa_ofdm_serializer_vcc.py +++ b/gr-digital/python/digital/qa_ofdm_serializer_vcc.py @@ -30,7 +30,7 @@ class qa_ofdm_serializer_vcc (gr_unittest.TestCase): tx_symbols = (0, 1, 1j, 2, 3, 0, 0, 0, 0, 0, 0, 4, 5, 2j, 6, 0, 0, 7, 8, 3j, 9, 0, 0, 0, 0, 0, 0, 10, 4j, 11, 12, 0, 0, 13, 1j, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 2j, 0, 0) - expected_result = tuple(range(1, 16)) + (0, 0, 0) + expected_result = list(range(1, 16)) + [0, 0, 0] occupied_carriers = ((1, 3, 4, 11, 12, 14), (1, 2, 4, 11, 13, 14),) n_syms = len(tx_symbols) // fft_len src = blocks.vector_source_c(tx_symbols, False, fft_len) @@ -48,7 +48,7 @@ class qa_ofdm_serializer_vcc (gr_unittest.TestCase): 0, 0, 0, 0, 6, 1j, 7, 8, 0, 9, 10, 1j, 11, 0, 0, 0, 0, 0, 0, 0, 0, 12, 13, 14, 0, 15, 16, 17, 0, 0, 0, 0, ) - expected_result = tuple(range(18)) + expected_result = list(range(18)) occupied_carriers = ((13, 14, 15, 1, 2, 3), (-4, -2, -1, 1, 2, 4),) n_syms = len(tx_symbols) // fft_len src = blocks.vector_source_c(tx_symbols, False, fft_len) @@ -66,7 +66,7 @@ class qa_ofdm_serializer_vcc (gr_unittest.TestCase): 0, 0, 7, 8, 3j, 9, 0, 0, 0, 0, 0, 0, 10, 4j, 11, 12, 0, 0, 13, 1j, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 2j, 0) carr_offset = 1 # Compare this with tx_symbols from the previous test - expected_result = tuple(range(1, 16)) + (0, 0, 0) + expected_result = list(range(1, 16)) + [0, 0, 0] occupied_carriers = ((1, 3, 4, 11, 12, 14), (1, 2, 4, 11, 13, 14),) n_syms = len(tx_symbols) // fft_len offsettag = gr.tag_t() @@ -97,7 +97,7 @@ class qa_ofdm_serializer_vcc (gr_unittest.TestCase): pilot_carriers = ((3,),(5,)) pilot_symbols = ((1j,),(-1j,)) #tx_data = tuple([numpy.random.randint(0, 10) for x in range(4 * n_syms)]) - tx_data = (1, 2, 3, 4) + tx_data = [1, 2, 3, 4] src = blocks.vector_source_c(tx_data, False, 1) alloc = digital.ofdm_carrier_allocator_cvc( fft_len, @@ -135,7 +135,7 @@ class qa_ofdm_serializer_vcc (gr_unittest.TestCase): occupied_carriers = ((-2, -1, 1, 2),) pilot_carriers = ((-3,),(3,)) pilot_symbols = ((1j,),(-1j,)) - tx_data = (1, 2, 3, 4) + tx_data = [1, 2, 3, 4] offsettag = gr.tag_t() offsettag.offset = 0 offsettag.key = pmt.string_to_symbol("ofdm_sync_carr_offset") @@ -172,11 +172,11 @@ class qa_ofdm_serializer_vcc (gr_unittest.TestCase): def test_005_packet_len_tag (self): """ Standard test """ fft_len = 16 - tx_symbols = list(range(1, 16)); + tx_symbols = list(range(1, 16)) tx_symbols = (0, 1, 1j, 2, 3, 0, 0, 0, 0, 0, 0, 4, 5, 2j, 6, 0, 0, 7, 8, 3j, 9, 0, 0, 0, 0, 0, 0, 10, 4j, 11, 12, 0, 0, 13, 1j, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 2j, 0, 0) - expected_result = tuple(range(1, 16)) + expected_result = list(range(1, 16)) occupied_carriers = ((1, 3, 4, 11, 12, 14), (1, 2, 4, 11, 13, 14),) n_syms = len(tx_symbols) // fft_len packet_len_tsb_key = "packet_len" @@ -195,7 +195,9 @@ class qa_ofdm_serializer_vcc (gr_unittest.TestCase): """ Make sure it fails if it should """ fft_len = 16 occupied_carriers = ((1, 3, 4, 11, 12, 112),) # Something invalid - self.assertRaises(TypeError, digital.ofdm_serializer_vcc, fft_len, occupied_carriers, self.tsb_key) + #self.assertRaises(TypeError, digital.ofdm_serializer_vcc, fft_len, occupied_carriers, self.tsb_key) + #pybind11 raises ValueError instead of TypeError + self.assertRaises(ValueError, digital.ofdm_serializer_vcc, fft_len, occupied_carriers, self.tsb_key) if __name__ == '__main__': diff --git a/gr-digital/python/digital/qa_ofdm_txrx.py b/gr-digital/python/digital/qa_ofdm_txrx.py index b2d1b80856..a15604afc6 100644 --- a/gr-digital/python/digital/qa_ofdm_txrx.py +++ b/gr-digital/python/digital/qa_ofdm_txrx.py @@ -40,7 +40,7 @@ class ofdm_rx_fg (gr.top_block): gr.top_block.__init__(self, "ofdm_rx") if prepend_zeros: samples = (0,) * prepend_zeros + tuple(samples) - src = blocks.vector_source_c(tuple(samples) + (0,) * 1000) + src = blocks.vector_source_c(list(samples) + [0,] * 1000) self.rx = ofdm_rx(frame_length_tag_key=len_tag_key, debug_log=LOG_DEBUG_INFO, scramble_bits=scramble_bits) if channel is not None: self.connect(src, channel, self.rx) @@ -100,7 +100,7 @@ class test_ofdm_txrx (gr_unittest.TestCase): len_tag_key = 'frame_len' n_bytes = 21 fft_len = 64 - test_data = tuple([random.randint(0, 255) for x in range(n_bytes)]) + test_data = list([random.randint(0, 255) for x in range(n_bytes)]) # 1.0/fft_len is one sub-carrier, a fine freq offset stays below that freq_offset = 1.0 / fft_len * 0.7 #channel = channels.channel_model(0.01, freq_offset) @@ -113,8 +113,8 @@ class test_ofdm_txrx (gr_unittest.TestCase): rx_fg = ofdm_rx_fg(tx_samples, len_tag_key, channel, prepend_zeros=100) rx_fg.run() rx_data = rx_fg.get_rx_bytes() - self.assertEqual(tuple(tx_fg.tx.sync_word1), tuple(rx_fg.rx.sync_word1)) - self.assertEqual(tuple(tx_fg.tx.sync_word2), tuple(rx_fg.rx.sync_word2)) + self.assertEqual(list(tx_fg.tx.sync_word1), list(rx_fg.rx.sync_word1)) + self.assertEqual(list(tx_fg.tx.sync_word2), list(rx_fg.rx.sync_word2)) self.assertEqual(test_data, rx_data) def test_003_tx1packet_scramble(self): @@ -122,7 +122,7 @@ class test_ofdm_txrx (gr_unittest.TestCase): len_tag_key = 'frame_len' n_bytes = 21 fft_len = 64 - test_data = tuple([random.randint(0, 255) for x in range(n_bytes)]) + test_data = list([random.randint(0, 255) for x in range(n_bytes)]) # 1.0/fft_len is one sub-carrier, a fine freq offset stays below that freq_offset = 1.0 / fft_len * 0.7 #channel = channels.channel_model(0.01, freq_offset) @@ -135,8 +135,8 @@ class test_ofdm_txrx (gr_unittest.TestCase): rx_fg = ofdm_rx_fg(tx_samples, len_tag_key, channel, prepend_zeros=100, scramble_bits=True) rx_fg.run() rx_data = rx_fg.get_rx_bytes() - self.assertEqual(tuple(tx_fg.tx.sync_word1), tuple(rx_fg.rx.sync_word1)) - self.assertEqual(tuple(tx_fg.tx.sync_word2), tuple(rx_fg.rx.sync_word2)) + self.assertEqual(list(tx_fg.tx.sync_word1), list(rx_fg.rx.sync_word1)) + self.assertEqual(list(tx_fg.tx.sync_word2), list(rx_fg.rx.sync_word2)) self.assertEqual(test_data, rx_data) def test_004_tx1packet_large_fO(self): @@ -145,7 +145,7 @@ class test_ofdm_txrx (gr_unittest.TestCase): fft_len = 64 len_tag_key = 'frame_len' n_bytes = 21 - test_data = tuple([random.randint(0, 255) for x in range(n_bytes)]) + test_data = list([random.randint(0, 255) for x in range(n_bytes)]) #test_data = tuple([255 for x in range(n_bytes)]) # 1.0/fft_len is one sub-carrier frequency_offset = 1.0 / fft_len * 2.5 diff --git a/gr-digital/python/digital/qa_packet_headergenerator_bb.py b/gr-digital/python/digital/qa_packet_headergenerator_bb.py index e88398f7a8..0f990c5d84 100644 --- a/gr-digital/python/digital/qa_packet_headergenerator_bb.py +++ b/gr-digital/python/digital/qa_packet_headergenerator_bb.py @@ -35,11 +35,11 @@ class qa_packet_headergenerator_bb (gr_unittest.TestCase): sink = blocks.vector_sink_b() self.tb.connect(src, header, sink) self.tb.run() - expected_data = ( + expected_data = [ 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0 - ) + ] self.assertEqual(sink.data(), expected_data) def test_002_32bits (self): @@ -50,12 +50,12 @@ class qa_packet_headergenerator_bb (gr_unittest.TestCase): sink = blocks.vector_sink_b() self.tb.connect(src, header, sink) self.tb.run() - expected_data = ( + expected_data = [ # | Number of symbols | Packet number | CRC 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1 - ) + ] self.assertEqual(sink.data(), expected_data) def test_003_12bits_formatter_object (self): @@ -67,11 +67,11 @@ class qa_packet_headergenerator_bb (gr_unittest.TestCase): sink = blocks.vector_sink_b() self.tb.connect(src, header, sink) self.tb.run() - expected_data = ( + expected_data = [ 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 - ) + ] self.assertEqual(sink.data(), expected_data) def test_004_8bits_formatter_ofdm (self): @@ -86,11 +86,11 @@ class qa_packet_headergenerator_bb (gr_unittest.TestCase): sink = blocks.vector_sink_b() self.tb.connect(src, header, sink) self.tb.run() - expected_data = ( + expected_data = [ 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 - ) + ] self.assertEqual(sink.data(), expected_data) if __name__ == '__main__': diff --git a/gr-digital/python/digital/qa_scrambler.py b/gr-digital/python/digital/qa_scrambler.py index 3d355ca7b8..ffe3f03bf4 100644 --- a/gr-digital/python/digital/qa_scrambler.py +++ b/gr-digital/python/digital/qa_scrambler.py @@ -21,7 +21,7 @@ def additive_scramble_lfsr(mask, seed, reglen, bpb, data): for i in range(0,bpb): scramble_word ^= l.next_bit() << i out.append(d ^ scramble_word) - return tuple(out) + return out class test_scrambler(gr_unittest.TestCase): @@ -32,17 +32,17 @@ class test_scrambler(gr_unittest.TestCase): self.tb = None def test_scrambler_descrambler(self): - src_data = (1,)*1000 + src_data = [1,]*1000 src = blocks.vector_source_b(src_data, False) scrambler = digital.scrambler_bb(0x8a, 0x7F, 7) # CCSDS 7-bit scrambler descrambler = digital.descrambler_bb(0x8a, 0x7F, 7) dst = blocks.vector_sink_b() self.tb.connect(src, scrambler, descrambler, dst) self.tb.run() - self.assertEqual(tuple(src_data[:-8]), dst.data()[8:]) # skip garbage during synchronization + self.assertEqual(src_data[:-8], dst.data()[8:]) # skip garbage during synchronization def test_additive_scrambler(self): - src_data = (1,)*1000 + src_data = [1,]*1000 src = blocks.vector_source_b(src_data, False) scrambler = digital.additive_scrambler_bb(0x8a, 0x7f, 7) descrambler = digital.additive_scrambler_bb(0x8a, 0x7f, 7) @@ -52,7 +52,7 @@ class test_scrambler(gr_unittest.TestCase): self.assertEqual(src_data, dst.data()) def test_additive_scrambler_reset(self): - src_data = (1,)*200 + src_data = [1,]*200 src = blocks.vector_source_b(src_data, False) scrambler = digital.additive_scrambler_bb(0x8a, 0x7f, 7, 50) dst = blocks.vector_sink_b() @@ -62,7 +62,7 @@ class test_scrambler(gr_unittest.TestCase): self.assertEqual(output[:50] * 4, output) def test_additive_scrambler_reset_3bpb(self): - src_data = (5,)*200 + src_data = [5,]*200 src = blocks.vector_source_b(src_data, False) scrambler = digital.additive_scrambler_bb(0x8a, 0x7f, 7, 50, 3) dst = blocks.vector_sink_b() @@ -72,7 +72,7 @@ class test_scrambler(gr_unittest.TestCase): self.assertEqual(output[:50] * 4, output) def test_additive_scrambler_tags(self): - src_data = (1,)*1000 + src_data = [1,]*1000 src = blocks.vector_source_b(src_data, False) scrambler = digital.additive_scrambler_bb(0x8a, 0x7f, 7, 100) descrambler = digital.additive_scrambler_bb(0x8a, 0x7f, 7, 100) diff --git a/gr-digital/python/digital/qa_simple_correlator.py b/gr-digital/python/digital/qa_simple_correlator.py index e4abe0956f..727499699c 100644 --- a/gr-digital/python/digital/qa_simple_correlator.py +++ b/gr-digital/python/digital/qa_simple_correlator.py @@ -20,11 +20,12 @@ class test_simple_correlator(gr_unittest.TestCase): self.tb = None def test_00(self): - expected_result = ( + expected_result = [ 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, - 0xcc, 0xdd, 0xee, 0xff) + 0xcc, 0xdd, 0xee, 0xff + ] # Filter taps to expand the data to oversample by 8 # Just using a RRC for some basic filter shape diff --git a/gr-digital/python/digital/qa_simple_framer.py b/gr-digital/python/digital/qa_simple_framer.py index 44d1449d60..fb1195a5d7 100644 --- a/gr-digital/python/digital/qa_simple_framer.py +++ b/gr-digital/python/digital/qa_simple_framer.py @@ -25,11 +25,12 @@ class test_simple_framer(gr_unittest.TestCase): 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff) - expected_result = ( + expected_result = [ 0xac, 0xdd, 0xa4, 0xe2, 0xf2, 0x8c, 0x20, 0xfc, 0x00, 0x00, 0x11, 0x22, 0x33, 0x55, 0xac, 0xdd, 0xa4, 0xe2, 0xf2, 0x8c, 0x20, 0xfc, 0x01, 0x44, 0x55, 0x66, 0x77, 0x55, 0xac, 0xdd, 0xa4, 0xe2, 0xf2, 0x8c, 0x20, 0xfc, 0x02, 0x88, 0x99, 0xaa, 0xbb, 0x55, - 0xac, 0xdd, 0xa4, 0xe2, 0xf2, 0x8c, 0x20, 0xfc, 0x03, 0xcc, 0xdd, 0xee, 0xff, 0x55) + 0xac, 0xdd, 0xa4, 0xe2, 0xf2, 0x8c, 0x20, 0xfc, 0x03, 0xcc, 0xdd, 0xee, 0xff, 0x55 + ] src = blocks.vector_source_b(src_data) op = digital.simple_framer(4) diff --git a/gr-digital/python/digital/qam.py b/gr-digital/python/digital/qam.py index e9dbfd843d..0473646d9f 100644 --- a/gr-digital/python/digital/qam.py +++ b/gr-digital/python/digital/qam.py @@ -22,7 +22,7 @@ from .generic_mod_demod import shared_mod_args, shared_demod_args from .utils.gray_code import gray_code from .utils import mod_codes from . import modulation_utils -from . import digital_swig as digital +from . import digital_python as digital # Default number of points in constellation. _def_constellation_points = 16 diff --git a/gr-digital/python/digital/qamlike.py b/gr-digital/python/digital/qamlike.py index f2d8def8c2..b2a488af16 100644 --- a/gr-digital/python/digital/qamlike.py +++ b/gr-digital/python/digital/qamlike.py @@ -12,7 +12,7 @@ This file contains constellations that are similar to QAM, but are not perfect s from __future__ import absolute_import from __future__ import unicode_literals -from . import digital_swig +from . import digital_python from .qam import large_ampls_to_corners_mapping def qam32_holeinside_constellation(large_ampls_to_corners=False): @@ -55,10 +55,10 @@ def qam32_holeinside_constellation(large_ampls_to_corners=False): width = 0.5 pre_diff_code = [] if not large_ampls_to_corners: - constellation = digital_swig.constellation_rect(points, pre_diff_code, 4, + constellation = digital_python.constellation_rect(points, pre_diff_code, 4, side, side, width, width) else: sector_values = large_ampls_to_corners_mapping(side, points, width) - constellation = digital_swig.constellation_expl_rect( + constellation = digital_python.constellation_expl_rect( points, pre_diff_code, 4, side, side, width, width, sector_values) return constellation diff --git a/gr-digital/python/digital/qpsk.py b/gr-digital/python/digital/qpsk.py index 3c75ef2869..e03c1c5a23 100644 --- a/gr-digital/python/digital/qpsk.py +++ b/gr-digital/python/digital/qpsk.py @@ -19,7 +19,7 @@ from gnuradio import gr from gnuradio.digital.generic_mod_demod import generic_mod, generic_demod from gnuradio.digital.generic_mod_demod import shared_mod_args, shared_demod_args from .utils import mod_codes -from . import digital_swig as digital +from . import digital_python as digital from . import modulation_utils # The default encoding (e.g. gray-code, set-partition) |