gnuradio.blocks: Miscellaneous

gnuradio.blocks.vector_source_b(std::vector< unsigned char, std::allocator< unsigned char > > const & data, bool repeat=False, int vlen=1, tags_vector_t tags=std::vector< gr::tag_t >()) → vector_source_b_sptr

Source that streams unsigned char items based on the input vector.

This block produces a stream of samples based on an input vector. In C++, this is a std::vector<unsigned char>, and in Python, this is either a list or tuple. The data can repeat infinitely until the flowgraph is terminated by some other event or, the default, run the data once and stop.

The vector source can also produce stream tags with the data. Pass in a vector of gr::tag_t objects and they will be emitted based on the specified offset of the tag.

GNU Radio provides a utility Python module in gr.tag_utils to convert between tags and Python objects: gr.tag_utils.python_to_tag.

We can create tags as Python lists (or tuples) using the list structure [int offset, pmt key, pmt value, pmt srcid]. It is important to define the list/tuple with the values in the correct order and with the correct data type. A python dictionary can also be used using the keys: “offset”, “key”, “value”, and “srcid” with the same data types as for the lists.

When given a list of tags, the vector source will emit the tags repeatedly by updating the offset relative to the vector stream length. That is, if the vector has 500 items and a tag has an offset of 0, that tag will be placed on item 0, 500, 1000, 1500, etc.

Constructor Specific Documentation:

Parameters:
  • data
  • repeat
  • vlen
  • tags
vector_source_b_sptr.active_thread_priority(vector_source_b_sptr self) → int
vector_source_b_sptr.declare_sample_delay(vector_source_b_sptr self, int which, int delay)

declare_sample_delay(vector_source_b_sptr self, unsigned int delay)

vector_source_b_sptr.message_subscribers(vector_source_b_sptr self, swig_int_ptr which_port) → swig_int_ptr
vector_source_b_sptr.min_noutput_items(vector_source_b_sptr self) → int
vector_source_b_sptr.pc_input_buffers_full_avg(vector_source_b_sptr self, int which) → float

pc_input_buffers_full_avg(vector_source_b_sptr self) -> pmt_vector_float

vector_source_b_sptr.pc_noutput_items_avg(vector_source_b_sptr self) → float
vector_source_b_sptr.pc_nproduced_avg(vector_source_b_sptr self) → float
vector_source_b_sptr.pc_output_buffers_full_avg(vector_source_b_sptr self, int which) → float

pc_output_buffers_full_avg(vector_source_b_sptr self) -> pmt_vector_float

vector_source_b_sptr.pc_throughput_avg(vector_source_b_sptr self) → float
vector_source_b_sptr.pc_work_time_avg(vector_source_b_sptr self) → float
vector_source_b_sptr.pc_work_time_total(vector_source_b_sptr self) → float
vector_source_b_sptr.rewind(vector_source_b_sptr self)
vector_source_b_sptr.sample_delay(vector_source_b_sptr self, int which) → unsigned int
vector_source_b_sptr.set_data(vector_source_b_sptr self, std::vector< unsigned char, std::allocator< unsigned char > > const & data, tags_vector_t tags=std::vector< gr::tag_t >())
vector_source_b_sptr.set_min_noutput_items(vector_source_b_sptr self, int m)
vector_source_b_sptr.set_thread_priority(vector_source_b_sptr self, int priority) → int
vector_source_b_sptr.thread_priority(vector_source_b_sptr self) → int
gnuradio.blocks.vector_source_c(pmt_vector_cfloat data, bool repeat=False, int vlen=1, tags_vector_t tags=std::vector< gr::tag_t >()) → vector_source_c_sptr

Source that streams gr_complex items based on the input vector.

This block produces a stream of samples based on an input vector. In C++, this is a std::vector<gr_complex>, and in Python, this is either a list or tuple. The data can repeat infinitely until the flowgraph is terminated by some other event or, the default, run the data once and stop.

The vector source can also produce stream tags with the data. Pass in a vector of gr::tag_t objects and they will be emitted based on the specified offset of the tag.

GNU Radio provides a utility Python module in gr.tag_utils to convert between tags and Python objects: gr.tag_utils.python_to_tag.

We can create tags as Python lists (or tuples) using the list structure [int offset, pmt key, pmt value, pmt srcid]. It is important to define the list/tuple with the values in the correct order and with the correct data type. A python dictionary can also be used using the keys: “offset”, “key”, “value”, and “srcid” with the same data types as for the lists.

When given a list of tags, the vector source will emit the tags repeatedly by updating the offset relative to the vector stream length. That is, if the vector has 500 items and a tag has an offset of 0, that tag will be placed on item 0, 500, 1000, 1500, etc.

Constructor Specific Documentation:

Parameters:
  • data
  • repeat
  • vlen
  • tags
vector_source_c_sptr.active_thread_priority(vector_source_c_sptr self) → int
vector_source_c_sptr.declare_sample_delay(vector_source_c_sptr self, int which, int delay)

