gnuradio.blocks: Measurement Tools

gnuradio.blocks.probe_signal_b() → probe_signal_b_sptr

Sink that allows a sample to be grabbed from Python.

Constructor Specific Documentation:

probe_signal_b_sptr.active_thread_priority(probe_signal_b_sptr self) → int

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

declare_sample_delay(probe_signal_b_sptr self, unsigned int delay)

probe_signal_b_sptr.level(probe_signal_b_sptr self) → unsigned char

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

probe_signal_b_sptr.min_noutput_items(probe_signal_b_sptr self) → int

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

pc_input_buffers_full_avg(probe_signal_b_sptr self) -> pmt_vector_float

probe_signal_b_sptr.pc_noutput_items_avg(probe_signal_b_sptr self) → float

probe_signal_b_sptr.pc_nproduced_avg(probe_signal_b_sptr self) → float

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

pc_output_buffers_full_avg(probe_signal_b_sptr self) -> pmt_vector_float

probe_signal_b_sptr.pc_work_time_avg(probe_signal_b_sptr self) → float

probe_signal_b_sptr.pc_work_time_total(probe_signal_b_sptr self) → float

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

probe_signal_b_sptr.set_min_noutput_items(probe_signal_b_sptr self, int m)

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

probe_signal_b_sptr.thread_priority(probe_signal_b_sptr self) → int

gnuradio.blocks.probe_signal_c() → probe_signal_c_sptr

Sink that allows a sample to be grabbed from Python.

Constructor Specific Documentation:

probe_signal_c_sptr.active_thread_priority(probe_signal_c_sptr self) → int

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

declare_sample_delay(probe_signal_c_sptr self, unsigned int delay)

probe_signal_c_sptr.level(probe_signal_c_sptr self) → gr_complex

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

probe_signal_c_sptr.min_noutput_items(probe_signal_c_sptr self) → int

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

pc_input_buffers_full_avg(probe_signal_c_sptr self) -> pmt_vector_float

probe_signal_c_sptr.pc_noutput_items_avg(probe_signal_c_sptr self) → float

probe_signal_c_sptr.pc_nproduced_avg(probe_signal_c_sptr self) → float

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

pc_output_buffers_full_avg(probe_signal_c_sptr self) -> pmt_vector_float

probe_signal_c_sptr.pc_work_time_avg(probe_signal_c_sptr self) → float

probe_signal_c_sptr.pc_work_time_total(probe_signal_c_sptr self) → float

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

probe_signal_c_sptr.set_min_noutput_items(probe_signal_c_sptr self, int m)

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

probe_signal_c_sptr.thread_priority(probe_signal_c_sptr self) → int

gnuradio.blocks.probe_signal_f() → probe_signal_f_sptr

Sink that allows a sample to be grabbed from Python.

Constructor Specific Documentation:

probe_signal_f_sptr.active_thread_priority(probe_signal_f_sptr self) → int

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

declare_sample_delay(probe_signal_f_sptr self, unsigned int delay)

probe_signal_f_sptr.level(probe_signal_f_sptr self) → float

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

probe_signal_f_sptr.min_noutput_items(probe_signal_f_sptr self) → int

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

pc_input_buffers_full_avg(probe_signal_f_sptr self) -> pmt_vector_float

probe_signal_f_sptr.pc_noutput_items_avg(probe_signal_f_sptr self) → float

probe_signal_f_sptr.pc_nproduced_avg(probe_signal_f_sptr self) → float

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

pc_output_buffers_full_avg(probe_signal_f_sptr self) -> pmt_vector_float

probe_signal_f_sptr.pc_work_time_avg(probe_signal_f_sptr self) → float

probe_signal_f_sptr.pc_work_time_total(probe_signal_f_sptr self) → float

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

probe_signal_f_sptr.set_min_noutput_items(probe_signal_f_sptr self, int m)

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

probe_signal_f_sptr.thread_priority(probe_signal_f_sptr self) → int

gnuradio.blocks.probe_signal_i() → probe_signal_i_sptr

Sink that allows a sample to be grabbed from Python.

Constructor Specific Documentation:

probe_signal_i_sptr.active_thread_priority(probe_signal_i_sptr self) → int

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

declare_sample_delay(probe_signal_i_sptr self, unsigned int delay)

probe_signal_i_sptr.level(probe_signal_i_sptr self) → int

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

probe_signal_i_sptr.min_noutput_items(probe_signal_i_sptr self) → int

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

pc_input_buffers_full_avg(probe_signal_i_sptr self) -> pmt_vector_float

probe_signal_i_sptr.pc_noutput_items_avg(probe_signal_i_sptr self) → float

probe_signal_i_sptr.pc_nproduced_avg(probe_signal_i_sptr self) → float

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

