gnuradio.uhd

Provides source and sink blocks to interface with the UHD library. Used to send and receive data between the Ettus Research, LLC product line.

gnuradio.uhd.amsg_source(*args, **kwargs)

amsg_source_sptr.msg_to_async_metadata_t(amsg_source_sptr self, message_sptr msg) → async_metadata_t

gnuradio.uhd.usrp_sink(*args, **kwargs)

usrp_sink_sptr.active_thread_priority(usrp_sink_sptr self) → int

usrp_sink_sptr.clear_command_time(usrp_sink_sptr self, size_t mboard=0)

usrp_sink_sptr.declare_sample_delay(usrp_sink_sptr self, int which, int delay)

declare_sample_delay(usrp_sink_sptr self, unsigned int delay)

usrp_sink_sptr.get_antenna(usrp_sink_sptr self, size_t chan=0) → std::string

usrp_sink_sptr.get_antennas(usrp_sink_sptr self, size_t chan=0) → std::vector< std::string,std::allocator< std::string > >

usrp_sink_sptr.get_bandwidth(usrp_sink_sptr self, size_t chan=0) → double

usrp_sink_sptr.get_bandwidth_range(usrp_sink_sptr self, size_t chan=0) → meta_range_t

usrp_sink_sptr.get_center_freq(usrp_sink_sptr self, size_t chan=0) → double

usrp_sink_sptr.get_clock_rate(usrp_sink_sptr self, size_t mboard=0) → double

usrp_sink_sptr.get_clock_source(usrp_sink_sptr self, size_t const mboard) → std::string

usrp_sink_sptr.get_clock_sources(usrp_sink_sptr self, size_t const mboard) → std::vector< std::string,std::allocator< std::string > >

usrp_sink_sptr.get_dboard_iface(usrp_sink_sptr self, size_t chan=0) → dboard_iface_sptr

usrp_sink_sptr.get_dboard_sensor(usrp_sink_sptr self, std::string const & name, size_t chan=0) → sensor_value_t

usrp_sink_sptr.get_dboard_sensor_names(usrp_sink_sptr self, size_t chan=0) → std::vector< std::string,std::allocator< std::string > >

usrp_sink_sptr.get_device(usrp_sink_sptr self) → ::uhd::usrp::multi_usrp::sptr

usrp_sink_sptr.get_freq_range(usrp_sink_sptr self, size_t chan=0) → meta_range_t

usrp_sink_sptr.get_gain(usrp_sink_sptr self, size_t chan=0) → double

get_gain(usrp_sink_sptr self, std::string const & name, size_t chan=0) -> double

usrp_sink_sptr.get_gain_names(usrp_sink_sptr self, size_t chan=0) → std::vector< std::string,std::allocator< std::string > >

usrp_sink_sptr.get_gain_range(usrp_sink_sptr self, size_t chan=0) → meta_range_t

get_gain_range(usrp_sink_sptr self, std::string const & name, size_t chan=0) -> meta_range_t

usrp_sink_sptr.get_gpio_attr(usrp_sink_sptr self, std::string const & bank, std::string const & attr, size_t const mboard=0) → boost::uint32_t

usrp_sink_sptr.get_gpio_banks(usrp_sink_sptr self, size_t const mboard) → std::vector< std::string,std::allocator< std::string > >

usrp_sink_sptr.get_mboard_sensor(usrp_sink_sptr self, std::string const & name, size_t mboard=0) → sensor_value_t

usrp_sink_sptr.get_mboard_sensor_names(usrp_sink_sptr self, size_t mboard=0) → std::vector< std::string,std::allocator< std::string > >

usrp_sink_sptr.get_normalized_gain(usrp_sink_sptr self, size_t chan=0) → double

usrp_sink_sptr.get_num_mboards(usrp_sink_sptr self) → size_t

usrp_sink_sptr.get_samp_rate(usrp_sink_sptr self) → double

usrp_sink_sptr.get_samp_rates(usrp_sink_sptr self) → meta_range_t