declare_sample_delay(vector_source_c_sptr self, unsigned int delay)

vector_source_c_sptr.message_subscribers(vector_source_c_sptr self, swig_int_ptr which_port) → swig_int_ptr
vector_source_c_sptr.min_noutput_items(vector_source_c_sptr self) → int
vector_source_c_sptr.pc_input_buffers_full_avg(vector_source_c_sptr self, int which) → float

pc_input_buffers_full_avg(vector_source_c_sptr self) -> pmt_vector_float

vector_source_c_sptr.pc_noutput_items_avg(vector_source_c_sptr self) → float
vector_source_c_sptr.pc_nproduced_avg(vector_source_c_sptr self) → float
vector_source_c_sptr.pc_output_buffers_full_avg(vector_source_c_sptr self, int which) → float

pc_output_buffers_full_avg(vector_source_c_sptr self) -> pmt_vector_float

vector_source_c_sptr.pc_throughput_avg(vector_source_c_sptr self) → float
vector_source_c_sptr.pc_work_time_avg(vector_source_c_sptr self) → float
vector_source_c_sptr.pc_work_time_total(vector_source_c_sptr self) → float
vector_source_c_sptr.rewind(vector_source_c_sptr self)
vector_source_c_sptr.sample_delay(vector_source_c_sptr self, int which) → unsigned int
vector_source_c_sptr.set_data(vector_source_c_sptr self, pmt_vector_cfloat data, tags_vector_t tags=std::vector< gr::tag_t >())
vector_source_c_sptr.set_min_noutput_items(vector_source_c_sptr self, int m)
vector_source_c_sptr.set_thread_priority(vector_source_c_sptr self, int priority) → int
vector_source_c_sptr.thread_priority(vector_source_c_sptr self) → int
gnuradio.blocks.vector_source_f(pmt_vector_float data, bool repeat=False, int vlen=1, tags_vector_t tags=std::vector< gr::tag_t >()) → vector_source_f_sptr

Source that streams float items based on the input vector.

This block produces a stream of samples based on an input vector. In C++, this is a std::vector<float>, and in Python, this is either a list or tuple. The data can repeat infinitely until the flowgraph is terminated by some other event or, the default, run the data once and stop.

The vector source can also produce stream tags with the data. Pass in a vector of gr::tag_t objects and they will be emitted based on the specified offset of the tag.

GNU Radio provides a utility Python module in gr.tag_utils to convert between tags and Python objects: gr.tag_utils.python_to_tag.

We can create tags as Python lists (or tuples) using the list structure [int offset, pmt key, pmt value, pmt srcid]. It is important to define the list/tuple with the values in the correct order and with the correct data type. A python dictionary can also be used using the keys: “offset”, “key”, “value”, and “srcid” with the same data types as for the lists.

When given a list of tags, the vector source will emit the tags repeatedly by updating the offset relative to the vector stream length. That is, if the vector has 500 items and a tag has an offset of 0, that tag will be placed on item 0, 500, 1000, 1500, etc.

Constructor Specific Documentation:

Parameters:
  • data
  • repeat
  • vlen
  • tags
vector_source_f_sptr.active_thread_priority(vector_source_f_sptr self) → int
vector_source_f_sptr.declare_sample_delay(vector_source_f_sptr self, int which, int delay)

declare_sample_delay(vector_source_f_sptr self, unsigned int delay)

vector_source_f_sptr.message_subscribers(vector_source_f_sptr self, swig_int_ptr which_port) → swig_int_ptr
vector_source_f_sptr.min_noutput_items(vector_source_f_sptr self) → int
vector_source_f_sptr.pc_input_buffers_full_avg(vector_source_f_sptr self, int which) → float

pc_input_buffers_full_avg(vector_source_f_sptr self) -> pmt_vector_float

vector_source_f_sptr.pc_noutput_items_avg(vector_source_f_sptr self) → float
vector_source_f_sptr.pc_nproduced_avg(vector_source_f_sptr self) → float
vector_source_f_sptr.pc_output_buffers_full_avg(vector_source_f_sptr self, int which) → float

pc_output_buffers_full_avg(vector_source_f_sptr self) -> pmt_vector_float

vector_source_f_sptr.pc_throughput_avg(vector_source_f_sptr self) → float
vector_source_f_sptr.pc_work_time_avg(vector_source_f_sptr self) → float
vector_source_f_sptr.pc_work_time_total(vector_source_f_sptr self) → float
vector_source_f_sptr.rewind(vector_source_f_sptr self)
vector_source_f_sptr.sample_delay(vector_source_f_sptr self, int which) → unsigned int
vector_source_f_sptr.set_data(vector_source_f_sptr self, pmt_vector_float data, tags_vector_t tags=std::vector< gr::tag_t >())
vector_source_f_sptr.set_min_noutput_items(vector_source_f_sptr self, int m)
vector_source_f_sptr.set_thread_priority(vector_source_f_sptr self, int priority) → int
vector_source_f_sptr.thread_priority(vector_source_f_sptr self) → int
gnuradio.blocks.vector_source_i(std::vector< int, std::allocator< int > > const & data, bool repeat=False, int vlen=1, tags_vector_t tags=std::vector< gr::tag_t >()) → vector_source_i_sptr