pc_output_buffers_full_avg(probe_signal_i_sptr self) -> pmt_vector_float

probe_signal_i_sptr.pc_work_time_avg(probe_signal_i_sptr self) → float

probe_signal_i_sptr.pc_work_time_total(probe_signal_i_sptr self) → float

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

probe_signal_i_sptr.set_min_noutput_items(probe_signal_i_sptr self, int m)

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

probe_signal_i_sptr.thread_priority(probe_signal_i_sptr self) → int

gnuradio.blocks.probe_signal_s() → probe_signal_s_sptr

Sink that allows a sample to be grabbed from Python.

Constructor Specific Documentation:

probe_signal_s_sptr.active_thread_priority(probe_signal_s_sptr self) → int

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

declare_sample_delay(probe_signal_s_sptr self, unsigned int delay)

probe_signal_s_sptr.level(probe_signal_s_sptr self) → short

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

probe_signal_s_sptr.min_noutput_items(probe_signal_s_sptr self) → int

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

pc_input_buffers_full_avg(probe_signal_s_sptr self) -> pmt_vector_float

probe_signal_s_sptr.pc_noutput_items_avg(probe_signal_s_sptr self) → float

probe_signal_s_sptr.pc_nproduced_avg(probe_signal_s_sptr self) → float

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

pc_output_buffers_full_avg(probe_signal_s_sptr self) -> pmt_vector_float

probe_signal_s_sptr.pc_work_time_avg(probe_signal_s_sptr self) → float

probe_signal_s_sptr.pc_work_time_total(probe_signal_s_sptr self) → float

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

probe_signal_s_sptr.set_min_noutput_items(probe_signal_s_sptr self, int m)

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

probe_signal_s_sptr.thread_priority(probe_signal_s_sptr self) → int

gnuradio.blocks.probe_signal_vb(size_t size) → probe_signal_vb_sptr

Sink that allows a vector of samples to be grabbed from Python.

Constructor Specific Documentation:

Parameters:size –

probe_signal_vb_sptr.active_thread_priority(probe_signal_vb_sptr self) → int

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

declare_sample_delay(probe_signal_vb_sptr self, unsigned int delay)

probe_signal_vb_sptr.level(probe_signal_vb_sptr self) → std::vector< unsigned char,std::allocator< unsigned char > >

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

probe_signal_vb_sptr.min_noutput_items(probe_signal_vb_sptr self) → int

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

pc_input_buffers_full_avg(probe_signal_vb_sptr self) -> pmt_vector_float

probe_signal_vb_sptr.pc_noutput_items_avg(probe_signal_vb_sptr self) → float

probe_signal_vb_sptr.pc_nproduced_avg(probe_signal_vb_sptr self) → float

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

pc_output_buffers_full_avg(probe_signal_vb_sptr self) -> pmt_vector_float

probe_signal_vb_sptr.pc_work_time_avg(probe_signal_vb_sptr self) → float

probe_signal_vb_sptr.pc_work_time_total(probe_signal_vb_sptr self) → float

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

probe_signal_vb_sptr.set_min_noutput_items(probe_signal_vb_sptr self, int m)

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

probe_signal_vb_sptr.thread_priority(probe_signal_vb_sptr self) → int

gnuradio.blocks.probe_signal_vc(size_t size) → probe_signal_vc_sptr

Sink that allows a vector of samples to be grabbed from Python.

Constructor Specific Documentation:

Parameters:size –

probe_signal_vc_sptr.active_thread_priority(probe_signal_vc_sptr self) → int

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

declare_sample_delay(probe_signal_vc_sptr self, unsigned int delay)

probe_signal_vc_sptr.level(probe_signal_vc_sptr self) → pmt_vector_cfloat

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

probe_signal_vc_sptr.min_noutput_items(probe_signal_vc_sptr self) → int

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

pc_input_buffers_full_avg(probe_signal_vc_sptr self) -> pmt_vector_float

probe_signal_vc_sptr.pc_noutput_items_avg(probe_signal_vc_sptr self) → float

probe_signal_vc_sptr.pc_nproduced_avg(probe_signal_vc_sptr self) → float

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

pc_output_buffers_full_avg(probe_signal_vc_sptr self) -> pmt_vector_float

probe_signal_vc_sptr.pc_work_time_avg(probe_signal_vc_sptr self) → float

probe_signal_vc_sptr.pc_work_time_total(probe_signal_vc_sptr self) → float

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

probe_signal_vc_sptr.set_min_noutput_items(probe_signal_vc_sptr self, int m)

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

probe_signal_vc_sptr.thread_priority(probe_signal_vc_sptr self) → int

gnuradio.blocks.probe_signal_vf(size_t size) → probe_signal_vf_sptr