usrp_sink_sptr.get_sensor(usrp_sink_sptr self, std::string const & name, size_t chan=0) → sensor_value_t

usrp_sink_sptr.get_sensor_names(usrp_sink_sptr self, size_t chan=0) → std::vector< std::string,std::allocator< std::string > >

usrp_sink_sptr.get_subdev_spec(usrp_sink_sptr self, size_t mboard=0) → std::string

usrp_sink_sptr.get_time_last_pps(usrp_sink_sptr self, size_t mboard=0) → time_spec_t

usrp_sink_sptr.get_time_now(usrp_sink_sptr self, size_t mboard=0) → time_spec_t

usrp_sink_sptr.get_time_source(usrp_sink_sptr self, size_t const mboard) → std::string

usrp_sink_sptr.get_time_sources(usrp_sink_sptr self, size_t const mboard) → std::vector< std::string,std::allocator< std::string > >

usrp_sink_sptr.get_usrp_info(usrp_sink_sptr self, size_t chan=0) → string_string_dict_t

usrp_sink_sptr.message_subscribers(usrp_sink_sptr self, swig_int_ptr which_port) → swig_int_ptr

usrp_sink_sptr.min_noutput_items(usrp_sink_sptr self) → int

usrp_sink_sptr.pc_input_buffers_full_avg(usrp_sink_sptr self, int which) → float

pc_input_buffers_full_avg(usrp_sink_sptr self) -> pmt_vector_float

usrp_sink_sptr.pc_noutput_items_avg(usrp_sink_sptr self) → float

usrp_sink_sptr.pc_nproduced_avg(usrp_sink_sptr self) → float

usrp_sink_sptr.pc_output_buffers_full_avg(usrp_sink_sptr self, int which) → float

pc_output_buffers_full_avg(usrp_sink_sptr self) -> pmt_vector_float

usrp_sink_sptr.pc_throughput_avg(usrp_sink_sptr self) → float

usrp_sink_sptr.pc_work_time_avg(usrp_sink_sptr self) → float

usrp_sink_sptr.pc_work_time_total(usrp_sink_sptr self) → float

usrp_sink_sptr.sample_delay(usrp_sink_sptr self, int which) → unsigned int

usrp_sink_sptr.set_antenna(usrp_sink_sptr self, std::string const & ant, size_t chan=0)

usrp_sink_sptr.set_bandwidth(usrp_sink_sptr self, double bandwidth, size_t chan=0)

usrp_sink_sptr.set_center_freq(usrp_sink_sptr self, tune_request_t tune_request, size_t chan=0) → tune_result_t

set_center_freq(usrp_sink_sptr self, double freq, size_t chan=0) -> tune_result_t

usrp_sink_sptr.set_clock_config(usrp_sink_sptr self, clock_config_t clock_config, size_t mboard=0)

usrp_sink_sptr.set_clock_rate(usrp_sink_sptr self, double rate, size_t mboard=0)

usrp_sink_sptr.set_clock_source(usrp_sink_sptr self, std::string const & source, size_t const mboard=0)

usrp_sink_sptr.set_command_time(usrp_sink_sptr self, time_spec_t time_spec, size_t mboard=0)

usrp_sink_sptr.set_dc_offset(usrp_sink_sptr self, std::complex< double > const & offset, size_t chan=0)

usrp_sink_sptr.set_gain(usrp_sink_sptr self, double gain, size_t chan=0)

set_gain(usrp_sink_sptr self, double gain, std::string const & name, size_t chan=0)

usrp_sink_sptr.set_gpio_attr(*args, **kwargs)

set_gpio_attr(usrp_sink_sptr self, std::string const & bank, std::string const & attr, boost::uint32_t const value, boost::uint32_t const mask=0xffffffff, size_t const mboard=0)

usrp_sink_sptr.set_iq_balance(usrp_sink_sptr self, std::complex< double > const & correction, size_t chan=0)