Source that streams int items based on the input vector.

This block produces a stream of samples based on an input vector. In C++, this is a std::vector<int>, and in Python, this is either a list or tuple. The data can repeat infinitely until the flowgraph is terminated by some other event or, the default, run the data once and stop.

The vector source can also produce stream tags with the data. Pass in a vector of gr::tag_t objects and they will be emitted based on the specified offset of the tag.

GNU Radio provides a utility Python module in gr.tag_utils to convert between tags and Python objects: gr.tag_utils.python_to_tag.

We can create tags as Python lists (or tuples) using the list structure [int offset, pmt key, pmt value, pmt srcid]. It is important to define the list/tuple with the values in the correct order and with the correct data type. A python dictionary can also be used using the keys: “offset”, “key”, “value”, and “srcid” with the same data types as for the lists.

When given a list of tags, the vector source will emit the tags repeatedly by updating the offset relative to the vector stream length. That is, if the vector has 500 items and a tag has an offset of 0, that tag will be placed on item 0, 500, 1000, 1500, etc.

Constructor Specific Documentation:

Parameters:
  • data
  • repeat
  • vlen
  • tags
vector_source_i_sptr.active_thread_priority(vector_source_i_sptr self) → int
vector_source_i_sptr.declare_sample_delay(vector_source_i_sptr self, int which, int delay)

declare_sample_delay(vector_source_i_sptr self, unsigned int delay)

vector_source_i_sptr.message_subscribers(vector_source_i_sptr self, swig_int_ptr which_port) → swig_int_ptr
vector_source_i_sptr.min_noutput_items(vector_source_i_sptr self) → int
vector_source_i_sptr.pc_input_buffers_full_avg(vector_source_i_sptr self, int which) → float

pc_input_buffers_full_avg(vector_source_i_sptr self) -> pmt_vector_float

vector_source_i_sptr.pc_noutput_items_avg(vector_source_i_sptr self) → float
vector_source_i_sptr.pc_nproduced_avg(vector_source_i_sptr self) → float
vector_source_i_sptr.pc_output_buffers_full_avg(vector_source_i_sptr self, int which) → float

pc_output_buffers_full_avg(vector_source_i_sptr self) -> pmt_vector_float

vector_source_i_sptr.pc_throughput_avg(vector_source_i_sptr self) → float
vector_source_i_sptr.pc_work_time_avg(vector_source_i_sptr self) → float
vector_source_i_sptr.pc_work_time_total(vector_source_i_sptr self) → float
vector_source_i_sptr.rewind(vector_source_i_sptr self)
vector_source_i_sptr.sample_delay(vector_source_i_sptr self, int which) → unsigned int
vector_source_i_sptr.set_data(vector_source_i_sptr self, std::vector< int, std::allocator< int > > const & data, tags_vector_t tags=std::vector< gr::tag_t >())
vector_source_i_sptr.set_min_noutput_items(vector_source_i_sptr self, int m)
vector_source_i_sptr.set_thread_priority(vector_source_i_sptr self, int priority) → int
vector_source_i_sptr.thread_priority(vector_source_i_sptr self) → int
gnuradio.blocks.vector_source_s(std::vector< short, std::allocator< short > > const & data, bool repeat=False, int vlen=1, tags_vector_t tags=std::vector< gr::tag_t >()) → vector_source_s_sptr

Source that streams short items based on the input vector.

This block produces a stream of samples based on an input vector. In C++, this is a std::vector<short>, and in Python, this is either a list or tuple. The data can repeat infinitely until the flowgraph is terminated by some other event or, the default, run the data once and stop.

The vector source can also produce stream tags with the data. Pass in a vector of gr::tag_t objects and they will be emitted based on the specified offset of the tag.

GNU Radio provides a utility Python module in gr.tag_utils to convert between tags and Python objects: gr.tag_utils.python_to_tag.

We can create tags as Python lists (or tuples) using the list structure [int offset, pmt key, pmt value, pmt srcid]. It is important to define the list/tuple with the values in the correct order and with the correct data type. A python dictionary can also be used using the keys: “offset”, “key”, “value”, and “srcid” with the same data types as for the lists.

When given a list of tags, the vector source will emit the tags repeatedly by updating the offset relative to the vector stream length. That is, if the vector has 500 items and a tag has an offset of 0, that tag will be placed on item 0, 500, 1000, 1500, etc.

Constructor Specific Documentation:

Parameters:
  • data
  • repeat
  • vlen
  • tags
