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_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_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_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_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_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_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_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.

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_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

Constructor Specific Documentation:

Make a delay block.

Parameters:

• itemsize – size of the data items.
• delay – number of samples to delay stream.

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_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)

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_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_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_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_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_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_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_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