usrp_sink_sptr.set_min_noutput_items(usrp_sink_sptr self, int m)

usrp_sink_sptr.set_normalized_gain(usrp_sink_sptr self, double norm_gain, size_t chan=0)

usrp_sink_sptr.set_samp_rate(usrp_sink_sptr self, double rate)

usrp_sink_sptr.set_start_time(usrp_sink_sptr self, time_spec_t time)

usrp_sink_sptr.set_stream_args(usrp_sink_sptr self, stream_args_t stream_args)

usrp_sink_sptr.set_subdev_spec(usrp_sink_sptr self, std::string const & spec, size_t mboard=0)

usrp_sink_sptr.set_thread_priority(usrp_sink_sptr self, int priority) → int

usrp_sink_sptr.set_time_next_pps(usrp_sink_sptr self, time_spec_t time_spec)

usrp_sink_sptr.set_time_now(usrp_sink_sptr self, time_spec_t time_spec, size_t mboard=0)

usrp_sink_sptr.set_time_source(usrp_sink_sptr self, std::string const & source, size_t const mboard=0)

usrp_sink_sptr.set_time_unknown_pps(usrp_sink_sptr self, time_spec_t time_spec)

usrp_sink_sptr.set_user_register(usrp_sink_sptr self, uint8_t const addr, uint32_t const data, size_t mboard=0)

usrp_sink_sptr.thread_priority(usrp_sink_sptr self) → int

gnuradio.uhd.usrp_source(*args, **kwargs)

usrp_source_sptr.active_thread_priority(usrp_source_sptr self) → int

usrp_source_sptr.clear_command_time(usrp_source_sptr self, size_t mboard=0)

usrp_source_sptr.declare_sample_delay(usrp_source_sptr self, int which, int delay)

declare_sample_delay(usrp_source_sptr self, unsigned int delay)

usrp_source_sptr.finite_acquisition(usrp_source_sptr self, size_t const nsamps) → pmt_vector_cfloat

usrp_source_sptr.finite_acquisition_v(usrp_source_sptr self, size_t const nsamps) → gr_vector_vector_complexf

usrp_source_sptr.get_antenna(usrp_source_sptr self, size_t chan=0) → std::string

usrp_source_sptr.get_antennas(usrp_source_sptr self, size_t chan=0) → std::vector< std::string,std::allocator< std::string > >

usrp_source_sptr.get_bandwidth(usrp_source_sptr self, size_t chan=0) → double

usrp_source_sptr.get_bandwidth_range(usrp_source_sptr self, size_t chan=0) → meta_range_t

usrp_source_sptr.get_center_freq(usrp_source_sptr self, size_t chan=0) → double

usrp_source_sptr.get_clock_rate(usrp_source_sptr self, size_t mboard=0) → double

usrp_source_sptr.get_clock_source(usrp_source_sptr self, size_t const mboard) → std::string

usrp_source_sptr.get_clock_sources(usrp_source_sptr self, size_t const mboard) → std::vector< std::string,std::allocator< std::string > >

usrp_source_sptr.get_dboard_iface(usrp_source_sptr self, size_t chan=0) → dboard_iface_sptr

usrp_source_sptr.get_dboard_sensor(usrp_source_sptr self, std::string const & name, size_t chan=0) → sensor_value_t

usrp_source_sptr.get_dboard_sensor_names(usrp_source_sptr self, size_t chan=0) → std::vector< std::string,std::allocator< std::string > >

usrp_source_sptr.get_device(usrp_source_sptr self) → ::uhd::usrp::multi_usrp::sptr

usrp_source_sptr.get_freq_range(usrp_source_sptr self, size_t chan=0) → meta_range_t

usrp_source_sptr.get_gain(usrp_source_sptr self, size_t chan=0) → double

get_gain(usrp_source_sptr self, std::string const & name, size_t chan=0) -> double

usrp_source_sptr.get_gain_names(usrp_source_sptr self, size_t chan=0) → std::vector< std::string,std::allocator< std::string > >