vector_source_s_sptr.active_thread_priority(vector_source_s_sptr self) → int
vector_source_s_sptr.declare_sample_delay(vector_source_s_sptr self, int which, int delay)

declare_sample_delay(vector_source_s_sptr self, unsigned int delay)

vector_source_s_sptr.message_subscribers(vector_source_s_sptr self, swig_int_ptr which_port) → swig_int_ptr
vector_source_s_sptr.min_noutput_items(vector_source_s_sptr self) → int
vector_source_s_sptr.pc_input_buffers_full_avg(vector_source_s_sptr self, int which) → float

pc_input_buffers_full_avg(vector_source_s_sptr self) -> pmt_vector_float

vector_source_s_sptr.pc_noutput_items_avg(vector_source_s_sptr self) → float
vector_source_s_sptr.pc_nproduced_avg(vector_source_s_sptr self) → float
vector_source_s_sptr.pc_output_buffers_full_avg(vector_source_s_sptr self, int which) → float

pc_output_buffers_full_avg(vector_source_s_sptr self) -> pmt_vector_float

vector_source_s_sptr.pc_throughput_avg(vector_source_s_sptr self) → float
vector_source_s_sptr.pc_work_time_avg(vector_source_s_sptr self) → float
vector_source_s_sptr.pc_work_time_total(vector_source_s_sptr self) → float
vector_source_s_sptr.rewind(vector_source_s_sptr self)
vector_source_s_sptr.sample_delay(vector_source_s_sptr self, int which) → unsigned int
vector_source_s_sptr.set_data(vector_source_s_sptr self, std::vector< short, std::allocator< short > > const & data, tags_vector_t tags=std::vector< gr::tag_t >())
vector_source_s_sptr.set_min_noutput_items(vector_source_s_sptr self, int m)
vector_source_s_sptr.set_thread_priority(vector_source_s_sptr self, int priority) → int
vector_source_s_sptr.thread_priority(vector_source_s_sptr self) → int
gnuradio.blocks.bin_statistics_f(unsigned int vlen, msg_queue_sptr msgq, gr::feval_dd * tune, size_t tune_delay, size_t dwell_delay) → bin_statistics_f_sptr

control scanning and record frequency domain statistics

Constructor Specific Documentation:

Build a bin statistics block. See qa_bin_statistics.py and gr-uhd/examples/python/usrp_spectrum_sense.py for examples of its use, specifically how to use the callback function.

Parameters:
  • vlen – vector length
  • msgq – message queue
  • tune – a feval_dd callback function
  • tune_delay – number of samples for the tune delay
  • dwell_delay – number of samples for the dwell delay
bin_statistics_f_sptr.active_thread_priority(bin_statistics_f_sptr self) → int
bin_statistics_f_sptr.declare_sample_delay(bin_statistics_f_sptr self, int which, int delay)

declare_sample_delay(bin_statistics_f_sptr self, unsigned int delay)

bin_statistics_f_sptr.message_subscribers(bin_statistics_f_sptr self, swig_int_ptr which_port) → swig_int_ptr
bin_statistics_f_sptr.min_noutput_items(bin_statistics_f_sptr self) → int
bin_statistics_f_sptr.pc_input_buffers_full_avg(bin_statistics_f_sptr self, int which) → float

pc_input_buffers_full_avg(bin_statistics_f_sptr self) -> pmt_vector_float

bin_statistics_f_sptr.pc_noutput_items_avg(bin_statistics_f_sptr self) → float
bin_statistics_f_sptr.pc_nproduced_avg(bin_statistics_f_sptr self) → float
bin_statistics_f_sptr.pc_output_buffers_full_avg(bin_statistics_f_sptr self, int which) → float

pc_output_buffers_full_avg(bin_statistics_f_sptr self) -> pmt_vector_float

bin_statistics_f_sptr.pc_throughput_avg(bin_statistics_f_sptr self) → float
bin_statistics_f_sptr.pc_work_time_avg(bin_statistics_f_sptr self) → float
bin_statistics_f_sptr.pc_work_time_total(bin_statistics_f_sptr self) → float
bin_statistics_f_sptr.sample_delay(bin_statistics_f_sptr self, int which) → unsigned int
bin_statistics_f_sptr.set_min_noutput_items(bin_statistics_f_sptr self, int m)
bin_statistics_f_sptr.set_thread_priority(bin_statistics_f_sptr self, int priority) → int
bin_statistics_f_sptr.thread_priority(bin_statistics_f_sptr self) → int
gnuradio.blocks.check_lfsr_32k_s() → check_lfsr_32k_s_sptr

sink that checks if its input stream consists of a lfsr_32k sequence.

This sink is typically used along with gr::blocks::lfsr_32k_source_s to test the USRP using its digital loopback mode.

Constructor Specific Documentation:

check_lfsr_32k_s_sptr.active_thread_priority(check_lfsr_32k_s_sptr self) → int
check_lfsr_32k_s_sptr.declare_sample_delay(check_lfsr_32k_s_sptr self, int which, int delay)

