gnuradio.blocks

Processing blocks common to many flowgraphs.

gnuradio.blocks.abs_ff(size_t vlen=1) → abs_ff_sptr

output[m] = abs(input[m]) for all M streams.

absolute value of data stream (Strip sign)

Constructor Specific Documentation:

Create an instance of abs_ff.

Parameters:vlen
abs_ff_sptr.active_thread_priority(abs_ff_sptr self) → int
abs_ff_sptr.declare_sample_delay(abs_ff_sptr self, int which, int delay)

declare_sample_delay(abs_ff_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(abs_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(abs_ff_sptr self) -> pmt_vector_float

abs_ff_sptr.pc_throughput_avg(abs_ff_sptr self) → float
abs_ff_sptr.pc_work_time_avg(abs_ff_sptr self) → float
abs_ff_sptr.pc_work_time_total(abs_ff_sptr self) → float
abs_ff_sptr.sample_delay(abs_ff_sptr self, int which) → unsigned int
abs_ff_sptr.set_min_noutput_items(abs_ff_sptr self, int m)
abs_ff_sptr.set_thread_priority(abs_ff_sptr self, int priority) → int
abs_ff_sptr.thread_priority(abs_ff_sptr self) → int
gnuradio.blocks.abs_ii(size_t vlen=1) → abs_ii_sptr

output[m] = abs(input[m]) for all M streams.

absolute value of data stream (Strip sign)

Constructor Specific Documentation:

Create an instance of abs_ii.

Parameters:vlen
abs_ii_sptr.active_thread_priority(abs_ii_sptr self) → int
abs_ii_sptr.declare_sample_delay(abs_ii_sptr self, int which, int delay)

declare_sample_delay(abs_ii_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(abs_ii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(abs_ii_sptr self) -> pmt_vector_float

abs_ii_sptr.pc_throughput_avg(abs_ii_sptr self) → float
abs_ii_sptr.pc_work_time_avg(abs_ii_sptr self) → float
abs_ii_sptr.pc_work_time_total(abs_ii_sptr self) → float
abs_ii_sptr.sample_delay(abs_ii_sptr self, int which) → unsigned int
abs_ii_sptr.set_min_noutput_items(abs_ii_sptr self, int m)
abs_ii_sptr.set_thread_priority(abs_ii_sptr self, int priority) → int
abs_ii_sptr.thread_priority(abs_ii_sptr self) → int
gnuradio.blocks.abs_ss(size_t vlen=1) → abs_ss_sptr

output[m] = abs(input[m]) for all M streams.

absolute value of data stream (Strip sign)

Constructor Specific Documentation:

Create an instance of abs_ss.

Parameters:vlen
abs_ss_sptr.active_thread_priority(abs_ss_sptr self) → int
abs_ss_sptr.declare_sample_delay(abs_ss_sptr self, int which, int delay)

declare_sample_delay(abs_ss_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(abs_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(abs_ss_sptr self) -> pmt_vector_float

abs_ss_sptr.pc_throughput_avg(abs_ss_sptr self) → float
abs_ss_sptr.pc_work_time_avg(abs_ss_sptr self) → float
abs_ss_sptr.pc_work_time_total(abs_ss_sptr self) → float
abs_ss_sptr.sample_delay(abs_ss_sptr self, int which) → unsigned int
abs_ss_sptr.set_min_noutput_items(abs_ss_sptr self, int m)
abs_ss_sptr.set_thread_priority(abs_ss_sptr self, int priority) → int
abs_ss_sptr.thread_priority(abs_ss_sptr self) → int
gnuradio.blocks.add_cc(size_t vlen=1) → add_cc_sptr

output = sum(input[0], input[1], ..., input[M-1])

Add samples across all input streams. For all samples on all input streams :

Constructor Specific Documentation:

Parameters:vlen
add_cc_sptr.active_thread_priority(add_cc_sptr self) → int
add_cc_sptr.declare_sample_delay(add_cc_sptr self, int which, int delay)

declare_sample_delay(add_cc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(add_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(add_cc_sptr self) -> pmt_vector_float

add_cc_sptr.pc_throughput_avg(add_cc_sptr self) → float
add_cc_sptr.pc_work_time_avg(add_cc_sptr self) → float
add_cc_sptr.pc_work_time_total(add_cc_sptr self) → float
add_cc_sptr.sample_delay(add_cc_sptr self, int which) → unsigned int
add_cc_sptr.set_min_noutput_items(add_cc_sptr self, int m)
add_cc_sptr.set_thread_priority(add_cc_sptr self, int priority) → int
add_cc_sptr.thread_priority(add_cc_sptr self) → int
gnuradio.blocks.add_const_bb(unsigned char k) → add_const_bb_sptr

output = input + constant

Constructor Specific Documentation:

Create an instance of add_const_bb.

Parameters:k – additive constant
add_const_bb_sptr.active_thread_priority(add_const_bb_sptr self) → int
add_const_bb_sptr.declare_sample_delay(add_const_bb_sptr self, int which, int delay)

declare_sample_delay(add_const_bb_sptr self, unsigned int delay)

add_const_bb_sptr.k(add_const_bb_sptr self) → unsigned char

Return additive constant.

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

pc_input_buffers_full_avg(add_const_bb_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(add_const_bb_sptr self) -> pmt_vector_float

add_const_bb_sptr.pc_throughput_avg(add_const_bb_sptr self) → float
add_const_bb_sptr.pc_work_time_avg(add_const_bb_sptr self) → float
add_const_bb_sptr.pc_work_time_total(add_const_bb_sptr self) → float
add_const_bb_sptr.sample_delay(add_const_bb_sptr self, int which) → unsigned int
add_const_bb_sptr.set_k(add_const_bb_sptr self, unsigned char k)

Set additive constant.

add_const_bb_sptr.set_min_noutput_items(add_const_bb_sptr self, int m)
add_const_bb_sptr.set_thread_priority(add_const_bb_sptr self, int priority) → int
add_const_bb_sptr.thread_priority(add_const_bb_sptr self) → int
gnuradio.blocks.add_const_cc(gr_complex k) → add_const_cc_sptr

output = input + constant

Constructor Specific Documentation:

Create an instance of add_const_cc.

Parameters:k – additive constant
add_const_cc_sptr.active_thread_priority(add_const_cc_sptr self) → int
add_const_cc_sptr.declare_sample_delay(add_const_cc_sptr self, int which, int delay)

declare_sample_delay(add_const_cc_sptr self, unsigned int delay)

add_const_cc_sptr.k(add_const_cc_sptr self) → gr_complex

Return additive constant.

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

pc_input_buffers_full_avg(add_const_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(add_const_cc_sptr self) -> pmt_vector_float

add_const_cc_sptr.pc_throughput_avg(add_const_cc_sptr self) → float
add_const_cc_sptr.pc_work_time_avg(add_const_cc_sptr self) → float
add_const_cc_sptr.pc_work_time_total(add_const_cc_sptr self) → float
add_const_cc_sptr.sample_delay(add_const_cc_sptr self, int which) → unsigned int
add_const_cc_sptr.set_k(add_const_cc_sptr self, gr_complex k)

Set additive constant.

add_const_cc_sptr.set_min_noutput_items(add_const_cc_sptr self, int m)
add_const_cc_sptr.set_thread_priority(add_const_cc_sptr self, int priority) → int
add_const_cc_sptr.thread_priority(add_const_cc_sptr self) → int
gnuradio.blocks.add_const_ff(float k) → add_const_ff_sptr

output = input + constant

Constructor Specific Documentation:

Create an instance of add_const_ff.

Parameters:k – additive constant
add_const_ff_sptr.active_thread_priority(add_const_ff_sptr self) → int
add_const_ff_sptr.declare_sample_delay(add_const_ff_sptr self, int which, int delay)

declare_sample_delay(add_const_ff_sptr self, unsigned int delay)

add_const_ff_sptr.k(add_const_ff_sptr self) → float

Return additive constant.

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

pc_input_buffers_full_avg(add_const_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(add_const_ff_sptr self) -> pmt_vector_float

add_const_ff_sptr.pc_throughput_avg(add_const_ff_sptr self) → float
add_const_ff_sptr.pc_work_time_avg(add_const_ff_sptr self) → float
add_const_ff_sptr.pc_work_time_total(add_const_ff_sptr self) → float
add_const_ff_sptr.sample_delay(add_const_ff_sptr self, int which) → unsigned int
add_const_ff_sptr.set_k(add_const_ff_sptr self, float k)

Set additive constant.

add_const_ff_sptr.set_min_noutput_items(add_const_ff_sptr self, int m)
add_const_ff_sptr.set_thread_priority(add_const_ff_sptr self, int priority) → int
add_const_ff_sptr.thread_priority(add_const_ff_sptr self) → int
gnuradio.blocks.add_const_ii(int k) → add_const_ii_sptr

output = input + constant

Constructor Specific Documentation:

Create an instance of add_const_ii.

Parameters:k – additive constant
add_const_ii_sptr.active_thread_priority(add_const_ii_sptr self) → int
add_const_ii_sptr.declare_sample_delay(add_const_ii_sptr self, int which, int delay)

declare_sample_delay(add_const_ii_sptr self, unsigned int delay)

add_const_ii_sptr.k(add_const_ii_sptr self) → int

Return additive constant.

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

pc_input_buffers_full_avg(add_const_ii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(add_const_ii_sptr self) -> pmt_vector_float

add_const_ii_sptr.pc_throughput_avg(add_const_ii_sptr self) → float
add_const_ii_sptr.pc_work_time_avg(add_const_ii_sptr self) → float
add_const_ii_sptr.pc_work_time_total(add_const_ii_sptr self) → float
add_const_ii_sptr.sample_delay(add_const_ii_sptr self, int which) → unsigned int
add_const_ii_sptr.set_k(add_const_ii_sptr self, int k)

Set additive constant.

add_const_ii_sptr.set_min_noutput_items(add_const_ii_sptr self, int m)
add_const_ii_sptr.set_thread_priority(add_const_ii_sptr self, int priority) → int
add_const_ii_sptr.thread_priority(add_const_ii_sptr self) → int
gnuradio.blocks.add_const_ss(short k) → add_const_ss_sptr

output = input + constant

Constructor Specific Documentation:

Create an instance of add_const_ss.

Parameters:k – additive constant
add_const_ss_sptr.active_thread_priority(add_const_ss_sptr self) → int
add_const_ss_sptr.declare_sample_delay(add_const_ss_sptr self, int which, int delay)

declare_sample_delay(add_const_ss_sptr self, unsigned int delay)

add_const_ss_sptr.k(add_const_ss_sptr self) → short

Return additive constant.

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

pc_input_buffers_full_avg(add_const_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(add_const_ss_sptr self) -> pmt_vector_float

add_const_ss_sptr.pc_throughput_avg(add_const_ss_sptr self) → float
add_const_ss_sptr.pc_work_time_avg(add_const_ss_sptr self) → float
add_const_ss_sptr.pc_work_time_total(add_const_ss_sptr self) → float
add_const_ss_sptr.sample_delay(add_const_ss_sptr self, int which) → unsigned int
add_const_ss_sptr.set_k(add_const_ss_sptr self, short k)

Set additive constant.

add_const_ss_sptr.set_min_noutput_items(add_const_ss_sptr self, int m)
add_const_ss_sptr.set_thread_priority(add_const_ss_sptr self, int priority) → int
add_const_ss_sptr.thread_priority(add_const_ss_sptr self) → int
gnuradio.blocks.add_const_vbb(std::vector< unsigned char, std::allocator< unsigned char > > k) → add_const_vbb_sptr

output[m] = input[m] + constant vector for all M streams.

Constructor Specific Documentation:

Create an instance of add_const_vbb.

Parameters:k – additive constant vector
add_const_vbb_sptr.active_thread_priority(add_const_vbb_sptr self) → int
add_const_vbb_sptr.declare_sample_delay(add_const_vbb_sptr self, int which, int delay)

declare_sample_delay(add_const_vbb_sptr self, unsigned int delay)

add_const_vbb_sptr.k(add_const_vbb_sptr self) → std::vector< unsigned char,std::allocator< unsigned char > >

Return additive constant vector.

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

pc_input_buffers_full_avg(add_const_vbb_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(add_const_vbb_sptr self) -> pmt_vector_float

add_const_vbb_sptr.pc_throughput_avg(add_const_vbb_sptr self) → float
add_const_vbb_sptr.pc_work_time_avg(add_const_vbb_sptr self) → float
add_const_vbb_sptr.pc_work_time_total(add_const_vbb_sptr self) → float
add_const_vbb_sptr.sample_delay(add_const_vbb_sptr self, int which) → unsigned int
add_const_vbb_sptr.set_k(add_const_vbb_sptr self, std::vector< unsigned char, std::allocator< unsigned char > > k)

Set additive constant vector.

add_const_vbb_sptr.set_min_noutput_items(add_const_vbb_sptr self, int m)
add_const_vbb_sptr.set_thread_priority(add_const_vbb_sptr self, int priority) → int
add_const_vbb_sptr.thread_priority(add_const_vbb_sptr self) → int
gnuradio.blocks.add_const_vcc(pmt_vector_cfloat k) → add_const_vcc_sptr

output[m] = input[m] + constant vector for all M streams.

Constructor Specific Documentation:

Create an instance of add_const_vcc.

Parameters:k – additive constant vector
add_const_vcc_sptr.active_thread_priority(add_const_vcc_sptr self) → int
add_const_vcc_sptr.declare_sample_delay(add_const_vcc_sptr self, int which, int delay)

declare_sample_delay(add_const_vcc_sptr self, unsigned int delay)

add_const_vcc_sptr.k(add_const_vcc_sptr self) → pmt_vector_cfloat

Return additive constant vector.

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

pc_input_buffers_full_avg(add_const_vcc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(add_const_vcc_sptr self) -> pmt_vector_float

add_const_vcc_sptr.pc_throughput_avg(add_const_vcc_sptr self) → float
add_const_vcc_sptr.pc_work_time_avg(add_const_vcc_sptr self) → float
add_const_vcc_sptr.pc_work_time_total(add_const_vcc_sptr self) → float
add_const_vcc_sptr.sample_delay(add_const_vcc_sptr self, int which) → unsigned int
add_const_vcc_sptr.set_k(add_const_vcc_sptr self, pmt_vector_cfloat k)

Set additive constant vector.

add_const_vcc_sptr.set_min_noutput_items(add_const_vcc_sptr self, int m)
add_const_vcc_sptr.set_thread_priority(add_const_vcc_sptr self, int priority) → int
add_const_vcc_sptr.thread_priority(add_const_vcc_sptr self) → int
gnuradio.blocks.add_const_vff(pmt_vector_float k) → add_const_vff_sptr

output[m] = input[m] + constant vector for all M streams.

Constructor Specific Documentation:

Create an instance of add_const_vff.

Parameters:k – additive constant vector
add_const_vff_sptr.active_thread_priority(add_const_vff_sptr self) → int
add_const_vff_sptr.declare_sample_delay(add_const_vff_sptr self, int which, int delay)

declare_sample_delay(add_const_vff_sptr self, unsigned int delay)

add_const_vff_sptr.k(add_const_vff_sptr self) → pmt_vector_float

Return additive constant vector.

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

pc_input_buffers_full_avg(add_const_vff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(add_const_vff_sptr self) -> pmt_vector_float

add_const_vff_sptr.pc_throughput_avg(add_const_vff_sptr self) → float
add_const_vff_sptr.pc_work_time_avg(add_const_vff_sptr self) → float
add_const_vff_sptr.pc_work_time_total(add_const_vff_sptr self) → float
add_const_vff_sptr.sample_delay(add_const_vff_sptr self, int which) → unsigned int
add_const_vff_sptr.set_k(add_const_vff_sptr self, pmt_vector_float k)

Set additive constant vector.

add_const_vff_sptr.set_min_noutput_items(add_const_vff_sptr self, int m)
add_const_vff_sptr.set_thread_priority(add_const_vff_sptr self, int priority) → int
add_const_vff_sptr.thread_priority(add_const_vff_sptr self) → int
gnuradio.blocks.add_const_vii(std::vector< int, std::allocator< int > > k) → add_const_vii_sptr

output[m] = input[m] + constant vector for all M streams.

Constructor Specific Documentation:

Create an instance of add_const_vii.

Parameters:k – additive constant vector
add_const_vii_sptr.active_thread_priority(add_const_vii_sptr self) → int
add_const_vii_sptr.declare_sample_delay(add_const_vii_sptr self, int which, int delay)

declare_sample_delay(add_const_vii_sptr self, unsigned int delay)

add_const_vii_sptr.k(add_const_vii_sptr self) → std::vector< int,std::allocator< int > >

Return additive constant vector.

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

pc_input_buffers_full_avg(add_const_vii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(add_const_vii_sptr self) -> pmt_vector_float

add_const_vii_sptr.pc_throughput_avg(add_const_vii_sptr self) → float
add_const_vii_sptr.pc_work_time_avg(add_const_vii_sptr self) → float
add_const_vii_sptr.pc_work_time_total(add_const_vii_sptr self) → float
add_const_vii_sptr.sample_delay(add_const_vii_sptr self, int which) → unsigned int
add_const_vii_sptr.set_k(add_const_vii_sptr self, std::vector< int, std::allocator< int > > k)

Set additive constant vector.

add_const_vii_sptr.set_min_noutput_items(add_const_vii_sptr self, int m)
add_const_vii_sptr.set_thread_priority(add_const_vii_sptr self, int priority) → int
add_const_vii_sptr.thread_priority(add_const_vii_sptr self) → int
gnuradio.blocks.add_const_vss(std::vector< short, std::allocator< short > > k) → add_const_vss_sptr

output[m] = input[m] + constant vector for all M streams.

Constructor Specific Documentation:

Create an instance of add_const_vss.

Parameters:k – additive constant vector
add_const_vss_sptr.active_thread_priority(add_const_vss_sptr self) → int
add_const_vss_sptr.declare_sample_delay(add_const_vss_sptr self, int which, int delay)

declare_sample_delay(add_const_vss_sptr self, unsigned int delay)

add_const_vss_sptr.k(add_const_vss_sptr self) → std::vector< short,std::allocator< short > >

Return additive constant vector.

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

pc_input_buffers_full_avg(add_const_vss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(add_const_vss_sptr self) -> pmt_vector_float

add_const_vss_sptr.pc_throughput_avg(add_const_vss_sptr self) → float
add_const_vss_sptr.pc_work_time_avg(add_const_vss_sptr self) → float
add_const_vss_sptr.pc_work_time_total(add_const_vss_sptr self) → float
add_const_vss_sptr.sample_delay(add_const_vss_sptr self, int which) → unsigned int
add_const_vss_sptr.set_k(add_const_vss_sptr self, std::vector< short, std::allocator< short > > k)

Set additive constant vector.

add_const_vss_sptr.set_min_noutput_items(add_const_vss_sptr self, int m)
add_const_vss_sptr.set_thread_priority(add_const_vss_sptr self, int priority) → int
add_const_vss_sptr.thread_priority(add_const_vss_sptr self) → int
gnuradio.blocks.add_ff(size_t vlen=1) → add_ff_sptr

output = sum (input_0, input_1, ...)

Add across all input streams.

Constructor Specific Documentation:

Add streams of float values.

Parameters:vlen – Vector length
add_ff_sptr.active_thread_priority(add_ff_sptr self) → int
add_ff_sptr.declare_sample_delay(add_ff_sptr self, int which, int delay)

declare_sample_delay(add_ff_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(add_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(add_ff_sptr self) -> pmt_vector_float

add_ff_sptr.pc_throughput_avg(add_ff_sptr self) → float
add_ff_sptr.pc_work_time_avg(add_ff_sptr self) → float
add_ff_sptr.pc_work_time_total(add_ff_sptr self) → float
add_ff_sptr.sample_delay(add_ff_sptr self, int which) → unsigned int
add_ff_sptr.set_min_noutput_items(add_ff_sptr self, int m)
add_ff_sptr.set_thread_priority(add_ff_sptr self, int priority) → int
add_ff_sptr.thread_priority(add_ff_sptr self) → int
gnuradio.blocks.add_ii(size_t vlen=1) → add_ii_sptr

output = sum(input[0], input[1], ..., input[M-1])

Add samples across all input streams. For all samples on all input streams :

Constructor Specific Documentation:

Parameters:vlen
add_ii_sptr.active_thread_priority(add_ii_sptr self) → int
add_ii_sptr.declare_sample_delay(add_ii_sptr self, int which, int delay)

declare_sample_delay(add_ii_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(add_ii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(add_ii_sptr self) -> pmt_vector_float

add_ii_sptr.pc_throughput_avg(add_ii_sptr self) → float
add_ii_sptr.pc_work_time_avg(add_ii_sptr self) → float
add_ii_sptr.pc_work_time_total(add_ii_sptr self) → float
add_ii_sptr.sample_delay(add_ii_sptr self, int which) → unsigned int
add_ii_sptr.set_min_noutput_items(add_ii_sptr self, int m)
add_ii_sptr.set_thread_priority(add_ii_sptr self, int priority) → int
add_ii_sptr.thread_priority(add_ii_sptr self) → int
gnuradio.blocks.add_ss(size_t vlen=1) → add_ss_sptr

output = sum(input[0], input[1], ..., input[M-1])

Add samples across all input streams. For all samples on all input streams :

Constructor Specific Documentation:

Parameters:vlen
add_ss_sptr.active_thread_priority(add_ss_sptr self) → int
add_ss_sptr.declare_sample_delay(add_ss_sptr self, int which, int delay)

declare_sample_delay(add_ss_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(add_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(add_ss_sptr self) -> pmt_vector_float

add_ss_sptr.pc_throughput_avg(add_ss_sptr self) → float
add_ss_sptr.pc_work_time_avg(add_ss_sptr self) → float
add_ss_sptr.pc_work_time_total(add_ss_sptr self) → float
add_ss_sptr.sample_delay(add_ss_sptr self, int which) → unsigned int
add_ss_sptr.set_min_noutput_items(add_ss_sptr self, int m)
add_ss_sptr.set_thread_priority(add_ss_sptr self, int priority) → int
add_ss_sptr.thread_priority(add_ss_sptr self) → int
gnuradio.blocks.and_bb(size_t vlen=1) → and_bb_sptr

output = input[0] & input[1] & ... & input[M-1]

bitwise boolean AND across all input streams.

Constructor Specific Documentation:

Parameters:vlen
and_bb_sptr.active_thread_priority(and_bb_sptr self) → int
and_bb_sptr.declare_sample_delay(and_bb_sptr self, int which, int delay)

declare_sample_delay(and_bb_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(and_bb_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(and_bb_sptr self) -> pmt_vector_float

and_bb_sptr.pc_throughput_avg(and_bb_sptr self) → float
and_bb_sptr.pc_work_time_avg(and_bb_sptr self) → float
and_bb_sptr.pc_work_time_total(and_bb_sptr self) → float
and_bb_sptr.sample_delay(and_bb_sptr self, int which) → unsigned int
and_bb_sptr.set_min_noutput_items(and_bb_sptr self, int m)
and_bb_sptr.set_thread_priority(and_bb_sptr self, int priority) → int
and_bb_sptr.thread_priority(and_bb_sptr self) → int
gnuradio.blocks.and_const_bb(unsigned char k) → and_const_bb_sptr

output[m] = input[m] & value for all M streams.

Bitwise boolean AND of constant with the data stream.

Constructor Specific Documentation:

Create an instance of and_const_bb.

Parameters:k – AND constant
and_const_bb_sptr.active_thread_priority(and_const_bb_sptr self) → int
and_const_bb_sptr.declare_sample_delay(and_const_bb_sptr self, int which, int delay)

declare_sample_delay(and_const_bb_sptr self, unsigned int delay)

and_const_bb_sptr.k(and_const_bb_sptr self) → unsigned char

Return AND constant.

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

pc_input_buffers_full_avg(and_const_bb_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(and_const_bb_sptr self) -> pmt_vector_float

and_const_bb_sptr.pc_throughput_avg(and_const_bb_sptr self) → float
and_const_bb_sptr.pc_work_time_avg(and_const_bb_sptr self) → float
and_const_bb_sptr.pc_work_time_total(and_const_bb_sptr self) → float
and_const_bb_sptr.sample_delay(and_const_bb_sptr self, int which) → unsigned int
and_const_bb_sptr.set_k(and_const_bb_sptr self, unsigned char k)

Set AND constant.

and_const_bb_sptr.set_min_noutput_items(and_const_bb_sptr self, int m)
and_const_bb_sptr.set_thread_priority(and_const_bb_sptr self, int priority) → int
and_const_bb_sptr.thread_priority(and_const_bb_sptr self) → int
gnuradio.blocks.and_const_ii(int k) → and_const_ii_sptr

output[m] = input[m] & value for all M streams.

Bitwise boolean AND of constant with the data stream.

Constructor Specific Documentation:

Create an instance of and_const_ii.

Parameters:k – AND constant
and_const_ii_sptr.active_thread_priority(and_const_ii_sptr self) → int
and_const_ii_sptr.declare_sample_delay(and_const_ii_sptr self, int which, int delay)

declare_sample_delay(and_const_ii_sptr self, unsigned int delay)

and_const_ii_sptr.k(and_const_ii_sptr self) → int

Return AND constant.

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

pc_input_buffers_full_avg(and_const_ii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(and_const_ii_sptr self) -> pmt_vector_float

and_const_ii_sptr.pc_throughput_avg(and_const_ii_sptr self) → float
and_const_ii_sptr.pc_work_time_avg(and_const_ii_sptr self) → float
and_const_ii_sptr.pc_work_time_total(and_const_ii_sptr self) → float
and_const_ii_sptr.sample_delay(and_const_ii_sptr self, int which) → unsigned int
and_const_ii_sptr.set_k(and_const_ii_sptr self, int k)

Set AND constant.

and_const_ii_sptr.set_min_noutput_items(and_const_ii_sptr self, int m)
and_const_ii_sptr.set_thread_priority(and_const_ii_sptr self, int priority) → int
and_const_ii_sptr.thread_priority(and_const_ii_sptr self) → int
gnuradio.blocks.and_const_ss(short k) → and_const_ss_sptr

output[m] = input[m] & value for all M streams.

Bitwise boolean AND of constant with the data stream.

Constructor Specific Documentation:

Create an instance of and_const_ss.

Parameters:k – AND constant
and_const_ss_sptr.active_thread_priority(and_const_ss_sptr self) → int
and_const_ss_sptr.declare_sample_delay(and_const_ss_sptr self, int which, int delay)

declare_sample_delay(and_const_ss_sptr self, unsigned int delay)

and_const_ss_sptr.k(and_const_ss_sptr self) → short

Return AND constant.

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

pc_input_buffers_full_avg(and_const_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(and_const_ss_sptr self) -> pmt_vector_float

and_const_ss_sptr.pc_throughput_avg(and_const_ss_sptr self) → float
and_const_ss_sptr.pc_work_time_avg(and_const_ss_sptr self) → float
and_const_ss_sptr.pc_work_time_total(and_const_ss_sptr self) → float
and_const_ss_sptr.sample_delay(and_const_ss_sptr self, int which) → unsigned int
and_const_ss_sptr.set_k(and_const_ss_sptr self, short k)

Set AND constant.

and_const_ss_sptr.set_min_noutput_items(and_const_ss_sptr self, int m)
and_const_ss_sptr.set_thread_priority(and_const_ss_sptr self, int priority) → int
and_const_ss_sptr.thread_priority(and_const_ss_sptr self) → int
gnuradio.blocks.and_ii(size_t vlen=1) → and_ii_sptr

output = input[0] & input[1] & ... & input[M-1]

bitwise boolean AND across all input streams.

Constructor Specific Documentation:

Parameters:vlen
and_ii_sptr.active_thread_priority(and_ii_sptr self) → int
and_ii_sptr.declare_sample_delay(and_ii_sptr self, int which, int delay)

declare_sample_delay(and_ii_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(and_ii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(and_ii_sptr self) -> pmt_vector_float

and_ii_sptr.pc_throughput_avg(and_ii_sptr self) → float
and_ii_sptr.pc_work_time_avg(and_ii_sptr self) → float
and_ii_sptr.pc_work_time_total(and_ii_sptr self) → float
and_ii_sptr.sample_delay(and_ii_sptr self, int which) → unsigned int
and_ii_sptr.set_min_noutput_items(and_ii_sptr self, int m)
and_ii_sptr.set_thread_priority(and_ii_sptr self, int priority) → int
and_ii_sptr.thread_priority(and_ii_sptr self) → int
gnuradio.blocks.and_ss(size_t vlen=1) → and_ss_sptr

output = input[0] & input[1] & ... & input[M-1]

bitwise boolean AND across all input streams.

Constructor Specific Documentation:

Parameters:vlen
and_ss_sptr.active_thread_priority(and_ss_sptr self) → int
and_ss_sptr.declare_sample_delay(and_ss_sptr self, int which, int delay)

declare_sample_delay(and_ss_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(and_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(and_ss_sptr self) -> pmt_vector_float

and_ss_sptr.pc_throughput_avg(and_ss_sptr self) → float
and_ss_sptr.pc_work_time_avg(and_ss_sptr self) → float
and_ss_sptr.pc_work_time_total(and_ss_sptr self) → float
and_ss_sptr.sample_delay(and_ss_sptr self, int which) → unsigned int
and_ss_sptr.set_min_noutput_items(and_ss_sptr self, int m)
and_ss_sptr.set_thread_priority(and_ss_sptr self, int priority) → int
and_ss_sptr.thread_priority(and_ss_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.argmax_fs(size_t vlen) → argmax_fs_sptr

Compares vectors from multiple streams and determines the index in the vector and stream number where the maximum value occurred.

Data is passed in as a vector of length from multiple input sources. It will look through these streams of data items and output two streams:

Constructor Specific Documentation:

Parameters:vlen
argmax_fs_sptr.active_thread_priority(argmax_fs_sptr self) → int
argmax_fs_sptr.declare_sample_delay(argmax_fs_sptr self, int which, int delay)

declare_sample_delay(argmax_fs_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(argmax_fs_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(argmax_fs_sptr self) -> pmt_vector_float

argmax_fs_sptr.pc_throughput_avg(argmax_fs_sptr self) → float
argmax_fs_sptr.pc_work_time_avg(argmax_fs_sptr self) → float
argmax_fs_sptr.pc_work_time_total(argmax_fs_sptr self) → float
argmax_fs_sptr.sample_delay(argmax_fs_sptr self, int which) → unsigned int
argmax_fs_sptr.set_min_noutput_items(argmax_fs_sptr self, int m)
argmax_fs_sptr.set_thread_priority(argmax_fs_sptr self, int priority) → int
argmax_fs_sptr.thread_priority(argmax_fs_sptr self) → int
gnuradio.blocks.argmax_is(size_t vlen) → argmax_is_sptr

Compares vectors from multiple streams and determines the index in the vector and stream number where the maximum value occurred.

Data is passed in as a vector of length from multiple input sources. It will look through these streams of data items and output two streams:

Constructor Specific Documentation:

Parameters:vlen
argmax_is_sptr.active_thread_priority(argmax_is_sptr self) → int
argmax_is_sptr.declare_sample_delay(argmax_is_sptr self, int which, int delay)

declare_sample_delay(argmax_is_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(argmax_is_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(argmax_is_sptr self) -> pmt_vector_float

argmax_is_sptr.pc_throughput_avg(argmax_is_sptr self) → float
argmax_is_sptr.pc_work_time_avg(argmax_is_sptr self) → float
argmax_is_sptr.pc_work_time_total(argmax_is_sptr self) → float
argmax_is_sptr.sample_delay(argmax_is_sptr self, int which) → unsigned int
argmax_is_sptr.set_min_noutput_items(argmax_is_sptr self, int m)
argmax_is_sptr.set_thread_priority(argmax_is_sptr self, int priority) → int
argmax_is_sptr.thread_priority(argmax_is_sptr self) → int
gnuradio.blocks.argmax_ss(size_t vlen) → argmax_ss_sptr

Compares vectors from multiple streams and determines the index in the vector and stream number where the maximum value occurred.

Data is passed in as a vector of length from multiple input sources. It will look through these streams of data items and output two streams:

Constructor Specific Documentation:

Parameters:vlen
argmax_ss_sptr.active_thread_priority(argmax_ss_sptr self) → int
argmax_ss_sptr.declare_sample_delay(argmax_ss_sptr self, int which, int delay)

declare_sample_delay(argmax_ss_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(argmax_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(argmax_ss_sptr self) -> pmt_vector_float

argmax_ss_sptr.pc_throughput_avg(argmax_ss_sptr self) → float
argmax_ss_sptr.pc_work_time_avg(argmax_ss_sptr self) → float
argmax_ss_sptr.pc_work_time_total(argmax_ss_sptr self) → float
argmax_ss_sptr.sample_delay(argmax_ss_sptr self, int which) → unsigned int
argmax_ss_sptr.set_min_noutput_items(argmax_ss_sptr self, int m)
argmax_ss_sptr.set_thread_priority(argmax_ss_sptr self, int priority) → int
argmax_ss_sptr.thread_priority(argmax_ss_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.burst_tagger(size_t itemsize) → burst_tagger_sptr

Sets a burst on/off tag based on the value of the trigger input.

This block takes two inputs, a signal stream on the input stream 0 and a trigger stream of shorts on input stream 1. If the trigger stream goes above 0, a tag with the key “burst” will be transmitted as a pmt::PMT_T. When the trigger signal falls below 0, the “burst” tag will be transmitted as pmt::PMT_F.

The signal on stream 0 is retransmitted to output stream 0.

Constructor Specific Documentation:

Build a burst tagger gnuradio/blocks.

Parameters:itemsize – itemsize of the signal stream on input 0.
burst_tagger_sptr.active_thread_priority(burst_tagger_sptr self) → int
burst_tagger_sptr.declare_sample_delay(burst_tagger_sptr self, int which, int delay)

declare_sample_delay(burst_tagger_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(burst_tagger_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(burst_tagger_sptr self) -> pmt_vector_float

burst_tagger_sptr.pc_throughput_avg(burst_tagger_sptr self) → float
burst_tagger_sptr.pc_work_time_avg(burst_tagger_sptr self) → float
burst_tagger_sptr.pc_work_time_total(burst_tagger_sptr self) → float
burst_tagger_sptr.sample_delay(burst_tagger_sptr self, int which) → unsigned int
burst_tagger_sptr.set_false_tag(burst_tagger_sptr self, std::string const & key, bool value)

For the false burst tag, change the key name to and a new value of .

burst_tagger_sptr.set_min_noutput_items(burst_tagger_sptr self, int m)
burst_tagger_sptr.set_thread_priority(burst_tagger_sptr self, int priority) → int
burst_tagger_sptr.set_true_tag(burst_tagger_sptr self, std::string const & key, bool value)

For the true burst tag, change the key name to and a new value of .

burst_tagger_sptr.thread_priority(burst_tagger_sptr self) → int
gnuradio.blocks.char_to_float(size_t vlen=1, float scale=1.0) → char_to_float_sptr

Convert stream of chars to a stream of float.

Converts length vectors of input char samples to floats and applies a scaling factor of

Constructor Specific Documentation:

Build a chars to float stream converter block.

Parameters:
  • vlen – vector length of data streams.
  • scale – a scalar divider to change the output signal scale.
char_to_float_sptr.active_thread_priority(char_to_float_sptr self) → int
char_to_float_sptr.declare_sample_delay(char_to_float_sptr self, int which, int delay)

declare_sample_delay(char_to_float_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(char_to_float_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(char_to_float_sptr self) -> pmt_vector_float

char_to_float_sptr.pc_throughput_avg(char_to_float_sptr self) → float
char_to_float_sptr.pc_work_time_avg(char_to_float_sptr self) → float
char_to_float_sptr.pc_work_time_total(char_to_float_sptr self) → float
char_to_float_sptr.sample_delay(char_to_float_sptr self, int which) → unsigned int
char_to_float_sptr.scale(char_to_float_sptr self) → float

Get the scalar divider value.

char_to_float_sptr.set_min_noutput_items(char_to_float_sptr self, int m)
char_to_float_sptr.set_scale(char_to_float_sptr self, float scale)

Set the scalar divider value.

char_to_float_sptr.set_thread_priority(char_to_float_sptr self, int priority) → int
char_to_float_sptr.thread_priority(char_to_float_sptr self) → int
gnuradio.blocks.char_to_short(size_t vlen=1) → char_to_short_sptr

Convert stream of chars to a stream of shorts.

Converts length vectors of input char samples to shorts, multiplying each element by 256:

Constructor Specific Documentation:

Parameters:vlen
char_to_short_sptr.active_thread_priority(char_to_short_sptr self) → int
char_to_short_sptr.declare_sample_delay(char_to_short_sptr self, int which, int delay)

declare_sample_delay(char_to_short_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(char_to_short_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(char_to_short_sptr self) -> pmt_vector_float

char_to_short_sptr.pc_throughput_avg(char_to_short_sptr self) → float
char_to_short_sptr.pc_work_time_avg(char_to_short_sptr self) → float
char_to_short_sptr.pc_work_time_total(char_to_short_sptr self) → float
char_to_short_sptr.sample_delay(char_to_short_sptr self, int which) → unsigned int
char_to_short_sptr.set_min_noutput_items(char_to_short_sptr self, int m)
char_to_short_sptr.set_thread_priority(char_to_short_sptr self, int priority) → int
char_to_short_sptr.thread_priority(char_to_short_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.complex_to_arg(size_t vlen=1) → complex_to_arg_sptr

complex in, arg (arctan) out (float)

Constructor Specific Documentation:

Build a complex to arg block.

Parameters:vlen – vector len (default 1)
complex_to_arg_sptr.active_thread_priority(complex_to_arg_sptr self) → int
complex_to_arg_sptr.declare_sample_delay(complex_to_arg_sptr self, int which, int delay)

declare_sample_delay(complex_to_arg_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(complex_to_arg_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(complex_to_arg_sptr self) -> pmt_vector_float

complex_to_arg_sptr.pc_throughput_avg(complex_to_arg_sptr self) → float
complex_to_arg_sptr.pc_work_time_avg(complex_to_arg_sptr self) → float
complex_to_arg_sptr.pc_work_time_total(complex_to_arg_sptr self) → float
complex_to_arg_sptr.sample_delay(complex_to_arg_sptr self, int which) → unsigned int
complex_to_arg_sptr.set_min_noutput_items(complex_to_arg_sptr self, int m)
complex_to_arg_sptr.set_thread_priority(complex_to_arg_sptr self, int priority) → int
complex_to_arg_sptr.thread_priority(complex_to_arg_sptr self) → int
gnuradio.blocks.complex_to_float(size_t vlen=1) → complex_to_float_sptr

Convert a stream of gr_complex to 1 or 2 streams of float.

If a single output stream is attached, this will output the real part of the input complex samples. If a second output stream is connected, output[0] is the real part and output[1] is the imaginary part.

Constructor Specific Documentation:

Build a complex to float block.

Parameters:vlen – vector len (default 1)
complex_to_float_sptr.active_thread_priority(complex_to_float_sptr self) → int
complex_to_float_sptr.declare_sample_delay(complex_to_float_sptr self, int which, int delay)

declare_sample_delay(complex_to_float_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(complex_to_float_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(complex_to_float_sptr self) -> pmt_vector_float

complex_to_float_sptr.pc_throughput_avg(complex_to_float_sptr self) → float
complex_to_float_sptr.pc_work_time_avg(complex_to_float_sptr self) → float
complex_to_float_sptr.pc_work_time_total(complex_to_float_sptr self) → float
complex_to_float_sptr.sample_delay(complex_to_float_sptr self, int which) → unsigned int
complex_to_float_sptr.set_min_noutput_items(complex_to_float_sptr self, int m)
complex_to_float_sptr.set_thread_priority(complex_to_float_sptr self, int priority) → int
complex_to_float_sptr.thread_priority(complex_to_float_sptr self) → int
gnuradio.blocks.complex_to_imag(size_t vlen=1) → complex_to_imag_sptr

Produces the imaginary part (as a float0 of a complex stream.

Constructor Specific Documentation:

Build a complex to imaginary part block.

Parameters:vlen – vector len (default 1)
complex_to_imag_sptr.active_thread_priority(complex_to_imag_sptr self) → int
complex_to_imag_sptr.declare_sample_delay(complex_to_imag_sptr self, int which, int delay)

declare_sample_delay(complex_to_imag_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(complex_to_imag_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(complex_to_imag_sptr self) -> pmt_vector_float

complex_to_imag_sptr.pc_throughput_avg(complex_to_imag_sptr self) → float
complex_to_imag_sptr.pc_work_time_avg(complex_to_imag_sptr self) → float
complex_to_imag_sptr.pc_work_time_total(complex_to_imag_sptr self) → float
complex_to_imag_sptr.sample_delay(complex_to_imag_sptr self, int which) → unsigned int
complex_to_imag_sptr.set_min_noutput_items(complex_to_imag_sptr self, int m)
complex_to_imag_sptr.set_thread_priority(complex_to_imag_sptr self, int priority) → int
complex_to_imag_sptr.thread_priority(complex_to_imag_sptr self) → int
gnuradio.blocks.complex_to_interleaved_short(bool vector=False) → complex_to_interleaved_short_sptr

Convert stream of complex to a stream of interleaved shorts.

The output stream contains shorts with twice as many output items as input items. For every complex input item, we produce two output shorts that contain the real part and imaginary part converted to shorts:

Constructor Specific Documentation:

Build a complex to interleaved shorts block.

Parameters:vector
complex_to_interleaved_short_sptr.active_thread_priority(complex_to_interleaved_short_sptr self) → int
complex_to_interleaved_short_sptr.declare_sample_delay(complex_to_interleaved_short_sptr self, int which, int delay)

declare_sample_delay(complex_to_interleaved_short_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(complex_to_interleaved_short_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(complex_to_interleaved_short_sptr self) -> pmt_vector_float

complex_to_interleaved_short_sptr.pc_throughput_avg(complex_to_interleaved_short_sptr self) → float
complex_to_interleaved_short_sptr.pc_work_time_avg(complex_to_interleaved_short_sptr self) → float
complex_to_interleaved_short_sptr.pc_work_time_total(complex_to_interleaved_short_sptr self) → float
complex_to_interleaved_short_sptr.sample_delay(complex_to_interleaved_short_sptr self, int which) → unsigned int
complex_to_interleaved_short_sptr.set_min_noutput_items(complex_to_interleaved_short_sptr self, int m)
complex_to_interleaved_short_sptr.set_thread_priority(complex_to_interleaved_short_sptr self, int priority) → int
complex_to_interleaved_short_sptr.thread_priority(complex_to_interleaved_short_sptr self) → int
gnuradio.blocks.complex_to_mag(size_t vlen=1) → complex_to_mag_sptr

complex in, magnitude out (float)

Calculates the magnitude of the complex samples:

Or: The input stream can be a vector of length , and for each vector, each item is converted using the above function. So above, m is from 0 to noutput_items*vlen for each call to work.

Constructor Specific Documentation:

Build a complex to magnitude block.

Parameters:vlen – vector len (default 1)
complex_to_mag_sptr.active_thread_priority(complex_to_mag_sptr self) → int
complex_to_mag_sptr.declare_sample_delay(complex_to_mag_sptr self, int which, int delay)

declare_sample_delay(complex_to_mag_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(complex_to_mag_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(complex_to_mag_sptr self) -> pmt_vector_float

complex_to_mag_sptr.pc_throughput_avg(complex_to_mag_sptr self) → float
complex_to_mag_sptr.pc_work_time_avg(complex_to_mag_sptr self) → float
complex_to_mag_sptr.pc_work_time_total(complex_to_mag_sptr self) → float
complex_to_mag_sptr.sample_delay(complex_to_mag_sptr self, int which) → unsigned int
complex_to_mag_sptr.set_min_noutput_items(complex_to_mag_sptr self, int m)
complex_to_mag_sptr.set_thread_priority(complex_to_mag_sptr self, int priority) → int
complex_to_mag_sptr.thread_priority(complex_to_mag_sptr self) → int
gnuradio.blocks.complex_to_mag_squared(size_t vlen=1) → complex_to_mag_squared_sptr

complex in, magnitude squared out (float)

Calculates the magnitude squared of the complex samples:

Or: The input stream can be a vector of length , and for each vector, each item is converted using the above function. So above, m is from 0 to noutput_items*vlen for each call to work.

Constructor Specific Documentation:

Build a complex to magnitude squared block.

Parameters:vlen – vector len (default 1)
complex_to_mag_squared_sptr.active_thread_priority(complex_to_mag_squared_sptr self) → int
complex_to_mag_squared_sptr.declare_sample_delay(complex_to_mag_squared_sptr self, int which, int delay)

declare_sample_delay(complex_to_mag_squared_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(complex_to_mag_squared_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(complex_to_mag_squared_sptr self) -> pmt_vector_float

complex_to_mag_squared_sptr.pc_throughput_avg(complex_to_mag_squared_sptr self) → float
complex_to_mag_squared_sptr.pc_work_time_avg(complex_to_mag_squared_sptr self) → float
complex_to_mag_squared_sptr.pc_work_time_total(complex_to_mag_squared_sptr self) → float
complex_to_mag_squared_sptr.sample_delay(complex_to_mag_squared_sptr self, int which) → unsigned int
complex_to_mag_squared_sptr.set_min_noutput_items(complex_to_mag_squared_sptr self, int m)
complex_to_mag_squared_sptr.set_thread_priority(complex_to_mag_squared_sptr self, int priority) → int
complex_to_mag_squared_sptr.thread_priority(complex_to_mag_squared_sptr self) → int
gnuradio.blocks.complex_to_real(size_t vlen=1) → complex_to_real_sptr

Produces the real part (as a float0 of a complex stream.

Constructor Specific Documentation:

Build a complex to real part block.

Parameters:vlen – vector len (default 1)
complex_to_real_sptr.active_thread_priority(complex_to_real_sptr self) → int
complex_to_real_sptr.declare_sample_delay(complex_to_real_sptr self, int which, int delay)

declare_sample_delay(complex_to_real_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(complex_to_real_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(complex_to_real_sptr self) -> pmt_vector_float

complex_to_real_sptr.pc_throughput_avg(complex_to_real_sptr self) → float
complex_to_real_sptr.pc_work_time_avg(complex_to_real_sptr self) → float
complex_to_real_sptr.pc_work_time_total(complex_to_real_sptr self) → float
complex_to_real_sptr.sample_delay(complex_to_real_sptr self, int which) → unsigned int
complex_to_real_sptr.set_min_noutput_items(complex_to_real_sptr self, int m)
complex_to_real_sptr.set_thread_priority(complex_to_real_sptr self, int priority) → int
complex_to_real_sptr.thread_priority(complex_to_real_sptr self) → int
gnuradio.blocks.conjugate_cc() → conjugate_cc_sptr

output = complex conjugate of input

Constructor Specific Documentation:

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

declare_sample_delay(conjugate_cc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(conjugate_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(conjugate_cc_sptr self) -> pmt_vector_float

conjugate_cc_sptr.pc_throughput_avg(conjugate_cc_sptr self) → float
conjugate_cc_sptr.pc_work_time_avg(conjugate_cc_sptr self) → float
conjugate_cc_sptr.pc_work_time_total(conjugate_cc_sptr self) → float
conjugate_cc_sptr.sample_delay(conjugate_cc_sptr self, int which) → unsigned int
conjugate_cc_sptr.set_min_noutput_items(conjugate_cc_sptr self, int m)
conjugate_cc_sptr.set_thread_priority(conjugate_cc_sptr self, int priority) → int
conjugate_cc_sptr.thread_priority(conjugate_cc_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.ctrlport_probe2_b(std::string const & id, std::string const & desc, int len, unsigned int disp_mask) → ctrlport_probe2_b_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_b_sptr.active_thread_priority(ctrlport_probe2_b_sptr self) → int
ctrlport_probe2_b_sptr.declare_sample_delay(ctrlport_probe2_b_sptr self, int which, int delay)

declare_sample_delay(ctrlport_probe2_b_sptr self, unsigned int delay)

ctrlport_probe2_b_sptr.get(ctrlport_probe2_b_sptr self) → std::vector< signed char,std::allocator< signed char > >
ctrlport_probe2_b_sptr.message_subscribers(ctrlport_probe2_b_sptr self, swig_int_ptr which_port) → swig_int_ptr
ctrlport_probe2_b_sptr.min_noutput_items(ctrlport_probe2_b_sptr self) → int
ctrlport_probe2_b_sptr.pc_input_buffers_full_avg(ctrlport_probe2_b_sptr self, int which) → float

pc_input_buffers_full_avg(ctrlport_probe2_b_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(ctrlport_probe2_b_sptr self) -> pmt_vector_float

ctrlport_probe2_b_sptr.pc_throughput_avg(ctrlport_probe2_b_sptr self) → float
ctrlport_probe2_b_sptr.pc_work_time_avg(ctrlport_probe2_b_sptr self) → float
ctrlport_probe2_b_sptr.pc_work_time_total(ctrlport_probe2_b_sptr self) → float
ctrlport_probe2_b_sptr.sample_delay(ctrlport_probe2_b_sptr self, int which) → unsigned int
ctrlport_probe2_b_sptr.set_length(ctrlport_probe2_b_sptr self, int len)
ctrlport_probe2_b_sptr.set_min_noutput_items(ctrlport_probe2_b_sptr self, int m)
ctrlport_probe2_b_sptr.set_thread_priority(ctrlport_probe2_b_sptr self, int priority) → int
ctrlport_probe2_b_sptr.thread_priority(ctrlport_probe2_b_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_throughput_avg(ctrlport_probe2_c_sptr self) → 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_probe2_f(std::string const & id, std::string const & desc, int len, unsigned int disp_mask) → ctrlport_probe2_f_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_f_sptr.active_thread_priority(ctrlport_probe2_f_sptr self) → int
ctrlport_probe2_f_sptr.declare_sample_delay(ctrlport_probe2_f_sptr self, int which, int delay)

declare_sample_delay(ctrlport_probe2_f_sptr self, unsigned int delay)

ctrlport_probe2_f_sptr.get(ctrlport_probe2_f_sptr self) → pmt_vector_float
ctrlport_probe2_f_sptr.message_subscribers(ctrlport_probe2_f_sptr self, swig_int_ptr which_port) → swig_int_ptr
ctrlport_probe2_f_sptr.min_noutput_items(ctrlport_probe2_f_sptr self) → int
ctrlport_probe2_f_sptr.pc_input_buffers_full_avg(ctrlport_probe2_f_sptr self, int which) → float

pc_input_buffers_full_avg(ctrlport_probe2_f_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(ctrlport_probe2_f_sptr self) -> pmt_vector_float

ctrlport_probe2_f_sptr.pc_throughput_avg(ctrlport_probe2_f_sptr self) → float
ctrlport_probe2_f_sptr.pc_work_time_avg(ctrlport_probe2_f_sptr self) → float
ctrlport_probe2_f_sptr.pc_work_time_total(ctrlport_probe2_f_sptr self) → float
ctrlport_probe2_f_sptr.sample_delay(ctrlport_probe2_f_sptr self, int which) → unsigned int
ctrlport_probe2_f_sptr.set_length(ctrlport_probe2_f_sptr self, int len)
ctrlport_probe2_f_sptr.set_min_noutput_items(ctrlport_probe2_f_sptr self, int m)
ctrlport_probe2_f_sptr.set_thread_priority(ctrlport_probe2_f_sptr self, int priority) → int
ctrlport_probe2_f_sptr.thread_priority(ctrlport_probe2_f_sptr self) → int
gnuradio.blocks.ctrlport_probe2_i(std::string const & id, std::string const & desc, int len, unsigned int disp_mask) → ctrlport_probe2_i_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_i_sptr.active_thread_priority(ctrlport_probe2_i_sptr self) → int
ctrlport_probe2_i_sptr.declare_sample_delay(ctrlport_probe2_i_sptr self, int which, int delay)

declare_sample_delay(ctrlport_probe2_i_sptr self, unsigned int delay)

ctrlport_probe2_i_sptr.get(ctrlport_probe2_i_sptr self) → std::vector< int,std::allocator< int > >
ctrlport_probe2_i_sptr.message_subscribers(ctrlport_probe2_i_sptr self, swig_int_ptr which_port) → swig_int_ptr
ctrlport_probe2_i_sptr.min_noutput_items(ctrlport_probe2_i_sptr self) → int
ctrlport_probe2_i_sptr.pc_input_buffers_full_avg(ctrlport_probe2_i_sptr self, int which) → float

pc_input_buffers_full_avg(ctrlport_probe2_i_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(ctrlport_probe2_i_sptr self) -> pmt_vector_float

ctrlport_probe2_i_sptr.pc_throughput_avg(ctrlport_probe2_i_sptr self) → float
ctrlport_probe2_i_sptr.pc_work_time_avg(ctrlport_probe2_i_sptr self) → float
ctrlport_probe2_i_sptr.pc_work_time_total(ctrlport_probe2_i_sptr self) → float
ctrlport_probe2_i_sptr.sample_delay(ctrlport_probe2_i_sptr self, int which) → unsigned int
ctrlport_probe2_i_sptr.set_length(ctrlport_probe2_i_sptr self, int len)
ctrlport_probe2_i_sptr.set_min_noutput_items(ctrlport_probe2_i_sptr self, int m)
ctrlport_probe2_i_sptr.set_thread_priority(ctrlport_probe2_i_sptr self, int priority) → int
ctrlport_probe2_i_sptr.thread_priority(ctrlport_probe2_i_sptr self) → int
gnuradio.blocks.ctrlport_probe2_s(std::string const & id, std::string const & desc, int len, unsigned int disp_mask) → ctrlport_probe2_s_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_s_sptr.active_thread_priority(ctrlport_probe2_s_sptr self) → int
ctrlport_probe2_s_sptr.declare_sample_delay(ctrlport_probe2_s_sptr self, int which, int delay)

declare_sample_delay(ctrlport_probe2_s_sptr self, unsigned int delay)

ctrlport_probe2_s_sptr.get(ctrlport_probe2_s_sptr self) → std::vector< short,std::allocator< short > >
ctrlport_probe2_s_sptr.message_subscribers(ctrlport_probe2_s_sptr self, swig_int_ptr which_port) → swig_int_ptr
ctrlport_probe2_s_sptr.min_noutput_items(ctrlport_probe2_s_sptr self) → int
ctrlport_probe2_s_sptr.pc_input_buffers_full_avg(ctrlport_probe2_s_sptr self, int which) → float

pc_input_buffers_full_avg(ctrlport_probe2_s_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(ctrlport_probe2_s_sptr self) -> pmt_vector_float

ctrlport_probe2_s_sptr.pc_throughput_avg(ctrlport_probe2_s_sptr self) → float
ctrlport_probe2_s_sptr.pc_work_time_avg(ctrlport_probe2_s_sptr self) → float
ctrlport_probe2_s_sptr.pc_work_time_total(ctrlport_probe2_s_sptr self) → float
ctrlport_probe2_s_sptr.sample_delay(ctrlport_probe2_s_sptr self, int which) → unsigned int
ctrlport_probe2_s_sptr.set_length(ctrlport_probe2_s_sptr self, int len)
ctrlport_probe2_s_sptr.set_min_noutput_items(ctrlport_probe2_s_sptr self, int m)
ctrlport_probe2_s_sptr.set_thread_priority(ctrlport_probe2_s_sptr self, int priority) → int
ctrlport_probe2_s_sptr.thread_priority(ctrlport_probe2_s_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_throughput_avg(ctrlport_probe_c_sptr self) → 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.deinterleave(size_t itemsize, unsigned int blocksize=1) → deinterleave_sptr

deinterleave an input block of samples into N outputs.

This block deinterleaves blocks of samples. For each output connection, the input stream will be deinterleaved successively to the output connections. By default, the block deinterleaves a single input to each output unless blocksize is given in the constructor.

Constructor Specific Documentation:

Make a deinterleave block.

Parameters:
  • itemsize – stream itemsize
  • blocksize – size of block to deinterleave
deinterleave_sptr.active_thread_priority(deinterleave_sptr self) → int
deinterleave_sptr.declare_sample_delay(deinterleave_sptr self, int which, int delay)

declare_sample_delay(deinterleave_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(deinterleave_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(deinterleave_sptr self) -> pmt_vector_float

deinterleave_sptr.pc_throughput_avg(deinterleave_sptr self) → float
deinterleave_sptr.pc_work_time_avg(deinterleave_sptr self) → float
deinterleave_sptr.pc_work_time_total(deinterleave_sptr self) → float
deinterleave_sptr.sample_delay(deinterleave_sptr self, int which) → unsigned int
deinterleave_sptr.set_min_noutput_items(deinterleave_sptr self, int m)
deinterleave_sptr.set_thread_priority(deinterleave_sptr self, int priority) → int
deinterleave_sptr.thread_priority(deinterleave_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.divide_cc(size_t vlen=1) → divide_cc_sptr

output = input[0] / input[1] / ... / input[M-1]

Divide across all input streams.

Constructor Specific Documentation:

Parameters:vlen
divide_cc_sptr.active_thread_priority(divide_cc_sptr self) → int
divide_cc_sptr.declare_sample_delay(divide_cc_sptr self, int which, int delay)

declare_sample_delay(divide_cc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(divide_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(divide_cc_sptr self) -> pmt_vector_float

divide_cc_sptr.pc_throughput_avg(divide_cc_sptr self) → float
divide_cc_sptr.pc_work_time_avg(divide_cc_sptr self) → float
divide_cc_sptr.pc_work_time_total(divide_cc_sptr self) → float
divide_cc_sptr.sample_delay(divide_cc_sptr self, int which) → unsigned int
divide_cc_sptr.set_min_noutput_items(divide_cc_sptr self, int m)
divide_cc_sptr.set_thread_priority(divide_cc_sptr self, int priority) → int
divide_cc_sptr.thread_priority(divide_cc_sptr self) → int
gnuradio.blocks.divide_ff(size_t vlen=1) → divide_ff_sptr

output = input[0] / input[1] / ... / input[M-1]

Divide across all input streams.

Constructor Specific Documentation:

Parameters:vlen
divide_ff_sptr.active_thread_priority(divide_ff_sptr self) → int
divide_ff_sptr.declare_sample_delay(divide_ff_sptr self, int which, int delay)

declare_sample_delay(divide_ff_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(divide_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(divide_ff_sptr self) -> pmt_vector_float

divide_ff_sptr.pc_throughput_avg(divide_ff_sptr self) → float
divide_ff_sptr.pc_work_time_avg(divide_ff_sptr self) → float
divide_ff_sptr.pc_work_time_total(divide_ff_sptr self) → float
divide_ff_sptr.sample_delay(divide_ff_sptr self, int which) → unsigned int
divide_ff_sptr.set_min_noutput_items(divide_ff_sptr self, int m)
divide_ff_sptr.set_thread_priority(divide_ff_sptr self, int priority) → int
divide_ff_sptr.thread_priority(divide_ff_sptr self) → int
gnuradio.blocks.divide_ii(size_t vlen=1) → divide_ii_sptr

output = input[0] / input[1] / ... / input[M-1]

Divide across all input streams.

Constructor Specific Documentation:

Parameters:vlen
divide_ii_sptr.active_thread_priority(divide_ii_sptr self) → int
divide_ii_sptr.declare_sample_delay(divide_ii_sptr self, int which, int delay)

declare_sample_delay(divide_ii_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(divide_ii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(divide_ii_sptr self) -> pmt_vector_float

divide_ii_sptr.pc_throughput_avg(divide_ii_sptr self) → float
divide_ii_sptr.pc_work_time_avg(divide_ii_sptr self) → float
divide_ii_sptr.pc_work_time_total(divide_ii_sptr self) → float
divide_ii_sptr.sample_delay(divide_ii_sptr self, int which) → unsigned int
divide_ii_sptr.set_min_noutput_items(divide_ii_sptr self, int m)
divide_ii_sptr.set_thread_priority(divide_ii_sptr self, int priority) → int
divide_ii_sptr.thread_priority(divide_ii_sptr self) → int
gnuradio.blocks.divide_ss(size_t vlen=1) → divide_ss_sptr

output = input[0] / input[1] / ... / input[M-1]

Divide across all input streams.

Constructor Specific Documentation:

Parameters:vlen
divide_ss_sptr.active_thread_priority(divide_ss_sptr self) → int
divide_ss_sptr.declare_sample_delay(divide_ss_sptr self, int which, int delay)

declare_sample_delay(divide_ss_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(divide_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(divide_ss_sptr self) -> pmt_vector_float

divide_ss_sptr.pc_throughput_avg(divide_ss_sptr self) → float
divide_ss_sptr.pc_work_time_avg(divide_ss_sptr self) → float
divide_ss_sptr.pc_work_time_total(divide_ss_sptr self) → float
divide_ss_sptr.sample_delay(divide_ss_sptr self, int which) → unsigned int
divide_ss_sptr.set_min_noutput_items(divide_ss_sptr self, int m)
divide_ss_sptr.set_thread_priority(divide_ss_sptr self, int priority) → int
divide_ss_sptr.thread_priority(divide_ss_sptr self) → int
gnuradio.blocks.endian_swap(size_t item_size_bytes=1) → endian_swap_sptr

Convert stream of items into their byte swapped version.

Constructor Specific Documentation:

Make an endian swap block.

Parameters:item_size_bytes – number of bytes per item, 1=no-op, 2=uint16_t, 4=uint32_t, 8=uint64_t
endian_swap_sptr.active_thread_priority(endian_swap_sptr self) → int
endian_swap_sptr.declare_sample_delay(endian_swap_sptr self, int which, int delay)

declare_sample_delay(endian_swap_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(endian_swap_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(endian_swap_sptr self) -> pmt_vector_float

endian_swap_sptr.pc_throughput_avg(endian_swap_sptr self) → float
endian_swap_sptr.pc_work_time_avg(endian_swap_sptr self) → float
endian_swap_sptr.pc_work_time_total(endian_swap_sptr self) → float
endian_swap_sptr.sample_delay(endian_swap_sptr self, int which) → unsigned int
endian_swap_sptr.set_min_noutput_items(endian_swap_sptr self, int m)
endian_swap_sptr.set_thread_priority(endian_swap_sptr self, int priority) → int
endian_swap_sptr.thread_priority(endian_swap_sptr self) → int
gnuradio.blocks.file_descriptor_sink(size_t itemsize, int fd) → file_descriptor_sink_sptr

Write stream to file descriptor.

Constructor Specific Documentation:

Build a file descriptor sink block. The provided file descriptor will be closed when the sink is destroyed.

Parameters:
  • itemsize – item size of the incoming data stream.
  • fd – file descriptor (as an integer).
file_descriptor_sink_sptr.active_thread_priority(file_descriptor_sink_sptr self) → int
file_descriptor_sink_sptr.declare_sample_delay(file_descriptor_sink_sptr self, int which, int delay)

declare_sample_delay(file_descriptor_sink_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(file_descriptor_sink_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(file_descriptor_sink_sptr self) -> pmt_vector_float

file_descriptor_sink_sptr.pc_throughput_avg(file_descriptor_sink_sptr self) → float
file_descriptor_sink_sptr.pc_work_time_avg(file_descriptor_sink_sptr self) → float
file_descriptor_sink_sptr.pc_work_time_total(file_descriptor_sink_sptr self) → float
file_descriptor_sink_sptr.sample_delay(file_descriptor_sink_sptr self, int which) → unsigned int
file_descriptor_sink_sptr.set_min_noutput_items(file_descriptor_sink_sptr self, int m)
file_descriptor_sink_sptr.set_thread_priority(file_descriptor_sink_sptr self, int priority) → int
file_descriptor_sink_sptr.thread_priority(file_descriptor_sink_sptr self) → int
gnuradio.blocks.file_descriptor_source(size_t itemsize, int fd, bool repeat=False) → file_descriptor_source_sptr

Read stream from file descriptor.

Constructor Specific Documentation:

Build a file descriptor source block. The provided file descriptor will be closed when the sink is destroyed.

Parameters:
  • itemsize – item size of the incoming data stream.
  • fd – file descriptor (as an integer).
  • repeat – repeat the data stream continuously.
file_descriptor_source_sptr.active_thread_priority(file_descriptor_source_sptr self) → int
file_descriptor_source_sptr.declare_sample_delay(file_descriptor_source_sptr self, int which, int delay)

declare_sample_delay(file_descriptor_source_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(file_descriptor_source_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(file_descriptor_source_sptr self) -> pmt_vector_float

file_descriptor_source_sptr.pc_throughput_avg(file_descriptor_source_sptr self) → float
file_descriptor_source_sptr.pc_work_time_avg(file_descriptor_source_sptr self) → float
file_descriptor_source_sptr.pc_work_time_total(file_descriptor_source_sptr self) → float
file_descriptor_source_sptr.sample_delay(file_descriptor_source_sptr self, int which) → unsigned int
file_descriptor_source_sptr.set_min_noutput_items(file_descriptor_source_sptr self, int m)
file_descriptor_source_sptr.set_thread_priority(file_descriptor_source_sptr self, int priority) → int
file_descriptor_source_sptr.thread_priority(file_descriptor_source_sptr self) → int
gnuradio.blocks.file_meta_sink(size_t itemsize, std::string const & filename, double samp_rate=1, double relative_rate=1, gr::blocks::gr_file_types type, bool complex=True, size_t max_segment_size=1000000, std::string const & extra_dict, bool detached_header=False) → file_meta_sink_sptr

Write stream to file with meta-data headers.

These files represent data as binary information in between meta-data headers. The headers contain information about the type of data and properties of the data in the next segment of samples. The information includes:

Tags can be sent to the file to update the information, which will create a new header. Headers are found by searching from the first header (at position 0 in the file) and reading where the data segment starts plus the data segment size. Following will either be a new header or EOF.

Constructor Specific Documentation:

Create a meta-data file sink.

Parameters:
  • itemsize – (size_t): Size of data type.
  • filename – (string): Name of file to write data to.
  • samp_rate – (double): Sample rate of data. If sample rate will be set by a tag, such as rx_tag from a UHD source, this is basically ignored.
  • relative_rate – (double): Rate chance from source of sample rate tag to sink.
  • type – (gr_file_types): Data type (int, float, etc.)
  • complex – (bool): If data stream is complex
  • max_segment_size – (size_t): Length of a single segment before the header is repeated (in items).
  • extra_dict – (string): a serialized PMT dictionary of extra information. Currently not supported.
  • detached_header – (bool): Set to true to store the header info in a separate file (named filename.hdr)
file_meta_sink_sptr.active_thread_priority(file_meta_sink_sptr self) → int
file_meta_sink_sptr.close(file_meta_sink_sptr self)
file_meta_sink_sptr.declare_sample_delay(file_meta_sink_sptr self, int which, int delay)

declare_sample_delay(file_meta_sink_sptr self, unsigned int delay)

file_meta_sink_sptr.do_update(file_meta_sink_sptr self)
file_meta_sink_sptr.message_subscribers(file_meta_sink_sptr self, swig_int_ptr which_port) → swig_int_ptr
file_meta_sink_sptr.min_noutput_items(file_meta_sink_sptr self) → int
file_meta_sink_sptr.open(file_meta_sink_sptr self, std::string const & filename) → bool
file_meta_sink_sptr.pc_input_buffers_full_avg(file_meta_sink_sptr self, int which) → float

pc_input_buffers_full_avg(file_meta_sink_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(file_meta_sink_sptr self) -> pmt_vector_float

file_meta_sink_sptr.pc_throughput_avg(file_meta_sink_sptr self) → float
file_meta_sink_sptr.pc_work_time_avg(file_meta_sink_sptr self) → float
file_meta_sink_sptr.pc_work_time_total(file_meta_sink_sptr self) → float
file_meta_sink_sptr.sample_delay(file_meta_sink_sptr self, int which) → unsigned int
file_meta_sink_sptr.set_min_noutput_items(file_meta_sink_sptr self, int m)
file_meta_sink_sptr.set_thread_priority(file_meta_sink_sptr self, int priority) → int
file_meta_sink_sptr.set_unbuffered(file_meta_sink_sptr self, bool unbuffered)
file_meta_sink_sptr.thread_priority(file_meta_sink_sptr self) → int
gnuradio.blocks.file_meta_source(std::string const & filename, bool repeat=False, bool detached_header=False, std::string const & hdr_filename) → file_meta_source_sptr

Reads stream from file with meta-data headers. Headers are parsed into tags.

The information in the metadata headers includes:

Any item inside of the extra header dictionary is ready out and made into a stream tag.

Constructor Specific Documentation:

Create a meta-data file source.

Parameters:
  • filename – (string): Name of file to write data to.
  • repeat – (bool): Repeats file when EOF is found.
  • detached_header – (bool): Set to true if header info is stored in a separate file (usually named filename.hdr)
  • hdr_filename – (string): Name of detached header file if used. Defaults to ‘filename.hdr’ if detached_header is true but this field is an empty string.
file_meta_source_sptr.active_thread_priority(file_meta_source_sptr self) → int
file_meta_source_sptr.close(file_meta_source_sptr self)
file_meta_source_sptr.declare_sample_delay(file_meta_source_sptr self, int which, int delay)

declare_sample_delay(file_meta_source_sptr self, unsigned int delay)

file_meta_source_sptr.do_update(file_meta_source_sptr self)
file_meta_source_sptr.message_subscribers(file_meta_source_sptr self, swig_int_ptr which_port) → swig_int_ptr
file_meta_source_sptr.min_noutput_items(file_meta_source_sptr self) → int
file_meta_source_sptr.open(file_meta_source_sptr self, std::string const & filename, std::string const & hdr_filename) → bool
file_meta_source_sptr.pc_input_buffers_full_avg(file_meta_source_sptr self, int which) → float

pc_input_buffers_full_avg(file_meta_source_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(file_meta_source_sptr self) -> pmt_vector_float

file_meta_source_sptr.pc_throughput_avg(file_meta_source_sptr self) → float
file_meta_source_sptr.pc_work_time_avg(file_meta_source_sptr self) → float
file_meta_source_sptr.pc_work_time_total(file_meta_source_sptr self) → float
file_meta_source_sptr.sample_delay(file_meta_source_sptr self, int which) → unsigned int
file_meta_source_sptr.set_min_noutput_items(file_meta_source_sptr self, int m)
file_meta_source_sptr.set_thread_priority(file_meta_source_sptr self, int priority) → int
file_meta_source_sptr.thread_priority(file_meta_source_sptr self) → int
gnuradio.blocks.file_sink(size_t itemsize, char const * filename, bool append=False) → file_sink_sptr

Write stream to file.

Constructor Specific Documentation:

Make a file sink.

Parameters:
  • itemsize – size of the input data items.
  • filename – name of the file to open and write output to.
  • append – if true, data is appended to the file instead of overwriting the initial content.
file_sink_sptr.active_thread_priority(file_sink_sptr self) → int
file_sink_sptr.close(file_sink_sptr self)

Close current output file.

Closes current output file and ignores any output until open is called to connect to another file.

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

declare_sample_delay(file_sink_sptr self, unsigned int delay)

file_sink_sptr.do_update(file_sink_sptr self)

if we’ve had an update, do it now.

file_sink_sptr.message_subscribers(file_sink_sptr self, swig_int_ptr which_port) → swig_int_ptr
file_sink_sptr.min_noutput_items(file_sink_sptr self) → int
file_sink_sptr.open(file_sink_sptr self, char const * filename) → bool

Open filename and begin output to it.

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

pc_input_buffers_full_avg(file_sink_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(file_sink_sptr self) -> pmt_vector_float

file_sink_sptr.pc_throughput_avg(file_sink_sptr self) → float
file_sink_sptr.pc_work_time_avg(file_sink_sptr self) → float
file_sink_sptr.pc_work_time_total(file_sink_sptr self) → float
file_sink_sptr.sample_delay(file_sink_sptr self, int which) → unsigned int
file_sink_sptr.set_min_noutput_items(file_sink_sptr self, int m)
file_sink_sptr.set_thread_priority(file_sink_sptr self, int priority) → int
file_sink_sptr.set_unbuffered(file_sink_sptr self, bool unbuffered)

turn on unbuffered writes for slower outputs

file_sink_sptr.thread_priority(file_sink_sptr self) → int
gnuradio.blocks.file_source(size_t itemsize, char const * filename, bool repeat=False) → file_source_sptr

Read stream from file.

Constructor Specific Documentation:

Create a file source.

Opens as a source of items into a flowgraph. The data is expected to be in binary format, item after item. The of the block determines the conversion from bits to items.

If is turned on, the file will repeat the file after it’s reached the end.

Parameters:
  • itemsize – the size of each item in the file, in bytes
  • filename – name of the file to source from
  • repeat – repeat file from start
file_source_sptr.active_thread_priority(file_source_sptr self) → int
file_source_sptr.close(file_source_sptr self)

Close the file handle.

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

declare_sample_delay(file_source_sptr self, unsigned int delay)

file_source_sptr.message_subscribers(file_source_sptr self, swig_int_ptr which_port) → swig_int_ptr
file_source_sptr.min_noutput_items(file_source_sptr self) → int
file_source_sptr.open(file_source_sptr self, char const * filename, bool repeat)

Opens a new file.

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

pc_input_buffers_full_avg(file_source_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(file_source_sptr self) -> pmt_vector_float

file_source_sptr.pc_throughput_avg(file_source_sptr self) → float
file_source_sptr.pc_work_time_avg(file_source_sptr self) → float
file_source_sptr.pc_work_time_total(file_source_sptr self) → float
file_source_sptr.sample_delay(file_source_sptr self, int which) → unsigned int
file_source_sptr.seek(file_source_sptr self, long seek_point, int whence) → bool

seek file to relative to

file_source_sptr.set_begin_tag(file_source_sptr self, swig_int_ptr val)

Add a stream tag to the first sample of the file if true.

file_source_sptr.set_min_noutput_items(file_source_sptr self, int m)
file_source_sptr.set_thread_priority(file_source_sptr self, int priority) → int
file_source_sptr.thread_priority(file_source_sptr self) → int
gnuradio.blocks.float_to_char(size_t vlen=1, float scale=1.0) → float_to_char_sptr

Convert stream of floats to a stream of char.

Constructor Specific Documentation:

Build a float to char block.

Parameters:
  • vlen – vector length of data streams.
  • scale – a scalar multiplier to change the output signal scale.
float_to_char_sptr.active_thread_priority(float_to_char_sptr self) → int
float_to_char_sptr.declare_sample_delay(float_to_char_sptr self, int which, int delay)

declare_sample_delay(float_to_char_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(float_to_char_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(float_to_char_sptr self) -> pmt_vector_float

float_to_char_sptr.pc_throughput_avg(float_to_char_sptr self) → float
float_to_char_sptr.pc_work_time_avg(float_to_char_sptr self) → float
float_to_char_sptr.pc_work_time_total(float_to_char_sptr self) → float
float_to_char_sptr.sample_delay(float_to_char_sptr self, int which) → unsigned int
float_to_char_sptr.scale(float_to_char_sptr self) → float

Get the scalar multiplier value.

float_to_char_sptr.set_min_noutput_items(float_to_char_sptr self, int m)
float_to_char_sptr.set_scale(float_to_char_sptr self, float scale)

Set the scalar multiplier value.

float_to_char_sptr.set_thread_priority(float_to_char_sptr self, int priority) → int
float_to_char_sptr.thread_priority(float_to_char_sptr self) → int
gnuradio.blocks.float_to_complex(size_t vlen=1) → float_to_complex_sptr

one or two floats in, complex out

Constructor Specific Documentation:

Build a float to complex block.

Parameters:vlen – vector len (default 1)
float_to_complex_sptr.active_thread_priority(float_to_complex_sptr self) → int
float_to_complex_sptr.declare_sample_delay(float_to_complex_sptr self, int which, int delay)

declare_sample_delay(float_to_complex_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(float_to_complex_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(float_to_complex_sptr self) -> pmt_vector_float

float_to_complex_sptr.pc_throughput_avg(float_to_complex_sptr self) → float
float_to_complex_sptr.pc_work_time_avg(float_to_complex_sptr self) → float
float_to_complex_sptr.pc_work_time_total(float_to_complex_sptr self) → float
float_to_complex_sptr.sample_delay(float_to_complex_sptr self, int which) → unsigned int
float_to_complex_sptr.set_min_noutput_items(float_to_complex_sptr self, int m)
float_to_complex_sptr.set_thread_priority(float_to_complex_sptr self, int priority) → int
float_to_complex_sptr.thread_priority(float_to_complex_sptr self) → int
gnuradio.blocks.float_to_int(size_t vlen=1, float scale=1.0) → float_to_int_sptr

Convert stream of floats to a stream of ints.

Constructor Specific Documentation:

Build a float to int block.

Parameters:
  • vlen – vector length of data streams.
  • scale – a scalar multiplier to change the output signal scale.
float_to_int_sptr.active_thread_priority(float_to_int_sptr self) → int
float_to_int_sptr.declare_sample_delay(float_to_int_sptr self, int which, int delay)

declare_sample_delay(float_to_int_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(float_to_int_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(float_to_int_sptr self) -> pmt_vector_float

float_to_int_sptr.pc_throughput_avg(float_to_int_sptr self) → float
float_to_int_sptr.pc_work_time_avg(float_to_int_sptr self) → float
float_to_int_sptr.pc_work_time_total(float_to_int_sptr self) → float
float_to_int_sptr.sample_delay(float_to_int_sptr self, int which) → unsigned int
float_to_int_sptr.scale(float_to_int_sptr self) → float

Get the scalar multiplier value.

float_to_int_sptr.set_min_noutput_items(float_to_int_sptr self, int m)
float_to_int_sptr.set_scale(float_to_int_sptr self, float scale)

Set the scalar multiplier value.

float_to_int_sptr.set_thread_priority(float_to_int_sptr self, int priority) → int
float_to_int_sptr.thread_priority(float_to_int_sptr self) → int
gnuradio.blocks.float_to_short(size_t vlen=1, float scale=1.0) → float_to_short_sptr

Convert stream of floats to a stream of shorts.

Constructor Specific Documentation:

Build a float to short block.

Parameters:
  • vlen – vector length of data streams.
  • scale – a scalar multiplier to change the output signal scale.
float_to_short_sptr.active_thread_priority(float_to_short_sptr self) → int
float_to_short_sptr.declare_sample_delay(float_to_short_sptr self, int which, int delay)

declare_sample_delay(float_to_short_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(float_to_short_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(float_to_short_sptr self) -> pmt_vector_float

float_to_short_sptr.pc_throughput_avg(float_to_short_sptr self) → float
float_to_short_sptr.pc_work_time_avg(float_to_short_sptr self) → float
float_to_short_sptr.pc_work_time_total(float_to_short_sptr self) → float
float_to_short_sptr.sample_delay(float_to_short_sptr self, int which) → unsigned int
float_to_short_sptr.scale(float_to_short_sptr self) → float

Get the scalar multiplier value.

float_to_short_sptr.set_min_noutput_items(float_to_short_sptr self, int m)
float_to_short_sptr.set_scale(float_to_short_sptr self, float scale)

Set the scalar multiplier value.

float_to_short_sptr.set_thread_priority(float_to_short_sptr self, int priority) → int
float_to_short_sptr.thread_priority(float_to_short_sptr self) → int
gnuradio.blocks.float_to_uchar() → float_to_uchar_sptr

Convert stream of floats to a stream of unsigned chars.

Constructor Specific Documentation:

Build a float to uchar block.

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

declare_sample_delay(float_to_uchar_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(float_to_uchar_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(float_to_uchar_sptr self) -> pmt_vector_float

float_to_uchar_sptr.pc_throughput_avg(float_to_uchar_sptr self) → float
float_to_uchar_sptr.pc_work_time_avg(float_to_uchar_sptr self) → float
float_to_uchar_sptr.pc_work_time_total(float_to_uchar_sptr self) → float
float_to_uchar_sptr.sample_delay(float_to_uchar_sptr self, int which) → unsigned int
float_to_uchar_sptr.set_min_noutput_items(float_to_uchar_sptr self, int m)
float_to_uchar_sptr.set_thread_priority(float_to_uchar_sptr self, int priority) → int
float_to_uchar_sptr.thread_priority(float_to_uchar_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, uint64_t 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.int_to_float(size_t vlen=1, float scale=1.0) → int_to_float_sptr

Convert stream of ints to a stream of floats.

Constructor Specific Documentation:

Build an int to float block.

Parameters:
  • vlen – vector length of data streams.
  • scale – a scalar divider to change the output signal scale.
int_to_float_sptr.active_thread_priority(int_to_float_sptr self) → int
int_to_float_sptr.declare_sample_delay(int_to_float_sptr self, int which, int delay)

declare_sample_delay(int_to_float_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(int_to_float_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(int_to_float_sptr self) -> pmt_vector_float

int_to_float_sptr.pc_throughput_avg(int_to_float_sptr self) → float
int_to_float_sptr.pc_work_time_avg(int_to_float_sptr self) → float
int_to_float_sptr.pc_work_time_total(int_to_float_sptr self) → float
int_to_float_sptr.sample_delay(int_to_float_sptr self, int which) → unsigned int
int_to_float_sptr.scale(int_to_float_sptr self) → float

Get the scalar divider value.

int_to_float_sptr.set_min_noutput_items(int_to_float_sptr self, int m)
int_to_float_sptr.set_scale(int_to_float_sptr self, float scale)

Set the scalar divider value.

int_to_float_sptr.set_thread_priority(int_to_float_sptr self, int priority) → int
int_to_float_sptr.thread_priority(int_to_float_sptr self) → int
gnuradio.blocks.integrate_cc(int decim, int vlen=1) → integrate_cc_sptr

Integrate successive samples and decimate.

Constructor Specific Documentation:

Parameters:
  • decim
  • vlen
integrate_cc_sptr.active_thread_priority(integrate_cc_sptr self) → int
integrate_cc_sptr.declare_sample_delay(integrate_cc_sptr self, int which, int delay)

declare_sample_delay(integrate_cc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(integrate_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(integrate_cc_sptr self) -> pmt_vector_float

integrate_cc_sptr.pc_throughput_avg(integrate_cc_sptr self) → float
integrate_cc_sptr.pc_work_time_avg(integrate_cc_sptr self) → float
integrate_cc_sptr.pc_work_time_total(integrate_cc_sptr self) → float
integrate_cc_sptr.sample_delay(integrate_cc_sptr self, int which) → unsigned int
integrate_cc_sptr.set_min_noutput_items(integrate_cc_sptr self, int m)
integrate_cc_sptr.set_thread_priority(integrate_cc_sptr self, int priority) → int
integrate_cc_sptr.thread_priority(integrate_cc_sptr self) → int
gnuradio.blocks.integrate_ff(int decim, int vlen=1) → integrate_ff_sptr

Integrate successive samples and decimate.

Constructor Specific Documentation:

Parameters:
  • decim
  • vlen
integrate_ff_sptr.active_thread_priority(integrate_ff_sptr self) → int
integrate_ff_sptr.declare_sample_delay(integrate_ff_sptr self, int which, int delay)

declare_sample_delay(integrate_ff_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(integrate_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(integrate_ff_sptr self) -> pmt_vector_float

integrate_ff_sptr.pc_throughput_avg(integrate_ff_sptr self) → float
integrate_ff_sptr.pc_work_time_avg(integrate_ff_sptr self) → float
integrate_ff_sptr.pc_work_time_total(integrate_ff_sptr self) → float
integrate_ff_sptr.sample_delay(integrate_ff_sptr self, int which) → unsigned int
integrate_ff_sptr.set_min_noutput_items(integrate_ff_sptr self, int m)
integrate_ff_sptr.set_thread_priority(integrate_ff_sptr self, int priority) → int
integrate_ff_sptr.thread_priority(integrate_ff_sptr self) → int
gnuradio.blocks.integrate_ii(int decim, int vlen=1) → integrate_ii_sptr

Integrate successive samples and decimate.

Constructor Specific Documentation:

Parameters:
  • decim
  • vlen
integrate_ii_sptr.active_thread_priority(integrate_ii_sptr self) → int
integrate_ii_sptr.declare_sample_delay(integrate_ii_sptr self, int which, int delay)

declare_sample_delay(integrate_ii_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(integrate_ii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(integrate_ii_sptr self) -> pmt_vector_float

integrate_ii_sptr.pc_throughput_avg(integrate_ii_sptr self) → float
integrate_ii_sptr.pc_work_time_avg(integrate_ii_sptr self) → float
integrate_ii_sptr.pc_work_time_total(integrate_ii_sptr self) → float
integrate_ii_sptr.sample_delay(integrate_ii_sptr self, int which) → unsigned int
integrate_ii_sptr.set_min_noutput_items(integrate_ii_sptr self, int m)
integrate_ii_sptr.set_thread_priority(integrate_ii_sptr self, int priority) → int
integrate_ii_sptr.thread_priority(integrate_ii_sptr self) → int
gnuradio.blocks.integrate_ss(int decim, int vlen=1) → integrate_ss_sptr

Integrate successive samples and decimate.

Constructor Specific Documentation:

Parameters:
  • decim
  • vlen
integrate_ss_sptr.active_thread_priority(integrate_ss_sptr self) → int
integrate_ss_sptr.declare_sample_delay(integrate_ss_sptr self, int which, int delay)

declare_sample_delay(integrate_ss_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(integrate_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(integrate_ss_sptr self) -> pmt_vector_float

integrate_ss_sptr.pc_throughput_avg(integrate_ss_sptr self) → float
integrate_ss_sptr.pc_work_time_avg(integrate_ss_sptr self) → float
integrate_ss_sptr.pc_work_time_total(integrate_ss_sptr self) → float
integrate_ss_sptr.sample_delay(integrate_ss_sptr self, int which) → unsigned int
integrate_ss_sptr.set_min_noutput_items(integrate_ss_sptr self, int m)
integrate_ss_sptr.set_thread_priority(integrate_ss_sptr self, int priority) → int
integrate_ss_sptr.thread_priority(integrate_ss_sptr self) → int
gnuradio.blocks.interleave(size_t itemsize, unsigned int blocksize=1) → interleave_sptr

interleave N inputs into a single output

This block interleaves blocks of samples. For each input connection, the samples are interleaved successively to the output connection. By default, the block interleaves a single sample from each input to the output unless blocksize is given in the constructor.

Constructor Specific Documentation:

Make a stream interleave block.

Parameters:
  • itemsize – stream itemsize
  • blocksize – size of block of samples to interleave
interleave_sptr.active_thread_priority(interleave_sptr self) → int
interleave_sptr.declare_sample_delay(interleave_sptr self, int which, int delay)

declare_sample_delay(interleave_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(interleave_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(interleave_sptr self) -> pmt_vector_float

interleave_sptr.pc_throughput_avg(interleave_sptr self) → float
interleave_sptr.pc_work_time_avg(interleave_sptr self) → float
interleave_sptr.pc_work_time_total(interleave_sptr self) → float
interleave_sptr.sample_delay(interleave_sptr self, int which) → unsigned int
interleave_sptr.set_min_noutput_items(interleave_sptr self, int m)
interleave_sptr.set_thread_priority(interleave_sptr self, int priority) → int
interleave_sptr.thread_priority(interleave_sptr self) → int
gnuradio.blocks.interleaved_char_to_complex(bool vector_input=False) → interleaved_char_to_complex_sptr

Convert stream of interleaved chars to a stream of complex.

Constructor Specific Documentation:

Build an interleaved char to complex block.

Parameters:vector_input
interleaved_char_to_complex_sptr.active_thread_priority(interleaved_char_to_complex_sptr self) → int
interleaved_char_to_complex_sptr.declare_sample_delay(interleaved_char_to_complex_sptr self, int which, int delay)

declare_sample_delay(interleaved_char_to_complex_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(interleaved_char_to_complex_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(interleaved_char_to_complex_sptr self) -> pmt_vector_float

interleaved_char_to_complex_sptr.pc_throughput_avg(interleaved_char_to_complex_sptr self) → float
interleaved_char_to_complex_sptr.pc_work_time_avg(interleaved_char_to_complex_sptr self) → float
interleaved_char_to_complex_sptr.pc_work_time_total(interleaved_char_to_complex_sptr self) → float
interleaved_char_to_complex_sptr.sample_delay(interleaved_char_to_complex_sptr self, int which) → unsigned int
interleaved_char_to_complex_sptr.set_min_noutput_items(interleaved_char_to_complex_sptr self, int m)
interleaved_char_to_complex_sptr.set_thread_priority(interleaved_char_to_complex_sptr self, int priority) → int
interleaved_char_to_complex_sptr.thread_priority(interleaved_char_to_complex_sptr self) → int
gnuradio.blocks.interleaved_short_to_complex(bool vector_input=False, bool swap=False) → interleaved_short_to_complex_sptr

Convert stream of interleaved shorts to a stream of complex.

Constructor Specific Documentation:

Build an interleaved short to complex block.

Parameters:
  • vector_input
  • swap
interleaved_short_to_complex_sptr.active_thread_priority(interleaved_short_to_complex_sptr self) → int
interleaved_short_to_complex_sptr.declare_sample_delay(interleaved_short_to_complex_sptr self, int which, int delay)

declare_sample_delay(interleaved_short_to_complex_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(interleaved_short_to_complex_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(interleaved_short_to_complex_sptr self) -> pmt_vector_float

interleaved_short_to_complex_sptr.pc_throughput_avg(interleaved_short_to_complex_sptr self) → float
interleaved_short_to_complex_sptr.pc_work_time_avg(interleaved_short_to_complex_sptr self) → float
interleaved_short_to_complex_sptr.pc_work_time_total(interleaved_short_to_complex_sptr self) → float
interleaved_short_to_complex_sptr.sample_delay(interleaved_short_to_complex_sptr self, int which) → unsigned int
interleaved_short_to_complex_sptr.set_min_noutput_items(interleaved_short_to_complex_sptr self, int m)
interleaved_short_to_complex_sptr.set_swap(interleaved_short_to_complex_sptr self, bool swap)
interleaved_short_to_complex_sptr.set_thread_priority(interleaved_short_to_complex_sptr self, int priority) → int
interleaved_short_to_complex_sptr.thread_priority(interleaved_short_to_complex_sptr self) → int
gnuradio.blocks.keep_m_in_n(size_t itemsize, int m, int n, int offset) → keep_m_in_n_sptr

decimate a stream, keeping the first items out of every starting after items.

Constructor Specific Documentation:

Make a keep m in n block.

Parameters:
  • itemsize – stream itemsize
  • m – number of items to take in block of items
  • n – block size in items
  • offset – initial item offset into the stream
keep_m_in_n_sptr.active_thread_priority(keep_m_in_n_sptr self) → int
keep_m_in_n_sptr.declare_sample_delay(keep_m_in_n_sptr self, int which, int delay)

declare_sample_delay(keep_m_in_n_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(keep_m_in_n_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(keep_m_in_n_sptr self) -> pmt_vector_float

keep_m_in_n_sptr.pc_throughput_avg(keep_m_in_n_sptr self) → float
keep_m_in_n_sptr.pc_work_time_avg(keep_m_in_n_sptr self) → float
keep_m_in_n_sptr.pc_work_time_total(keep_m_in_n_sptr self) → float
keep_m_in_n_sptr.sample_delay(keep_m_in_n_sptr self, int which) → unsigned int
keep_m_in_n_sptr.set_m(keep_m_in_n_sptr self, int m)
keep_m_in_n_sptr.set_min_noutput_items(keep_m_in_n_sptr self, int m)
keep_m_in_n_sptr.set_n(keep_m_in_n_sptr self, int n)
keep_m_in_n_sptr.set_offset(keep_m_in_n_sptr self, int offset)
keep_m_in_n_sptr.set_thread_priority(keep_m_in_n_sptr self, int priority) → int
keep_m_in_n_sptr.thread_priority(keep_m_in_n_sptr self) → int
gnuradio.blocks.keep_one_in_n(size_t itemsize, int n) → keep_one_in_n_sptr

decimate a stream, keeping the last item out of every .

Constructor Specific Documentation:

Make a keep one in n block.

Parameters:
  • itemsize – stream itemsize
  • n – block size in items
keep_one_in_n_sptr.active_thread_priority(keep_one_in_n_sptr self) → int
keep_one_in_n_sptr.declare_sample_delay(keep_one_in_n_sptr self, int which, int delay)

declare_sample_delay(keep_one_in_n_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(keep_one_in_n_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(keep_one_in_n_sptr self) -> pmt_vector_float

keep_one_in_n_sptr.pc_throughput_avg(keep_one_in_n_sptr self) → float
keep_one_in_n_sptr.pc_work_time_avg(keep_one_in_n_sptr self) → float
keep_one_in_n_sptr.pc_work_time_total(keep_one_in_n_sptr self) → float
keep_one_in_n_sptr.sample_delay(keep_one_in_n_sptr self, int which) → unsigned int
keep_one_in_n_sptr.set_min_noutput_items(keep_one_in_n_sptr self, int m)
keep_one_in_n_sptr.set_n(keep_one_in_n_sptr self, int n)
keep_one_in_n_sptr.set_thread_priority(keep_one_in_n_sptr self, int priority) → int
keep_one_in_n_sptr.thread_priority(keep_one_in_n_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.max_ff(size_t vlen, size_t vlen_out=1) → max_ff_sptr

Compares vectors from multiple streams and determines the maximum value from each vector over all streams.

Data is passed in as a vector of length from multiple input sources. If vlen_out == 1 then It will look through these streams of data items and the output stream will contain the maximum value in the vector. If vlen_out == vlen and not equal to 1 then output will be a vector with individual items selected from the maximum corresponding input vector items.

Constructor Specific Documentation:

Parameters:
  • vlen
  • vlen_out
max_ff_sptr.active_thread_priority(max_ff_sptr self) → int
max_ff_sptr.declare_sample_delay(max_ff_sptr self, int which, int delay)

declare_sample_delay(max_ff_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(max_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(max_ff_sptr self) -> pmt_vector_float

max_ff_sptr.pc_throughput_avg(max_ff_sptr self) → float
max_ff_sptr.pc_work_time_avg(max_ff_sptr self) → float
max_ff_sptr.pc_work_time_total(max_ff_sptr self) → float
max_ff_sptr.sample_delay(max_ff_sptr self, int which) → unsigned int
max_ff_sptr.set_min_noutput_items(max_ff_sptr self, int m)
max_ff_sptr.set_thread_priority(max_ff_sptr self, int priority) → int
max_ff_sptr.thread_priority(max_ff_sptr self) → int
gnuradio.blocks.max_ii(size_t vlen, size_t vlen_out=1) → max_ii_sptr

Compares vectors from multiple streams and determines the maximum value from each vector over all streams.

Data is passed in as a vector of length from multiple input sources. If vlen_out == 1 then It will look through these streams of data items and the output stream will contain the maximum value in the vector. If vlen_out == vlen and not equal to 1 then output will be a vector with individual items selected from the maximum corresponding input vector items.

Constructor Specific Documentation:

Parameters:
  • vlen
  • vlen_out
max_ii_sptr.active_thread_priority(max_ii_sptr self) → int
max_ii_sptr.declare_sample_delay(max_ii_sptr self, int which, int delay)

declare_sample_delay(max_ii_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(max_ii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(max_ii_sptr self) -> pmt_vector_float

max_ii_sptr.pc_throughput_avg(max_ii_sptr self) → float
max_ii_sptr.pc_work_time_avg(max_ii_sptr self) → float
max_ii_sptr.pc_work_time_total(max_ii_sptr self) → float
max_ii_sptr.sample_delay(max_ii_sptr self, int which) → unsigned int
max_ii_sptr.set_min_noutput_items(max_ii_sptr self, int m)
max_ii_sptr.set_thread_priority(max_ii_sptr self, int priority) → int
max_ii_sptr.thread_priority(max_ii_sptr self) → int
gnuradio.blocks.max_ss(size_t vlen, size_t vlen_out=1) → max_ss_sptr

Compares vectors from multiple streams and determines the maximum value from each vector over all streams.

Data is passed in as a vector of length from multiple input sources. If vlen_out == 1 then It will look through these streams of data items and the output stream will contain the maximum value in the vector. If vlen_out == vlen and not equal to 1 then output will be a vector with individual items selected from the maximum corresponding input vector items.

Constructor Specific Documentation:

Parameters:
  • vlen
  • vlen_out
max_ss_sptr.active_thread_priority(max_ss_sptr self) → int
max_ss_sptr.declare_sample_delay(max_ss_sptr self, int which, int delay)

declare_sample_delay(max_ss_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(max_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(max_ss_sptr self) -> pmt_vector_float

max_ss_sptr.pc_throughput_avg(max_ss_sptr self) → float
max_ss_sptr.pc_work_time_avg(max_ss_sptr self) → float
max_ss_sptr.pc_work_time_total(max_ss_sptr self) → float
max_ss_sptr.sample_delay(max_ss_sptr self, int which) → unsigned int
max_ss_sptr.set_min_noutput_items(max_ss_sptr self, int m)
max_ss_sptr.set_thread_priority(max_ss_sptr self, int priority) → int
max_ss_sptr.thread_priority(max_ss_sptr self) → int
gnuradio.blocks.message_burst_source(size_t itemsize, int msgq_limit) → message_burst_source_sptr

make(size_t itemsize, msg_queue_sptr msgq) -> message_burst_source_sptr

Turn received messages into a stream and tag them for UHD to send.

Constructor Specific Documentation:

Parameters:
  • itemsize
  • msgq_limit
message_burst_source_sptr.active_thread_priority(message_burst_source_sptr self) → int
message_burst_source_sptr.declare_sample_delay(message_burst_source_sptr self, int which, int delay)

declare_sample_delay(message_burst_source_sptr self, unsigned int delay)

message_burst_source_sptr.message_subscribers(message_burst_source_sptr self, swig_int_ptr which_port) → swig_int_ptr
message_burst_source_sptr.min_noutput_items(message_burst_source_sptr self) → int
message_burst_source_sptr.msgq(message_burst_source_sptr self) → msg_queue_sptr
message_burst_source_sptr.pc_input_buffers_full_avg(message_burst_source_sptr self, int which) → float

pc_input_buffers_full_avg(message_burst_source_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(message_burst_source_sptr self) -> pmt_vector_float

message_burst_source_sptr.pc_throughput_avg(message_burst_source_sptr self) → float
message_burst_source_sptr.pc_work_time_avg(message_burst_source_sptr self) → float
message_burst_source_sptr.pc_work_time_total(message_burst_source_sptr self) → float
message_burst_source_sptr.sample_delay(message_burst_source_sptr self, int which) → unsigned int
message_burst_source_sptr.set_min_noutput_items(message_burst_source_sptr self, int m)
message_burst_source_sptr.set_thread_priority(message_burst_source_sptr self, int priority) → int
message_burst_source_sptr.thread_priority(message_burst_source_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.message_sink(size_t itemsize, msg_queue_sptr msgq, bool dont_block) → message_sink_sptr

make(size_t itemsize, msg_queue_sptr msgq, bool dont_block, std::string const & lengthtagname) -> message_sink_sptr

Gather received items into messages and insert into msgq.

Constructor Specific Documentation:

Parameters:
  • itemsize
  • msgq
  • dont_block
message_sink_sptr.active_thread_priority(message_sink_sptr self) → int
message_sink_sptr.declare_sample_delay(message_sink_sptr self, int which, int delay)

declare_sample_delay(message_sink_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(message_sink_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(message_sink_sptr self) -> pmt_vector_float

message_sink_sptr.pc_throughput_avg(message_sink_sptr self) → float
message_sink_sptr.pc_work_time_avg(message_sink_sptr self) → float
message_sink_sptr.pc_work_time_total(message_sink_sptr self) → float
message_sink_sptr.sample_delay(message_sink_sptr self, int which) → unsigned int
message_sink_sptr.set_min_noutput_items(message_sink_sptr self, int m)
message_sink_sptr.set_thread_priority(message_sink_sptr self, int priority) → int
message_sink_sptr.thread_priority(message_sink_sptr self) → int
gnuradio.blocks.message_source(size_t itemsize, int msgq_limit=0) → message_source_sptr

make(size_t itemsize, msg_queue_sptr msgq) -> message_source_sptr make(size_t itemsize, msg_queue_sptr msgq, std::string const & lengthtagname) -> message_source_sptr

Turn received messages into a stream.

Constructor Specific Documentation:

Parameters:
  • itemsize
  • msgq_limit
message_source_sptr.active_thread_priority(message_source_sptr self) → int
message_source_sptr.declare_sample_delay(message_source_sptr self, int which, int delay)

declare_sample_delay(message_source_sptr self, unsigned int delay)

message_source_sptr.message_subscribers(message_source_sptr self, swig_int_ptr which_port) → swig_int_ptr
message_source_sptr.min_noutput_items(message_source_sptr self) → int
message_source_sptr.msgq(message_source_sptr self) → msg_queue_sptr
message_source_sptr.pc_input_buffers_full_avg(message_source_sptr self, int which) → float

pc_input_buffers_full_avg(message_source_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(message_source_sptr self) -> pmt_vector_float

message_source_sptr.pc_throughput_avg(message_source_sptr self) → float
message_source_sptr.pc_work_time_avg(message_source_sptr self) → float
message_source_sptr.pc_work_time_total(message_source_sptr self) → float
message_source_sptr.sample_delay(message_source_sptr self, int which) → unsigned int
message_source_sptr.set_min_noutput_items(message_source_sptr self, int m)
message_source_sptr.set_thread_priority(message_source_sptr self, int priority) → int
message_source_sptr.thread_priority(message_source_sptr self) → int
gnuradio.blocks.message_strobe(swig_int_ptr msg, float period_ms) → message_strobe_sptr

Send message at defined interval.

Takes a PMT message and sends it out every milliseconds. Useful for testing/debugging the message system.

Constructor Specific Documentation:

Make a message stobe block to send message every milliseconds.

Parameters:
  • msg – The message to send as a PMT.
  • period_ms – the time period in milliseconds in which to send .
message_strobe_sptr.active_thread_priority(message_strobe_sptr self) → int
message_strobe_sptr.declare_sample_delay(message_strobe_sptr self, int which, int delay)

declare_sample_delay(message_strobe_sptr self, unsigned int delay)

message_strobe_sptr.message_subscribers(message_strobe_sptr self, swig_int_ptr which_port) → swig_int_ptr
message_strobe_sptr.min_noutput_items(message_strobe_sptr self) → int
message_strobe_sptr.msg(message_strobe_sptr self) → swig_int_ptr

Get the value of the message being sent.

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

pc_input_buffers_full_avg(message_strobe_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(message_strobe_sptr self) -> pmt_vector_float

message_strobe_sptr.pc_throughput_avg(message_strobe_sptr self) → float
message_strobe_sptr.pc_work_time_avg(message_strobe_sptr self) → float
message_strobe_sptr.pc_work_time_total(message_strobe_sptr self) → float
message_strobe_sptr.period(message_strobe_sptr self) → float

Get the time interval of the strobe.

message_strobe_sptr.sample_delay(message_strobe_sptr self, int which) → unsigned int
message_strobe_sptr.set_min_noutput_items(message_strobe_sptr self, int m)
message_strobe_sptr.set_msg(message_strobe_sptr self, swig_int_ptr msg)

Reset the message being sent.

message_strobe_sptr.set_period(message_strobe_sptr self, float period_ms)

Reset the sending interval.

message_strobe_sptr.set_thread_priority(message_strobe_sptr self, int priority) → int
message_strobe_sptr.thread_priority(message_strobe_sptr self) → int
gnuradio.blocks.message_strobe_random(swig_int_ptr msg, gr::blocks::message_strobe_random_distribution_t dist, float mean_ms, float std_ms) → message_strobe_random_sptr

Send message at defined interval.

Takes a PMT message and sends it out every at random intervals. The interval is basedon a random distribution, , with specified mean () and variance (). Useful for testing/debugging the message system.

Constructor Specific Documentation:

Make a message stobe block to sends message at random intervals defined by the distribution with mean and standard deviation .

Parameters:
  • msg – The message to send as a PMT.
  • dist – The random distribution from which to draw events.
  • mean_ms – The mean of the distribution.
  • std_ms – The standard deviation of the distribution.
message_strobe_random_sptr.active_thread_priority(message_strobe_random_sptr self) → int
message_strobe_random_sptr.declare_sample_delay(message_strobe_random_sptr self, int which, int delay)

declare_sample_delay(message_strobe_random_sptr self, unsigned int delay)

message_strobe_random_sptr.dist(message_strobe_random_sptr self) → gr::blocks::message_strobe_random_distribution_t

get the current distribution.

message_strobe_random_sptr.mean(message_strobe_random_sptr self) → float

Get the time interval of the strobe_random.

message_strobe_random_sptr.message_subscribers(message_strobe_random_sptr self, swig_int_ptr which_port) → swig_int_ptr
message_strobe_random_sptr.min_noutput_items(message_strobe_random_sptr self) → int
message_strobe_random_sptr.msg(message_strobe_random_sptr self) → swig_int_ptr

Get the value of the message being sent.

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

pc_input_buffers_full_avg(message_strobe_random_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(message_strobe_random_sptr self) -> pmt_vector_float

message_strobe_random_sptr.pc_throughput_avg(message_strobe_random_sptr self) → float
message_strobe_random_sptr.pc_work_time_avg(message_strobe_random_sptr self) → float
message_strobe_random_sptr.pc_work_time_total(message_strobe_random_sptr self) → float
message_strobe_random_sptr.sample_delay(message_strobe_random_sptr self, int which) → unsigned int
message_strobe_random_sptr.set_dist(message_strobe_random_sptr self, gr::blocks::message_strobe_random_distribution_t dist)
message_strobe_random_sptr.set_mean(message_strobe_random_sptr self, float mean)

Reset the sending interval.

message_strobe_random_sptr.set_min_noutput_items(message_strobe_random_sptr self, int m)
message_strobe_random_sptr.set_msg(message_strobe_random_sptr self, swig_int_ptr msg)

Reset the message being sent.

message_strobe_random_sptr.set_std(message_strobe_random_sptr self, float std)

Reset the sending interval.

message_strobe_random_sptr.set_thread_priority(message_strobe_random_sptr self, int priority) → int
message_strobe_random_sptr.std(message_strobe_random_sptr self) → float

Get the std of strobe_random.

message_strobe_random_sptr.thread_priority(message_strobe_random_sptr self) → int
gnuradio.blocks.min_ff(size_t vlen, size_t vlen_out=1) → min_ff_sptr

Compares vectors from multiple streams and determines the minimum value from each vector over all streams.

Data is passed in as a vector of length from multiple input sources. If vlen_out == 1 then It will look through these streams of data items and the output stream will contain the minimum value in the vector. If vlen_out == vlen and not equal to 1 then output will be a vector with individual items selected from the minimum corresponding input vector items.

Constructor Specific Documentation:

Parameters:
  • vlen
  • vlen_out
min_ff_sptr.active_thread_priority(min_ff_sptr self) → int
min_ff_sptr.declare_sample_delay(min_ff_sptr self, int which, int delay)

declare_sample_delay(min_ff_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(min_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(min_ff_sptr self) -> pmt_vector_float

min_ff_sptr.pc_throughput_avg(min_ff_sptr self) → float
min_ff_sptr.pc_work_time_avg(min_ff_sptr self) → float
min_ff_sptr.pc_work_time_total(min_ff_sptr self) → float
min_ff_sptr.sample_delay(min_ff_sptr self, int which) → unsigned int
min_ff_sptr.set_min_noutput_items(min_ff_sptr self, int m)
min_ff_sptr.set_thread_priority(min_ff_sptr self, int priority) → int
min_ff_sptr.thread_priority(min_ff_sptr self) → int
gnuradio.blocks.min_ii(size_t vlen, size_t vlen_out=1) → min_ii_sptr

Compares vectors from multiple streams and determines the minimum value from each vector over all streams.

Data is passed in as a vector of length from multiple input sources. If vlen_out == 1 then It will look through these streams of data items and the output stream will contain the minimum value in the vector. If vlen_out == vlen and not equal to 1 then output will be a vector with individual items selected from the minimum corresponding input vector items.

Constructor Specific Documentation:

Parameters:
  • vlen
  • vlen_out
min_ii_sptr.active_thread_priority(min_ii_sptr self) → int
min_ii_sptr.declare_sample_delay(min_ii_sptr self, int which, int delay)

declare_sample_delay(min_ii_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(min_ii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(min_ii_sptr self) -> pmt_vector_float

min_ii_sptr.pc_throughput_avg(min_ii_sptr self) → float
min_ii_sptr.pc_work_time_avg(min_ii_sptr self) → float
min_ii_sptr.pc_work_time_total(min_ii_sptr self) → float
min_ii_sptr.sample_delay(min_ii_sptr self, int which) → unsigned int
min_ii_sptr.set_min_noutput_items(min_ii_sptr self, int m)
min_ii_sptr.set_thread_priority(min_ii_sptr self, int priority) → int
min_ii_sptr.thread_priority(min_ii_sptr self) → int
gnuradio.blocks.min_ss(size_t vlen, size_t vlen_out=1) → min_ss_sptr

Compares vectors from multiple streams and determines the minimum value from each vector over all streams.

Data is passed in as a vector of length from multiple input sources. If vlen_out == 1 then It will look through these streams of data items and the output stream will contain the minimum value in the vector. If vlen_out == vlen and not equal to 1 then output will be a vector with individual items selected from the minimum corresponding input vector items.

Constructor Specific Documentation:

Parameters:
  • vlen
  • vlen_out
min_ss_sptr.active_thread_priority(min_ss_sptr self) → int
min_ss_sptr.declare_sample_delay(min_ss_sptr self, int which, int delay)

declare_sample_delay(min_ss_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(min_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(min_ss_sptr self) -> pmt_vector_float

min_ss_sptr.pc_throughput_avg(min_ss_sptr self) → float
min_ss_sptr.pc_work_time_avg(min_ss_sptr self) → float
min_ss_sptr.pc_work_time_total(min_ss_sptr self) → float
min_ss_sptr.sample_delay(min_ss_sptr self, int which) → unsigned int
min_ss_sptr.set_min_noutput_items(min_ss_sptr self, int m)
min_ss_sptr.set_thread_priority(min_ss_sptr self, int priority) → int
min_ss_sptr.thread_priority(min_ss_sptr self) → int
gnuradio.blocks.moving_average_cc(int length, gr_complex scale, int max_iter=4096, unsigned int vlen=1) → moving_average_cc_sptr

output is the moving sum of the last N samples, scaled by the scale factor

Constructor Specific Documentation:

Create a moving average block.

Parameters:
  • length – Number of samples to use in the average.
  • scale – scale factor for the result.
  • max_iter – limits how long we go without flushing the accumulator This is necessary to avoid numerical instability for float and complex.
  • vlen – When > 1, do a per-vector-element moving average
moving_average_cc_sptr.active_thread_priority(moving_average_cc_sptr self) → int
moving_average_cc_sptr.declare_sample_delay(moving_average_cc_sptr self, int which, int delay)

declare_sample_delay(moving_average_cc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(moving_average_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(moving_average_cc_sptr self) -> pmt_vector_float

moving_average_cc_sptr.pc_throughput_avg(moving_average_cc_sptr self) → float
moving_average_cc_sptr.pc_work_time_avg(moving_average_cc_sptr self) → float
moving_average_cc_sptr.pc_work_time_total(moving_average_cc_sptr self) → float
moving_average_cc_sptr.sample_delay(moving_average_cc_sptr self, int which) → unsigned int
moving_average_cc_sptr.scale(moving_average_cc_sptr self) → gr_complex

Get the scale factor being used.

moving_average_cc_sptr.set_length(moving_average_cc_sptr self, int length)

Set the length.

moving_average_cc_sptr.set_length_and_scale(moving_average_cc_sptr self, int length, gr_complex scale)

Set both the length and the scale factor together.

moving_average_cc_sptr.set_min_noutput_items(moving_average_cc_sptr self, int m)
moving_average_cc_sptr.set_scale(moving_average_cc_sptr self, gr_complex scale)

Set the scale factor.

moving_average_cc_sptr.set_thread_priority(moving_average_cc_sptr self, int priority) → int
moving_average_cc_sptr.thread_priority(moving_average_cc_sptr self) → int
gnuradio.blocks.moving_average_ff(int length, float scale, int max_iter=4096, unsigned int vlen=1) → moving_average_ff_sptr

output is the moving sum of the last N samples, scaled by the scale factor

Constructor Specific Documentation:

Create a moving average block.

Parameters:
  • length – Number of samples to use in the average.
  • scale – scale factor for the result.
  • max_iter – limits how long we go without flushing the accumulator This is necessary to avoid numerical instability for float and complex.
  • vlen – When > 1, do a per-vector-element moving average
moving_average_ff_sptr.active_thread_priority(moving_average_ff_sptr self) → int
moving_average_ff_sptr.declare_sample_delay(moving_average_ff_sptr self, int which, int delay)

declare_sample_delay(moving_average_ff_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(moving_average_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(moving_average_ff_sptr self) -> pmt_vector_float

moving_average_ff_sptr.pc_throughput_avg(moving_average_ff_sptr self) → float
moving_average_ff_sptr.pc_work_time_avg(moving_average_ff_sptr self) → float
moving_average_ff_sptr.pc_work_time_total(moving_average_ff_sptr self) → float
moving_average_ff_sptr.sample_delay(moving_average_ff_sptr self, int which) → unsigned int
moving_average_ff_sptr.scale(moving_average_ff_sptr self) → float

Get the scale factor being used.

moving_average_ff_sptr.set_length(moving_average_ff_sptr self, int length)

Set the length.

moving_average_ff_sptr.set_length_and_scale(moving_average_ff_sptr self, int length, float scale)

Set both the length and the scale factor together.

moving_average_ff_sptr.set_min_noutput_items(moving_average_ff_sptr self, int m)
moving_average_ff_sptr.set_scale(moving_average_ff_sptr self, float scale)

Set the scale factor.

moving_average_ff_sptr.set_thread_priority(moving_average_ff_sptr self, int priority) → int
moving_average_ff_sptr.thread_priority(moving_average_ff_sptr self) → int
gnuradio.blocks.moving_average_ii(int length, int scale, int max_iter=4096, unsigned int vlen=1) → moving_average_ii_sptr

output is the moving sum of the last N samples, scaled by the scale factor

Constructor Specific Documentation:

Create a moving average block.

Parameters:
  • length – Number of samples to use in the average.
  • scale – scale factor for the result.
  • max_iter – limits how long we go without flushing the accumulator This is necessary to avoid numerical instability for float and complex.
  • vlen – When > 1, do a per-vector-element moving average
moving_average_ii_sptr.active_thread_priority(moving_average_ii_sptr self) → int
moving_average_ii_sptr.declare_sample_delay(moving_average_ii_sptr self, int which, int delay)

declare_sample_delay(moving_average_ii_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(moving_average_ii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(moving_average_ii_sptr self) -> pmt_vector_float

moving_average_ii_sptr.pc_throughput_avg(moving_average_ii_sptr self) → float
moving_average_ii_sptr.pc_work_time_avg(moving_average_ii_sptr self) → float
moving_average_ii_sptr.pc_work_time_total(moving_average_ii_sptr self) → float
moving_average_ii_sptr.sample_delay(moving_average_ii_sptr self, int which) → unsigned int
moving_average_ii_sptr.scale(moving_average_ii_sptr self) → int

Get the scale factor being used.

moving_average_ii_sptr.set_length(moving_average_ii_sptr self, int length)

Set the length.

moving_average_ii_sptr.set_length_and_scale(moving_average_ii_sptr self, int length, int scale)

Set both the length and the scale factor together.

moving_average_ii_sptr.set_min_noutput_items(moving_average_ii_sptr self, int m)
moving_average_ii_sptr.set_scale(moving_average_ii_sptr self, int scale)

Set the scale factor.

moving_average_ii_sptr.set_thread_priority(moving_average_ii_sptr self, int priority) → int
moving_average_ii_sptr.thread_priority(moving_average_ii_sptr self) → int
gnuradio.blocks.moving_average_ss(int length, short scale, int max_iter=4096, unsigned int vlen=1) → moving_average_ss_sptr

output is the moving sum of the last N samples, scaled by the scale factor

Constructor Specific Documentation:

Create a moving average block.

Parameters:
  • length – Number of samples to use in the average.
  • scale – scale factor for the result.
  • max_iter – limits how long we go without flushing the accumulator This is necessary to avoid numerical instability for float and complex.
  • vlen – When > 1, do a per-vector-element moving average
moving_average_ss_sptr.active_thread_priority(moving_average_ss_sptr self) → int
moving_average_ss_sptr.declare_sample_delay(moving_average_ss_sptr self, int which, int delay)

declare_sample_delay(moving_average_ss_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(moving_average_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(moving_average_ss_sptr self) -> pmt_vector_float

moving_average_ss_sptr.pc_throughput_avg(moving_average_ss_sptr self) → float
moving_average_ss_sptr.pc_work_time_avg(moving_average_ss_sptr self) → float
moving_average_ss_sptr.pc_work_time_total(moving_average_ss_sptr self) → float
moving_average_ss_sptr.sample_delay(moving_average_ss_sptr self, int which) → unsigned int
moving_average_ss_sptr.scale(moving_average_ss_sptr self) → short

Get the scale factor being used.

moving_average_ss_sptr.set_length(moving_average_ss_sptr self, int length)

Set the length.

moving_average_ss_sptr.set_length_and_scale(moving_average_ss_sptr self, int length, short scale)

Set both the length and the scale factor together.

moving_average_ss_sptr.set_min_noutput_items(moving_average_ss_sptr self, int m)
moving_average_ss_sptr.set_scale(moving_average_ss_sptr self, short scale)

Set the scale factor.

moving_average_ss_sptr.set_thread_priority(moving_average_ss_sptr self, int priority) → int
moving_average_ss_sptr.thread_priority(moving_average_ss_sptr self) → int
gnuradio.blocks.multiply_cc(size_t vlen=1) → multiply_cc_sptr

output = prod (input_0, input_1, ...)

Multiply across all input streams.

Constructor Specific Documentation:

Multiply streams of complex values.

Parameters:vlen – Vector length
multiply_cc_sptr.active_thread_priority(multiply_cc_sptr self) → int
multiply_cc_sptr.declare_sample_delay(multiply_cc_sptr self, int which, int delay)

declare_sample_delay(multiply_cc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(multiply_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(multiply_cc_sptr self) -> pmt_vector_float

multiply_cc_sptr.pc_throughput_avg(multiply_cc_sptr self) → float
multiply_cc_sptr.pc_work_time_avg(multiply_cc_sptr self) → float
multiply_cc_sptr.pc_work_time_total(multiply_cc_sptr self) → float
multiply_cc_sptr.sample_delay(multiply_cc_sptr self, int which) → unsigned int
multiply_cc_sptr.set_min_noutput_items(multiply_cc_sptr self, int m)
multiply_cc_sptr.set_thread_priority(multiply_cc_sptr self, int priority) → int
multiply_cc_sptr.thread_priority(multiply_cc_sptr self) → int
gnuradio.blocks.multiply_conjugate_cc(size_t vlen=1) → multiply_conjugate_cc_sptr

Multiplies stream 0 by the complex conjugate of stream 1.

Constructor Specific Documentation:

Multiplies a streams by the conjugate of a second stream.

Parameters:vlen – Vector length
multiply_conjugate_cc_sptr.active_thread_priority(multiply_conjugate_cc_sptr self) → int
multiply_conjugate_cc_sptr.declare_sample_delay(multiply_conjugate_cc_sptr self, int which, int delay)

declare_sample_delay(multiply_conjugate_cc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(multiply_conjugate_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(multiply_conjugate_cc_sptr self) -> pmt_vector_float

multiply_conjugate_cc_sptr.pc_throughput_avg(multiply_conjugate_cc_sptr self) → float
multiply_conjugate_cc_sptr.pc_work_time_avg(multiply_conjugate_cc_sptr self) → float
multiply_conjugate_cc_sptr.pc_work_time_total(multiply_conjugate_cc_sptr self) → float
multiply_conjugate_cc_sptr.sample_delay(multiply_conjugate_cc_sptr self, int which) → unsigned int
multiply_conjugate_cc_sptr.set_min_noutput_items(multiply_conjugate_cc_sptr self, int m)
multiply_conjugate_cc_sptr.set_thread_priority(multiply_conjugate_cc_sptr self, int priority) → int
multiply_conjugate_cc_sptr.thread_priority(multiply_conjugate_cc_sptr self) → int
gnuradio.blocks.multiply_const_cc(gr_complex k, size_t vlen=1) → multiply_const_cc_sptr

output = input * complex constant

Constructor Specific Documentation:

Create an instance of multiply_const_cc.

Parameters:
  • k – complex multiplicative constant
  • vlen – Vector length of incoming stream
multiply_const_cc_sptr.active_thread_priority(multiply_const_cc_sptr self) → int
multiply_const_cc_sptr.declare_sample_delay(multiply_const_cc_sptr self, int which, int delay)

declare_sample_delay(multiply_const_cc_sptr self, unsigned int delay)

multiply_const_cc_sptr.k(multiply_const_cc_sptr self) → gr_complex

Return complex multiplicative constant.

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

pc_input_buffers_full_avg(multiply_const_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(multiply_const_cc_sptr self) -> pmt_vector_float

multiply_const_cc_sptr.pc_throughput_avg(multiply_const_cc_sptr self) → float
multiply_const_cc_sptr.pc_work_time_avg(multiply_const_cc_sptr self) → float
multiply_const_cc_sptr.pc_work_time_total(multiply_const_cc_sptr self) → float
multiply_const_cc_sptr.sample_delay(multiply_const_cc_sptr self, int which) → unsigned int
multiply_const_cc_sptr.set_k(multiply_const_cc_sptr self, gr_complex k)

Set complex multiplicative constant.

multiply_const_cc_sptr.set_min_noutput_items(multiply_const_cc_sptr self, int m)
multiply_const_cc_sptr.set_thread_priority(multiply_const_cc_sptr self, int priority) → int
multiply_const_cc_sptr.thread_priority(multiply_const_cc_sptr self) → int
gnuradio.blocks.multiply_const_ff(float k, size_t vlen=1) → multiply_const_ff_sptr

output = input * real constant

Constructor Specific Documentation:

Create an instance of multiply_const_ff.

Parameters:
  • k – real multiplicative constant
  • vlen – Vector length of incoming stream
multiply_const_ff_sptr.active_thread_priority(multiply_const_ff_sptr self) → int
multiply_const_ff_sptr.declare_sample_delay(multiply_const_ff_sptr self, int which, int delay)

declare_sample_delay(multiply_const_ff_sptr self, unsigned int delay)

multiply_const_ff_sptr.k(multiply_const_ff_sptr self) → float

Return real multiplicative constant.

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

pc_input_buffers_full_avg(multiply_const_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(multiply_const_ff_sptr self) -> pmt_vector_float

multiply_const_ff_sptr.pc_throughput_avg(multiply_const_ff_sptr self) → float
multiply_const_ff_sptr.pc_work_time_avg(multiply_const_ff_sptr self) → float
multiply_const_ff_sptr.pc_work_time_total(multiply_const_ff_sptr self) → float
multiply_const_ff_sptr.sample_delay(multiply_const_ff_sptr self, int which) → unsigned int
multiply_const_ff_sptr.set_k(multiply_const_ff_sptr self, float k)

Set real multiplicative constant.

multiply_const_ff_sptr.set_min_noutput_items(multiply_const_ff_sptr self, int m)
multiply_const_ff_sptr.set_thread_priority(multiply_const_ff_sptr self, int priority) → int
multiply_const_ff_sptr.thread_priority(multiply_const_ff_sptr self) → int
gnuradio.blocks.multiply_const_ii(int k) → multiply_const_ii_sptr

output = input * constant

Constructor Specific Documentation:

Create an instance of multiply_const_ii.

Parameters:k – multiplicative constant
multiply_const_ii_sptr.active_thread_priority(multiply_const_ii_sptr self) → int
multiply_const_ii_sptr.declare_sample_delay(multiply_const_ii_sptr self, int which, int delay)

declare_sample_delay(multiply_const_ii_sptr self, unsigned int delay)

multiply_const_ii_sptr.k(multiply_const_ii_sptr self) → int

Return multiplicative constant.

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

pc_input_buffers_full_avg(multiply_const_ii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(multiply_const_ii_sptr self) -> pmt_vector_float

multiply_const_ii_sptr.pc_throughput_avg(multiply_const_ii_sptr self) → float
multiply_const_ii_sptr.pc_work_time_avg(multiply_const_ii_sptr self) → float
multiply_const_ii_sptr.pc_work_time_total(multiply_const_ii_sptr self) → float
multiply_const_ii_sptr.sample_delay(multiply_const_ii_sptr self, int which) → unsigned int
multiply_const_ii_sptr.set_k(multiply_const_ii_sptr self, int k)

Set multiplicative constant.

multiply_const_ii_sptr.set_min_noutput_items(multiply_const_ii_sptr self, int m)
multiply_const_ii_sptr.set_thread_priority(multiply_const_ii_sptr self, int priority) → int
multiply_const_ii_sptr.thread_priority(multiply_const_ii_sptr self) → int
gnuradio.blocks.multiply_const_ss(short k) → multiply_const_ss_sptr

output = input * constant

Constructor Specific Documentation:

Create an instance of multiply_const_ss.

Parameters:k – multiplicative constant
multiply_const_ss_sptr.active_thread_priority(multiply_const_ss_sptr self) → int
multiply_const_ss_sptr.declare_sample_delay(multiply_const_ss_sptr self, int which, int delay)

declare_sample_delay(multiply_const_ss_sptr self, unsigned int delay)

multiply_const_ss_sptr.k(multiply_const_ss_sptr self) → short

Return multiplicative constant.

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

pc_input_buffers_full_avg(multiply_const_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(multiply_const_ss_sptr self) -> pmt_vector_float

multiply_const_ss_sptr.pc_throughput_avg(multiply_const_ss_sptr self) → float
multiply_const_ss_sptr.pc_work_time_avg(multiply_const_ss_sptr self) → float
multiply_const_ss_sptr.pc_work_time_total(multiply_const_ss_sptr self) → float
multiply_const_ss_sptr.sample_delay(multiply_const_ss_sptr self, int which) → unsigned int
multiply_const_ss_sptr.set_k(multiply_const_ss_sptr self, short k)

Set multiplicative constant.

multiply_const_ss_sptr.set_min_noutput_items(multiply_const_ss_sptr self, int m)
multiply_const_ss_sptr.set_thread_priority(multiply_const_ss_sptr self, int priority) → int
multiply_const_ss_sptr.thread_priority(multiply_const_ss_sptr self) → int
gnuradio.blocks.multiply_const_vcc(pmt_vector_cfloat k) → multiply_const_vcc_sptr

output = input * constant vector (element-wise)

Constructor Specific Documentation:

Create an instance of multiply_const_vcc.

Parameters:k – multiplicative constant vector
multiply_const_vcc_sptr.active_thread_priority(multiply_const_vcc_sptr self) → int
multiply_const_vcc_sptr.declare_sample_delay(multiply_const_vcc_sptr self, int which, int delay)

declare_sample_delay(multiply_const_vcc_sptr self, unsigned int delay)

multiply_const_vcc_sptr.k(multiply_const_vcc_sptr self) → pmt_vector_cfloat

Return multiplicative constant vector.

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

pc_input_buffers_full_avg(multiply_const_vcc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(multiply_const_vcc_sptr self) -> pmt_vector_float

multiply_const_vcc_sptr.pc_throughput_avg(multiply_const_vcc_sptr self) → float
multiply_const_vcc_sptr.pc_work_time_avg(multiply_const_vcc_sptr self) → float
multiply_const_vcc_sptr.pc_work_time_total(multiply_const_vcc_sptr self) → float
multiply_const_vcc_sptr.sample_delay(multiply_const_vcc_sptr self, int which) → unsigned int
multiply_const_vcc_sptr.set_k(multiply_const_vcc_sptr self, pmt_vector_cfloat k)

Set multiplicative constant vector.

multiply_const_vcc_sptr.set_min_noutput_items(multiply_const_vcc_sptr self, int m)
multiply_const_vcc_sptr.set_thread_priority(multiply_const_vcc_sptr self, int priority) → int
multiply_const_vcc_sptr.thread_priority(multiply_const_vcc_sptr self) → int
gnuradio.blocks.multiply_const_vff(pmt_vector_float k) → multiply_const_vff_sptr

output = input * constant vector (element-wise)

Constructor Specific Documentation:

Create an instance of multiply_const_vff.

Parameters:k – multiplicative constant vector
multiply_const_vff_sptr.active_thread_priority(multiply_const_vff_sptr self) → int
multiply_const_vff_sptr.declare_sample_delay(multiply_const_vff_sptr self, int which, int delay)

declare_sample_delay(multiply_const_vff_sptr self, unsigned int delay)

multiply_const_vff_sptr.k(multiply_const_vff_sptr self) → pmt_vector_float

Return multiplicative constant vector.

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

pc_input_buffers_full_avg(multiply_const_vff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(multiply_const_vff_sptr self) -> pmt_vector_float

multiply_const_vff_sptr.pc_throughput_avg(multiply_const_vff_sptr self) → float
multiply_const_vff_sptr.pc_work_time_avg(multiply_const_vff_sptr self) → float
multiply_const_vff_sptr.pc_work_time_total(multiply_const_vff_sptr self) → float
multiply_const_vff_sptr.sample_delay(multiply_const_vff_sptr self, int which) → unsigned int
multiply_const_vff_sptr.set_k(multiply_const_vff_sptr self, pmt_vector_float k)

Set multiplicative constant vector.

multiply_const_vff_sptr.set_min_noutput_items(multiply_const_vff_sptr self, int m)
multiply_const_vff_sptr.set_thread_priority(multiply_const_vff_sptr self, int priority) → int
multiply_const_vff_sptr.thread_priority(multiply_const_vff_sptr self) → int
gnuradio.blocks.multiply_const_vii(std::vector< int, std::allocator< int > > k) → multiply_const_vii_sptr

output = input * constant vector (element-wise)

Constructor Specific Documentation:

Create an instance of multiply_const_vii.

Parameters:k – multiplicative constant vector
multiply_const_vii_sptr.active_thread_priority(multiply_const_vii_sptr self) → int
multiply_const_vii_sptr.declare_sample_delay(multiply_const_vii_sptr self, int which, int delay)

declare_sample_delay(multiply_const_vii_sptr self, unsigned int delay)

multiply_const_vii_sptr.k(multiply_const_vii_sptr self) → std::vector< int,std::allocator< int > >

Return multiplicative constant vector.

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

pc_input_buffers_full_avg(multiply_const_vii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(multiply_const_vii_sptr self) -> pmt_vector_float

multiply_const_vii_sptr.pc_throughput_avg(multiply_const_vii_sptr self) → float
multiply_const_vii_sptr.pc_work_time_avg(multiply_const_vii_sptr self) → float
multiply_const_vii_sptr.pc_work_time_total(multiply_const_vii_sptr self) → float
multiply_const_vii_sptr.sample_delay(multiply_const_vii_sptr self, int which) → unsigned int
multiply_const_vii_sptr.set_k(multiply_const_vii_sptr self, std::vector< int, std::allocator< int > > k)

Set multiplicative constant vector.

multiply_const_vii_sptr.set_min_noutput_items(multiply_const_vii_sptr self, int m)
multiply_const_vii_sptr.set_thread_priority(multiply_const_vii_sptr self, int priority) → int
multiply_const_vii_sptr.thread_priority(multiply_const_vii_sptr self) → int
gnuradio.blocks.multiply_const_vss(std::vector< short, std::allocator< short > > k) → multiply_const_vss_sptr

output = input * constant vector (element-wise)

Constructor Specific Documentation:

Create an instance of multiply_const_vss.

Parameters:k – multiplicative constant vector
multiply_const_vss_sptr.active_thread_priority(multiply_const_vss_sptr self) → int
multiply_const_vss_sptr.declare_sample_delay(multiply_const_vss_sptr self, int which, int delay)

declare_sample_delay(multiply_const_vss_sptr self, unsigned int delay)

multiply_const_vss_sptr.k(multiply_const_vss_sptr self) → std::vector< short,std::allocator< short > >

Return multiplicative constant vector.

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

pc_input_buffers_full_avg(multiply_const_vss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(multiply_const_vss_sptr self) -> pmt_vector_float

multiply_const_vss_sptr.pc_throughput_avg(multiply_const_vss_sptr self) → float
multiply_const_vss_sptr.pc_work_time_avg(multiply_const_vss_sptr self) → float
multiply_const_vss_sptr.pc_work_time_total(multiply_const_vss_sptr self) → float
multiply_const_vss_sptr.sample_delay(multiply_const_vss_sptr self, int which) → unsigned int
multiply_const_vss_sptr.set_k(multiply_const_vss_sptr self, std::vector< short, std::allocator< short > > k)

Set multiplicative constant vector.

multiply_const_vss_sptr.set_min_noutput_items(multiply_const_vss_sptr self, int m)
multiply_const_vss_sptr.set_thread_priority(multiply_const_vss_sptr self, int priority) → int
multiply_const_vss_sptr.thread_priority(multiply_const_vss_sptr self) → int
gnuradio.blocks.multiply_ff(size_t vlen=1) → multiply_ff_sptr

output = prod (input_0, input_1, ...)

Multiply across all input streams.

Constructor Specific Documentation:

Multiply streams of float values.

Parameters:vlen – Vector length
multiply_ff_sptr.active_thread_priority(multiply_ff_sptr self) → int
multiply_ff_sptr.declare_sample_delay(multiply_ff_sptr self, int which, int delay)

declare_sample_delay(multiply_ff_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(multiply_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(multiply_ff_sptr self) -> pmt_vector_float

multiply_ff_sptr.pc_throughput_avg(multiply_ff_sptr self) → float
multiply_ff_sptr.pc_work_time_avg(multiply_ff_sptr self) → float
multiply_ff_sptr.pc_work_time_total(multiply_ff_sptr self) → float
multiply_ff_sptr.sample_delay(multiply_ff_sptr self, int which) → unsigned int
multiply_ff_sptr.set_min_noutput_items(multiply_ff_sptr self, int m)
multiply_ff_sptr.set_thread_priority(multiply_ff_sptr self, int priority) → int
multiply_ff_sptr.thread_priority(multiply_ff_sptr self) → int
gnuradio.blocks.multiply_ii(size_t vlen=1) → multiply_ii_sptr

output = prod (input_0, input_1, ...)

Multiply across all input streams.

Constructor Specific Documentation:

Parameters:vlen
multiply_ii_sptr.active_thread_priority(multiply_ii_sptr self) → int
multiply_ii_sptr.declare_sample_delay(multiply_ii_sptr self, int which, int delay)

declare_sample_delay(multiply_ii_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(multiply_ii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(multiply_ii_sptr self) -> pmt_vector_float

multiply_ii_sptr.pc_throughput_avg(multiply_ii_sptr self) → float
multiply_ii_sptr.pc_work_time_avg(multiply_ii_sptr self) → float
multiply_ii_sptr.pc_work_time_total(multiply_ii_sptr self) → float
multiply_ii_sptr.sample_delay(multiply_ii_sptr self, int which) → unsigned int
multiply_ii_sptr.set_min_noutput_items(multiply_ii_sptr self, int m)
multiply_ii_sptr.set_thread_priority(multiply_ii_sptr self, int priority) → int
multiply_ii_sptr.thread_priority(multiply_ii_sptr self) → int
gnuradio.blocks.multiply_matrix_ff(std::vector< std::vector< float, std::allocator< float > >, std::allocator< std::vector< float, std::allocator< float > > > > A, gr::block::tag_propagation_policy_t tag_propagation_policy) → multiply_matrix_ff_sptr

Matrix multiplexer/multiplier: y(k) = A x(k)

This block is similar to gr::blocks::multiply_const_ff, the difference being it can handle several inputs and outputs, and the input-to-output relation can be described by the following mathematical equation: and are column-vectors describing the elements on the input port at time step (this is a sync block with no memory).

Examples for where to use this block include:

This block features a special tag propagation mode: When setting the tag propagation policy to gr::block::TPP_CUSTOM, a tag is propagated from input to output , if .

Message Ports This block as one input message port (). A message sent to this port will be converted to a std::vector<std::vector<float> >, and then passed on to set_A(). If no conversion is possible, a warning is issued via the logging interface, and A remains unchanged.

: It is not possible to change the dimension of the matrix after initialization, as this affects the I/O signature! If a matrix of invalid size is passed to the block, an alert is raised via the logging interface, and A remains unchanged.

Constructor Specific Documentation:

Parameters:
  • A – The matrix
  • tag_propagation_policy – The tag propagation policy. Note this can be any gr::block::tag_propagation_policy_t value. In case of TPP_CUSTOM, tags are only transferred from input to output .
multiply_matrix_ff_sptr.MSG_PORT_NAME_SET_A(multiply_matrix_ff_sptr self) → std::string const &
multiply_matrix_ff_sptr.active_thread_priority(multiply_matrix_ff_sptr self) → int
multiply_matrix_ff_sptr.declare_sample_delay(multiply_matrix_ff_sptr self, int which, int delay)

declare_sample_delay(multiply_matrix_ff_sptr self, unsigned int delay)

multiply_matrix_ff_sptr.get_A(multiply_matrix_ff_sptr self) → std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const &

Returns the current matrix.

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

pc_input_buffers_full_avg(multiply_matrix_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(multiply_matrix_ff_sptr self) -> pmt_vector_float

multiply_matrix_ff_sptr.pc_throughput_avg(multiply_matrix_ff_sptr self) → float
multiply_matrix_ff_sptr.pc_work_time_avg(multiply_matrix_ff_sptr self) → float
multiply_matrix_ff_sptr.pc_work_time_total(multiply_matrix_ff_sptr self) → float
multiply_matrix_ff_sptr.sample_delay(multiply_matrix_ff_sptr self, int which) → unsigned int
multiply_matrix_ff_sptr.set_A(multiply_matrix_ff_sptr self, std::vector< std::vector< float, std::allocator< float > >, std::allocator< std::vector< float, std::allocator< float > > > > const & new_A) → bool

Sets the matrix to a new value . Returns true if the new matrix was valid and could be changed.

multiply_matrix_ff_sptr.set_min_noutput_items(multiply_matrix_ff_sptr self, int m)
multiply_matrix_ff_sptr.set_thread_priority(multiply_matrix_ff_sptr self, int priority) → int
multiply_matrix_ff_sptr.thread_priority(multiply_matrix_ff_sptr self) → int
gnuradio.blocks.multiply_ss(size_t vlen=1) → multiply_ss_sptr

output = prod (input_0, input_1, ...)

Multiply across all input streams.

Constructor Specific Documentation:

Parameters:vlen
multiply_ss_sptr.active_thread_priority(multiply_ss_sptr self) → int
multiply_ss_sptr.declare_sample_delay(multiply_ss_sptr self, int which, int delay)

declare_sample_delay(multiply_ss_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(multiply_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(multiply_ss_sptr self) -> pmt_vector_float

multiply_ss_sptr.pc_throughput_avg(multiply_ss_sptr self) → float
multiply_ss_sptr.pc_work_time_avg(multiply_ss_sptr self) → float
multiply_ss_sptr.pc_work_time_total(multiply_ss_sptr self) → float
multiply_ss_sptr.sample_delay(multiply_ss_sptr self, int which) → unsigned int
multiply_ss_sptr.set_min_noutput_items(multiply_ss_sptr self, int m)
multiply_ss_sptr.set_thread_priority(multiply_ss_sptr self, int priority) → int
multiply_ss_sptr.thread_priority(multiply_ss_sptr self) → int
gnuradio.blocks.mute_cc(bool mute=False) → mute_cc_sptr

output = input or zero if muted.

Constructor Specific Documentation:

Parameters:mute
mute_cc_sptr.active_thread_priority(mute_cc_sptr self) → int
mute_cc_sptr.declare_sample_delay(mute_cc_sptr self, int which, int delay)

declare_sample_delay(mute_cc_sptr self, unsigned int delay)

mute_cc_sptr.message_subscribers(mute_cc_sptr self, swig_int_ptr which_port) → swig_int_ptr
mute_cc_sptr.min_noutput_items(mute_cc_sptr self) → int
mute_cc_sptr.mute(mute_cc_sptr self) → bool
mute_cc_sptr.pc_input_buffers_full_avg(mute_cc_sptr self, int which) → float

pc_input_buffers_full_avg(mute_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(mute_cc_sptr self) -> pmt_vector_float

mute_cc_sptr.pc_throughput_avg(mute_cc_sptr self) → float
mute_cc_sptr.pc_work_time_avg(mute_cc_sptr self) → float
mute_cc_sptr.pc_work_time_total(mute_cc_sptr self) → float
mute_cc_sptr.sample_delay(mute_cc_sptr self, int which) → unsigned int
mute_cc_sptr.set_min_noutput_items(mute_cc_sptr self, int m)
mute_cc_sptr.set_mute(mute_cc_sptr self, bool mute=False)
mute_cc_sptr.set_thread_priority(mute_cc_sptr self, int priority) → int
mute_cc_sptr.thread_priority(mute_cc_sptr self) → int
gnuradio.blocks.mute_ff(bool mute=False) → mute_ff_sptr

output = input or zero if muted.

Constructor Specific Documentation:

Parameters:mute
mute_ff_sptr.active_thread_priority(mute_ff_sptr self) → int
mute_ff_sptr.declare_sample_delay(mute_ff_sptr self, int which, int delay)

declare_sample_delay(mute_ff_sptr self, unsigned int delay)

mute_ff_sptr.message_subscribers(mute_ff_sptr self, swig_int_ptr which_port) → swig_int_ptr
mute_ff_sptr.min_noutput_items(mute_ff_sptr self) → int
mute_ff_sptr.mute(mute_ff_sptr self) → bool
mute_ff_sptr.pc_input_buffers_full_avg(mute_ff_sptr self, int which) → float

pc_input_buffers_full_avg(mute_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(mute_ff_sptr self) -> pmt_vector_float

mute_ff_sptr.pc_throughput_avg(mute_ff_sptr self) → float
mute_ff_sptr.pc_work_time_avg(mute_ff_sptr self) → float
mute_ff_sptr.pc_work_time_total(mute_ff_sptr self) → float
mute_ff_sptr.sample_delay(mute_ff_sptr self, int which) → unsigned int
mute_ff_sptr.set_min_noutput_items(mute_ff_sptr self, int m)
mute_ff_sptr.set_mute(mute_ff_sptr self, bool mute=False)
mute_ff_sptr.set_thread_priority(mute_ff_sptr self, int priority) → int
mute_ff_sptr.thread_priority(mute_ff_sptr self) → int
gnuradio.blocks.mute_ii(bool mute=False) → mute_ii_sptr

output = input or zero if muted.

Constructor Specific Documentation:

Parameters:mute
mute_ii_sptr.active_thread_priority(mute_ii_sptr self) → int
mute_ii_sptr.declare_sample_delay(mute_ii_sptr self, int which, int delay)

declare_sample_delay(mute_ii_sptr self, unsigned int delay)

mute_ii_sptr.message_subscribers(mute_ii_sptr self, swig_int_ptr which_port) → swig_int_ptr
mute_ii_sptr.min_noutput_items(mute_ii_sptr self) → int
mute_ii_sptr.mute(mute_ii_sptr self) → bool
mute_ii_sptr.pc_input_buffers_full_avg(mute_ii_sptr self, int which) → float

pc_input_buffers_full_avg(mute_ii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(mute_ii_sptr self) -> pmt_vector_float

mute_ii_sptr.pc_throughput_avg(mute_ii_sptr self) → float
mute_ii_sptr.pc_work_time_avg(mute_ii_sptr self) → float
mute_ii_sptr.pc_work_time_total(mute_ii_sptr self) → float
mute_ii_sptr.sample_delay(mute_ii_sptr self, int which) → unsigned int
mute_ii_sptr.set_min_noutput_items(mute_ii_sptr self, int m)
mute_ii_sptr.set_mute(mute_ii_sptr self, bool mute=False)
mute_ii_sptr.set_thread_priority(mute_ii_sptr self, int priority) → int
mute_ii_sptr.thread_priority(mute_ii_sptr self) → int
gnuradio.blocks.mute_ss(bool mute=False) → mute_ss_sptr

output = input or zero if muted.

Constructor Specific Documentation:

Parameters:mute
mute_ss_sptr.active_thread_priority(mute_ss_sptr self) → int
mute_ss_sptr.declare_sample_delay(mute_ss_sptr self, int which, int delay)

declare_sample_delay(mute_ss_sptr self, unsigned int delay)

mute_ss_sptr.message_subscribers(mute_ss_sptr self, swig_int_ptr which_port) → swig_int_ptr
mute_ss_sptr.min_noutput_items(mute_ss_sptr self) → int
mute_ss_sptr.mute(mute_ss_sptr self) → bool
mute_ss_sptr.pc_input_buffers_full_avg(mute_ss_sptr self, int which) → float

pc_input_buffers_full_avg(mute_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(mute_ss_sptr self) -> pmt_vector_float

mute_ss_sptr.pc_throughput_avg(mute_ss_sptr self) → float
mute_ss_sptr.pc_work_time_avg(mute_ss_sptr self) → float
mute_ss_sptr.pc_work_time_total(mute_ss_sptr self) → float
mute_ss_sptr.sample_delay(mute_ss_sptr self, int which) → unsigned int
mute_ss_sptr.set_min_noutput_items(mute_ss_sptr self, int m)
mute_ss_sptr.set_mute(mute_ss_sptr self, bool mute=False)
mute_ss_sptr.set_thread_priority(mute_ss_sptr self, int priority) → int
mute_ss_sptr.thread_priority(mute_ss_sptr self) → int
gnuradio.blocks.nlog10_ff(float n=1.0, size_t vlen=1, float k=0.0) → nlog10_ff_sptr

output = n*log10(input) + k

Constructor Specific Documentation:

Make an instance of an nlog10_ff block.

Parameters:
  • n – Scalar multiplicative constant
  • vlen – Input vector length
  • k – Scalar additive constant
nlog10_ff_sptr.active_thread_priority(nlog10_ff_sptr self) → int
nlog10_ff_sptr.declare_sample_delay(nlog10_ff_sptr self, int which, int delay)

declare_sample_delay(nlog10_ff_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(nlog10_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(nlog10_ff_sptr self) -> pmt_vector_float

nlog10_ff_sptr.pc_throughput_avg(nlog10_ff_sptr self) → float
nlog10_ff_sptr.pc_work_time_avg(nlog10_ff_sptr self) → float
nlog10_ff_sptr.pc_work_time_total(nlog10_ff_sptr self) → float
nlog10_ff_sptr.sample_delay(nlog10_ff_sptr self, int which) → unsigned int
nlog10_ff_sptr.set_min_noutput_items(nlog10_ff_sptr self, int m)
nlog10_ff_sptr.set_thread_priority(nlog10_ff_sptr self, int priority) → int
nlog10_ff_sptr.thread_priority(nlog10_ff_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.not_bb(size_t vlen=1) → not_bb_sptr

output = ~input

bitwise boolean not of input streams.

Constructor Specific Documentation:

Parameters:vlen
not_bb_sptr.active_thread_priority(not_bb_sptr self) → int
not_bb_sptr.declare_sample_delay(not_bb_sptr self, int which, int delay)

declare_sample_delay(not_bb_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(not_bb_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(not_bb_sptr self) -> pmt_vector_float

not_bb_sptr.pc_throughput_avg(not_bb_sptr self) → float
not_bb_sptr.pc_work_time_avg(not_bb_sptr self) → float
not_bb_sptr.pc_work_time_total(not_bb_sptr self) → float
not_bb_sptr.sample_delay(not_bb_sptr self, int which) → unsigned int
not_bb_sptr.set_min_noutput_items(not_bb_sptr self, int m)
not_bb_sptr.set_thread_priority(not_bb_sptr self, int priority) → int
not_bb_sptr.thread_priority(not_bb_sptr self) → int
gnuradio.blocks.not_ii(size_t vlen=1) → not_ii_sptr

output = ~input

bitwise boolean not of input streams.

Constructor Specific Documentation:

Parameters:vlen
not_ii_sptr.active_thread_priority(not_ii_sptr self) → int
not_ii_sptr.declare_sample_delay(not_ii_sptr self, int which, int delay)

declare_sample_delay(not_ii_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(not_ii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(not_ii_sptr self) -> pmt_vector_float

not_ii_sptr.pc_throughput_avg(not_ii_sptr self) → float
not_ii_sptr.pc_work_time_avg(not_ii_sptr self) → float
not_ii_sptr.pc_work_time_total(not_ii_sptr self) → float
not_ii_sptr.sample_delay(not_ii_sptr self, int which) → unsigned int
not_ii_sptr.set_min_noutput_items(not_ii_sptr self, int m)
not_ii_sptr.set_thread_priority(not_ii_sptr self, int priority) → int
not_ii_sptr.thread_priority(not_ii_sptr self) → int
gnuradio.blocks.not_ss(size_t vlen=1) → not_ss_sptr

output = ~input

bitwise boolean not of input streams.

Constructor Specific Documentation:

Parameters:vlen
not_ss_sptr.active_thread_priority(not_ss_sptr self) → int
not_ss_sptr.declare_sample_delay(not_ss_sptr self, int which, int delay)

declare_sample_delay(not_ss_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(not_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(not_ss_sptr self) -> pmt_vector_float

not_ss_sptr.pc_throughput_avg(not_ss_sptr self) → float
not_ss_sptr.pc_work_time_avg(not_ss_sptr self) → float
not_ss_sptr.pc_work_time_total(not_ss_sptr self) → float
not_ss_sptr.sample_delay(not_ss_sptr self, int which) → unsigned int
not_ss_sptr.set_min_noutput_items(not_ss_sptr self, int m)
not_ss_sptr.set_thread_priority(not_ss_sptr self, int priority) → int
not_ss_sptr.thread_priority(not_ss_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.or_bb(size_t vlen=1) → or_bb_sptr

output = input_0 | input_1 | , ... | input_N)

Bitwise boolean or across all input streams.

Constructor Specific Documentation:

Parameters:vlen
or_bb_sptr.active_thread_priority(or_bb_sptr self) → int
or_bb_sptr.declare_sample_delay(or_bb_sptr self, int which, int delay)

declare_sample_delay(or_bb_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(or_bb_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(or_bb_sptr self) -> pmt_vector_float

or_bb_sptr.pc_throughput_avg(or_bb_sptr self) → float
or_bb_sptr.pc_work_time_avg(or_bb_sptr self) → float
or_bb_sptr.pc_work_time_total(or_bb_sptr self) → float
or_bb_sptr.sample_delay(or_bb_sptr self, int which) → unsigned int
or_bb_sptr.set_min_noutput_items(or_bb_sptr self, int m)
or_bb_sptr.set_thread_priority(or_bb_sptr self, int priority) → int
or_bb_sptr.thread_priority(or_bb_sptr self) → int
gnuradio.blocks.or_ii(size_t vlen=1) → or_ii_sptr

output = input_0 | input_1 | , ... | input_N)

Bitwise boolean or across all input streams.

Constructor Specific Documentation:

Parameters:vlen
or_ii_sptr.active_thread_priority(or_ii_sptr self) → int
or_ii_sptr.declare_sample_delay(or_ii_sptr self, int which, int delay)

declare_sample_delay(or_ii_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(or_ii_sptr self) -> pmt_vector_float

or_ii_sptr.pc_noutput_items_avg(or_ii_sp