usrp_source_sptr.get_gain_range(usrp_source_sptr self, size_t chan=0) → meta_range_t

get_gain_range(usrp_source_sptr self, std::string const & name, size_t chan=0) -> meta_range_t

usrp_source_sptr.get_gpio_attr(usrp_source_sptr self, std::string const & bank, std::string const & attr, size_t const mboard=0) → boost::uint32_t

usrp_source_sptr.get_gpio_banks(usrp_source_sptr self, size_t const mboard) → std::vector< std::string,std::allocator< std::string > >

usrp_source_sptr.get_lo_export_enabled(usrp_source_sptr self, std::string const & name, size_t chan=0) → bool

usrp_source_sptr.get_lo_freq(usrp_source_sptr self, std::string const & name, size_t chan=0) → double

usrp_source_sptr.get_lo_freq_range(usrp_source_sptr self, std::string const & name, size_t chan=0) → meta_range_t

usrp_source_sptr.get_lo_names(usrp_source_sptr self, size_t chan=0) → std::vector< std::string,std::allocator< std::string > >

usrp_source_sptr.get_lo_source(usrp_source_sptr self, std::string const & name, size_t chan=0) → std::string const

usrp_source_sptr.get_lo_sources(usrp_source_sptr self, std::string const & name, size_t chan=0) → std::vector< std::string,std::allocator< std::string > >

usrp_source_sptr.get_mboard_sensor(usrp_source_sptr self, std::string const & name, size_t mboard=0) → sensor_value_t

usrp_source_sptr.get_mboard_sensor_names(usrp_source_sptr self, size_t mboard=0) → std::vector< std::string,std::allocator< std::string > >

usrp_source_sptr.get_normalized_gain(usrp_source_sptr self, size_t chan=0) → double

usrp_source_sptr.get_num_mboards(usrp_source_sptr self) → size_t

usrp_source_sptr.get_samp_rate(usrp_source_sptr self) → double

usrp_source_sptr.get_samp_rates(usrp_source_sptr self) → meta_range_t

usrp_source_sptr.get_sensor(usrp_source_sptr self, std::string const & name, size_t chan=0) → sensor_value_t

usrp_source_sptr.get_sensor_names(usrp_source_sptr self, size_t chan=0) → std::vector< std::string,std::allocator< std::string > >

usrp_source_sptr.get_subdev_spec(usrp_source_sptr self, size_t mboard=0) → std::string

usrp_source_sptr.get_time_last_pps(usrp_source_sptr self, size_t mboard=0) → time_spec_t

usrp_source_sptr.get_time_now(usrp_source_sptr self, size_t mboard=0) → time_spec_t

usrp_source_sptr.get_time_source(usrp_source_sptr self, size_t const mboard) → std::string

usrp_source_sptr.get_time_sources(usrp_source_sptr self, size_t const mboard) → std::vector< std::string,std::allocator< std::string > >

usrp_source_sptr.get_usrp_info(usrp_source_sptr self, size_t chan=0) → string_string_dict_t

usrp_source_sptr.issue_stream_cmd(usrp_source_sptr self, stream_cmd_t cmd)

usrp_source_sptr.message_subscribers(usrp_source_sptr self, swig_int_ptr which_port) → swig_int_ptr

usrp_source_sptr.min_noutput_items(usrp_source_sptr self) → int

usrp_source_sptr.pc_input_buffers_full_avg(usrp_source_sptr self, int which) → float

pc_input_buffers_full_avg(usrp_source_sptr self) -> pmt_vector_float

usrp_source_sptr.pc_noutput_items_avg(usrp_source_sptr self) → float

usrp_source_sptr.pc_nproduced_avg(usrp_source_sptr self) → float

usrp_source_sptr.pc_output_buffers_full_avg(usrp_source_sptr self, int which) → float

pc_output_buffers_full_avg(usrp_source_sptr self) -> pmt_vector_float