declare_sample_delay(check_lfsr_32k_s_sptr self, unsigned int delay)

check_lfsr_32k_s_sptr.message_subscribers(check_lfsr_32k_s_sptr self, swig_int_ptr which_port) → swig_int_ptr
check_lfsr_32k_s_sptr.min_noutput_items(check_lfsr_32k_s_sptr self) → int
check_lfsr_32k_s_sptr.nright(check_lfsr_32k_s_sptr self) → long
check_lfsr_32k_s_sptr.ntotal(check_lfsr_32k_s_sptr self) → long
check_lfsr_32k_s_sptr.pc_input_buffers_full_avg(check_lfsr_32k_s_sptr self, int which) → float

pc_input_buffers_full_avg(check_lfsr_32k_s_sptr self) -> pmt_vector_float

check_lfsr_32k_s_sptr.pc_noutput_items_avg(check_lfsr_32k_s_sptr self) → float
check_lfsr_32k_s_sptr.pc_nproduced_avg(check_lfsr_32k_s_sptr self) → float
check_lfsr_32k_s_sptr.pc_output_buffers_full_avg(check_lfsr_32k_s_sptr self, int which) → float

pc_output_buffers_full_avg(check_lfsr_32k_s_sptr self) -> pmt_vector_float

check_lfsr_32k_s_sptr.pc_throughput_avg(check_lfsr_32k_s_sptr self) → float
check_lfsr_32k_s_sptr.pc_work_time_avg(check_lfsr_32k_s_sptr self) → float
check_lfsr_32k_s_sptr.pc_work_time_total(check_lfsr_32k_s_sptr self) → float
check_lfsr_32k_s_sptr.runlength(check_lfsr_32k_s_sptr self) → long
check_lfsr_32k_s_sptr.sample_delay(check_lfsr_32k_s_sptr self, int which) → unsigned int
check_lfsr_32k_s_sptr.set_min_noutput_items(check_lfsr_32k_s_sptr self, int m)
check_lfsr_32k_s_sptr.set_thread_priority(check_lfsr_32k_s_sptr self, int priority) → int
check_lfsr_32k_s_sptr.thread_priority(check_lfsr_32k_s_sptr self) → int
gnuradio.blocks.copy(size_t itemsize) → copy_sptr

output[i] = input[i]

When enabled (default), this block copies its input to its output. When disabled, this block drops its input on the floor.

Message Ports:

Constructor Specific Documentation:

Parameters:itemsize
copy_sptr.active_thread_priority(copy_sptr self) → int
copy_sptr.declare_sample_delay(copy_sptr self, int which, int delay)

declare_sample_delay(copy_sptr self, unsigned int delay)

copy_sptr.enabled(copy_sptr self) → bool
copy_sptr.message_subscribers(copy_sptr self, swig_int_ptr which_port) → swig_int_ptr
copy_sptr.min_noutput_items(copy_sptr self) → int
copy_sptr.pc_input_buffers_full_avg(copy_sptr self, int which) → float

pc_input_buffers_full_avg(copy_sptr self) -> pmt_vector_float

copy_sptr.pc_noutput_items_avg(copy_sptr self) → float
copy_sptr.pc_nproduced_avg(copy_sptr self) → float
copy_sptr.pc_output_buffers_full_avg(copy_sptr self, int which) → float

pc_output_buffers_full_avg(copy_sptr self) -> pmt_vector_float

copy_sptr.pc_throughput_avg(copy_sptr self) → float
copy_sptr.pc_work_time_avg(copy_sptr self) → float
copy_sptr.pc_work_time_total(copy_sptr self) → float
copy_sptr.sample_delay(copy_sptr self, int which) → unsigned int
copy_sptr.set_enabled(copy_sptr self, bool enable)
copy_sptr.set_min_noutput_items(copy_sptr self, int m)
copy_sptr.set_thread_priority(copy_sptr self, int priority) → int
copy_sptr.thread_priority(copy_sptr self) → int
gnuradio.blocks.delay(size_t itemsize, int delay) → delay_sptr

delay the input by a certain number of samples

Positive delays insert zero items at the beginning of the stream. Negative delays discard items from the stream.

You cannot initialize this block with a negative delay, however. That leads to a causality issue with the buffers when they are initialized. If you need to negetively delay one path, then put the positive delay on the other path instead.

Constructor Specific Documentation:

Make a delay block.

Parameters:
  • itemsize – size of the data items.
  • delay – number of samples to delay stream (>= 0).
delay_sptr.active_thread_priority(delay_sptr self) → int
delay_sptr.declare_sample_delay(delay_sptr self, int which, int delay)

declare_sample_delay(delay_sptr self, unsigned int delay)

delay_sptr.dly(delay_sptr self) → int
delay_sptr.message_subscribers(delay_sptr self, swig_int_ptr which_port) → swig_int_ptr
delay_sptr.min_noutput_items(delay_sptr self) → int
delay_sptr.pc_input_buffers_full_avg(delay_sptr self, int which) → float

