gnuradio.blocks: Debug Tools

gnuradio.blocks.vector_sink_b(int vlen=1) → vector_sink_b_sptr

unsigned char sink that writes to a vector

Constructor Specific Documentation:

Parameters:vlen
vector_sink_b_sptr.active_thread_priority(vector_sink_b_sptr self) → int
vector_sink_b_sptr.data(vector_sink_b_sptr self) → std::vector< unsigned char,std::allocator< unsigned char > >
vector_sink_b_sptr.declare_sample_delay(vector_sink_b_sptr self, int which, int delay)

declare_sample_delay(vector_sink_b_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(vector_sink_b_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(vector_sink_b_sptr self) -> pmt_vector_float

vector_sink_b_sptr.pc_throughput_avg(vector_sink_b_sptr self) → float
vector_sink_b_sptr.pc_work_time_avg(vector_sink_b_sptr self) → float
vector_sink_b_sptr.pc_work_time_total(vector_sink_b_sptr self) → float
vector_sink_b_sptr.reset(vector_sink_b_sptr self)
vector_sink_b_sptr.sample_delay(vector_sink_b_sptr self, int which) → unsigned int
vector_sink_b_sptr.set_min_noutput_items(vector_sink_b_sptr self, int m)
vector_sink_b_sptr.set_thread_priority(vector_sink_b_sptr self, int priority) → int
vector_sink_b_sptr.tags(vector_sink_b_sptr self) → tags_vector_t
vector_sink_b_sptr.thread_priority(vector_sink_b_sptr self) → int
gnuradio.blocks.vector_sink_c(int vlen=1) → vector_sink_c_sptr

gr_complex sink that writes to a vector

Constructor Specific Documentation:

Parameters:vlen
vector_sink_c_sptr.active_thread_priority(vector_sink_c_sptr self) → int
vector_sink_c_sptr.data(vector_sink_c_sptr self) → pmt_vector_cfloat
vector_sink_c_sptr.declare_sample_delay(vector_sink_c_sptr self, int which, int delay)

declare_sample_delay(vector_sink_c_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(vector_sink_c_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(vector_sink_c_sptr self) -> pmt_vector_float

vector_sink_c_sptr.pc_throughput_avg(vector_sink_c_sptr self) → float
vector_sink_c_sptr.pc_work_time_avg(vector_sink_c_sptr self) → float
vector_sink_c_sptr.pc_work_time_total(vector_sink_c_sptr self) → float
vector_sink_c_sptr.reset(vector_sink_c_sptr self)
vector_sink_c_sptr.sample_delay(vector_sink_c_sptr self, int which) → unsigned int
vector_sink_c_sptr.set_min_noutput_items(vector_sink_c_sptr self, int m)
vector_sink_c_sptr.set_thread_priority(vector_sink_c_sptr self, int priority) → int
vector_sink_c_sptr.tags(vector_sink_c_sptr self) → tags_vector_t
vector_sink_c_sptr.thread_priority(vector_sink_c_sptr self) → int
gnuradio.blocks.vector_sink_f(int vlen=1) → vector_sink_f_sptr

float sink that writes to a vector

Constructor Specific Documentation:

Parameters:vlen
vector_sink_f_sptr.active_thread_priority(vector_sink_f_sptr self) → int
vector_sink_f_sptr.data(vector_sink_f_sptr self) → pmt_vector_float
vector_sink_f_sptr.declare_sample_delay(vector_sink_f_sptr self, int which, int delay)

declare_sample_delay(vector_sink_f_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(vector_sink_f_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(vector_sink_f_sptr self) -> pmt_vector_float

vector_sink_f_sptr.pc_throughput_avg(vector_sink_f_sptr self) → float
vector_sink_f_sptr.pc_work_time_avg(vector_sink_f_sptr self) → float
vector_sink_f_sptr.pc_work_time_total(vector_sink_f_sptr self) → float
vector_sink_f_sptr.reset(vector_sink_f_sptr self)
vector_sink_f_sptr.sample_delay(vector_sink_f_sptr self, int which) → unsigned int
vector_sink_f_sptr.set_min_noutput_items(vector_sink_f_sptr self, int m)
vector_sink_f_sptr.set_thread_priority(vector_sink_f_sptr self, int priority) → int
vector_sink_f_sptr.tags(vector_sink_f_sptr self) → tags_vector_t
vector_sink_f_sptr.thread_priority(vector_sink_f_sptr self) → int
gnuradio.blocks.vector_sink_i(int vlen=1) → vector_sink_i_sptr

int sink that writes to a vector

Constructor Specific Documentation:

Parameters:vlen
vector_sink_i_sptr.active_thread_priority(vector_sink_i_sptr self) → int
vector_sink_i_sptr.data(vector_sink_i_sptr self) → std::vector< int,std::allocator< int > >
vector_sink_i_sptr.declare_sample_delay(vector_sink_i_sptr self, int which, int delay)

declare_sample_delay(vector_sink_i_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(vector_sink_i_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(vector_sink_i_sptr self) -> pmt_vector_float

vector_sink_i_sptr.pc_throughput_avg(vector_sink_i_sptr self) → float
vector_sink_i_sptr.pc_work_time_avg(vector_sink_i_sptr self) → float
vector_sink_i_sptr.pc_work_time_total(vector_sink_i_sptr self) → float
vector_sink_i_sptr.reset(vector_sink_i_sptr self)
vector_sink_i_sptr.sample_delay(vector_sink_i_sptr self, int which) → unsigned int
vector_sink_i_sptr.set_min_noutput_items(vector_sink_i_sptr self, int m)
vector_sink_i_sptr.set_thread_priority(vector_sink_i_sptr self, int priority) → int
vector_sink_i_sptr.tags(vector_sink_i_sptr self) → tags_vector_t
vector_sink_i_sptr.thread_priority(vector_sink_i_sptr self) → int
gnuradio.blocks.vector_sink_s(int vlen=1) → vector_sink_s_sptr

short sink that writes to a vector

Constructor Specific Documentation:

Parameters:vlen
vector_sink_s_sptr.active_thread_priority(vector_sink_s_sptr self) → int
vector_sink_s_sptr.data(vector_sink_s_sptr self) → std::vector< short,std::allocator< short > >
vector_sink_s_sptr.declare_sample_delay(vector_sink_s_sptr self, int which, int delay)

declare_sample_delay(vector_sink_s_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(vector_sink_s_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(vector_sink_s_sptr self) -> pmt_vector_float

vector_sink_s_sptr.pc_throughput_avg(vector_sink_s_sptr self) → float
vector_sink_s_sptr.pc_work_time_avg(vector_sink_s_sptr self) → float
vector_sink_s_sptr.pc_work_time_total(vector_sink_s_sptr self) → float
vector_sink_s_sptr.reset(vector_sink_s_sptr self)
vector_sink_s_sptr.sample_delay(vector_sink_s_sptr self, int which) → unsigned int
vector_sink_s_sptr.set_min_noutput_items(vector_sink_s_sptr self, int m)
vector_sink_s_sptr.set_thread_priority(vector_sink_s_sptr self, int priority) → int
vector_sink_s_sptr.tags(vector_sink_s_sptr self) → tags_vector_t
vector_sink_s_sptr.thread_priority(vector_sink_s_sptr self) → int
gnuradio.blocks.annotator_1to1(int when, size_t sizeof_stream_item) → annotator_1to1_sptr

1-to-1 stream annotator testing block. FOR TESTING PURPOSES ONLY.

This block creates tags to be sent downstream every 10,000 items it sees. The tags contain the name and ID of the instantiated block, use “seq” as a key, and have a counter that increments by 1 for every tag produced that is used as the tag’s value. The tags are propagated using the 1-to-1 policy.

It also stores a copy of all tags it sees flow past it. These tags can be recalled externally with the data() member.

Warning

This block is only meant for testing and showing how to use the tags.

Constructor Specific Documentation:

Parameters:
  • when
  • sizeof_stream_item
annotator_1to1_sptr.active_thread_priority(annotator_1to1_sptr self) → int
annotator_1to1_sptr.data(annotator_1to1_sptr self) → tags_vector_t
annotator_1to1_sptr.declare_sample_delay(annotator_1to1_sptr self, int which, int delay)

declare_sample_delay(annotator_1to1_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(annotator_1to1_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(annotator_1to1_sptr self) -> pmt_vector_float

annotator_1to1_sptr.pc_throughput_avg(annotator_1to1_sptr self) → float
annotator_1to1_sptr.pc_work_time_avg(annotator_1to1_sptr self) → float
annotator_1to1_sptr.pc_work_time_total(annotator_1to1_sptr self) → float
annotator_1to1_sptr.sample_delay(annotator_1to1_sptr self, int which) → unsigned int
annotator_1to1_sptr.set_min_noutput_items(annotator_1to1_sptr self, int m)
annotator_1to1_sptr.set_thread_priority(annotator_1to1_sptr self, int priority) → int
annotator_1to1_sptr.thread_priority(annotator_1to1_sptr self) → int
gnuradio.blocks.annotator_alltoall(int when, size_t sizeof_stream_item) → annotator_alltoall_sptr

All-to-all stream annotator testing block. FOR TESTING PURPOSES ONLY.

This block creates tags to be sent downstream every 10,000 items it sees. The tags contain the name and ID of the instantiated block, use “seq” as a key, and have a counter that increments by 1 for every tag produced that is used as the tag’s value. The tags are propagated using the all-to-all policy.

It also stores a copy of all tags it sees flow past it. These tags can be recalled externally with the data() member.

This block is only meant for testing and showing how to use the tags.

Constructor Specific Documentation:

Parameters:
  • when
  • sizeof_stream_item
annotator_alltoall_sptr.active_thread_priority(annotator_alltoall_sptr self) → int
annotator_alltoall_sptr.data(annotator_alltoall_sptr self) → tags_vector_t
annotator_alltoall_sptr.declare_sample_delay(annotator_alltoall_sptr self, int which, int delay)

declare_sample_delay(annotator_alltoall_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(annotator_alltoall_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(annotator_alltoall_sptr self) -> pmt_vector_float

annotator_alltoall_sptr.pc_throughput_avg(annotator_alltoall_sptr self) → float
annotator_alltoall_sptr.pc_work_time_avg(annotator_alltoall_sptr self) → float
annotator_alltoall_sptr.pc_work_time_total(annotator_alltoall_sptr self) → float
annotator_alltoall_sptr.sample_delay(annotator_alltoall_sptr self, int which) → unsigned int
annotator_alltoall_sptr.set_min_noutput_items(annotator_alltoall_sptr self, int m)
annotator_alltoall_sptr.set_thread_priority(annotator_alltoall_sptr self, int priority) → int
annotator_alltoall_sptr.thread_priority(annotator_alltoall_sptr self) → int
gnuradio.blocks.annotator_raw(size_t sizeof_stream_item) → annotator_raw_sptr

raw stream annotator testing block.

This block creates arbitrary tags to be sent downstream gnuradio/blocks to be sent are set manually via accessor methods and are sent only once.

This block is intended for testing of tag related gnuradio/blocks

Constructor Specific Documentation:

Parameters:sizeof_stream_item
annotator_raw_sptr.active_thread_priority(annotator_raw_sptr self) → int
annotator_raw_sptr.add_tag(annotator_raw_sptr self, uint64_t offset, swig_int_ptr key, swig_int_ptr val)
annotator_raw_sptr.declare_sample_delay(annotator_raw_sptr self, int which, int delay)

declare_sample_delay(annotator_raw_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(annotator_raw_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(annotator_raw_sptr self) -> pmt_vector_float

annotator_raw_sptr.pc_throughput_avg(annotator_raw_sptr self) → float
annotator_raw_sptr.pc_work_time_avg(annotator_raw_sptr self) → float
annotator_raw_sptr.pc_work_time_total(annotator_raw_sptr self) → float
annotator_raw_sptr.sample_delay(annotator_raw_sptr self, int which) → unsigned int
annotator_raw_sptr.set_min_noutput_items(annotator_raw_sptr self, int m)
annotator_raw_sptr.set_thread_priority(annotator_raw_sptr self, int priority) → int
annotator_raw_sptr.thread_priority(annotator_raw_sptr self) → int
gnuradio.blocks.message_debug() → message_debug_sptr

Debug block for the message passing system.

The message debug block is used to capture and print or store messages as they are received. Any block that generates a message may connect that message port to one or more of the three message input ports of this debug block. The message ports are:

Constructor Specific Documentation:

Build the message debug block. It takes no parameters and has three message ports: print, store, and print_pdu.

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

declare_sample_delay(message_debug_sptr self, unsigned int delay)

message_debug_sptr.get_message(message_debug_sptr self, int i) → swig_int_ptr

Get a message (as a PMT) from the message vector at index .

Messages passed to the ‘store’ port will be stored in a vector. This function retrieves those messages by index. They are index in order of when they were received (all messages are just pushed onto the back of a vector). This is mostly useful in debugging message passing graphs and in QA code.

message_debug_sptr.message_subscribers(message_debug_sptr self, swig_int_ptr which_port) → swig_int_ptr
message_debug_sptr.min_noutput_items(message_debug_sptr self) → int
message_debug_sptr.num_messages(message_debug_sptr self) → int

Reports the number of messages received by this block.

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

pc_input_buffers_full_avg(message_debug_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(message_debug_sptr self) -> pmt_vector_float

message_debug_sptr.pc_throughput_avg(message_debug_sptr self) → float
message_debug_sptr.pc_work_time_avg(message_debug_sptr self) → float
message_debug_sptr.pc_work_time_total(message_debug_sptr self) → float
message_debug_sptr.sample_delay(message_debug_sptr self, int which) → unsigned int
message_debug_sptr.set_min_noutput_items(message_debug_sptr self, int m)
message_debug_sptr.set_thread_priority(message_debug_sptr self, int priority) → int
message_debug_sptr.thread_priority(message_debug_sptr self) → int
gnuradio.blocks.random_pdu(int mintime, int maxtime, char byte_mask=0xFF, int length_modulo=1) → random_pdu_sptr

Sends a random PDU at intervals.

Constructor Specific Documentation:

Construct a random PDU generator.

Parameters:
  • mintime
  • maxtime
  • byte_mask
  • length_modulo
random_pdu_sptr.active_thread_priority(random_pdu_sptr self) → int
random_pdu_sptr.declare_sample_delay(random_pdu_sptr self, int which, int delay)

declare_sample_delay(random_pdu_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(random_pdu_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(random_pdu_sptr self) -> pmt_vector_float

random_pdu_sptr.pc_throughput_avg(random_pdu_sptr self) → float
random_pdu_sptr.pc_work_time_avg(random_pdu_sptr self) → float
random_pdu_sptr.pc_work_time_total(random_pdu_sptr self) → float
random_pdu_sptr.sample_delay(random_pdu_sptr self, int which) → unsigned int
random_pdu_sptr.set_min_noutput_items(random_pdu_sptr self, int m)
random_pdu_sptr.set_thread_priority(random_pdu_sptr self, int priority) → int
random_pdu_sptr.thread_priority(random_pdu_sptr self) → int
gnuradio.blocks.tag_debug(size_t sizeof_stream_item, std::string const & name, std::string const & key_filter="") → tag_debug_sptr

Bit bucket that prints out any tag received.

This block collects all tags sent to it on all input ports and displays them to stdout in a formatted way. The parameter is used to identify which debug sink generated the tag, so when connecting a block to this debug sink, an appropriate name is something that identifies the input block.

This block otherwise acts as a NULL sink in that items from the input stream are ignored. It is designed to be able to attach to any block and watch all tags streaming out of that block for debugging purposes.

Specifying a key will allow this block to filter out all other tags and only display tags that match the given key. This can help clean up the output and allow you to focus in on a particular tag of interest.

The tags from the last call to this work function are stored and can be retrieved using the function ‘current_tags’.

Constructor Specific Documentation:

Build a tag debug block

Parameters:
  • sizeof_stream_item – size of the items in the incoming stream.
  • name – name to identify which debug sink generated the info.
  • key_filter – Specify a tag’s key value to use as a filter.
tag_debug_sptr.active_thread_priority(tag_debug_sptr self) → int
tag_debug_sptr.current_tags(tag_debug_sptr self) → tags_vector_t

Returns a vector of tag_t items as of the last call to work.

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

declare_sample_delay(tag_debug_sptr self, unsigned int delay)

tag_debug_sptr.key_filter(tag_debug_sptr self) → std::string

Get the current filter key.

tag_debug_sptr.message_subscribers(tag_debug_sptr self, swig_int_ptr which_port) → swig_int_ptr
tag_debug_sptr.min_noutput_items(tag_debug_sptr self) → int
tag_debug_sptr.num_tags(tag_debug_sptr self) → int

Return the total number of tags in the tag queue.

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

pc_input_buffers_full_avg(tag_debug_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(tag_debug_sptr self) -> pmt_vector_float

tag_debug_sptr.pc_throughput_avg(tag_debug_sptr self) → float
tag_debug_sptr.pc_work_time_avg(tag_debug_sptr self) → float
tag_debug_sptr.pc_work_time_total(tag_debug_sptr self) → float
tag_debug_sptr.sample_delay(tag_debug_sptr self, int which) → unsigned int
tag_debug_sptr.set_display(tag_debug_sptr self, bool d)

Set the display of tags to stdout on/off.

tag_debug_sptr.set_key_filter(tag_debug_sptr self, std::string const & key_filter)

Set a new key to filter with.

tag_debug_sptr.set_min_noutput_items(tag_debug_sptr self, int m)
tag_debug_sptr.set_thread_priority(tag_debug_sptr self, int priority) → int
tag_debug_sptr.thread_priority(tag_debug_sptr self) → int

Previous topic

gnuradio.blocks: Stream Tag Tools

Next topic

gnuradio.blocks: Measurement Tools

This Page