usrp_source_sptr.pc_throughput_avg(usrp_source_sptr self) → float

usrp_source_sptr.pc_work_time_avg(usrp_source_sptr self) → float

usrp_source_sptr.pc_work_time_total(usrp_source_sptr self) → float

usrp_source_sptr.sample_delay(usrp_source_sptr self, int which) → unsigned int

usrp_source_sptr.set_antenna(usrp_source_sptr self, std::string const & ant, size_t chan=0)

usrp_source_sptr.set_auto_dc_offset(usrp_source_sptr self, bool const enb, size_t chan=0)

usrp_source_sptr.set_auto_iq_balance(usrp_source_sptr self, bool const enb, size_t chan=0)

usrp_source_sptr.set_bandwidth(usrp_source_sptr self, double bandwidth, size_t chan=0)

usrp_source_sptr.set_center_freq(usrp_source_sptr self, tune_request_t tune_request, size_t chan=0) → tune_result_t

set_center_freq(usrp_source_sptr self, double freq, size_t chan=0) -> tune_result_t

usrp_source_sptr.set_clock_config(usrp_source_sptr self, clock_config_t clock_config, size_t mboard=0)

usrp_source_sptr.set_clock_rate(usrp_source_sptr self, double rate, size_t mboard=0)

usrp_source_sptr.set_clock_source(usrp_source_sptr self, std::string const & source, size_t const mboard=0)

usrp_source_sptr.set_command_time(usrp_source_sptr self, time_spec_t time_spec, size_t mboard=0)

usrp_source_sptr.set_dc_offset(usrp_source_sptr self, std::complex< double > const & offset, size_t chan=0)

usrp_source_sptr.set_gain(usrp_source_sptr self, double gain, size_t chan=0)

set_gain(usrp_source_sptr self, double gain, std::string const & name, size_t chan=0)

usrp_source_sptr.set_gpio_attr(*args, **kwargs)

set_gpio_attr(usrp_source_sptr self, std::string const & bank, std::string const & attr, boost::uint32_t const value, boost::uint32_t const mask=0xffffffff, size_t const mboard=0)

usrp_source_sptr.set_iq_balance(usrp_source_sptr self, std::complex< double > const & correction, size_t chan=0)

usrp_source_sptr.set_lo_export_enabled(usrp_source_sptr self, bool enabled, std::string const & name, size_t chan=0)

usrp_source_sptr.set_lo_freq(usrp_source_sptr self, double freq, std::string const & name, size_t chan=0) → double

usrp_source_sptr.set_lo_source(usrp_source_sptr self, std::string const & src, std::string const & name, size_t chan=0)

usrp_source_sptr.set_min_noutput_items(usrp_source_sptr self, int m)

usrp_source_sptr.set_normalized_gain(usrp_source_sptr self, double norm_gain, size_t chan=0)

usrp_source_sptr.set_samp_rate(usrp_source_sptr self, double rate)

usrp_source_sptr.set_start_time(usrp_source_sptr self, time_spec_t time)

usrp_source_sptr.set_stream_args(usrp_source_sptr self, stream_args_t stream_args)

usrp_source_sptr.set_subdev_spec(usrp_source_sptr self, std::string const & spec, size_t mboard=0)

usrp_source_sptr.set_thread_priority(usrp_source_sptr self, int priority) → int

usrp_source_sptr.set_time_next_pps(usrp_source_sptr self, time_spec_t time_spec)

usrp_source_sptr.set_time_now(usrp_source_sptr self, time_spec_t time_spec, size_t mboard=0)

usrp_source_sptr.set_time_source(usrp_source_sptr self, std::string const & source, size_t const mboard=0)

usrp_source_sptr.set_time_unknown_pps(usrp_source_sptr self, time_spec_t time_spec)

usrp_source_sptr.set_user_register(usrp_source_sptr self, uint8_t const addr, uint32_t const data, size_t mboard=0)

usrp_source_sptr.thread_priority(usrp_source_sptr self) → int