pc_input_buffers_full_avg(delay_sptr self) -> pmt_vector_float

delay_sptr.pc_noutput_items_avg(delay_sptr self) → float
delay_sptr.pc_nproduced_avg(delay_sptr self) → float
delay_sptr.pc_output_buffers_full_avg(delay_sptr self, int which) → float

pc_output_buffers_full_avg(delay_sptr self) -> pmt_vector_float

delay_sptr.pc_throughput_avg(delay_sptr self) → float
delay_sptr.pc_work_time_avg(delay_sptr self) → float
delay_sptr.pc_work_time_total(delay_sptr self) → float
delay_sptr.sample_delay(delay_sptr self, int which) → unsigned int
delay_sptr.set_dly(delay_sptr self, int d)

Reset the delay.

delay_sptr.set_min_noutput_items(delay_sptr self, int m)
delay_sptr.set_thread_priority(delay_sptr self, int priority) → int
delay_sptr.thread_priority(delay_sptr self) → int
gnuradio.blocks.head(size_t sizeof_stream_item, uint64_t nitems) → head_sptr

copies the first N items to the output then signals done

Useful for building test cases

Constructor Specific Documentation:

Parameters:
  • sizeof_stream_item
  • nitems
head_sptr.active_thread_priority(head_sptr self) → int
head_sptr.declare_sample_delay(head_sptr self, int which, int delay)

declare_sample_delay(head_sptr self, unsigned int delay)

head_sptr.message_subscribers(head_sptr self, swig_int_ptr which_port) → swig_int_ptr
head_sptr.min_noutput_items(head_sptr self) → int
head_sptr.pc_input_buffers_full_avg(head_sptr self, int which) → float

pc_input_buffers_full_avg(head_sptr self) -> pmt_vector_float

head_sptr.pc_noutput_items_avg(head_sptr self) → float
head_sptr.pc_nproduced_avg(head_sptr self) → float
head_sptr.pc_output_buffers_full_avg(head_sptr self, int which) → float

pc_output_buffers_full_avg(head_sptr self) -> pmt_vector_float

head_sptr.pc_throughput_avg(head_sptr self) → float
head_sptr.pc_work_time_avg(head_sptr self) → float
head_sptr.pc_work_time_total(head_sptr self) → float
head_sptr.reset(head_sptr self)
head_sptr.sample_delay(head_sptr self, int which) → unsigned int
head_sptr.set_length(head_sptr self, int nitems)
head_sptr.set_min_noutput_items(head_sptr self, int m)
head_sptr.set_thread_priority(head_sptr self, int priority) → int
head_sptr.thread_priority(head_sptr self) → int
gnuradio.blocks.lfsr_32k_source_s() → lfsr_32k_source_s_sptr

LFSR pseudo-random source with period of 2^15 bits (2^11 shorts)

This source is typically used along with gr::blocks::check_lfsr_32k_s to test the USRP using its digital loopback mode.

Constructor Specific Documentation:

Make a LFSR 32k source block.

lfsr_32k_source_s_sptr.active_thread_priority(lfsr_32k_source_s_sptr self) → int
lfsr_32k_source_s_sptr.declare_sample_delay(lfsr_32k_source_s_sptr self, int which, int delay)

declare_sample_delay(lfsr_32k_source_s_sptr self, unsigned int delay)

lfsr_32k_source_s_sptr.message_subscribers(lfsr_32k_source_s_sptr self, swig_int_ptr which_port) → swig_int_ptr
lfsr_32k_source_s_sptr.min_noutput_items(lfsr_32k_source_s_sptr self) → int
lfsr_32k_source_s_sptr.pc_input_buffers_full_avg(lfsr_32k_source_s_sptr self, int which) → float

pc_input_buffers_full_avg(lfsr_32k_source_s_sptr self) -> pmt_vector_float

lfsr_32k_source_s_sptr.pc_noutput_items_avg(lfsr_32k_source_s_sptr self) → float
lfsr_32k_source_s_sptr.pc_nproduced_avg(lfsr_32k_source_s_sptr self) → float
lfsr_32k_source_s_sptr.pc_output_buffers_full_avg(lfsr_32k_source_s_sptr self, int which) → float

pc_output_buffers_full_avg(lfsr_32k_source_s_sptr self) -> pmt_vector_float

lfsr_32k_source_s_sptr.pc_throughput_avg(lfsr_32k_source_s_sptr self) → float
lfsr_32k_source_s_sptr.pc_work_time_avg(lfsr_32k_source_s_sptr self) → float
lfsr_32k_source_s_sptr.pc_work_time_total(lfsr_32k_source_s_sptr self) → float
lfsr_32k_source_s_sptr.sample_delay(lfsr_32k_source_s_sptr self, int which) → unsigned int
lfsr_32k_source_s_sptr.set_min_noutput_items(lfsr_32k_source_s_sptr self, int m)
lfsr_32k_source_s_sptr.set_thread_priority(lfsr_32k_source_s_sptr self, int priority) → int
lfsr_32k_source_s_sptr.thread_priority(lfsr_32k_source_s_sptr self) → int
gnuradio.blocks.nop(size_t sizeof_stream_item) → nop_sptr