Sink that allows a vector of samples to be grabbed from Python.

Constructor Specific Documentation:

Parameters:size –

probe_signal_vf_sptr.active_thread_priority(probe_signal_vf_sptr self) → int

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

declare_sample_delay(probe_signal_vf_sptr self, unsigned int delay)

probe_signal_vf_sptr.level(probe_signal_vf_sptr self) → pmt_vector_float

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

probe_signal_vf_sptr.min_noutput_items(probe_signal_vf_sptr self) → int

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

pc_input_buffers_full_avg(probe_signal_vf_sptr self) -> pmt_vector_float

probe_signal_vf_sptr.pc_noutput_items_avg(probe_signal_vf_sptr self) → float

probe_signal_vf_sptr.pc_nproduced_avg(probe_signal_vf_sptr self) → float

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

pc_output_buffers_full_avg(probe_signal_vf_sptr self) -> pmt_vector_float

probe_signal_vf_sptr.pc_work_time_avg(probe_signal_vf_sptr self) → float

probe_signal_vf_sptr.pc_work_time_total(probe_signal_vf_sptr self) → float

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

probe_signal_vf_sptr.set_min_noutput_items(probe_signal_vf_sptr self, int m)

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

probe_signal_vf_sptr.thread_priority(probe_signal_vf_sptr self) → int

gnuradio.blocks.probe_signal_vi(size_t size) → probe_signal_vi_sptr

Sink that allows a vector of samples to be grabbed from Python.

Constructor Specific Documentation:

Parameters:size –

probe_signal_vi_sptr.active_thread_priority(probe_signal_vi_sptr self) → int

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

declare_sample_delay(probe_signal_vi_sptr self, unsigned int delay)

probe_signal_vi_sptr.level(probe_signal_vi_sptr self) → std::vector< int,std::allocator< int > >

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

probe_signal_vi_sptr.min_noutput_items(probe_signal_vi_sptr self) → int

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

pc_input_buffers_full_avg(probe_signal_vi_sptr self) -> pmt_vector_float

probe_signal_vi_sptr.pc_noutput_items_avg(probe_signal_vi_sptr self) → float

probe_signal_vi_sptr.pc_nproduced_avg(probe_signal_vi_sptr self) → float

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

pc_output_buffers_full_avg(probe_signal_vi_sptr self) -> pmt_vector_float

probe_signal_vi_sptr.pc_work_time_avg(probe_signal_vi_sptr self) → float

probe_signal_vi_sptr.pc_work_time_total(probe_signal_vi_sptr self) → float

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

probe_signal_vi_sptr.set_min_noutput_items(probe_signal_vi_sptr self, int m)

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

probe_signal_vi_sptr.thread_priority(probe_signal_vi_sptr self) → int

gnuradio.blocks.probe_signal_vs(size_t size) → probe_signal_vs_sptr

Sink that allows a vector of samples to be grabbed from Python.

Constructor Specific Documentation:

Parameters:size –

probe_signal_vs_sptr.active_thread_priority(probe_signal_vs_sptr self) → int

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

declare_sample_delay(probe_signal_vs_sptr self, unsigned int delay)

probe_signal_vs_sptr.level(probe_signal_vs_sptr self) → std::vector< short,std::allocator< short > >

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

probe_signal_vs_sptr.min_noutput_items(probe_signal_vs_sptr self) → int

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

pc_input_buffers_full_avg(probe_signal_vs_sptr self) -> pmt_vector_float

probe_signal_vs_sptr.pc_noutput_items_avg(probe_signal_vs_sptr self) → float

probe_signal_vs_sptr.pc_nproduced_avg(probe_signal_vs_sptr self) → float

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

pc_output_buffers_full_avg(probe_signal_vs_sptr self) -> pmt_vector_float

probe_signal_vs_sptr.pc_work_time_avg(probe_signal_vs_sptr self) → float

probe_signal_vs_sptr.pc_work_time_total(probe_signal_vs_sptr self) → float

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

probe_signal_vs_sptr.set_min_noutput_items(probe_signal_vs_sptr self, int m)

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

probe_signal_vs_sptr.thread_priority(probe_signal_vs_sptr self) → int

gnuradio.blocks.ctrlport_probe2_c(std::string const & id, std::string const & desc, int len, unsigned int disp_mask) → ctrlport_probe2_c_sptr

A ControlPort probe to export vectors of signals.

This block acts as a sink in the flowgraph but also exports vectors of complex samples over ControlPort. This block holds the latest number of complex samples so that every query by a ControlPort client will get the same length vector.

Constructor Specific Documentation:

Make a ControlPort probe block.

Parameters:

• id – A string ID to name the probe over ControlPort.
• desc – A string describing the probe.
• len – Number of samples to transmit.
• disp_mask – Mask to set default display params.

