gnuradio.blocks: Debug Tools

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

unsigned char sink that writes to a vector

Constructor Specific Documentation:

Parameters:vlen
vector_sink_b_sptr.active_thread_priority(self) → int
vector_sink_b_sptr.data(self) → __dummy_0__
vector_sink_b_sptr.reset(self)
vector_sink_b_sptr.set_thread_priority(self, int priority) → int
vector_sink_b_sptr.tags(self) → tags_vector_t
vector_sink_b_sptr.thread_priority(self) → int
gnuradio.blocks.vector_sink_c(int vlen = 1) → sptr

gr_complex sink that writes to a vector

Constructor Specific Documentation:

Parameters:vlen
vector_sink_c_sptr.active_thread_priority(self) → int
vector_sink_c_sptr.data(self) → std::vector<(gr_complex,std::allocator<(gr_complex)>)>
vector_sink_c_sptr.reset(self)
vector_sink_c_sptr.set_thread_priority(self, int priority) → int
vector_sink_c_sptr.tags(self) → tags_vector_t
vector_sink_c_sptr.thread_priority(self) → int
gnuradio.blocks.vector_sink_f(int vlen = 1) → sptr

float sink that writes to a vector

Constructor Specific Documentation:

Parameters:vlen
vector_sink_f_sptr.active_thread_priority(self) → int
vector_sink_f_sptr.data(self) → pmt_vector_float
vector_sink_f_sptr.reset(self)
vector_sink_f_sptr.set_thread_priority(self, int priority) → int
vector_sink_f_sptr.tags(self) → tags_vector_t
vector_sink_f_sptr.thread_priority(self) → int
gnuradio.blocks.vector_sink_i(int vlen = 1) → sptr

int sink that writes to a vector

Constructor Specific Documentation:

Parameters:vlen
vector_sink_i_sptr.active_thread_priority(self) → int
vector_sink_i_sptr.data(self) → __dummy_5__
vector_sink_i_sptr.reset(self)
vector_sink_i_sptr.set_thread_priority(self, int priority) → int
vector_sink_i_sptr.tags(self) → tags_vector_t
vector_sink_i_sptr.thread_priority(self) → int
gnuradio.blocks.vector_sink_s(int vlen = 1) → sptr

short sink that writes to a vector

Constructor Specific Documentation:

Parameters:vlen
vector_sink_s_sptr.active_thread_priority(self) → int
vector_sink_s_sptr.data(self) → __dummy_4__
vector_sink_s_sptr.reset(self)
vector_sink_s_sptr.set_thread_priority(self, int priority) → int
vector_sink_s_sptr.tags(self) → tags_vector_t
vector_sink_s_sptr.thread_priority(self) → int
gnuradio.blocks.annotator_1to1(int when, size_t sizeof_stream_item) → 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(self) → int
annotator_1to1_sptr.data(self) → tags_vector_t
annotator_1to1_sptr.set_thread_priority(self, int priority) → int
annotator_1to1_sptr.thread_priority(self) → int
gnuradio.blocks.annotator_alltoall(int when, size_t sizeof_stream_item) → 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(self) → int
annotator_alltoall_sptr.data(self) → tags_vector_t
annotator_alltoall_sptr.set_thread_priority(self, int priority) → int
annotator_alltoall_sptr.thread_priority(self) → int
gnuradio.blocks.annotator_raw(size_t sizeof_stream_item) → 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(self) → int
annotator_raw_sptr.add_tag(self, uint64_t offset, pmt_t key, pmt_t val)
annotator_raw_sptr.set_thread_priority(self, int priority) → int
annotator_raw_sptr.thread_priority(self) → int
gnuradio.blocks.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(self) → int
message_debug_sptr.get_message(self, int i) → pmt_t

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.num_messages(self) → int

Reports the number of messages received by this block.

message_debug_sptr.set_thread_priority(self, int priority) → int
message_debug_sptr.thread_priority(self) → int
gnuradio.blocks.random_pdu(int mintime, int maxtime) → sptr

Sends a random PDU at intervals.

Constructor Specific Documentation:

Construct a random PDU generator.

Parameters:
  • mintime
  • maxtime
random_pdu_sptr.active_thread_priority(self) → int
random_pdu_sptr.set_thread_priority(self, int priority) → int
random_pdu_sptr.thread_priority(self) → int
gnuradio.blocks.tag_debug(size_t sizeof_stream_item, string name) → 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.

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.
tag_debug_sptr.active_thread_priority(self) → int
tag_debug_sptr.current_tags(self) → tags_vector_t

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

tag_debug_sptr.set_display(self, bool d)

Set the display of tags to stdout on/off.

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

Previous topic

gnuradio.blocks: Stream Tag Tools

Next topic

gnuradio.blocks: Measurement Tools

This Page