Does nothing. Used for testing only.

Constructor Specific Documentation:

Build a nop block.

Parameters:sizeof_stream_item – size of the stream items in bytes.
nop_sptr.active_thread_priority(nop_sptr self) → int
nop_sptr.ctrlport_test(nop_sptr self) → int
nop_sptr.declare_sample_delay(nop_sptr self, int which, int delay)

declare_sample_delay(nop_sptr self, unsigned int delay)

nop_sptr.message_subscribers(nop_sptr self, swig_int_ptr which_port) → swig_int_ptr
nop_sptr.min_noutput_items(nop_sptr self) → int
nop_sptr.nmsgs_received(nop_sptr self) → int
nop_sptr.pc_input_buffers_full_avg(nop_sptr self, int which) → float

pc_input_buffers_full_avg(nop_sptr self) -> pmt_vector_float

nop_sptr.pc_noutput_items_avg(nop_sptr self) → float
nop_sptr.pc_nproduced_avg(nop_sptr self) → float
nop_sptr.pc_output_buffers_full_avg(nop_sptr self, int which) → float

pc_output_buffers_full_avg(nop_sptr self) -> pmt_vector_float

nop_sptr.pc_throughput_avg(nop_sptr self) → float
nop_sptr.pc_work_time_avg(nop_sptr self) → float
nop_sptr.pc_work_time_total(nop_sptr self) → float
nop_sptr.sample_delay(nop_sptr self, int which) → unsigned int
nop_sptr.set_ctrlport_test(nop_sptr self, int x)
nop_sptr.set_min_noutput_items(nop_sptr self, int m)
nop_sptr.set_thread_priority(nop_sptr self, int priority) → int
nop_sptr.thread_priority(nop_sptr self) → int
gnuradio.blocks.null_sink(size_t sizeof_stream_item) → null_sink_sptr

Bit bucket. Use as a termination point when a sink is required and we don’t want to do anything real.

Constructor Specific Documentation:

Build a null sink block.

Parameters:sizeof_stream_item – size of the stream items in bytes.
null_sink_sptr.active_thread_priority(null_sink_sptr self) → int
null_sink_sptr.declare_sample_delay(null_sink_sptr self, int which, int delay)

declare_sample_delay(null_sink_sptr self, unsigned int delay)

null_sink_sptr.message_subscribers(null_sink_sptr self, swig_int_ptr which_port) → swig_int_ptr
null_sink_sptr.min_noutput_items(null_sink_sptr self) → int
null_sink_sptr.pc_input_buffers_full_avg(null_sink_sptr self, int which) → float

pc_input_buffers_full_avg(null_sink_sptr self) -> pmt_vector_float

null_sink_sptr.pc_noutput_items_avg(null_sink_sptr self) → float
null_sink_sptr.pc_nproduced_avg(null_sink_sptr self) → float
null_sink_sptr.pc_output_buffers_full_avg(null_sink_sptr self, int which) → float

pc_output_buffers_full_avg(null_sink_sptr self) -> pmt_vector_float

null_sink_sptr.pc_throughput_avg(null_sink_sptr self) → float
null_sink_sptr.pc_work_time_avg(null_sink_sptr self) → float
null_sink_sptr.pc_work_time_total(null_sink_sptr self) → float
null_sink_sptr.sample_delay(null_sink_sptr self, int which) → unsigned int
null_sink_sptr.set_min_noutput_items(null_sink_sptr self, int m)
null_sink_sptr.set_thread_priority(null_sink_sptr self, int priority) → int
null_sink_sptr.thread_priority(null_sink_sptr self) → int
gnuradio.blocks.null_source(size_t sizeof_stream_item) → null_source_sptr

A source of zeros used mainly for testing.

Constructor Specific Documentation:

Build a null source block.

Parameters:sizeof_stream_item – size of the stream items in bytes.
null_source_sptr.active_thread_priority(null_source_sptr self) → int
null_source_sptr.declare_sample_delay(null_source_sptr self, int which, int delay)

declare_sample_delay(null_source_sptr self, unsigned int delay)

null_source_sptr.message_subscribers(null_source_sptr self, swig_int_ptr which_port) → swig_int_ptr
null_source_sptr.min_noutput_items(null_source_sptr self) → int
null_source_sptr.pc_input_buffers_full_avg(null_source_sptr self, int which) → float

pc_input_buffers_full_avg(null_source_sptr self) -> pmt_vector_float

null_source_sptr.pc_noutput_items_avg(null_source_sptr self) → float
null_source_sptr.pc_nproduced_avg(null_source_sptr self) → float
null_source_sptr.pc_output_buffers_full_avg(null_source_sptr self, int which) → float