ctrlport_probe2_c_sptr.active_thread_priority(ctrlport_probe2_c_sptr self) → int

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

declare_sample_delay(ctrlport_probe2_c_sptr self, unsigned int delay)

ctrlport_probe2_c_sptr.get(ctrlport_probe2_c_sptr self) → pmt_vector_cfloat

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

ctrlport_probe2_c_sptr.min_noutput_items(ctrlport_probe2_c_sptr self) → int

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

pc_input_buffers_full_avg(ctrlport_probe2_c_sptr self) -> pmt_vector_float

ctrlport_probe2_c_sptr.pc_noutput_items_avg(ctrlport_probe2_c_sptr self) → float

ctrlport_probe2_c_sptr.pc_nproduced_avg(ctrlport_probe2_c_sptr self) → float

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

pc_output_buffers_full_avg(ctrlport_probe2_c_sptr self) -> pmt_vector_float

ctrlport_probe2_c_sptr.pc_work_time_avg(ctrlport_probe2_c_sptr self) → float

ctrlport_probe2_c_sptr.pc_work_time_total(ctrlport_probe2_c_sptr self) → float

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

ctrlport_probe2_c_sptr.set_length(ctrlport_probe2_c_sptr self, int len)

ctrlport_probe2_c_sptr.set_min_noutput_items(ctrlport_probe2_c_sptr self, int m)

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

ctrlport_probe2_c_sptr.thread_priority(ctrlport_probe2_c_sptr self) → int

gnuradio.blocks.ctrlport_probe_c(std::string const & id, std::string const & desc) → ctrlport_probe_c_sptr

A ControlPort probe to export vectors of signals.

This block acts as a sink in the flowgraph but also exports vectors of complex samples over ControlPort. This block simply sends the current vector held in the work function when the queried by a ControlPort client.

Constructor Specific Documentation:

Make a ControlPort probe block.

Parameters:

• id – A string ID to name the probe over ControlPort.
• desc – A string describing the probe.

ctrlport_probe_c_sptr.active_thread_priority(ctrlport_probe_c_sptr self) → int

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

declare_sample_delay(ctrlport_probe_c_sptr self, unsigned int delay)

ctrlport_probe_c_sptr.get(ctrlport_probe_c_sptr self) → pmt_vector_cfloat

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

ctrlport_probe_c_sptr.min_noutput_items(ctrlport_probe_c_sptr self) → int

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

pc_input_buffers_full_avg(ctrlport_probe_c_sptr self) -> pmt_vector_float

ctrlport_probe_c_sptr.pc_noutput_items_avg(ctrlport_probe_c_sptr self) → float

ctrlport_probe_c_sptr.pc_nproduced_avg(ctrlport_probe_c_sptr self) → float

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

pc_output_buffers_full_avg(ctrlport_probe_c_sptr self) -> pmt_vector_float

ctrlport_probe_c_sptr.pc_work_time_avg(ctrlport_probe_c_sptr self) → float

ctrlport_probe_c_sptr.pc_work_time_total(ctrlport_probe_c_sptr self) → float

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

ctrlport_probe_c_sptr.set_min_noutput_items(ctrlport_probe_c_sptr self, int m)

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

ctrlport_probe_c_sptr.thread_priority(ctrlport_probe_c_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_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.probe_rate(size_t itemsize, double update_rate_ms=500.0, double alpha=0.0001) → probe_rate_sptr

throughput measurement

Constructor Specific Documentation:

Make a throughput measurement block.

Parameters:

• itemsize – size of each stream item
• update_rate_ms – minimum update time in milliseconds
• alpha – gain for running average filter

probe_rate_sptr.active_thread_priority(probe_rate_sptr self) → int

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

declare_sample_delay(probe_rate_sptr self, unsigned int delay)

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

probe_rate_sptr.min_noutput_items(probe_rate_sptr self) → int

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

pc_input_buffers_full_avg(probe_rate_sptr self) -> pmt_vector_float

probe_rate_sptr.pc_noutput_items_avg(probe_rate_sptr self) → float

probe_rate_sptr.pc_nproduced_avg(probe_rate_sptr self) → float

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

pc_output_buffers_full_avg(probe_rate_sptr self) -> pmt_vector_float

probe_rate_sptr.pc_work_time_avg(probe_rate_sptr self) → float

probe_rate_sptr.pc_work_time_total(probe_rate_sptr self) → float

probe_rate_sptr.rate(probe_rate_sptr self) → double

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

probe_rate_sptr.set_alpha(probe_rate_sptr self, double alpha)

probe_rate_sptr.set_min_noutput_items(probe_rate_sptr self, int m)

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

probe_rate_sptr.thread_priority(probe_rate_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_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