pc_output_buffers_full_avg(null_source_sptr self) -> pmt_vector_float

null_source_sptr.pc_throughput_avg(null_source_sptr self) → float
null_source_sptr.pc_work_time_avg(null_source_sptr self) → float
null_source_sptr.pc_work_time_total(null_source_sptr self) → float
null_source_sptr.sample_delay(null_source_sptr self, int which) → unsigned int
null_source_sptr.set_min_noutput_items(null_source_sptr self, int m)
null_source_sptr.set_thread_priority(null_source_sptr self, int priority) → int
null_source_sptr.thread_priority(null_source_sptr self) → int
gnuradio.blocks.skiphead(size_t itemsize, uint64_t nitems_to_skip) → skiphead_sptr

skips the first N items, from then on copies items to the output

Useful for building test cases and sources which have metadata or junk at the start

Constructor Specific Documentation:

Parameters:
  • itemsize
  • nitems_to_skip
skiphead_sptr.active_thread_priority(skiphead_sptr self) → int
skiphead_sptr.declare_sample_delay(skiphead_sptr self, int which, int delay)

declare_sample_delay(skiphead_sptr self, unsigned int delay)

skiphead_sptr.message_subscribers(skiphead_sptr self, swig_int_ptr which_port) → swig_int_ptr
skiphead_sptr.min_noutput_items(skiphead_sptr self) → int
skiphead_sptr.pc_input_buffers_full_avg(skiphead_sptr self, int which) → float

pc_input_buffers_full_avg(skiphead_sptr self) -> pmt_vector_float

skiphead_sptr.pc_noutput_items_avg(skiphead_sptr self) → float
skiphead_sptr.pc_nproduced_avg(skiphead_sptr self) → float
skiphead_sptr.pc_output_buffers_full_avg(skiphead_sptr self, int which) → float

pc_output_buffers_full_avg(skiphead_sptr self) -> pmt_vector_float

skiphead_sptr.pc_throughput_avg(skiphead_sptr self) → float
skiphead_sptr.pc_work_time_avg(skiphead_sptr self) → float
skiphead_sptr.pc_work_time_total(skiphead_sptr self) → float
skiphead_sptr.sample_delay(skiphead_sptr self, int which) → unsigned int
skiphead_sptr.set_min_noutput_items(skiphead_sptr self, int m)
skiphead_sptr.set_thread_priority(skiphead_sptr self, int priority) → int
skiphead_sptr.thread_priority(skiphead_sptr self) → int
gnuradio.blocks.throttle(size_t itemsize, double samples_per_sec, bool ignore_tags=True) → throttle_sptr

throttle flow of samples such that the average rate does not exceed samples_per_sec.

input: one stream of itemsize; output: one stream of itemsize

N.B. this should only be used in GUI apps where there is no other rate limiting block. It is not intended nor effective at precisely controlling the rate of samples. That should be controlled by a source or sink tied to sample clock. E.g., a USRP or audio card.

Constructor Specific Documentation:

Parameters:
  • itemsize
  • samples_per_sec
  • ignore_tags
throttle_sptr.active_thread_priority(throttle_sptr self) → int
throttle_sptr.declare_sample_delay(throttle_sptr self, int which, int delay)

declare_sample_delay(throttle_sptr self, unsigned int delay)

throttle_sptr.message_subscribers(throttle_sptr self, swig_int_ptr which_port) → swig_int_ptr
throttle_sptr.min_noutput_items(throttle_sptr self) → int
throttle_sptr.pc_input_buffers_full_avg(throttle_sptr self, int which) → float

pc_input_buffers_full_avg(throttle_sptr self) -> pmt_vector_float

throttle_sptr.pc_noutput_items_avg(throttle_sptr self) → float
throttle_sptr.pc_nproduced_avg(throttle_sptr self) → float
throttle_sptr.pc_output_buffers_full_avg(throttle_sptr self, int which) → float

pc_output_buffers_full_avg(throttle_sptr self) -> pmt_vector_float

throttle_sptr.pc_throughput_avg(throttle_sptr self) → float
throttle_sptr.pc_work_time_avg(throttle_sptr self) → float
throttle_sptr.pc_work_time_total(throttle_sptr self) → float
throttle_sptr.sample_delay(throttle_sptr self, int which) → unsigned int
throttle_sptr.sample_rate(throttle_sptr self) → double

Get the sample rate in samples per second.

throttle_sptr.set_min_noutput_items(throttle_sptr self, int m)
throttle_sptr.set_sample_rate(throttle_sptr self, double rate)

Sets the sample rate in samples per second.

throttle_sptr.set_thread_priority(throttle_sptr self, int priority) → int
throttle_sptr.thread_priority(throttle_sptr self) → int

Previous topic

gnuradio.blocks: Waveform Generators

Next topic

gnuradio.analog: Level Controllers

This Page