gnuradio.blocks

Processing blocks common to many flowgraphs.

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

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

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

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

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

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

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)

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

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

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)

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

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

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)

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

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

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)

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

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

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)

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

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

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)

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

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

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)

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

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

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)

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

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

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)

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

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

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)

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

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

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

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

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

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

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)

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

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

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)

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

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

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)

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

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

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

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

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

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

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

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

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

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

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)

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)

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

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

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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=GR_FILE_FLOAT, bool complex=True, size_t max_segment_size=1000000, std::string const & extra_dict="", bool detached_header=False) → file_meta_sink_sptr

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

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

file_sink_sptr.active_thread_priority(file_sink_sptr self) → int

file_sink_sptr.close(file_sink_sptr self)

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)

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

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)

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

file_source_sptr.active_thread_priority(file_source_sptr self) → int

file_source_sptr.close(file_source_sptr self)

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)

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

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

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

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)

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

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

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

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)

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

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

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)

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

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

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

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

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

message_strobe_sptr.set_period(message_strobe_sptr self, float period_ms)

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

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

message_strobe_random_sptr.mean(message_strobe_random_sptr self) → float

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

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)

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)

message_strobe_random_sptr.set_std(message_strobe_random_sptr self, float std)

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

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

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

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

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) → moving_average_cc_sptr

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

moving_average_cc_sptr.set_length(moving_average_cc_sptr self, int length)

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

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)

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) → moving_average_ff_sptr

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

moving_average_ff_sptr.set_length(moving_average_ff_sptr self, int length)

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

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)

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) → moving_average_ii_sptr

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

moving_average_ii_sptr.set_length(moving_average_ii_sptr self, int length)

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

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)

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) → moving_average_ss_sptr

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

moving_average_ss_sptr.set_length(moving_average_ss_sptr self, int length)

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

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)

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

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

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

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

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)

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

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

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)

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

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

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)

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

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

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)

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

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

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)

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

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

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)

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

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

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)

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

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

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)

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

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

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=gr::block::TPP_ALL_TO_ALL) → multiply_matrix_ff_sptr

multiply_matrix_ff_sptr.MSG_PORT_NAME_SET_A(multiply_matrix_ff_sptr self) → std::string const &

multiply_matrix_ff_sptr.TPP_SELECT_BY_MATRIX(multiply_matrix_ff_sptr self) → int 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 &

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

multiply_matrix_ff_sptr.set_min_noutput_items(multiply_matrix_ff_sptr self, int m)

multiply_matrix_ff_sptr.set_tag_propagation_policy(multiply_matrix_ff_sptr self, gr::block::tag_propagation_policy_t p)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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_sptr self) → float

or_ii_sptr.pc_nproduced_avg(or_ii_sptr self) → float

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

pc_output_buffers_full_avg(or_ii_sptr self) -> pmt_vector_float

or_ii_sptr.pc_throughput_avg(or_ii_sptr self) → float

or_ii_sptr.pc_work_time_avg(or_ii_sptr self) → float

or_ii_sptr.pc_work_time_total(or_ii_sptr self) → float

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

or_ii_sptr.set_min_noutput_items(or_ii_sptr self, int m)

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

or_ii_sptr.thread_priority(or_ii_sptr self) → int

gnuradio.blocks.or_ss(size_t vlen=1) → or_ss_sptr

or_ss_sptr.active_thread_priority(or_ss_sptr self) → int

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

declare_sample_delay(or_ss_sptr self, unsigned int delay)

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

or_ss_sptr.min_noutput_items(or_ss_sptr self) → int

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

pc_input_buffers_full_avg(or_ss_sptr self) -> pmt_vector_float

or_ss_sptr.pc_noutput_items_avg(or_ss_sptr self) → float

or_ss_sptr.pc_nproduced_avg(or_ss_sptr self) → float

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

pc_output_buffers_full_avg(or_ss_sptr self) -> pmt_vector_float

or_ss_sptr.pc_throughput_avg(or_ss_sptr self) → float

or_ss_sptr.pc_work_time_avg(or_ss_sptr self) → float

or_ss_sptr.pc_work_time_total(or_ss_sptr self) → float

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

or_ss_sptr.set_min_noutput_items(or_ss_sptr self, int m)

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

or_ss_sptr.thread_priority(or_ss_sptr self) → int

gnuradio.blocks.pack_k_bits_bb(unsigned int k) → pack_k_bits_bb_sptr

pack_k_bits_bb_sptr.active_thread_priority(pack_k_bits_bb_sptr self) → int

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

declare_sample_delay(pack_k_bits_bb_sptr self, unsigned int delay)

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

pack_k_bits_bb_sptr.min_noutput_items(pack_k_bits_bb_sptr self) → int

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

pc_input_buffers_full_avg(pack_k_bits_bb_sptr self) -> pmt_vector_float

pack_k_bits_bb_sptr.pc_noutput_items_avg(pack_k_bits_bb_sptr self) → float

pack_k_bits_bb_sptr.pc_nproduced_avg(pack_k_bits_bb_sptr self) → float

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

pc_output_buffers_full_avg(pack_k_bits_bb_sptr self) -> pmt_vector_float

pack_k_bits_bb_sptr.pc_throughput_avg(pack_k_bits_bb_sptr self) → float

pack_k_bits_bb_sptr.pc_work_time_avg(pack_k_bits_bb_sptr self) → float

pack_k_bits_bb_sptr.pc_work_time_total(pack_k_bits_bb_sptr self) → float

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

pack_k_bits_bb_sptr.set_min_noutput_items(pack_k_bits_bb_sptr self, int m)

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

pack_k_bits_bb_sptr.thread_priority(pack_k_bits_bb_sptr self) → int

gnuradio.blocks.packed_to_unpacked_bb(unsigned int bits_per_chunk, gr::endianness_t endianness) → packed_to_unpacked_bb_sptr

packed_to_unpacked_bb_sptr.active_thread_priority(packed_to_unpacked_bb_sptr self) → int

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

declare_sample_delay(packed_to_unpacked_bb_sptr self, unsigned int delay)

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

packed_to_unpacked_bb_sptr.min_noutput_items(packed_to_unpacked_bb_sptr self) → int

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

pc_input_buffers_full_avg(packed_to_unpacked_bb_sptr self) -> pmt_vector_float

packed_to_unpacked_bb_sptr.pc_noutput_items_avg(packed_to_unpacked_bb_sptr self) → float

packed_to_unpacked_bb_sptr.pc_nproduced_avg(packed_to_unpacked_bb_sptr self) → float

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

pc_output_buffers_full_avg(packed_to_unpacked_bb_sptr self) -> pmt_vector_float

packed_to_unpacked_bb_sptr.pc_throughput_avg(packed_to_unpacked_bb_sptr self) → float

packed_to_unpacked_bb_sptr.pc_work_time_avg(packed_to_unpacked_bb_sptr self) → float

packed_to_unpacked_bb_sptr.pc_work_time_total(packed_to_unpacked_bb_sptr self) → float

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

packed_to_unpacked_bb_sptr.set_min_noutput_items(packed_to_unpacked_bb_sptr self, int m)

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

packed_to_unpacked_bb_sptr.thread_priority(packed_to_unpacked_bb_sptr self) → int

gnuradio.blocks.packed_to_unpacked_ii(unsigned int bits_per_chunk, gr::endianness_t endianness) → packed_to_unpacked_ii_sptr

packed_to_unpacked_ii_sptr.active_thread_priority(packed_to_unpacked_ii_sptr self) → int

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

declare_sample_delay(packed_to_unpacked_ii_sptr self, unsigned int delay)

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

packed_to_unpacked_ii_sptr.min_noutput_items(packed_to_unpacked_ii_sptr self) → int

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

pc_input_buffers_full_avg(packed_to_unpacked_ii_sptr self) -> pmt_vector_float

packed_to_unpacked_ii_sptr.pc_noutput_items_avg(packed_to_unpacked_ii_sptr self) → float

packed_to_unpacked_ii_sptr.pc_nproduced_avg(packed_to_unpacked_ii_sptr self) → float

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

pc_output_buffers_full_avg(packed_to_unpacked_ii_sptr self) -> pmt_vector_float

packed_to_unpacked_ii_sptr.pc_throughput_avg(packed_to_unpacked_ii_sptr self) → float

packed_to_unpacked_ii_sptr.pc_work_time_avg(packed_to_unpacked_ii_sptr self) → float

packed_to_unpacked_ii_sptr.pc_work_time_total(packed_to_unpacked_ii_sptr self) → float

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

packed_to_unpacked_ii_sptr.set_min_noutput_items(packed_to_unpacked_ii_sptr self, int m)

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

packed_to_unpacked_ii_sptr.thread_priority(packed_to_unpacked_ii_sptr self) → int

gnuradio.blocks.packed_to_unpacked_ss(unsigned int bits_per_chunk, gr::endianness_t endianness) → packed_to_unpacked_ss_sptr

packed_to_unpacked_ss_sptr.active_thread_priority(packed_to_unpacked_ss_sptr self) → int

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

declare_sample_delay(packed_to_unpacked_ss_sptr self, unsigned int delay)

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

packed_to_unpacked_ss_sptr.min_noutput_items(packed_to_unpacked_ss_sptr self) → int

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

pc_input_buffers_full_avg(packed_to_unpacked_ss_sptr self) -> pmt_vector_float

packed_to_unpacked_ss_sptr.pc_noutput_items_avg(packed_to_unpacked_ss_sptr self) → float

packed_to_unpacked_ss_sptr.pc_nproduced_avg(packed_to_unpacked_ss_sptr self) → float

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

pc_output_buffers_full_avg(packed_to_unpacked_ss_sptr self) -> pmt_vector_float

packed_to_unpacked_ss_sptr.pc_throughput_avg(packed_to_unpacked_ss_sptr self) → float

packed_to_unpacked_ss_sptr.pc_work_time_avg(packed_to_unpacked_ss_sptr self) → float

packed_to_unpacked_ss_sptr.pc_work_time_total(packed_to_unpacked_ss_sptr self) → float

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

packed_to_unpacked_ss_sptr.set_min_noutput_items(packed_to_unpacked_ss_sptr self, int m)

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

packed_to_unpacked_ss_sptr.thread_priority(packed_to_unpacked_ss_sptr self) → int

gnuradio.blocks.patterned_interleaver(size_t itemsize, std::vector< int, std::allocator< int > > pattern) → patterned_interleaver_sptr

patterned_interleaver_sptr.active_thread_priority(patterned_interleaver_sptr self) → int

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

declare_sample_delay(patterned_interleaver_sptr self, unsigned int delay)

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

patterned_interleaver_sptr.min_noutput_items(patterned_interleaver_sptr self) → int

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

pc_input_buffers_full_avg(patterned_interleaver_sptr self) -> pmt_vector_float

patterned_interleaver_sptr.pc_noutput_items_avg(patterned_interleaver_sptr self) → float

patterned_interleaver_sptr.pc_nproduced_avg(patterned_interleaver_sptr self) → float

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

pc_output_buffers_full_avg(patterned_interleaver_sptr self) -> pmt_vector_float

patterned_interleaver_sptr.pc_throughput_avg(patterned_interleaver_sptr self) → float

patterned_interleaver_sptr.pc_work_time_avg(patterned_interleaver_sptr self) → float

patterned_interleaver_sptr.pc_work_time_total(patterned_interleaver_sptr self) → float

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

patterned_interleaver_sptr.set_min_noutput_items(patterned_interleaver_sptr self, int m)

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

patterned_interleaver_sptr.thread_priority(patterned_interleaver_sptr self) → int

gnuradio.blocks.pdu_filter(swig_int_ptr k, swig_int_ptr v, bool invert=False) → pdu_filter_sptr

pdu_filter_sptr.active_thread_priority(pdu_filter_sptr self) → int

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

declare_sample_delay(pdu_filter_sptr self, unsigned int delay)

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

pdu_filter_sptr.min_noutput_items(pdu_filter_sptr self) → int

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

pc_input_buffers_full_avg(pdu_filter_sptr self) -> pmt_vector_float

pdu_filter_sptr.pc_noutput_items_avg(pdu_filter_sptr self) → float

pdu_filter_sptr.pc_nproduced_avg(pdu_filter_sptr self) → float

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

pc_output_buffers_full_avg(pdu_filter_sptr self) -> pmt_vector_float

pdu_filter_sptr.pc_throughput_avg(pdu_filter_sptr self) → float

pdu_filter_sptr.pc_work_time_avg(pdu_filter_sptr self) → float

pdu_filter_sptr.pc_work_time_total(pdu_filter_sptr self) → float

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

pdu_filter_sptr.set_min_noutput_items(pdu_filter_sptr self, int m)

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

pdu_filter_sptr.thread_priority(pdu_filter_sptr self) → int

gnuradio.blocks.pdu_remove(swig_int_ptr k) → pdu_remove_sptr

pdu_remove_sptr.active_thread_priority(pdu_remove_sptr self) → int

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

declare_sample_delay(pdu_remove_sptr self, unsigned int delay)

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

pdu_remove_sptr.min_noutput_items(pdu_remove_sptr self) → int

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

pc_input_buffers_full_avg(pdu_remove_sptr self) -> pmt_vector_float

pdu_remove_sptr.pc_noutput_items_avg(pdu_remove_sptr self) → float

pdu_remove_sptr.pc_nproduced_avg(pdu_remove_sptr self) → float

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

pc_output_buffers_full_avg(pdu_remove_sptr self) -> pmt_vector_float

pdu_remove_sptr.pc_throughput_avg(pdu_remove_sptr self) → float

pdu_remove_sptr.pc_work_time_avg(pdu_remove_sptr self) → float

pdu_remove_sptr.pc_work_time_total(pdu_remove_sptr self) → float

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

pdu_remove_sptr.set_min_noutput_items(pdu_remove_sptr self, int m)

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

pdu_remove_sptr.thread_priority(pdu_remove_sptr self) → int

gnuradio.blocks.pdu_set(swig_int_ptr k, swig_int_ptr v) → pdu_set_sptr

pdu_set_sptr.active_thread_priority(pdu_set_sptr self) → int

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

declare_sample_delay(pdu_set_sptr self, unsigned int delay)

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

pdu_set_sptr.min_noutput_items(pdu_set_sptr self) → int

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

pc_input_buffers_full_avg(pdu_set_sptr self) -> pmt_vector_float

pdu_set_sptr.pc_noutput_items_avg(pdu_set_sptr self) → float

pdu_set_sptr.pc_nproduced_avg(pdu_set_sptr self) → float

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

pc_output_buffers_full_avg(pdu_set_sptr self) -> pmt_vector_float

pdu_set_sptr.pc_throughput_avg(pdu_set_sptr self) → float

pdu_set_sptr.pc_work_time_avg(pdu_set_sptr self) → float

pdu_set_sptr.pc_work_time_total(pdu_set_sptr self) → float

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

pdu_set_sptr.set_min_noutput_items(pdu_set_sptr self, int m)

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

pdu_set_sptr.thread_priority(pdu_set_sptr self) → int

gnuradio.blocks.pdu_to_tagged_stream(gr::blocks::pdu::vector_type type, std::string const & lengthtagname="packet_len") → pdu_to_tagged_stream_sptr

pdu_to_tagged_stream_sptr.active_thread_priority(pdu_to_tagged_stream_sptr self) → int

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

declare_sample_delay(pdu_to_tagged_stream_sptr self, unsigned int delay)

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

pdu_to_tagged_stream_sptr.min_noutput_items(pdu_to_tagged_stream_sptr self) → int

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

pc_input_buffers_full_avg(pdu_to_tagged_stream_sptr self) -> pmt_vector_float

pdu_to_tagged_stream_sptr.pc_noutput_items_avg(pdu_to_tagged_stream_sptr self) → float

pdu_to_tagged_stream_sptr.pc_nproduced_avg(pdu_to_tagged_stream_sptr self) → float

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

pc_output_buffers_full_avg(pdu_to_tagged_stream_sptr self) -> pmt_vector_float

pdu_to_tagged_stream_sptr.pc_throughput_avg(pdu_to_tagged_stream_sptr self) → float

pdu_to_tagged_stream_sptr.pc_work_time_avg(pdu_to_tagged_stream_sptr self) → float

pdu_to_tagged_stream_sptr.pc_work_time_total(pdu_to_tagged_stream_sptr self) → float

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

pdu_to_tagged_stream_sptr.set_min_noutput_items(pdu_to_tagged_stream_sptr self, int m)

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

pdu_to_tagged_stream_sptr.thread_priority(pdu_to_tagged_stream_sptr self) → int

gnuradio.blocks.peak_detector2_fb(float threshold_factor_rise=7, int look_ahead=1000, float alpha=0.001) → peak_detector2_fb_sptr

peak_detector2_fb_sptr.active_thread_priority(peak_detector2_fb_sptr self) → int

peak_detector2_fb_sptr.alpha(peak_detector2_fb_sptr self) → float

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

declare_sample_delay(peak_detector2_fb_sptr self, unsigned int delay)

peak_detector2_fb_sptr.look_ahead(peak_detector2_fb_sptr self) → int

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

peak_detector2_fb_sptr.min_noutput_items(peak_detector2_fb_sptr self) → int

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

pc_input_buffers_full_avg(peak_detector2_fb_sptr self) -> pmt_vector_float

peak_detector2_fb_sptr.pc_noutput_items_avg(peak_detector2_fb_sptr self) → float

peak_detector2_fb_sptr.pc_nproduced_avg(peak_detector2_fb_sptr self) → float

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

pc_output_buffers_full_avg(peak_detector2_fb_sptr self) -> pmt_vector_float

peak_detector2_fb_sptr.pc_throughput_avg(peak_detector2_fb_sptr self) → float

peak_detector2_fb_sptr.pc_work_time_avg(peak_detector2_fb_sptr self) → float

peak_detector2_fb_sptr.pc_work_time_total(peak_detector2_fb_sptr self) → float

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

peak_detector2_fb_sptr.set_alpha(peak_detector2_fb_sptr self, float alpha)

peak_detector2_fb_sptr.set_look_ahead(peak_detector2_fb_sptr self, int look)

peak_detector2_fb_sptr.set_min_noutput_items(peak_detector2_fb_sptr self, int m)

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

peak_detector2_fb_sptr.set_threshold_factor_rise(peak_detector2_fb_sptr self, float thr)

peak_detector2_fb_sptr.thread_priority(peak_detector2_fb_sptr self) → int

peak_detector2_fb_sptr.threshold_factor_rise(peak_detector2_fb_sptr self) → float

gnuradio.blocks.peak_detector_fb(float threshold_factor_rise=0.25, float threshold_factor_fall=0.40, int look_ahead=10, float alpha=0.001) → peak_detector_fb_sptr

peak_detector_fb_sptr.active_thread_priority(peak_detector_fb_sptr self) → int

peak_detector_fb_sptr.alpha(peak_detector_fb_sptr self) → float

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

declare_sample_delay(peak_detector_fb_sptr self, unsigned int delay)

peak_detector_fb_sptr.look_ahead(peak_detector_fb_sptr self) → int

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

peak_detector_fb_sptr.min_noutput_items(peak_detector_fb_sptr self) → int

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

pc_input_buffers_full_avg(peak_detector_fb_sptr self) -> pmt_vector_float

peak_detector_fb_sptr.pc_noutput_items_avg(peak_detector_fb_sptr self) → float

peak_detector_fb_sptr.pc_nproduced_avg(peak_detector_fb_sptr self) → float

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

pc_output_buffers_full_avg(peak_detector_fb_sptr self) -> pmt_vector_float

peak_detector_fb_sptr.pc_throughput_avg(peak_detector_fb_sptr self) → float

peak_detector_fb_sptr.pc_work_time_avg(peak_detector_fb_sptr self) → float

peak_detector_fb_sptr.pc_work_time_total(peak_detector_fb_sptr self) → float

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

peak_detector_fb_sptr.set_alpha(peak_detector_fb_sptr self, float alpha)

peak_detector_fb_sptr.set_look_ahead(peak_detector_fb_sptr self, int look)

peak_detector_fb_sptr.set_min_noutput_items(peak_detector_fb_sptr self, int m)

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

peak_detector_fb_sptr.set_threshold_factor_fall(peak_detector_fb_sptr self, float thr)

peak_detector_fb_sptr.set_threshold_factor_rise(peak_detector_fb_sptr self, float thr)

peak_detector_fb_sptr.thread_priority(peak_detector_fb_sptr self) → int

peak_detector_fb_sptr.threshold_factor_fall(peak_detector_fb_sptr self) → float

peak_detector_fb_sptr.threshold_factor_rise(peak_detector_fb_sptr self) → float

gnuradio.blocks.peak_detector_ib(float threshold_factor_rise=0.25, float threshold_factor_fall=0.40, int look_ahead=10, float alpha=0.001) → peak_detector_ib_sptr

peak_detector_ib_sptr.active_thread_priority(peak_detector_ib_sptr self) → int

peak_detector_ib_sptr.alpha(peak_detector_ib_sptr self) → float

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

declare_sample_delay(peak_detector_ib_sptr self, unsigned int delay)

peak_detector_ib_sptr.look_ahead(peak_detector_ib_sptr self) → int

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

peak_detector_ib_sptr.min_noutput_items(peak_detector_ib_sptr self) → int

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

pc_input_buffers_full_avg(peak_detector_ib_sptr self) -> pmt_vector_float

peak_detector_ib_sptr.pc_noutput_items_avg(peak_detector_ib_sptr self) → float

peak_detector_ib_sptr.pc_nproduced_avg(peak_detector_ib_sptr self) → float

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

pc_output_buffers_full_avg(peak_detector_ib_sptr self) -> pmt_vector_float

peak_detector_ib_sptr.pc_throughput_avg(peak_detector_ib_sptr self) → float

peak_detector_ib_sptr.pc_work_time_avg(peak_detector_ib_sptr self) → float

peak_detector_ib_sptr.pc_work_time_total(peak_detector_ib_sptr self) → float

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

peak_detector_ib_sptr.set_alpha(peak_detector_ib_sptr self, float alpha)

peak_detector_ib_sptr.set_look_ahead(peak_detector_ib_sptr self, int look)

peak_detector_ib_sptr.set_min_noutput_items(peak_detector_ib_sptr self, int m)

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

peak_detector_ib_sptr.set_threshold_factor_fall(peak_detector_ib_sptr self, float thr)

peak_detector_ib_sptr.set_threshold_factor_rise(peak_detector_ib_sptr self, float thr)

peak_detector_ib_sptr.thread_priority(peak_detector_ib_sptr self) → int

peak_detector_ib_sptr.threshold_factor_fall(peak_detector_ib_sptr self) → float

peak_detector_ib_sptr.threshold_factor_rise(peak_detector_ib_sptr self) → float

gnuradio.blocks.peak_detector_sb(float threshold_factor_rise=0.25, float threshold_factor_fall=0.40, int look_ahead=10, float alpha=0.001) → peak_detector_sb_sptr

peak_detector_sb_sptr.active_thread_priority(peak_detector_sb_sptr self) → int

peak_detector_sb_sptr.alpha(peak_detector_sb_sptr self) → float

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

declare_sample_delay(peak_detector_sb_sptr self, unsigned int delay)

peak_detector_sb_sptr.look_ahead(peak_detector_sb_sptr self) → int

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

peak_detector_sb_sptr.min_noutput_items(peak_detector_sb_sptr self) → int

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

pc_input_buffers_full_avg(peak_detector_sb_sptr self) -> pmt_vector_float

peak_detector_sb_sptr.pc_noutput_items_avg(peak_detector_sb_sptr self) → float

peak_detector_sb_sptr.pc_nproduced_avg(peak_detector_sb_sptr self) → float

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

pc_output_buffers_full_avg(peak_detector_sb_sptr self) -> pmt_vector_float

peak_detector_sb_sptr.pc_throughput_avg(peak_detector_sb_sptr self) → float

peak_detector_sb_sptr.pc_work_time_avg(peak_detector_sb_sptr self) → float

peak_detector_sb_sptr.pc_work_time_total(peak_detector_sb_sptr self) → float

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

peak_detector_sb_sptr.set_alpha(peak_detector_sb_sptr self, float alpha)

peak_detector_sb_sptr.set_look_ahead(peak_detector_sb_sptr self, int look)

peak_detector_sb_sptr.set_min_noutput_items(peak_detector_sb_sptr self, int m)

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

peak_detector_sb_sptr.set_threshold_factor_fall(peak_detector_sb_sptr self, float thr)

peak_detector_sb_sptr.set_threshold_factor_rise(peak_detector_sb_sptr self, float thr)

peak_detector_sb_sptr.thread_priority(peak_detector_sb_sptr self) → int

peak_detector_sb_sptr.threshold_factor_fall(peak_detector_sb_sptr self) → float

peak_detector_sb_sptr.threshold_factor_rise(peak_detector_sb_sptr self) → float

gnuradio.blocks.plateau_detector_fb(int max_len, float threshold=0.9) → plateau_detector_fb_sptr

plateau_detector_fb_sptr.active_thread_priority(plateau_detector_fb_sptr self) → int

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

declare_sample_delay(plateau_detector_fb_sptr self, unsigned int delay)

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

plateau_detector_fb_sptr.min_noutput_items(plateau_detector_fb_sptr self) → int

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

pc_input_buffers_full_avg(plateau_detector_fb_sptr self) -> pmt_vector_float

plateau_detector_fb_sptr.pc_noutput_items_avg(plateau_detector_fb_sptr self) → float

plateau_detector_fb_sptr.pc_nproduced_avg(plateau_detector_fb_sptr self) → float

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

pc_output_buffers_full_avg(plateau_detector_fb_sptr self) -> pmt_vector_float

plateau_detector_fb_sptr.pc_throughput_avg(plateau_detector_fb_sptr self) → float

plateau_detector_fb_sptr.pc_work_time_avg(plateau_detector_fb_sptr self) → float

plateau_detector_fb_sptr.pc_work_time_total(plateau_detector_fb_sptr self) → float

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

plateau_detector_fb_sptr.set_min_noutput_items(plateau_detector_fb_sptr self, int m)

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

plateau_detector_fb_sptr.thread_priority(plateau_detector_fb_sptr self) → int

gnuradio.blocks.probe_rate(size_t itemsize, double update_rate_ms=500.0, double alpha=0.0001) → probe_rate_sptr

probe_rate_sptr.active_thread_priority(probe_rate_sptr self) → int

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

declare_sample_delay(probe_rate_sptr self, unsigned int delay)

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

probe_rate_sptr.min_noutput_items(probe_rate_sptr self) → int

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

pc_input_buffers_full_avg(probe_rate_sptr self) -> pmt_vector_float

probe_rate_sptr.pc_noutput_items_avg(probe_rate_sptr self) → float

probe_rate_sptr.pc_nproduced_avg(probe_rate_sptr self) → float

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

pc_output_buffers_full_avg(probe_rate_sptr self) -> pmt_vector_float

probe_rate_sptr.pc_throughput_avg(probe_rate_sptr self) → float

probe_rate_sptr.pc_work_time_avg(probe_rate_sptr self) → float

probe_rate_sptr.pc_work_time_total(probe_rate_sptr self) → float

probe_rate_sptr.rate(probe_rate_sptr self) → double

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

probe_rate_sptr.set_alpha(probe_rate_sptr self, double alpha)

probe_rate_sptr.set_min_noutput_items(probe_rate_sptr self, int m)

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

probe_rate_sptr.thread_priority(probe_rate_sptr self) → int

gnuradio.blocks.probe_signal_b() → probe_signal_b_sptr

probe_signal_b_sptr.active_thread_priority(probe_signal_b_sptr self) → int

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

declare_sample_delay(probe_signal_b_sptr self, unsigned int delay)

probe_signal_b_sptr.level(probe_signal_b_sptr self) → unsigned char

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

probe_signal_b_sptr.min_noutput_items(probe_signal_b_sptr self) → int

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

pc_input_buffers_full_avg(probe_signal_b_sptr self) -> pmt_vector_float

probe_signal_b_sptr.pc_noutput_items_avg(probe_signal_b_sptr self) → float

probe_signal_b_sptr.pc_nproduced_avg(probe_signal_b_sptr self) → float

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

pc_output_buffers_full_avg(probe_signal_b_sptr self) -> pmt_vector_float

probe_signal_b_sptr.pc_throughput_avg(probe_signal_b_sptr self) → float

probe_signal_b_sptr.pc_work_time_avg(probe_signal_b_sptr self) → float

probe_signal_b_sptr.pc_work_time_total(probe_signal_b_sptr self) → float

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

probe_signal_b_sptr.set_min_noutput_items(probe_signal_b_sptr self, int m)

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

probe_signal_b_sptr.thread_priority(probe_signal_b_sptr self) → int

gnuradio.blocks.probe_signal_c() → probe_signal_c_sptr

probe_signal_c_sptr.active_thread_priority(probe_signal_c_sptr self) → int

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

declare_sample_delay(probe_signal_c_sptr self, unsigned int delay)

probe_signal_c_sptr.level(probe_signal_c_sptr self) → gr_complex

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

probe_signal_c_sptr.min_noutput_items(probe_signal_c_sptr self) → int

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

pc_input_buffers_full_avg(probe_signal_c_sptr self) -> pmt_vector_float

probe_signal_c_sptr.pc_noutput_items_avg(probe_signal_c_sptr self) → float

probe_signal_c_sptr.pc_nproduced_avg(probe_signal_c_sptr self) → float

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

pc_output_buffers_full_avg(probe_signal_c_sptr self) -> pmt_vector_float

probe_signal_c_sptr.pc_throughput_avg(probe_signal_c_sptr self) → float

probe_signal_c_sptr.pc_work_time_avg(probe_signal_c_sptr self) → float

probe_signal_c_sptr.pc_work_time_total(probe_signal_c_sptr self) → float

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

probe_signal_c_sptr.set_min_noutput_items(probe_signal_c_sptr self, int m)

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

probe_signal_c_sptr.thread_priority(probe_signal_c_sptr self) → int

gnuradio.blocks.probe_signal_f() → probe_signal_f_sptr

probe_signal_f_sptr.active_thread_priority(probe_signal_f_sptr self) → int

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

declare_sample_delay(probe_signal_f_sptr self, unsigned int delay)

probe_signal_f_sptr.level(probe_signal_f_sptr self) → float

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

probe_signal_f_sptr.min_noutput_items(probe_signal_f_sptr self) → int

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

pc_input_buffers_full_avg(probe_signal_f_sptr self) -> pmt_vector_float

probe_signal_f_sptr.pc_noutput_items_avg(probe_signal_f_sptr self) → float

probe_signal_f_sptr.pc_nproduced_avg(probe_signal_f_sptr self) → float

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

pc_output_buffers_full_avg(probe_signal_f_sptr self) -> pmt_vector_float

probe_signal_f_sptr.pc_throughput_avg(probe_signal_f_sptr self) → float

probe_signal_f_sptr.pc_work_time_avg(probe_signal_f_sptr self) → float

probe_signal_f_sptr.pc_work_time_total(probe_signal_f_sptr self) → float

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

probe_signal_f_sptr.set_min_noutput_items(probe_signal_f_sptr self, int m)

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

probe_signal_f_sptr.thread_priority(probe_signal_f_sptr self) → int

gnuradio.blocks.probe_signal_i() → probe_signal_i_sptr

probe_signal_i_sptr.active_thread_priority(probe_signal_i_sptr self) → int

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

declare_sample_delay(probe_signal_i_sptr self, unsigned int delay)

probe_signal_i_sptr.level(probe_signal_i_sptr self) → int

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

probe_signal_i_sptr.min_noutput_items(probe_signal_i_sptr self) → int

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

pc_input_buffers_full_avg(probe_signal_i_sptr self) -> pmt_vector_float

probe_signal_i_sptr.pc_noutput_items_avg(probe_signal_i_sptr self) → float

probe_signal_i_sptr.pc_nproduced_avg(probe_signal_i_sptr self) → float

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

pc_output_buffers_full_avg(probe_signal_i_sptr self) -> pmt_vector_float

probe_signal_i_sptr.pc_throughput_avg(probe_signal_i_sptr self) → float

probe_signal_i_sptr.pc_work_time_avg(probe_signal_i_sptr self) → float

probe_signal_i_sptr.pc_work_time_total(probe_signal_i_sptr self) → float

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

probe_signal_i_sptr.set_min_noutput_items(probe_signal_i_sptr self, int m)

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

probe_signal_i_sptr.thread_priority(probe_signal_i_sptr self) → int

gnuradio.blocks.probe_signal_s() → probe_signal_s_sptr

probe_signal_s_sptr.active_thread_priority(probe_signal_s_sptr self) → int

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

declare_sample_delay(probe_signal_s_sptr self, unsigned int delay)

probe_signal_s_sptr.level(probe_signal_s_sptr self) → short

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

probe_signal_s_sptr.min_noutput_items(probe_signal_s_sptr self) → int

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

pc_input_buffers_full_avg(probe_signal_s_sptr self) -> pmt_vector_float

probe_signal_s_sptr.pc_noutput_items_avg(probe_signal_s_sptr self) → float

probe_signal_s_sptr.pc_nproduced_avg(probe_signal_s_sptr self) → float

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

pc_output_buffers_full_avg(probe_signal_s_sptr self) -> pmt_vector_float

probe_signal_s_sptr.pc_throughput_avg(probe_signal_s_sptr self) → float

probe_signal_s_sptr.pc_work_time_avg(probe_signal_s_sptr self) → float

probe_signal_s_sptr.pc_work_time_total(probe_signal_s_sptr self) → float

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

probe_signal_s_sptr.set_min_noutput_items(probe_signal_s_sptr self, int m)

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

probe_signal_s_sptr.thread_priority(probe_signal_s_sptr self) → int

gnuradio.blocks.probe_signal_vb(size_t size) → probe_signal_vb_sptr

probe_signal_vb_sptr.active_thread_priority(probe_signal_vb_sptr self) → int

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

declare_sample_delay(probe_signal_vb_sptr self, unsigned int delay)

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

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

probe_signal_vb_sptr.min_noutput_items(probe_signal_vb_sptr self) → int

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

pc_input_buffers_full_avg(probe_signal_vb_sptr self) -> pmt_vector_float

probe_signal_vb_sptr.pc_noutput_items_avg(probe_signal_vb_sptr self) → float

probe_signal_vb_sptr.pc_nproduced_avg(probe_signal_vb_sptr self) → float

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

pc_output_buffers_full_avg(probe_signal_vb_sptr self) -> pmt_vector_float

probe_signal_vb_sptr.pc_throughput_avg(probe_signal_vb_sptr self) → float

probe_signal_vb_sptr.pc_work_time_avg(probe_signal_vb_sptr self) → float

probe_signal_vb_sptr.pc_work_time_total(probe_signal_vb_sptr self) → float

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

probe_signal_vb_sptr.set_min_noutput_items(probe_signal_vb_sptr self, int m)

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

probe_signal_vb_sptr.thread_priority(probe_signal_vb_sptr self) → int

gnuradio.blocks.probe_signal_vc(size_t size) → probe_signal_vc_sptr

probe_signal_vc_sptr.active_thread_priority(probe_signal_vc_sptr self) → int

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

declare_sample_delay(probe_signal_vc_sptr self, unsigned int delay)

probe_signal_vc_sptr.level(probe_signal_vc_sptr self) → pmt_vector_cfloat

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

probe_signal_vc_sptr.min_noutput_items(probe_signal_vc_sptr self) → int

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

pc_input_buffers_full_avg(probe_signal_vc_sptr self) -> pmt_vector_float

probe_signal_vc_sptr.pc_noutput_items_avg(probe_signal_vc_sptr self) → float

probe_signal_vc_sptr.pc_nproduced_avg(probe_signal_vc_sptr self) → float

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

pc_output_buffers_full_avg(probe_signal_vc_sptr self) -> pmt_vector_float

probe_signal_vc_sptr.pc_throughput_avg(probe_signal_vc_sptr self) → float

probe_signal_vc_sptr.pc_work_time_avg(probe_signal_vc_sptr self) → float

probe_signal_vc_sptr.pc_work_time_total(probe_signal_vc_sptr self) → float

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

probe_signal_vc_sptr.set_min_noutput_items(probe_signal_vc_sptr self, int m)

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

probe_signal_vc_sptr.thread_priority(probe_signal_vc_sptr self) → int

gnuradio.blocks.probe_signal_vf(size_t size) → probe_signal_vf_sptr

probe_signal_vf_sptr.active_thread_priority(probe_signal_vf_sptr self) → int

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

declare_sample_delay(probe_signal_vf_sptr self, unsigned int delay)

probe_signal_vf_sptr.level(probe_signal_vf_sptr self) → pmt_vector_float

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

probe_signal_vf_sptr.min_noutput_items(probe_signal_vf_sptr self) → int

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

pc_input_buffers_full_avg(probe_signal_vf_sptr self) -> pmt_vector_float

probe_signal_vf_sptr.pc_noutput_items_avg(probe_signal_vf_sptr self) → float

probe_signal_vf_sptr.pc_nproduced_avg(probe_signal_vf_sptr self) → float

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

pc_output_buffers_full_avg(probe_signal_vf_sptr self) -> pmt_vector_float

probe_signal_vf_sptr.pc_throughput_avg(probe_signal_vf_sptr self) → float

probe_signal_vf_sptr.pc_work_time_avg(probe_signal_vf_sptr self) → float

probe_signal_vf_sptr.pc_work_time_total(probe_signal_vf_sptr self) → float

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

probe_signal_vf_sptr.set_min_noutput_items(probe_signal_vf_sptr self, int m)

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

probe_signal_vf_sptr.thread_priority(probe_signal_vf_sptr self) → int

gnuradio.blocks.probe_signal_vi(size_t size) → probe_signal_vi_sptr

probe_signal_vi_sptr.active_thread_priority(probe_signal_vi_sptr self) → int

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

declare_sample_delay(probe_signal_vi_sptr self, unsigned int delay)

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

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

probe_signal_vi_sptr.min_noutput_items(probe_signal_vi_sptr self) → int

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

pc_input_buffers_full_avg(probe_signal_vi_sptr self) -> pmt_vector_float

probe_signal_vi_sptr.pc_noutput_items_avg(probe_signal_vi_sptr self) → float

probe_signal_vi_sptr.pc_nproduced_avg(probe_signal_vi_sptr self) → float

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

pc_output_buffers_full_avg(probe_signal_vi_sptr self) -> pmt_vector_float

probe_signal_vi_sptr.pc_throughput_avg(probe_signal_vi_sptr self) → float

probe_signal_vi_sptr.pc_work_time_avg(probe_signal_vi_sptr self) → float

probe_signal_vi_sptr.pc_work_time_total(probe_signal_vi_sptr self) → float

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

probe_signal_vi_sptr.set_min_noutput_items(probe_signal_vi_sptr self, int m)

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

probe_signal_vi_sptr.thread_priority(probe_signal_vi_sptr self) → int

gnuradio.blocks.probe_signal_vs(size_t size) → probe_signal_vs_sptr

probe_signal_vs_sptr.active_thread_priority(probe_signal_vs_sptr self) → int

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

declare_sample_delay(probe_signal_vs_sptr self, unsigned int delay)

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

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

probe_signal_vs_sptr.min_noutput_items(probe_signal_vs_sptr self) → int

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

pc_input_buffers_full_avg(probe_signal_vs_sptr self) -> pmt_vector_float

probe_signal_vs_sptr.pc_noutput_items_avg(probe_signal_vs_sptr self) → float

probe_signal_vs_sptr.pc_nproduced_avg(probe_signal_vs_sptr self) → float

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

pc_output_buffers_full_avg(probe_signal_vs_sptr self) -> pmt_vector_float

probe_signal_vs_sptr.pc_throughput_avg(probe_signal_vs_sptr self) → float

probe_signal_vs_sptr.pc_work_time_avg(probe_signal_vs_sptr self) → float

probe_signal_vs_sptr.pc_work_time_total(probe_signal_vs_sptr self) → float

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

probe_signal_vs_sptr.set_min_noutput_items(probe_signal_vs_sptr self, int m)

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

probe_signal_vs_sptr.thread_priority(probe_signal_vs_sptr self) → int

gnuradio.blocks.random_pdu(int mintime, int maxtime, char byte_mask=0xFF, int length_modulo=1) → random_pdu_sptr

random_pdu_sptr.active_thread_priority(random_pdu_sptr self) → int

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

declare_sample_delay(random_pdu_sptr self, unsigned int delay)

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

random_pdu_sptr.min_noutput_items(random_pdu_sptr self) → int

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

pc_input_buffers_full_avg(random_pdu_sptr self) -> pmt_vector_float

random_pdu_sptr.pc_noutput_items_avg(random_pdu_sptr self) → float

random_pdu_sptr.pc_nproduced_avg(random_pdu_sptr self) → float

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

pc_output_buffers_full_avg(random_pdu_sptr self) -> pmt_vector_float

random_pdu_sptr.pc_throughput_avg(random_pdu_sptr self) → float

random_pdu_sptr.pc_work_time_avg(random_pdu_sptr self) → float

random_pdu_sptr.pc_work_time_total(random_pdu_sptr self) → float

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

random_pdu_sptr.set_min_noutput_items(random_pdu_sptr self, int m)

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

random_pdu_sptr.thread_priority(random_pdu_sptr self) → int

gnuradio.blocks.regenerate_bb(int period, unsigned int max_regen=500) → regenerate_bb_sptr

regenerate_bb_sptr.active_thread_priority(regenerate_bb_sptr self) → int

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

declare_sample_delay(regenerate_bb_sptr self, unsigned int delay)

regenerate_bb_sptr.max_regen(regenerate_bb_sptr self) → unsigned int

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

regenerate_bb_sptr.min_noutput_items(regenerate_bb_sptr self) → int

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

pc_input_buffers_full_avg(regenerate_bb_sptr self) -> pmt_vector_float

regenerate_bb_sptr.pc_noutput_items_avg(regenerate_bb_sptr self) → float

regenerate_bb_sptr.pc_nproduced_avg(regenerate_bb_sptr self) → float

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

pc_output_buffers_full_avg(regenerate_bb_sptr self) -> pmt_vector_float

regenerate_bb_sptr.pc_throughput_avg(regenerate_bb_sptr self) → float

regenerate_bb_sptr.pc_work_time_avg(regenerate_bb_sptr self) → float

regenerate_bb_sptr.pc_work_time_total(regenerate_bb_sptr self) → float

regenerate_bb_sptr.period(regenerate_bb_sptr self) → int

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

regenerate_bb_sptr.set_max_regen(regenerate_bb_sptr self, unsigned int regen)

regenerate_bb_sptr.set_min_noutput_items(regenerate_bb_sptr self, int m)

regenerate_bb_sptr.set_period(regenerate_bb_sptr self, int period)

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

regenerate_bb_sptr.thread_priority(regenerate_bb_sptr self) → int

gnuradio.blocks.repack_bits_bb(int k, int l=8, std::string const & tsb_tag_key="", bool align_output=False, gr::endianness_t endianness=GR_LSB_FIRST) → repack_bits_bb_sptr

repack_bits_bb_sptr.active_thread_priority(repack_bits_bb_sptr self) → int

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

declare_sample_delay(repack_bits_bb_sptr self, unsigned int delay)

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

repack_bits_bb_sptr.min_noutput_items(repack_bits_bb_sptr self) → int

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

pc_input_buffers_full_avg(repack_bits_bb_sptr self) -> pmt_vector_float

repack_bits_bb_sptr.pc_noutput_items_avg(repack_bits_bb_sptr self) → float

repack_bits_bb_sptr.pc_nproduced_avg(repack_bits_bb_sptr self) → float

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

pc_output_buffers_full_avg(repack_bits_bb_sptr self) -> pmt_vector_float

repack_bits_bb_sptr.pc_throughput_avg(repack_bits_bb_sptr self) → float

repack_bits_bb_sptr.pc_work_time_avg(repack_bits_bb_sptr self) → float

repack_bits_bb_sptr.pc_work_time_total(repack_bits_bb_sptr self) → float

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

repack_bits_bb_sptr.set_k_and_l(repack_bits_bb_sptr self, int k, int l)

repack_bits_bb_sptr.set_min_noutput_items(repack_bits_bb_sptr self, int m)

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

repack_bits_bb_sptr.thread_priority(repack_bits_bb_sptr self) → int

gnuradio.blocks.repeat(size_t itemsize, int repeat) → repeat_sptr

repeat_sptr.active_thread_priority(repeat_sptr self) → int

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

declare_sample_delay(repeat_sptr self, unsigned int delay)

repeat_sptr.interpolation(repeat_sptr self) → int

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

repeat_sptr.min_noutput_items(repeat_sptr self) → int

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

pc_input_buffers_full_avg(repeat_sptr self) -> pmt_vector_float

repeat_sptr.pc_noutput_items_avg(repeat_sptr self) → float

repeat_sptr.pc_nproduced_avg(repeat_sptr self) → float

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

pc_output_buffers_full_avg(repeat_sptr self) -> pmt_vector_float

repeat_sptr.pc_throughput_avg(repeat_sptr self) → float

repeat_sptr.pc_work_time_avg(repeat_sptr self) → float

repeat_sptr.pc_work_time_total(repeat_sptr self) → float

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

repeat_sptr.set_interpolation(repeat_sptr self, int interp)

repeat_sptr.set_min_noutput_items(repeat_sptr self, int m)

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

repeat_sptr.thread_priority(repeat_sptr self) → int

gnuradio.blocks.rms_cf(double alpha=0.0001) → rms_cf_sptr

rms_cf_sptr.active_thread_priority(rms_cf_sptr self) → int

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

declare_sample_delay(rms_cf_sptr self, unsigned int delay)

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

rms_cf_sptr.min_noutput_items(rms_cf_sptr self) → int

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

pc_input_buffers_full_avg(rms_cf_sptr self) -> pmt_vector_float

rms_cf_sptr.pc_noutput_items_avg(rms_cf_sptr self) → float

rms_cf_sptr.pc_nproduced_avg(rms_cf_sptr self) → float

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

pc_output_buffers_full_avg(rms_cf_sptr self) -> pmt_vector_float

rms_cf_sptr.pc_throughput_avg(rms_cf_sptr self) → float

rms_cf_sptr.pc_work_time_avg(rms_cf_sptr self) → float

rms_cf_sptr.pc_work_time_total(rms_cf_sptr self) → float

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

rms_cf_sptr.set_alpha(rms_cf_sptr self, double alpha)

rms_cf_sptr.set_min_noutput_items(rms_cf_sptr self, int m)

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

rms_cf_sptr.thread_priority(rms_cf_sptr self) → int

gnuradio.blocks.rms_ff(double alpha=0.0001) → rms_ff_sptr

rms_ff_sptr.active_thread_priority(rms_ff_sptr self) → int

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

declare_sample_delay(rms_ff_sptr self, unsigned int delay)

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

rms_ff_sptr.min_noutput_items(rms_ff_sptr self) → int

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

pc_input_buffers_full_avg(rms_ff_sptr self) -> pmt_vector_float

rms_ff_sptr.pc_noutput_items_avg(rms_ff_sptr self) → float

rms_ff_sptr.pc_nproduced_avg(rms_ff_sptr self) → float

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

pc_output_buffers_full_avg(rms_ff_sptr self) -> pmt_vector_float

rms_ff_sptr.pc_throughput_avg(rms_ff_sptr self) → float

rms_ff_sptr.pc_work_time_avg(rms_ff_sptr self) → float

rms_ff_sptr.pc_work_time_total(rms_ff_sptr self) → float

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

rms_ff_sptr.set_alpha(rms_ff_sptr self, double alpha)

rms_ff_sptr.set_min_noutput_items(rms_ff_sptr self, int m)

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

rms_ff_sptr.thread_priority(rms_ff_sptr self) → int

gnuradio.blocks.rotator_cc(double phase_inc=0.0) → rotator_cc_sptr

rotator_cc_sptr.active_thread_priority(rotator_cc_sptr self) → int

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

declare_sample_delay(rotator_cc_sptr self, unsigned int delay)

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

rotator_cc_sptr.min_noutput_items(rotator_cc_sptr self) → int

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

pc_input_buffers_full_avg(rotator_cc_sptr self) -> pmt_vector_float

rotator_cc_sptr.pc_noutput_items_avg(rotator_cc_sptr self) → float

rotator_cc_sptr.pc_nproduced_avg(rotator_cc_sptr self) → float

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

pc_output_buffers_full_avg(rotator_cc_sptr self) -> pmt_vector_float

rotator_cc_sptr.pc_throughput_avg(rotator_cc_sptr self) → float

rotator_cc_sptr.pc_work_time_avg(rotator_cc_sptr self) → float

rotator_cc_sptr.pc_work_time_total(rotator_cc_sptr self) → float

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

rotator_cc_sptr.set_min_noutput_items(rotator_cc_sptr self, int m)

rotator_cc_sptr.set_phase_inc(rotator_cc_sptr self, double phase_inc)

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

rotator_cc_sptr.thread_priority(rotator_cc_sptr self) → int

gnuradio.blocks.sample_and_hold_bb() → sample_and_hold_bb_sptr

sample_and_hold_bb_sptr.active_thread_priority(sample_and_hold_bb_sptr self) → int

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

declare_sample_delay(sample_and_hold_bb_sptr self, unsigned int delay)

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

sample_and_hold_bb_sptr.min_noutput_items(sample_and_hold_bb_sptr self) → int

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

pc_input_buffers_full_avg(sample_and_hold_bb_sptr self) -> pmt_vector_float

sample_and_hold_bb_sptr.pc_noutput_items_avg(sample_and_hold_bb_sptr self) → float

sample_and_hold_bb_sptr.pc_nproduced_avg(sample_and_hold_bb_sptr self) → float

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

pc_output_buffers_full_avg(sample_and_hold_bb_sptr self) -> pmt_vector_float

sample_and_hold_bb_sptr.pc_throughput_avg(sample_and_hold_bb_sptr self) → float

sample_and_hold_bb_sptr.pc_work_time_avg(sample_and_hold_bb_sptr self) → float

sample_and_hold_bb_sptr.pc_work_time_total(sample_and_hold_bb_sptr self) → float

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

sample_and_hold_bb_sptr.set_min_noutput_items(sample_and_hold_bb_sptr self, int m)

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

sample_and_hold_bb_sptr.thread_priority(sample_and_hold_bb_sptr self) → int

gnuradio.blocks.sample_and_hold_ff() → sample_and_hold_ff_sptr

sample_and_hold_ff_sptr.active_thread_priority(sample_and_hold_ff_sptr self) → int

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

declare_sample_delay(sample_and_hold_ff_sptr self, unsigned int delay)

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

sample_and_hold_ff_sptr.min_noutput_items(sample_and_hold_ff_sptr self) → int

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

pc_input_buffers_full_avg(sample_and_hold_ff_sptr self) -> pmt_vector_float

sample_and_hold_ff_sptr.pc_noutput_items_avg(sample_and_hold_ff_sptr self) → float

sample_and_hold_ff_sptr.pc_nproduced_avg(sample_and_hold_ff_sptr self) → float

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

pc_output_buffers_full_avg(sample_and_hold_ff_sptr self) -> pmt_vector_float

sample_and_hold_ff_sptr.pc_throughput_avg(sample_and_hold_ff_sptr self) → float

sample_and_hold_ff_sptr.pc_work_time_avg(sample_and_hold_ff_sptr self) → float

sample_and_hold_ff_sptr.pc_work_time_total(sample_and_hold_ff_sptr self) → float

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

sample_and_hold_ff_sptr.set_min_noutput_items(sample_and_hold_ff_sptr self, int m)

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

sample_and_hold_ff_sptr.thread_priority(sample_and_hold_ff_sptr self) → int

gnuradio.blocks.sample_and_hold_ii() → sample_and_hold_ii_sptr

sample_and_hold_ii_sptr.active_thread_priority(sample_and_hold_ii_sptr self) → int

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

declare_sample_delay(sample_and_hold_ii_sptr self, unsigned int delay)

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

sample_and_hold_ii_sptr.min_noutput_items(sample_and_hold_ii_sptr self) → int

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

pc_input_buffers_full_avg(sample_and_hold_ii_sptr self) -> pmt_vector_float

sample_and_hold_ii_sptr.pc_noutput_items_avg(sample_and_hold_ii_sptr self) → float

sample_and_hold_ii_sptr.pc_nproduced_avg(sample_and_hold_ii_sptr self) → float

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

pc_output_buffers_full_avg(sample_and_hold_ii_sptr self) -> pmt_vector_float

sample_and_hold_ii_sptr.pc_throughput_avg(sample_and_hold_ii_sptr self) → float

sample_and_hold_ii_sptr.pc_work_time_avg(sample_and_hold_ii_sptr self) → float

sample_and_hold_ii_sptr.pc_work_time_total(sample_and_hold_ii_sptr self) → float

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

sample_and_hold_ii_sptr.set_min_noutput_items(sample_and_hold_ii_sptr self, int m)

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

sample_and_hold_ii_sptr.thread_priority(sample_and_hold_ii_sptr self) → int

gnuradio.blocks.sample_and_hold_ss() → sample_and_hold_ss_sptr

sample_and_hold_ss_sptr.active_thread_priority(sample_and_hold_ss_sptr self) → int

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

declare_sample_delay(sample_and_hold_ss_sptr self, unsigned int delay)

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

sample_and_hold_ss_sptr.min_noutput_items(sample_and_hold_ss_sptr self) → int

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

pc_input_buffers_full_avg(sample_and_hold_ss_sptr self) -> pmt_vector_float

sample_and_hold_ss_sptr.pc_noutput_items_avg(sample_and_hold_ss_sptr self) → float

sample_and_hold_ss_sptr.pc_nproduced_avg(sample_and_hold_ss_sptr self) → float

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

pc_output_buffers_full_avg(sample_and_hold_ss_sptr self) -> pmt_vector_float

sample_and_hold_ss_sptr.pc_throughput_avg(sample_and_hold_ss_sptr self) → float

sample_and_hold_ss_sptr.pc_work_time_avg(sample_and_hold_ss_sptr self) → float

sample_and_hold_ss_sptr.pc_work_time_total(sample_and_hold_ss_sptr self) → float

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

sample_and_hold_ss_sptr.set_min_noutput_items(sample_and_hold_ss_sptr self, int m)

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

sample_and_hold_ss_sptr.thread_priority(sample_and_hold_ss_sptr self) → int

gnuradio.blocks.short_to_char(size_t vlen=1) → short_to_char_sptr

short_to_char_sptr.active_thread_priority(short_to_char_sptr self) → int

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

declare_sample_delay(short_to_char_sptr self, unsigned int delay)

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

short_to_char_sptr.min_noutput_items(short_to_char_sptr self) → int

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

pc_input_buffers_full_avg(short_to_char_sptr self) -> pmt_vector_float

short_to_char_sptr.pc_noutput_items_avg(short_to_char_sptr self) → float

short_to_char_sptr.pc_nproduced_avg(short_to_char_sptr self) → float

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

pc_output_buffers_full_avg(short_to_char_sptr self) -> pmt_vector_float

short_to_char_sptr.pc_throughput_avg(short_to_char_sptr self) → float

short_to_char_sptr.pc_work_time_avg(short_to_char_sptr self) → float

short_to_char_sptr.pc_work_time_total(short_to_char_sptr self) → float

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

short_to_char_sptr.set_min_noutput_items(short_to_char_sptr self, int m)

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

short_to_char_sptr.thread_priority(short_to_char_sptr self) → int

gnuradio.blocks.short_to_float(size_t vlen=1, float scale=1.0) → short_to_float_sptr

short_to_float_sptr.active_thread_priority(short_to_float_sptr self) → int

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

declare_sample_delay(short_to_float_sptr self, unsigned int delay)

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

short_to_float_sptr.min_noutput_items(short_to_float_sptr self) → int

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

pc_input_buffers_full_avg(short_to_float_sptr self) -> pmt_vector_float

short_to_float_sptr.pc_noutput_items_avg(short_to_float_sptr self) → float

short_to_float_sptr.pc_nproduced_avg(short_to_float_sptr self) → float

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

pc_output_buffers_full_avg(short_to_float_sptr self) -> pmt_vector_float

short_to_float_sptr.pc_throughput_avg(short_to_float_sptr self) → float

short_to_float_sptr.pc_work_time_avg(short_to_float_sptr self) → float

short_to_float_sptr.pc_work_time_total(short_to_float_sptr self) → float

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

short_to_float_sptr.scale(short_to_float_sptr self) → float

short_to_float_sptr.set_min_noutput_items(short_to_float_sptr self, int m)

short_to_float_sptr.set_scale(short_to_float_sptr self, float scale)

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

short_to_float_sptr.thread_priority(short_to_float_sptr self) → int

gnuradio.blocks.skiphead(size_t itemsize, uint64_t nitems_to_skip) → skiphead_sptr

skiphead_sptr.active_thread_priority(skiphead_sptr self) → int

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

declare_sample_delay(skiphead_sptr self, unsigned int delay)

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

skiphead_sptr.min_noutput_items(skiphead_sptr self) → int

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

pc_input_buffers_full_avg(skiphead_sptr self) -> pmt_vector_float

skiphead_sptr.pc_noutput_items_avg(skiphead_sptr self) → float

skiphead_sptr.pc_nproduced_avg(skiphead_sptr self) → float

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

pc_output_buffers_full_avg(skiphead_sptr self) -> pmt_vector_float

skiphead_sptr.pc_throughput_avg(skiphead_sptr self) → float

skiphead_sptr.pc_work_time_avg(skiphead_sptr self) → float

skiphead_sptr.pc_work_time_total(skiphead_sptr self) → float

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

skiphead_sptr.set_min_noutput_items(skiphead_sptr self, int m)

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

skiphead_sptr.thread_priority(skiphead_sptr self) → int

gnuradio.blocks.socket_pdu(std::string type, std::string addr, std::string port, int MTU=10000, bool tcp_no_delay=False) → socket_pdu_sptr

socket_pdu_sptr.active_thread_priority(socket_pdu_sptr self) → int

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

declare_sample_delay(socket_pdu_sptr self, unsigned int delay)

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

socket_pdu_sptr.min_noutput_items(socket_pdu_sptr self) → int

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

pc_input_buffers_full_avg(socket_pdu_sptr self) -> pmt_vector_float

socket_pdu_sptr.pc_noutput_items_avg(socket_pdu_sptr self) → float

socket_pdu_sptr.pc_nproduced_avg(socket_pdu_sptr self) → float

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

pc_output_buffers_full_avg(socket_pdu_sptr self) -> pmt_vector_float

socket_pdu_sptr.pc_throughput_avg(socket_pdu_sptr self) → float

socket_pdu_sptr.pc_work_time_avg(socket_pdu_sptr self) → float

socket_pdu_sptr.pc_work_time_total(socket_pdu_sptr self) → float

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

socket_pdu_sptr.set_min_noutput_items(socket_pdu_sptr self, int m)

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

socket_pdu_sptr.thread_priority(socket_pdu_sptr self) → int

gnuradio.blocks.stream_mux(size_t itemsize, std::vector< int, std::allocator< int > > const & lengths) → stream_mux_sptr

stream_mux_sptr.active_thread_priority(stream_mux_sptr self) → int

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

declare_sample_delay(stream_mux_sptr self, unsigned int delay)

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

stream_mux_sptr.min_noutput_items(stream_mux_sptr self) → int

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

pc_input_buffers_full_avg(stream_mux_sptr self) -> pmt_vector_float

stream_mux_sptr.pc_noutput_items_avg(stream_mux_sptr self) → float

stream_mux_sptr.pc_nproduced_avg(stream_mux_sptr self) → float

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

pc_output_buffers_full_avg(stream_mux_sptr self) -> pmt_vector_float

stream_mux_sptr.pc_throughput_avg(stream_mux_sptr self) → float

stream_mux_sptr.pc_work_time_avg(stream_mux_sptr self) → float

stream_mux_sptr.pc_work_time_total(stream_mux_sptr self) → float

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

stream_mux_sptr.set_min_noutput_items(stream_mux_sptr self, int m)

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

stream_mux_sptr.thread_priority(stream_mux_sptr self) → int

gnuradio.blocks.stream_to_streams(size_t itemsize, size_t nstreams) → stream_to_streams_sptr

stream_to_streams_sptr.active_thread_priority(stream_to_streams_sptr self) → int

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

declare_sample_delay(stream_to_streams_sptr self, unsigned int delay)

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

stream_to_streams_sptr.min_noutput_items(stream_to_streams_sptr self) → int

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

pc_input_buffers_full_avg(stream_to_streams_sptr self) -> pmt_vector_float

stream_to_streams_sptr.pc_noutput_items_avg(stream_to_streams_sptr self) → float

stream_to_streams_sptr.pc_nproduced_avg(stream_to_streams_sptr self) → float

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

pc_output_buffers_full_avg(stream_to_streams_sptr self) -> pmt_vector_float

stream_to_streams_sptr.pc_throughput_avg(stream_to_streams_sptr self) → float

stream_to_streams_sptr.pc_work_time_avg(stream_to_streams_sptr self) → float

stream_to_streams_sptr.pc_work_time_total(stream_to_streams_sptr self) → float

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

stream_to_streams_sptr.set_min_noutput_items(stream_to_streams_sptr self, int m)

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

stream_to_streams_sptr.thread_priority(stream_to_streams_sptr self) → int

gnuradio.blocks.stream_to_tagged_stream(size_t itemsize, int vlen, unsigned int packet_len, std::string const & len_tag_key) → stream_to_tagged_stream_sptr

stream_to_tagged_stream_sptr.active_thread_priority(stream_to_tagged_stream_sptr self) → int

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

declare_sample_delay(stream_to_tagged_stream_sptr self, unsigned int delay)

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

stream_to_tagged_stream_sptr.min_noutput_items(stream_to_tagged_stream_sptr self) → int

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

pc_input_buffers_full_avg(stream_to_tagged_stream_sptr self) -> pmt_vector_float

stream_to_tagged_stream_sptr.pc_noutput_items_avg(stream_to_tagged_stream_sptr self) → float

stream_to_tagged_stream_sptr.pc_nproduced_avg(stream_to_tagged_stream_sptr self) → float

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

pc_output_buffers_full_avg(stream_to_tagged_stream_sptr self) -> pmt_vector_float

stream_to_tagged_stream_sptr.pc_throughput_avg(stream_to_tagged_stream_sptr self) → float

stream_to_tagged_stream_sptr.pc_work_time_avg(stream_to_tagged_stream_sptr self) → float

stream_to_tagged_stream_sptr.pc_work_time_total(stream_to_tagged_stream_sptr self) → float

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

stream_to_tagged_stream_sptr.set_min_noutput_items(stream_to_tagged_stream_sptr self, int m)

stream_to_tagged_stream_sptr.set_packet_len(stream_to_tagged_stream_sptr self, unsigned int packet_len)

stream_to_tagged_stream_sptr.set_packet_len_pmt(stream_to_tagged_stream_sptr self, unsigned int packet_len)

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

stream_to_tagged_stream_sptr.thread_priority(stream_to_tagged_stream_sptr self) → int

gnuradio.blocks.stream_to_vector(size_t itemsize, size_t nitems_per_block) → stream_to_vector_sptr

stream_to_vector_sptr.active_thread_priority(stream_to_vector_sptr self) → int

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

declare_sample_delay(stream_to_vector_sptr self, unsigned int delay)

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

stream_to_vector_sptr.min_noutput_items(stream_to_vector_sptr self) → int

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

pc_input_buffers_full_avg(stream_to_vector_sptr self) -> pmt_vector_float

stream_to_vector_sptr.pc_noutput_items_avg(stream_to_vector_sptr self) → float

stream_to_vector_sptr.pc_nproduced_avg(stream_to_vector_sptr self) → float

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

pc_output_buffers_full_avg(stream_to_vector_sptr self) -> pmt_vector_float

stream_to_vector_sptr.pc_throughput_avg(stream_to_vector_sptr self) → float

stream_to_vector_sptr.pc_work_time_avg(stream_to_vector_sptr self) → float

stream_to_vector_sptr.pc_work_time_total(stream_to_vector_sptr self) → float

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

stream_to_vector_sptr.set_min_noutput_items(stream_to_vector_sptr self, int m)

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

stream_to_vector_sptr.thread_priority(stream_to_vector_sptr self) → int

gnuradio.blocks.streams_to_stream(size_t itemsize, size_t nstreams) → streams_to_stream_sptr

streams_to_stream_sptr.active_thread_priority(streams_to_stream_sptr self) → int

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

declare_sample_delay(streams_to_stream_sptr self, unsigned int delay)

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

streams_to_stream_sptr.min_noutput_items(streams_to_stream_sptr self) → int

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

pc_input_buffers_full_avg(streams_to_stream_sptr self) -> pmt_vector_float

streams_to_stream_sptr.pc_noutput_items_avg(streams_to_stream_sptr self) → float

streams_to_stream_sptr.pc_nproduced_avg(streams_to_stream_sptr self) → float

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

pc_output_buffers_full_avg(streams_to_stream_sptr self) -> pmt_vector_float

streams_to_stream_sptr.pc_throughput_avg(streams_to_stream_sptr self) → float

streams_to_stream_sptr.pc_work_time_avg(streams_to_stream_sptr self) → float

streams_to_stream_sptr.pc_work_time_total(streams_to_stream_sptr self) → float

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

streams_to_stream_sptr.set_min_noutput_items(streams_to_stream_sptr self, int m)

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

streams_to_stream_sptr.thread_priority(streams_to_stream_sptr self) → int

gnuradio.blocks.streams_to_vector(size_t itemsize, size_t nstreams) → streams_to_vector_sptr

streams_to_vector_sptr.active_thread_priority(streams_to_vector_sptr self) → int

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

declare_sample_delay(streams_to_vector_sptr self, unsigned int delay)

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

streams_to_vector_sptr.min_noutput_items(streams_to_vector_sptr self) → int

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

pc_input_buffers_full_avg(streams_to_vector_sptr self) -> pmt_vector_float

streams_to_vector_sptr.pc_noutput_items_avg(streams_to_vector_sptr self) → float

streams_to_vector_sptr.pc_nproduced_avg(streams_to_vector_sptr self) → float

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

pc_output_buffers_full_avg(streams_to_vector_sptr self) -> pmt_vector_float

streams_to_vector_sptr.pc_throughput_avg(streams_to_vector_sptr self) → float

streams_to_vector_sptr.pc_work_time_avg(streams_to_vector_sptr self) → float

streams_to_vector_sptr.pc_work_time_total(streams_to_vector_sptr self) → float

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

streams_to_vector_sptr.set_min_noutput_items(streams_to_vector_sptr self, int m)

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

streams_to_vector_sptr.thread_priority(streams_to_vector_sptr self) → int

gnuradio.blocks.stretch_ff(float lo, size_t vlen=1) → stretch_ff_sptr

stretch_ff_sptr.active_thread_priority(stretch_ff_sptr self) → int

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

declare_sample_delay(stretch_ff_sptr self, unsigned int delay)

stretch_ff_sptr.lo(stretch_ff_sptr self) → float

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

stretch_ff_sptr.min_noutput_items(stretch_ff_sptr self) → int

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

pc_input_buffers_full_avg(stretch_ff_sptr self) -> pmt_vector_float

stretch_ff_sptr.pc_noutput_items_avg(stretch_ff_sptr self) → float

stretch_ff_sptr.pc_nproduced_avg(stretch_ff_sptr self) → float

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

pc_output_buffers_full_avg(stretch_ff_sptr self) -> pmt_vector_float

stretch_ff_sptr.pc_throughput_avg(stretch_ff_sptr self) → float

stretch_ff_sptr.pc_work_time_avg(stretch_ff_sptr self) → float

stretch_ff_sptr.pc_work_time_total(stretch_ff_sptr self) → float

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

stretch_ff_sptr.set_lo(stretch_ff_sptr self, float lo)

stretch_ff_sptr.set_min_noutput_items(stretch_ff_sptr self, int m)

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

stretch_ff_sptr.thread_priority(stretch_ff_sptr self) → int

stretch_ff_sptr.vlen(stretch_ff_sptr self) → size_t

gnuradio.blocks.sub_cc(size_t vlen=1) → sub_cc_sptr

sub_cc_sptr.active_thread_priority(sub_cc_sptr self) → int

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

declare_sample_delay(sub_cc_sptr self, unsigned int delay)

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

sub_cc_sptr.min_noutput_items(sub_cc_sptr self) → int

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

pc_input_buffers_full_avg(sub_cc_sptr self) -> pmt_vector_float

sub_cc_sptr.pc_noutput_items_avg(sub_cc_sptr self) → float

sub_cc_sptr.pc_nproduced_avg(sub_cc_sptr self) → float

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

pc_output_buffers_full_avg(sub_cc_sptr self) -> pmt_vector_float

sub_cc_sptr.pc_throughput_avg(sub_cc_sptr self) → float

sub_cc_sptr.pc_work_time_avg(sub_cc_sptr self) → float

sub_cc_sptr.pc_work_time_total(sub_cc_sptr self) → float

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

sub_cc_sptr.set_min_noutput_items(sub_cc_sptr self, int m)

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

sub_cc_sptr.thread_priority(sub_cc_sptr self) → int

gnuradio.blocks.sub_ff(size_t vlen=1) → sub_ff_sptr

sub_ff_sptr.active_thread_priority(sub_ff_sptr self) → int

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

declare_sample_delay(sub_ff_sptr self, unsigned int delay)

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

sub_ff_sptr.min_noutput_items(sub_ff_sptr self) → int

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

pc_input_buffers_full_avg(sub_ff_sptr self) -> pmt_vector_float

sub_ff_sptr.pc_noutput_items_avg(sub_ff_sptr self) → float

sub_ff_sptr.pc_nproduced_avg(sub_ff_sptr self) → float

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

pc_output_buffers_full_avg(sub_ff_sptr self) -> pmt_vector_float

sub_ff_sptr.pc_throughput_avg(sub_ff_sptr self) → float

sub_ff_sptr.pc_work_time_avg(sub_ff_sptr self) → float

sub_ff_sptr.pc_work_time_total(sub_ff_sptr self) → float

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

sub_ff_sptr.set_min_noutput_items(sub_ff_sptr self, int m)

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

sub_ff_sptr.thread_priority(sub_ff_sptr self) → int

gnuradio.blocks.sub_ii(size_t vlen=1) → sub_ii_sptr

sub_ii_sptr.active_thread_priority(sub_ii_sptr self) → int

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

declare_sample_delay(sub_ii_sptr self, unsigned int delay)

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

sub_ii_sptr.min_noutput_items(sub_ii_sptr self) → int

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

pc_input_buffers_full_avg(sub_ii_sptr self) -> pmt_vector_float

sub_ii_sptr.pc_noutput_items_avg(sub_ii_sptr self) → float

sub_ii_sptr.pc_nproduced_avg(sub_ii_sptr self) → float

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

pc_output_buffers_full_avg(sub_ii_sptr self) -> pmt_vector_float

sub_ii_sptr.pc_throughput_avg(sub_ii_sptr self) → float

sub_ii_sptr.pc_work_time_avg(sub_ii_sptr self) → float

sub_ii_sptr.pc_work_time_total(sub_ii_sptr self) → float

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

sub_ii_sptr.set_min_noutput_items(sub_ii_sptr self, int m)

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

sub_ii_sptr.thread_priority(sub_ii_sptr self) → int

gnuradio.blocks.sub_ss(size_t vlen=1) → sub_ss_sptr

sub_ss_sptr.active_thread_priority(sub_ss_sptr self) → int

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

declare_sample_delay(sub_ss_sptr self, unsigned int delay)

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

sub_ss_sptr.min_noutput_items(sub_ss_sptr self) → int

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

pc_input_buffers_full_avg(sub_ss_sptr self) -> pmt_vector_float

sub_ss_sptr.pc_noutput_items_avg(sub_ss_sptr self) → float

sub_ss_sptr.pc_nproduced_avg(sub_ss_sptr self) → float

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

pc_output_buffers_full_avg(sub_ss_sptr self) -> pmt_vector_float

sub_ss_sptr.pc_throughput_avg(sub_ss_sptr self) → float

sub_ss_sptr.pc_work_time_avg(sub_ss_sptr self) → float

sub_ss_sptr.pc_work_time_total(sub_ss_sptr self) → float

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

sub_ss_sptr.set_min_noutput_items(sub_ss_sptr self, int m)

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

sub_ss_sptr.thread_priority(sub_ss_sptr self) → int

gnuradio.blocks.tag_debug(size_t sizeof_stream_item, std::string const & name, std::string const & key_filter="") → tag_debug_sptr

tag_debug_sptr.active_thread_priority(tag_debug_sptr self) → int

tag_debug_sptr.current_tags(tag_debug_sptr self) → tags_vector_t

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

declare_sample_delay(tag_debug_sptr self, unsigned int delay)

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

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

tag_debug_sptr.min_noutput_items(tag_debug_sptr self) → int

tag_debug_sptr.num_tags(tag_debug_sptr self) → int

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

pc_input_buffers_full_avg(tag_debug_sptr self) -> pmt_vector_float

tag_debug_sptr.pc_noutput_items_avg(tag_debug_sptr self) → float

tag_debug_sptr.pc_nproduced_avg(tag_debug_sptr self) → float

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

pc_output_buffers_full_avg(tag_debug_sptr self) -> pmt_vector_float

tag_debug_sptr.pc_throughput_avg(tag_debug_sptr self) → float

tag_debug_sptr.pc_work_time_avg(tag_debug_sptr self) → float

tag_debug_sptr.pc_work_time_total(tag_debug_sptr self) → float

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

tag_debug_sptr.set_display(tag_debug_sptr self, bool d)

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

tag_debug_sptr.set_min_noutput_items(tag_debug_sptr self, int m)

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

tag_debug_sptr.thread_priority(tag_debug_sptr self) → int

gnuradio.blocks.tag_gate(size_t item_size, bool propagate_tags=False) → tag_gate_sptr

tag_gate_sptr.active_thread_priority(tag_gate_sptr self) → int

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

declare_sample_delay(tag_gate_sptr self, unsigned int delay)

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

tag_gate_sptr.min_noutput_items(tag_gate_sptr self) → int

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

pc_input_buffers_full_avg(tag_gate_sptr self) -> pmt_vector_float

tag_gate_sptr.pc_noutput_items_avg(tag_gate_sptr self) → float

tag_gate_sptr.pc_nproduced_avg(tag_gate_sptr self) → float

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

pc_output_buffers_full_avg(tag_gate_sptr self) -> pmt_vector_float

tag_gate_sptr.pc_throughput_avg(tag_gate_sptr self) → float

tag_gate_sptr.pc_work_time_avg(tag_gate_sptr self) → float

tag_gate_sptr.pc_work_time_total(tag_gate_sptr self) → float

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

tag_gate_sptr.set_min_noutput_items(tag_gate_sptr self, int m)

tag_gate_sptr.set_propagation(tag_gate_sptr self, bool propagate_tags)

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

tag_gate_sptr.thread_priority(tag_gate_sptr self) → int

gnuradio.blocks.tagged_file_sink(size_t itemsize, double samp_rate) → tagged_file_sink_sptr

tagged_file_sink_sptr.active_thread_priority(tagged_file_sink_sptr self) → int

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

declare_sample_delay(tagged_file_sink_sptr self, unsigned int delay)

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

tagged_file_sink_sptr.min_noutput_items(tagged_file_sink_sptr self) → int

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

pc_input_buffers_full_avg(tagged_file_sink_sptr self) -> pmt_vector_float

tagged_file_sink_sptr.pc_noutput_items_avg(tagged_file_sink_sptr self) → float

tagged_file_sink_sptr.pc_nproduced_avg(tagged_file_sink_sptr self) → float

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

pc_output_buffers_full_avg(tagged_file_sink_sptr self) -> pmt_vector_float

tagged_file_sink_sptr.pc_throughput_avg(tagged_file_sink_sptr self) → float

tagged_file_sink_sptr.pc_work_time_avg(tagged_file_sink_sptr self) → float

tagged_file_sink_sptr.pc_work_time_total(tagged_file_sink_sptr self) → float

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

tagged_file_sink_sptr.set_min_noutput_items(tagged_file_sink_sptr self, int m)

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

tagged_file_sink_sptr.thread_priority(tagged_file_sink_sptr self) → int

gnuradio.blocks.tagged_stream_align(size_t itemsize, std::string const & lengthtagname) → tagged_stream_align_sptr

tagged_stream_align_sptr.active_thread_priority(tagged_stream_align_sptr self) → int

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

declare_sample_delay(tagged_stream_align_sptr self, unsigned int delay)

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

tagged_stream_align_sptr.min_noutput_items(tagged_stream_align_sptr self) → int

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

pc_input_buffers_full_avg(tagged_stream_align_sptr self) -> pmt_vector_float

tagged_stream_align_sptr.pc_noutput_items_avg(tagged_stream_align_sptr self) → float

tagged_stream_align_sptr.pc_nproduced_avg(tagged_stream_align_sptr self) → float

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

pc_output_buffers_full_avg(tagged_stream_align_sptr self) -> pmt_vector_float

tagged_stream_align_sptr.pc_throughput_avg(tagged_stream_align_sptr self) → float

tagged_stream_align_sptr.pc_work_time_avg(tagged_stream_align_sptr self) → float

tagged_stream_align_sptr.pc_work_time_total(tagged_stream_align_sptr self) → float

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

tagged_stream_align_sptr.set_min_noutput_items(tagged_stream_align_sptr self, int m)

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

tagged_stream_align_sptr.thread_priority(tagged_stream_align_sptr self) → int

gnuradio.blocks.tagged_stream_multiply_length(size_t itemsize, std::string const & lengthtagname, double scalar) → tagged_stream_multiply_length_sptr

tagged_stream_multiply_length_sptr.active_thread_priority(tagged_stream_multiply_length_sptr self) → int

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

declare_sample_delay(tagged_stream_multiply_length_sptr self, unsigned int delay)

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

tagged_stream_multiply_length_sptr.min_noutput_items(tagged_stream_multiply_length_sptr self) → int

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

pc_input_buffers_full_avg(tagged_stream_multiply_length_sptr self) -> pmt_vector_float

tagged_stream_multiply_length_sptr.pc_noutput_items_avg(tagged_stream_multiply_length_sptr self) → float

tagged_stream_multiply_length_sptr.pc_nproduced_avg(tagged_stream_multiply_length_sptr self) → float

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

pc_output_buffers_full_avg(tagged_stream_multiply_length_sptr self) -> pmt_vector_float

tagged_stream_multiply_length_sptr.pc_throughput_avg(tagged_stream_multiply_length_sptr self) → float

tagged_stream_multiply_length_sptr.pc_work_time_avg(tagged_stream_multiply_length_sptr self) → float

tagged_stream_multiply_length_sptr.pc_work_time_total(tagged_stream_multiply_length_sptr self) → float

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

tagged_stream_multiply_length_sptr.set_min_noutput_items(tagged_stream_multiply_length_sptr self, int m)

tagged_stream_multiply_length_sptr.set_scalar(tagged_stream_multiply_length_sptr self, double scalar)

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

tagged_stream_multiply_length_sptr.thread_priority(tagged_stream_multiply_length_sptr self) → int

gnuradio.blocks.tagged_stream_mux(size_t itemsize, std::string const & lengthtagname, unsigned int tag_preserve_head_pos=0) → tagged_stream_mux_sptr

tagged_stream_mux_sptr.active_thread_priority(tagged_stream_mux_sptr self) → int

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

declare_sample_delay(tagged_stream_mux_sptr self, unsigned int delay)

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

tagged_stream_mux_sptr.min_noutput_items(tagged_stream_mux_sptr self) → int

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

pc_input_buffers_full_avg(tagged_stream_mux_sptr self) -> pmt_vector_float

tagged_stream_mux_sptr.pc_noutput_items_avg(tagged_stream_mux_sptr self) → float

tagged_stream_mux_sptr.pc_nproduced_avg(tagged_stream_mux_sptr self) → float

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

pc_output_buffers_full_avg(tagged_stream_mux_sptr self) -> pmt_vector_float

tagged_stream_mux_sptr.pc_throughput_avg(tagged_stream_mux_sptr self) → float

tagged_stream_mux_sptr.pc_work_time_avg(tagged_stream_mux_sptr self) → float

tagged_stream_mux_sptr.pc_work_time_total(tagged_stream_mux_sptr self) → float

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

tagged_stream_mux_sptr.set_min_noutput_items(tagged_stream_mux_sptr self, int m)

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

tagged_stream_mux_sptr.thread_priority(tagged_stream_mux_sptr self) → int

gnuradio.blocks.tagged_stream_to_pdu(gr::blocks::pdu::vector_type type, std::string const & lengthtagname="packet_len") → tagged_stream_to_pdu_sptr

tagged_stream_to_pdu_sptr.active_thread_priority(tagged_stream_to_pdu_sptr self) → int

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

declare_sample_delay(tagged_stream_to_pdu_sptr self, unsigned int delay)

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

tagged_stream_to_pdu_sptr.min_noutput_items(tagged_stream_to_pdu_sptr self) → int

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

pc_input_buffers_full_avg(tagged_stream_to_pdu_sptr self) -> pmt_vector_float

tagged_stream_to_pdu_sptr.pc_noutput_items_avg(tagged_stream_to_pdu_sptr self) → float

tagged_stream_to_pdu_sptr.pc_nproduced_avg(tagged_stream_to_pdu_sptr self) → float

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

pc_output_buffers_full_avg(tagged_stream_to_pdu_sptr self) -> pmt_vector_float

tagged_stream_to_pdu_sptr.pc_throughput_avg(tagged_stream_to_pdu_sptr self) → float

tagged_stream_to_pdu_sptr.pc_work_time_avg(tagged_stream_to_pdu_sptr self) → float

tagged_stream_to_pdu_sptr.pc_work_time_total(tagged_stream_to_pdu_sptr self) → float

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

tagged_stream_to_pdu_sptr.set_min_noutput_items(tagged_stream_to_pdu_sptr self, int m)

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

tagged_stream_to_pdu_sptr.thread_priority(tagged_stream_to_pdu_sptr self) → int

gnuradio.blocks.tags_strobe(size_t sizeof_stream_item, swig_int_ptr value, uint64_t nsamps, swig_int_ptr key=pmt::intern("strobe")) → tags_strobe_sptr

tags_strobe_sptr.active_thread_priority(tags_strobe_sptr self) → int

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

declare_sample_delay(tags_strobe_sptr self, unsigned int delay)

tags_strobe_sptr.key(tags_strobe_sptr self) → swig_int_ptr

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

tags_strobe_sptr.min_noutput_items(tags_strobe_sptr self) → int

tags_strobe_sptr.nsamps(tags_strobe_sptr self) → uint64_t

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

pc_input_buffers_full_avg(tags_strobe_sptr self) -> pmt_vector_float

tags_strobe_sptr.pc_noutput_items_avg(tags_strobe_sptr self) → float

tags_strobe_sptr.pc_nproduced_avg(tags_strobe_sptr self) → float

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

pc_output_buffers_full_avg(tags_strobe_sptr self) -> pmt_vector_float

tags_strobe_sptr.pc_throughput_avg(tags_strobe_sptr self) → float

tags_strobe_sptr.pc_work_time_avg(tags_strobe_sptr self) → float

tags_strobe_sptr.pc_work_time_total(tags_strobe_sptr self) → float

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

tags_strobe_sptr.set_key(tags_strobe_sptr self, swig_int_ptr key)

tags_strobe_sptr.set_min_noutput_items(tags_strobe_sptr self, int m)

tags_strobe_sptr.set_nsamps(tags_strobe_sptr self, uint64_t nsamps)

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

tags_strobe_sptr.set_value(tags_strobe_sptr self, swig_int_ptr value)

tags_strobe_sptr.thread_priority(tags_strobe_sptr self) → int

tags_strobe_sptr.value(tags_strobe_sptr self) → swig_int_ptr

gnuradio.blocks.threshold_ff(float lo, float hi, float initial_state=0) → threshold_ff_sptr

threshold_ff_sptr.active_thread_priority(threshold_ff_sptr self) → int

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

declare_sample_delay(threshold_ff_sptr self, unsigned int delay)

threshold_ff_sptr.hi(threshold_ff_sptr self) → float

threshold_ff_sptr.last_state(threshold_ff_sptr self) → float

threshold_ff_sptr.lo(threshold_ff_sptr self) → float

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

threshold_ff_sptr.min_noutput_items(threshold_ff_sptr self) → int

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

pc_input_buffers_full_avg(threshold_ff_sptr self) -> pmt_vector_float

threshold_ff_sptr.pc_noutput_items_avg(threshold_ff_sptr self) → float

threshold_ff_sptr.pc_nproduced_avg(threshold_ff_sptr self) → float

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

pc_output_buffers_full_avg(threshold_ff_sptr self) -> pmt_vector_float

threshold_ff_sptr.pc_throughput_avg(threshold_ff_sptr self) → float

threshold_ff_sptr.pc_work_time_avg(threshold_ff_sptr self) → float

threshold_ff_sptr.pc_work_time_total(threshold_ff_sptr self) → float

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

threshold_ff_sptr.set_hi(threshold_ff_sptr self, float hi)

threshold_ff_sptr.set_last_state(threshold_ff_sptr self, float last_state)

threshold_ff_sptr.set_lo(threshold_ff_sptr self, float lo)

threshold_ff_sptr.set_min_noutput_items(threshold_ff_sptr self, int m)

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

threshold_ff_sptr.thread_priority(threshold_ff_sptr self) → int

gnuradio.blocks.throttle(size_t itemsize, double samples_per_sec, bool ignore_tags=True) → throttle_sptr

throttle_sptr.active_thread_priority(throttle_sptr self) → int

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

declare_sample_delay(throttle_sptr self, unsigned int delay)

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

throttle_sptr.min_noutput_items(throttle_sptr self) → int

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

pc_input_buffers_full_avg(throttle_sptr self) -> pmt_vector_float

throttle_sptr.pc_noutput_items_avg(throttle_sptr self) → float

throttle_sptr.pc_nproduced_avg(throttle_sptr self) → float

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

pc_output_buffers_full_avg(throttle_sptr self) -> pmt_vector_float

throttle_sptr.pc_throughput_avg(throttle_sptr self) → float

throttle_sptr.pc_work_time_avg(throttle_sptr self) → float

throttle_sptr.pc_work_time_total(throttle_sptr self) → float

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

throttle_sptr.sample_rate(throttle_sptr self) → double

throttle_sptr.set_min_noutput_items(throttle_sptr self, int m)

throttle_sptr.set_sample_rate(throttle_sptr self, double rate)

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

throttle_sptr.thread_priority(throttle_sptr self) → int

gnuradio.blocks.transcendental(std::string const & name, std::string const & type="float") → transcendental_sptr

transcendental_sptr.active_thread_priority(transcendental_sptr self) → int

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

declare_sample_delay(transcendental_sptr self, unsigned int delay)

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

transcendental_sptr.min_noutput_items(transcendental_sptr self) → int

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

pc_input_buffers_full_avg(transcendental_sptr self) -> pmt_vector_float

transcendental_sptr.pc_noutput_items_avg(transcendental_sptr self) → float

transcendental_sptr.pc_nproduced_avg(transcendental_sptr self) → float

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

pc_output_buffers_full_avg(transcendental_sptr self) -> pmt_vector_float

transcendental_sptr.pc_throughput_avg(transcendental_sptr self) → float

transcendental_sptr.pc_work_time_avg(transcendental_sptr self) → float

transcendental_sptr.pc_work_time_total(transcendental_sptr self) → float

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

transcendental_sptr.set_min_noutput_items(transcendental_sptr self, int m)

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

transcendental_sptr.thread_priority(transcendental_sptr self) → int

gnuradio.blocks.tsb_vector_sink_b(int vlen=1, std::string const & tsb_key="ts_last") → tsb_vector_sink_b_sptr

tsb_vector_sink_b_sptr.active_thread_priority(tsb_vector_sink_b_sptr self) → int

tsb_vector_sink_b_sptr.data(tsb_vector_sink_b_sptr self) → std::vector< std::vector< unsigned char,std::allocator< unsigned char > >,std::allocator< std::vector< unsigned char,std::allocator< unsigned char > > > >

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

declare_sample_delay(tsb_vector_sink_b_sptr self, unsigned int delay)

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

tsb_vector_sink_b_sptr.min_noutput_items(tsb_vector_sink_b_sptr self) → int

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

pc_input_buffers_full_avg(tsb_vector_sink_b_sptr self) -> pmt_vector_float

tsb_vector_sink_b_sptr.pc_noutput_items_avg(tsb_vector_sink_b_sptr self) → float

tsb_vector_sink_b_sptr.pc_nproduced_avg(tsb_vector_sink_b_sptr self) → float

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

pc_output_buffers_full_avg(tsb_vector_sink_b_sptr self) -> pmt_vector_float

tsb_vector_sink_b_sptr.pc_throughput_avg(tsb_vector_sink_b_sptr self) → float

tsb_vector_sink_b_sptr.pc_work_time_avg(tsb_vector_sink_b_sptr self) → float

tsb_vector_sink_b_sptr.pc_work_time_total(tsb_vector_sink_b_sptr self) → float

tsb_vector_sink_b_sptr.reset(tsb_vector_sink_b_sptr self)

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

tsb_vector_sink_b_sptr.set_min_noutput_items(tsb_vector_sink_b_sptr self, int m)

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

tsb_vector_sink_b_sptr.tags(tsb_vector_sink_b_sptr self) → tags_vector_t

tsb_vector_sink_b_sptr.thread_priority(tsb_vector_sink_b_sptr self) → int

gnuradio.blocks.tsb_vector_sink_c(int vlen=1, std::string const & tsb_key="ts_last") → tsb_vector_sink_c_sptr

tsb_vector_sink_c_sptr.active_thread_priority(tsb_vector_sink_c_sptr self) → int

tsb_vector_sink_c_sptr.data(tsb_vector_sink_c_sptr self) → gr_vector_vector_complexf

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

declare_sample_delay(tsb_vector_sink_c_sptr self, unsigned int delay)

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

tsb_vector_sink_c_sptr.min_noutput_items(tsb_vector_sink_c_sptr self) → int

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

pc_input_buffers_full_avg(tsb_vector_sink_c_sptr self) -> pmt_vector_float

tsb_vector_sink_c_sptr.pc_noutput_items_avg(tsb_vector_sink_c_sptr self) → float

tsb_vector_sink_c_sptr.pc_nproduced_avg(tsb_vector_sink_c_sptr self) → float

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

pc_output_buffers_full_avg(tsb_vector_sink_c_sptr self) -> pmt_vector_float

tsb_vector_sink_c_sptr.pc_throughput_avg(tsb_vector_sink_c_sptr self) → float

tsb_vector_sink_c_sptr.pc_work_time_avg(tsb_vector_sink_c_sptr self) → float

tsb_vector_sink_c_sptr.pc_work_time_total(tsb_vector_sink_c_sptr self) → float

tsb_vector_sink_c_sptr.reset(tsb_vector_sink_c_sptr self)

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

tsb_vector_sink_c_sptr.set_min_noutput_items(tsb_vector_sink_c_sptr self, int m)

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

tsb_vector_sink_c_sptr.tags(tsb_vector_sink_c_sptr self) → tags_vector_t

tsb_vector_sink_c_sptr.thread_priority(tsb_vector_sink_c_sptr self) → int

gnuradio.blocks.tsb_vector_sink_f(int vlen=1, std::string const & tsb_key="ts_last") → tsb_vector_sink_f_sptr

tsb_vector_sink_f_sptr.active_thread_priority(tsb_vector_sink_f_sptr self) → int

tsb_vector_sink_f_sptr.data(tsb_vector_sink_f_sptr self) → std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >

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

declare_sample_delay(tsb_vector_sink_f_sptr self, unsigned int delay)

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

tsb_vector_sink_f_sptr.min_noutput_items(tsb_vector_sink_f_sptr self) → int

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

pc_input_buffers_full_avg(tsb_vector_sink_f_sptr self) -> pmt_vector_float

tsb_vector_sink_f_sptr.pc_noutput_items_avg(tsb_vector_sink_f_sptr self) → float

tsb_vector_sink_f_sptr.pc_nproduced_avg(tsb_vector_sink_f_sptr self) → float

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

pc_output_buffers_full_avg(tsb_vector_sink_f_sptr self) -> pmt_vector_float

tsb_vector_sink_f_sptr.pc_throughput_avg(tsb_vector_sink_f_sptr self) → float

tsb_vector_sink_f_sptr.pc_work_time_avg(tsb_vector_sink_f_sptr self) → float

tsb_vector_sink_f_sptr.pc_work_time_total(tsb_vector_sink_f_sptr self) → float

tsb_vector_sink_f_sptr.reset(tsb_vector_sink_f_sptr self)

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

tsb_vector_sink_f_sptr.set_min_noutput_items(tsb_vector_sink_f_sptr self, int m)

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

tsb_vector_sink_f_sptr.tags(tsb_vector_sink_f_sptr self) → tags_vector_t

tsb_vector_sink_f_sptr.thread_priority(tsb_vector_sink_f_sptr self) → int

gnuradio.blocks.tsb_vector_sink_i(int vlen=1, std::string const & tsb_key="ts_last") → tsb_vector_sink_i_sptr

tsb_vector_sink_i_sptr.active_thread_priority(tsb_vector_sink_i_sptr self) → int

tsb_vector_sink_i_sptr.data(tsb_vector_sink_i_sptr self) → std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >

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

declare_sample_delay(tsb_vector_sink_i_sptr self, unsigned int delay)

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

tsb_vector_sink_i_sptr.min_noutput_items(tsb_vector_sink_i_sptr self) → int

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

pc_input_buffers_full_avg(tsb_vector_sink_i_sptr self) -> pmt_vector_float

tsb_vector_sink_i_sptr.pc_noutput_items_avg(tsb_vector_sink_i_sptr self) → float

tsb_vector_sink_i_sptr.pc_nproduced_avg(tsb_vector_sink_i_sptr self) → float

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

pc_output_buffers_full_avg(tsb_vector_sink_i_sptr self) -> pmt_vector_float

tsb_vector_sink_i_sptr.pc_throughput_avg(tsb_vector_sink_i_sptr self) → float

tsb_vector_sink_i_sptr.pc_work_time_avg(tsb_vector_sink_i_sptr self) → float

tsb_vector_sink_i_sptr.pc_work_time_total(tsb_vector_sink_i_sptr self) → float

tsb_vector_sink_i_sptr.reset(tsb_vector_sink_i_sptr self)

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

tsb_vector_sink_i_sptr.set_min_noutput_items(tsb_vector_sink_i_sptr self, int m)

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

tsb_vector_sink_i_sptr.tags(tsb_vector_sink_i_sptr self) → tags_vector_t

tsb_vector_sink_i_sptr.thread_priority(tsb_vector_sink_i_sptr self) → int

gnuradio.blocks.tsb_vector_sink_s(int vlen=1, std::string const & tsb_key="ts_last") → tsb_vector_sink_s_sptr

tsb_vector_sink_s_sptr.active_thread_priority(tsb_vector_sink_s_sptr self) → int

tsb_vector_sink_s_sptr.data(tsb_vector_sink_s_sptr self) → std::vector< std::vector< short,std::allocator< short > >,std::allocator< std::vector< short,std::allocator< short > > > >

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

declare_sample_delay(tsb_vector_sink_s_sptr self, unsigned int delay)

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

tsb_vector_sink_s_sptr.min_noutput_items(tsb_vector_sink_s_sptr self) → int

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

pc_input_buffers_full_avg(tsb_vector_sink_s_sptr self) -> pmt_vector_float

tsb_vector_sink_s_sptr.pc_noutput_items_avg(tsb_vector_sink_s_sptr self) → float

tsb_vector_sink_s_sptr.pc_nproduced_avg(tsb_vector_sink_s_sptr self) → float

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

pc_output_buffers_full_avg(tsb_vector_sink_s_sptr self) -> pmt_vector_float

tsb_vector_sink_s_sptr.pc_throughput_avg(tsb_vector_sink_s_sptr self) → float

tsb_vector_sink_s_sptr.pc_work_time_avg(tsb_vector_sink_s_sptr self) → float

tsb_vector_sink_s_sptr.pc_work_time_total(tsb_vector_sink_s_sptr self) → float

tsb_vector_sink_s_sptr.reset(tsb_vector_sink_s_sptr self)

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

tsb_vector_sink_s_sptr.set_min_noutput_items(tsb_vector_sink_s_sptr self, int m)

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

tsb_vector_sink_s_sptr.tags(tsb_vector_sink_s_sptr self) → tags_vector_t

tsb_vector_sink_s_sptr.thread_priority(tsb_vector_sink_s_sptr self) → int

gnuradio.blocks.tuntap_pdu(std::string dev, int MTU=10000, bool istunflag=False) → tuntap_pdu_sptr

tuntap_pdu_sptr.active_thread_priority(tuntap_pdu_sptr self) → int

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

declare_sample_delay(tuntap_pdu_sptr self, unsigned int delay)

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

tuntap_pdu_sptr.min_noutput_items(tuntap_pdu_sptr self) → int

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

pc_input_buffers_full_avg(tuntap_pdu_sptr self) -> pmt_vector_float

tuntap_pdu_sptr.pc_noutput_items_avg(tuntap_pdu_sptr self) → float

tuntap_pdu_sptr.pc_nproduced_avg(tuntap_pdu_sptr self) → float

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

pc_output_buffers_full_avg(tuntap_pdu_sptr self) -> pmt_vector_float

tuntap_pdu_sptr.pc_throughput_avg(tuntap_pdu_sptr self) → float

tuntap_pdu_sptr.pc_work_time_avg(tuntap_pdu_sptr self) → float

tuntap_pdu_sptr.pc_work_time_total(tuntap_pdu_sptr self) → float

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

tuntap_pdu_sptr.set_min_noutput_items(tuntap_pdu_sptr self, int m)

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

tuntap_pdu_sptr.thread_priority(tuntap_pdu_sptr self) → int

gnuradio.blocks.uchar_to_float() → uchar_to_float_sptr

uchar_to_float_sptr.active_thread_priority(uchar_to_float_sptr self) → int

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

declare_sample_delay(uchar_to_float_sptr self, unsigned int delay)

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

uchar_to_float_sptr.min_noutput_items(uchar_to_float_sptr self) → int

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

pc_input_buffers_full_avg(uchar_to_float_sptr self) -> pmt_vector_float

uchar_to_float_sptr.pc_noutput_items_avg(uchar_to_float_sptr self) → float

uchar_to_float_sptr.pc_nproduced_avg(uchar_to_float_sptr self) → float

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

pc_output_buffers_full_avg(uchar_to_float_sptr self) -> pmt_vector_float

uchar_to_float_sptr.pc_throughput_avg(uchar_to_float_sptr self) → float

uchar_to_float_sptr.pc_work_time_avg(uchar_to_float_sptr self) → float

uchar_to_float_sptr.pc_work_time_total(uchar_to_float_sptr self) → float

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

uchar_to_float_sptr.set_min_noutput_items(uchar_to_float_sptr self, int m)

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

uchar_to_float_sptr.thread_priority(uchar_to_float_sptr self) → int

gnuradio.blocks.udp_sink(size_t itemsize, std::string const & host, int port, int payload_size=1472, bool eof=True) → udp_sink_sptr

udp_sink_sptr.active_thread_priority(udp_sink_sptr self) → int

udp_sink_sptr.connect(udp_sink_sptr self, std::string const & host, int port)

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

declare_sample_delay(udp_sink_sptr self, unsigned int delay)

udp_sink_sptr.disconnect(udp_sink_sptr self)

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

udp_sink_sptr.min_noutput_items(udp_sink_sptr self) → int

udp_sink_sptr.payload_size(udp_sink_sptr self) → int

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

pc_input_buffers_full_avg(udp_sink_sptr self) -> pmt_vector_float

udp_sink_sptr.pc_noutput_items_avg(udp_sink_sptr self) → float

udp_sink_sptr.pc_nproduced_avg(udp_sink_sptr self) → float

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

pc_output_buffers_full_avg(udp_sink_sptr self) -> pmt_vector_float

udp_sink_sptr.pc_throughput_avg(udp_sink_sptr self) → float

udp_sink_sptr.pc_work_time_avg(udp_sink_sptr self) → float

udp_sink_sptr.pc_work_time_total(udp_sink_sptr self) → float

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

udp_sink_sptr.set_min_noutput_items(udp_sink_sptr self, int m)

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

udp_sink_sptr.thread_priority(udp_sink_sptr self) → int

gnuradio.blocks.udp_source(size_t itemsize, std::string const & host, int port, int payload_size=1472, bool eof=True) → udp_source_sptr

udp_source_sptr.active_thread_priority(udp_source_sptr self) → int

udp_source_sptr.connect(udp_source_sptr self, std::string const & host, int port)

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

declare_sample_delay(udp_source_sptr self, unsigned int delay)

udp_source_sptr.disconnect(udp_source_sptr self)

udp_source_sptr.get_port(udp_source_sptr self) → int

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

udp_source_sptr.min_noutput_items(udp_source_sptr self) → int

udp_source_sptr.payload_size(udp_source_sptr self) → int

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

pc_input_buffers_full_avg(udp_source_sptr self) -> pmt_vector_float

udp_source_sptr.pc_noutput_items_avg(udp_source_sptr self) → float

udp_source_sptr.pc_nproduced_avg(udp_source_sptr self) → float

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

pc_output_buffers_full_avg(udp_source_sptr self) -> pmt_vector_float

udp_source_sptr.pc_throughput_avg(udp_source_sptr self) → float

udp_source_sptr.pc_work_time_avg(udp_source_sptr self) → float

udp_source_sptr.pc_work_time_total(udp_source_sptr self) → float

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

udp_source_sptr.set_min_noutput_items(udp_source_sptr self, int m)

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

udp_source_sptr.thread_priority(udp_source_sptr self) → int

gnuradio.blocks.unpack_k_bits_bb(unsigned int k) → unpack_k_bits_bb_sptr

unpack_k_bits_bb_sptr.active_thread_priority(unpack_k_bits_bb_sptr self) → int

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

declare_sample_delay(unpack_k_bits_bb_sptr self, unsigned int delay)

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

unpack_k_bits_bb_sptr.min_noutput_items(unpack_k_bits_bb_sptr self) → int

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

pc_input_buffers_full_avg(unpack_k_bits_bb_sptr self) -> pmt_vector_float

unpack_k_bits_bb_sptr.pc_noutput_items_avg(unpack_k_bits_bb_sptr self) → float

unpack_k_bits_bb_sptr.pc_nproduced_avg(unpack_k_bits_bb_sptr self) → float

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

pc_output_buffers_full_avg(unpack_k_bits_bb_sptr self) -> pmt_vector_float

unpack_k_bits_bb_sptr.pc_throughput_avg(unpack_k_bits_bb_sptr self) → float

unpack_k_bits_bb_sptr.pc_work_time_avg(unpack_k_bits_bb_sptr self) → float

unpack_k_bits_bb_sptr.pc_work_time_total(unpack_k_bits_bb_sptr self) → float

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

unpack_k_bits_bb_sptr.set_min_noutput_items(unpack_k_bits_bb_sptr self, int m)

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

unpack_k_bits_bb_sptr.thread_priority(unpack_k_bits_bb_sptr self) → int

gnuradio.blocks.unpacked_to_packed_bb(unsigned int bits_per_chunk, gr::endianness_t endianness) → unpacked_to_packed_bb_sptr

unpacked_to_packed_bb_sptr.active_thread_priority(unpacked_to_packed_bb_sptr self) → int

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

declare_sample_delay(unpacked_to_packed_bb_sptr self, unsigned int delay)

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

unpacked_to_packed_bb_sptr.min_noutput_items(unpacked_to_packed_bb_sptr self) → int

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

pc_input_buffers_full_avg(unpacked_to_packed_bb_sptr self) -> pmt_vector_float

unpacked_to_packed_bb_sptr.pc_noutput_items_avg(unpacked_to_packed_bb_sptr self) → float

unpacked_to_packed_bb_sptr.pc_nproduced_avg(unpacked_to_packed_bb_sptr self) → float

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

pc_output_buffers_full_avg(unpacked_to_packed_bb_sptr self) -> pmt_vector_float

unpacked_to_packed_bb_sptr.pc_throughput_avg(unpacked_to_packed_bb_sptr self) → float

unpacked_to_packed_bb_sptr.pc_work_time_avg(unpacked_to_packed_bb_sptr self) → float

unpacked_to_packed_bb_sptr.pc_work_time_total(unpacked_to_packed_bb_sptr self) → float

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

unpacked_to_packed_bb_sptr.set_min_noutput_items(unpacked_to_packed_bb_sptr self, int m)

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

unpacked_to_packed_bb_sptr.thread_priority(unpacked_to_packed_bb_sptr self) → int

gnuradio.blocks.unpacked_to_packed_ii(unsigned int bits_per_chunk, gr::endianness_t endianness) → unpacked_to_packed_ii_sptr

unpacked_to_packed_ii_sptr.active_thread_priority(unpacked_to_packed_ii_sptr self) → int

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

declare_sample_delay(unpacked_to_packed_ii_sptr self, unsigned int delay)

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

unpacked_to_packed_ii_sptr.min_noutput_items(unpacked_to_packed_ii_sptr self) → int

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

pc_input_buffers_full_avg(unpacked_to_packed_ii_sptr self) -> pmt_vector_float

unpacked_to_packed_ii_sptr.pc_noutput_items_avg(unpacked_to_packed_ii_sptr self) → float

unpacked_to_packed_ii_sptr.pc_nproduced_avg(unpacked_to_packed_ii_sptr self) → float

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

pc_output_buffers_full_avg(unpacked_to_packed_ii_sptr self) -> pmt_vector_float

unpacked_to_packed_ii_sptr.pc_throughput_avg(unpacked_to_packed_ii_sptr self) → float

unpacked_to_packed_ii_sptr.pc_work_time_avg(unpacked_to_packed_ii_sptr self) → float

unpacked_to_packed_ii_sptr.pc_work_time_total(unpacked_to_packed_ii_sptr self) → float

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

unpacked_to_packed_ii_sptr.set_min_noutput_items(unpacked_to_packed_ii_sptr self, int m)

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

unpacked_to_packed_ii_sptr.thread_priority(unpacked_to_packed_ii_sptr self) → int

gnuradio.blocks.unpacked_to_packed_ss(unsigned int bits_per_chunk, gr::endianness_t endianness) → unpacked_to_packed_ss_sptr

unpacked_to_packed_ss_sptr.active_thread_priority(unpacked_to_packed_ss_sptr self) → int

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

declare_sample_delay(unpacked_to_packed_ss_sptr self, unsigned int delay)

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

unpacked_to_packed_ss_sptr.min_noutput_items(unpacked_to_packed_ss_sptr self) → int

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

pc_input_buffers_full_avg(unpacked_to_packed_ss_sptr self) -> pmt_vector_float

unpacked_to_packed_ss_sptr.pc_noutput_items_avg(unpacked_to_packed_ss_sptr self) → float

unpacked_to_packed_ss_sptr.pc_nproduced_avg(unpacked_to_packed_ss_sptr self) → float

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

pc_output_buffers_full_avg(unpacked_to_packed_ss_sptr self) -> pmt_vector_float

unpacked_to_packed_ss_sptr.pc_throughput_avg(unpacked_to_packed_ss_sptr self) → float

unpacked_to_packed_ss_sptr.pc_work_time_avg(unpacked_to_packed_ss_sptr self) → float

unpacked_to_packed_ss_sptr.pc_work_time_total(unpacked_to_packed_ss_sptr self) → float

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

unpacked_to_packed_ss_sptr.set_min_noutput_items(unpacked_to_packed_ss_sptr self, int m)

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

unpacked_to_packed_ss_sptr.thread_priority(unpacked_to_packed_ss_sptr self) → int

gnuradio.blocks.vco_c(double sampling_rate, double sensitivity, double amplitude) → vco_c_sptr

vco_c_sptr.active_thread_priority(vco_c_sptr self) → int

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

declare_sample_delay(vco_c_sptr self, unsigned int delay)

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

vco_c_sptr.min_noutput_items(vco_c_sptr self) → int

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

pc_input_buffers_full_avg(vco_c_sptr self) -> pmt_vector_float

vco_c_sptr.pc_noutput_items_avg(vco_c_sptr self) → float

vco_c_sptr.pc_nproduced_avg(vco_c_sptr self) → float

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

pc_output_buffers_full_avg(vco_c_sptr self) -> pmt_vector_float

vco_c_sptr.pc_throughput_avg(vco_c_sptr self) → float

vco_c_sptr.pc_work_time_avg(vco_c_sptr self) → float

vco_c_sptr.pc_work_time_total(vco_c_sptr self) → float

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

vco_c_sptr.set_min_noutput_items(vco_c_sptr self, int m)

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

vco_c_sptr.thread_priority(vco_c_sptr self) → int

gnuradio.blocks.vco_f(double sampling_rate, double sensitivity, double amplitude) → vco_f_sptr

vco_f_sptr.active_thread_priority(vco_f_sptr self) → int

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

declare_sample_delay(vco_f_sptr self, unsigned int delay)

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

vco_f_sptr.min_noutput_items(vco_f_sptr self) → int

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

pc_input_buffers_full_avg(vco_f_sptr self) -> pmt_vector_float

vco_f_sptr.pc_noutput_items_avg(vco_f_sptr self) → float

vco_f_sptr.pc_nproduced_avg(vco_f_sptr self) → float

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

pc_output_buffers_full_avg(vco_f_sptr self) -> pmt_vector_float

vco_f_sptr.pc_throughput_avg(vco_f_sptr self) → float

vco_f_sptr.pc_work_time_avg(vco_f_sptr self) → float

vco_f_sptr.pc_work_time_total(vco_f_sptr self) → float

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

vco_f_sptr.set_min_noutput_items(vco_f_sptr self, int m)

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

vco_f_sptr.thread_priority(vco_f_sptr self) → int

gnuradio.blocks.vector_insert_b(std::vector< unsigned char, std::allocator< unsigned char > > const & data, int periodicity, int offset=0) → vector_insert_b_sptr

vector_insert_b_sptr.active_thread_priority(vector_insert_b_sptr self) → int

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

declare_sample_delay(vector_insert_b_sptr self, unsigned int delay)

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

vector_insert_b_sptr.min_noutput_items(vector_insert_b_sptr self) → int

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

pc_input_buffers_full_avg(vector_insert_b_sptr self) -> pmt_vector_float

vector_insert_b_sptr.pc_noutput_items_avg(vector_insert_b_sptr self) → float

vector_insert_b_sptr.pc_nproduced_avg(vector_insert_b_sptr self) → float

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

pc_output_buffers_full_avg(vector_insert_b_sptr self) -> pmt_vector_float

vector_insert_b_sptr.pc_throughput_avg(vector_insert_b_sptr self) → float

vector_insert_b_sptr.pc_work_time_avg(vector_insert_b_sptr self) → float

vector_insert_b_sptr.pc_work_time_total(vector_insert_b_sptr self) → float

vector_insert_b_sptr.rewind(vector_insert_b_sptr self)

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

vector_insert_b_sptr.set_data(vector_insert_b_sptr self, std::vector< unsigned char, std::allocator< unsigned char > > const & data)

vector_insert_b_sptr.set_min_noutput_items(vector_insert_b_sptr self, int m)

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

vector_insert_b_sptr.thread_priority(vector_insert_b_sptr self) → int

gnuradio.blocks.vector_insert_c(pmt_vector_cfloat data, int periodicity, int offset=0) → vector_insert_c_sptr

vector_insert_c_sptr.active_thread_priority(vector_insert_c_sptr self) → int

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

declare_sample_delay(vector_insert_c_sptr self, unsigned int delay)

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

vector_insert_c_sptr.min_noutput_items(vector_insert_c_sptr self) → int

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

pc_input_buffers_full_avg(vector_insert_c_sptr self) -> pmt_vector_float

vector_insert_c_sptr.pc_noutput_items_avg(vector_insert_c_sptr self) → float

vector_insert_c_sptr.pc_nproduced_avg(vector_insert_c_sptr self) → float

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

pc_output_buffers_full_avg(vector_insert_c_sptr self) -> pmt_vector_float

vector_insert_c_sptr.pc_throughput_avg(vector_insert_c_sptr self) → float

vector_insert_c_sptr.pc_work_time_avg(vector_insert_c_sptr self) → float

vector_insert_c_sptr.pc_work_time_total(vector_insert_c_sptr self) → float

vector_insert_c_sptr.rewind(vector_insert_c_sptr self)

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

vector_insert_c_sptr.set_data(vector_insert_c_sptr self, pmt_vector_cfloat data)

vector_insert_c_sptr.set_min_noutput_items(vector_insert_c_sptr self, int m)

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

vector_insert_c_sptr.thread_priority(vector_insert_c_sptr self) → int

gnuradio.blocks.vector_insert_f(pmt_vector_float data, int periodicity, int offset=0) → vector_insert_f_sptr

vector_insert_f_sptr.active_thread_priority(vector_insert_f_sptr self) → int

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

declare_sample_delay(vector_insert_f_sptr self, unsigned int delay)

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

vector_insert_f_sptr.min_noutput_items(vector_insert_f_sptr self) → int

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

pc_input_buffers_full_avg(vector_insert_f_sptr self) -> pmt_vector_float

vector_insert_f_sptr.pc_noutput_items_avg(vector_insert_f_sptr self) → float

vector_insert_f_sptr.pc_nproduced_avg(vector_insert_f_sptr self) → float

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

pc_output_buffers_full_avg(vector_insert_f_sptr self) -> pmt_vector_float

vector_insert_f_sptr.pc_throughput_avg(vector_insert_f_sptr self) → float

vector_insert_f_sptr.pc_work_time_avg(vector_insert_f_sptr self) → float

vector_insert_f_sptr.pc_work_time_total(vector_insert_f_sptr self) → float

vector_insert_f_sptr.rewind(vector_insert_f_sptr self)

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

vector_insert_f_sptr.set_data(vector_insert_f_sptr self, pmt_vector_float data)

vector_insert_f_sptr.set_min_noutput_items(vector_insert_f_sptr self, int m)

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

vector_insert_f_sptr.thread_priority(vector_insert_f_sptr self) → int

gnuradio.blocks.vector_insert_i(std::vector< int, std::allocator< int > > const & data, int periodicity, int offset=0) → vector_insert_i_sptr

vector_insert_i_sptr.active_thread_priority(vector_insert_i_sptr self) → int

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

declare_sample_delay(vector_insert_i_sptr self, unsigned int delay)

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

vector_insert_i_sptr.min_noutput_items(vector_insert_i_sptr self) → int

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

pc_input_buffers_full_avg(vector_insert_i_sptr self) -> pmt_vector_float

vector_insert_i_sptr.pc_noutput_items_avg(vector_insert_i_sptr self) → float

vector_insert_i_sptr.pc_nproduced_avg(vector_insert_i_sptr self) → float

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

pc_output_buffers_full_avg(vector_insert_i_sptr self) -> pmt_vector_float

vector_insert_i_sptr.pc_throughput_avg(vector_insert_i_sptr self) → float

vector_insert_i_sptr.pc_work_time_avg(vector_insert_i_sptr self) → float

vector_insert_i_sptr.pc_work_time_total(vector_insert_i_sptr self) → float

vector_insert_i_sptr.rewind(vector_insert_i_sptr self)

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

vector_insert_i_sptr.set_data(vector_insert_i_sptr self, std::vector< int, std::allocator< int > > const & data)

vector_insert_i_sptr.set_min_noutput_items(vector_insert_i_sptr self, int m)

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

vector_insert_i_sptr.thread_priority(vector_insert_i_sptr self) → int

gnuradio.blocks.vector_insert_s(std::vector< short, std::allocator< short > > const & data, int periodicity, int offset=0) → vector_insert_s_sptr

vector_insert_s_sptr.active_thread_priority(vector_insert_s_sptr self) → int

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

declare_sample_delay(vector_insert_s_sptr self, unsigned int delay)

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

vector_insert_s_sptr.min_noutput_items(vector_insert_s_sptr self) → int

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

pc_input_buffers_full_avg(vector_insert_s_sptr self) -> pmt_vector_float

vector_insert_s_sptr.pc_noutput_items_avg(vector_insert_s_sptr self) → float

vector_insert_s_sptr.pc_nproduced_avg(vector_insert_s_sptr self) → float

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

pc_output_buffers_full_avg(vector_insert_s_sptr self) -> pmt_vector_float

vector_insert_s_sptr.pc_throughput_avg(vector_insert_s_sptr self) → float

vector_insert_s_sptr.pc_work_time_avg(vector_insert_s_sptr self) → float

vector_insert_s_sptr.pc_work_time_total(vector_insert_s_sptr self) → float

vector_insert_s_sptr.rewind(vector_insert_s_sptr self)

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

vector_insert_s_sptr.set_data(vector_insert_s_sptr self, std::vector< short, std::allocator< short > > const & data)

vector_insert_s_sptr.set_min_noutput_items(vector_insert_s_sptr self, int m)

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

vector_insert_s_sptr.thread_priority(vector_insert_s_sptr self) → int

gnuradio.blocks.vector_map(size_t item_size, gr_vsize_t in_vlens, gr_vvvsize_t mapping) → vector_map_sptr

vector_map_sptr.active_thread_priority(vector_map_sptr self) → int

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

declare_sample_delay(vector_map_sptr self, unsigned int delay)

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

vector_map_sptr.min_noutput_items(vector_map_sptr self) → int

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

pc_input_buffers_full_avg(vector_map_sptr self) -> pmt_vector_float

vector_map_sptr.pc_noutput_items_avg(vector_map_sptr self) → float

vector_map_sptr.pc_nproduced_avg(vector_map_sptr self) → float

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

pc_output_buffers_full_avg(vector_map_sptr self) -> pmt_vector_float

vector_map_sptr.pc_throughput_avg(vector_map_sptr self) → float

vector_map_sptr.pc_work_time_avg(vector_map_sptr self) → float

vector_map_sptr.pc_work_time_total(vector_map_sptr self) → float

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

vector_map_sptr.set_mapping(vector_map_sptr self, gr_vvvsize_t mapping)

vector_map_sptr.set_min_noutput_items(vector_map_sptr self, int m)

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

vector_map_sptr.thread_priority(vector_map_sptr self) → int

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

vector_sink_b_sptr.active_thread_priority(vector_sink_b_sptr self) → int

vector_sink_b_sptr.data(vector_sink_b_sptr self) → std::vector< unsigned char,std::allocator< unsigned char > >

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

declare_sample_delay(vector_sink_b_sptr self, unsigned int delay)

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

vector_sink_b_sptr.min_noutput_items(vector_sink_b_sptr self) → int

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

pc_input_buffers_full_avg(vector_sink_b_sptr self) -> pmt_vector_float

vector_sink_b_sptr.pc_noutput_items_avg(vector_sink_b_sptr self) → float

vector_sink_b_sptr.pc_nproduced_avg(vector_sink_b_sptr self) → float

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

pc_output_buffers_full_avg(vector_sink_b_sptr self) -> pmt_vector_float

vector_sink_b_sptr.pc_throughput_avg(vector_sink_b_sptr self) → float

vector_sink_b_sptr.pc_work_time_avg(vector_sink_b_sptr self) → float

vector_sink_b_sptr.pc_work_time_total(vector_sink_b_sptr self) → float

vector_sink_b_sptr.reset(vector_sink_b_sptr self)

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

vector_sink_b_sptr.set_min_noutput_items(vector_sink_b_sptr self, int m)

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

vector_sink_b_sptr.tags(vector_sink_b_sptr self) → tags_vector_t

vector_sink_b_sptr.thread_priority(vector_sink_b_sptr self) → int

gnuradio.blocks.vector_sink_c(int vlen=1) → vector_sink_c_sptr

vector_sink_c_sptr.active_thread_priority(vector_sink_c_sptr self) → int

vector_sink_c_sptr.data(vector_sink_c_sptr self) → pmt_vector_cfloat

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

declare_sample_delay(vector_sink_c_sptr self, unsigned int delay)

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

vector_sink_c_sptr.min_noutput_items(vector_sink_c_sptr self) → int

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

pc_input_buffers_full_avg(vector_sink_c_sptr self) -> pmt_vector_float

vector_sink_c_sptr.pc_noutput_items_avg(vector_sink_c_sptr self) → float

vector_sink_c_sptr.pc_nproduced_avg(vector_sink_c_sptr self) → float

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

pc_output_buffers_full_avg(vector_sink_c_sptr self) -> pmt_vector_float

vector_sink_c_sptr.pc_throughput_avg(vector_sink_c_sptr self) → float

vector_sink_c_sptr.pc_work_time_avg(vector_sink_c_sptr self) → float

vector_sink_c_sptr.pc_work_time_total(vector_sink_c_sptr self) → float

vector_sink_c_sptr.reset(vector_sink_c_sptr self)

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

vector_sink_c_sptr.set_min_noutput_items(vector_sink_c_sptr self, int m)

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

vector_sink_c_sptr.tags(vector_sink_c_sptr self) → tags_vector_t

vector_sink_c_sptr.thread_priority(vector_sink_c_sptr self) → int

gnuradio.blocks.vector_sink_f(int vlen=1) → vector_sink_f_sptr

vector_sink_f_sptr.active_thread_priority(vector_sink_f_sptr self) → int

vector_sink_f_sptr.data(vector_sink_f_sptr self) → pmt_vector_float

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

declare_sample_delay(vector_sink_f_sptr self, unsigned int delay)

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

vector_sink_f_sptr.min_noutput_items(vector_sink_f_sptr self) → int

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

pc_input_buffers_full_avg(vector_sink_f_sptr self) -> pmt_vector_float

vector_sink_f_sptr.pc_noutput_items_avg(vector_sink_f_sptr self) → float

vector_sink_f_sptr.pc_nproduced_avg(vector_sink_f_sptr self) → float

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

pc_output_buffers_full_avg(vector_sink_f_sptr self) -> pmt_vector_float

vector_sink_f_sptr.pc_throughput_avg(vector_sink_f_sptr self) → float

vector_sink_f_sptr.pc_work_time_avg(vector_sink_f_sptr self) → float

vector_sink_f_sptr.pc_work_time_total(vector_sink_f_sptr self) → float

vector_sink_f_sptr.reset(vector_sink_f_sptr self)

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

vector_sink_f_sptr.set_min_noutput_items(vector_sink_f_sptr self, int m)

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

vector_sink_f_sptr.tags(vector_sink_f_sptr self) → tags_vector_t

vector_sink_f_sptr.thread_priority(vector_sink_f_sptr self) → int

gnuradio.blocks.vector_sink_i(int vlen=1) → vector_sink_i_sptr

vector_sink_i_sptr.active_thread_priority(vector_sink_i_sptr self) → int

vector_sink_i_sptr.data(vector_sink_i_sptr self) → std::vector< int,std::allocator< int > >

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

declare_sample_delay(vector_sink_i_sptr self, unsigned int delay)

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

vector_sink_i_sptr.min_noutput_items(vector_sink_i_sptr self) → int

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

pc_input_buffers_full_avg(vector_sink_i_sptr self) -> pmt_vector_float

vector_sink_i_sptr.pc_noutput_items_avg(vector_sink_i_sptr self) → float

vector_sink_i_sptr.pc_nproduced_avg(vector_sink_i_sptr self) → float

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

pc_output_buffers_full_avg(vector_sink_i_sptr self) -> pmt_vector_float

vector_sink_i_sptr.pc_throughput_avg(vector_sink_i_sptr self) → float

vector_sink_i_sptr.pc_work_time_avg(vector_sink_i_sptr self) → float

vector_sink_i_sptr.pc_work_time_total(vector_sink_i_sptr self) → float

vector_sink_i_sptr.reset(vector_sink_i_sptr self)

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

vector_sink_i_sptr.set_min_noutput_items(vector_sink_i_sptr self, int m)

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

vector_sink_i_sptr.tags(vector_sink_i_sptr self) → tags_vector_t

vector_sink_i_sptr.thread_priority(vector_sink_i_sptr self) → int

gnuradio.blocks.vector_sink_s(int vlen=1) → vector_sink_s_sptr

vector_sink_s_sptr.active_thread_priority(vector_sink_s_sptr self) → int

vector_sink_s_sptr.data(vector_sink_s_sptr self) → std::vector< short,std::allocator< short > >

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

declare_sample_delay(vector_sink_s_sptr self, unsigned int delay)

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

vector_sink_s_sptr.min_noutput_items(vector_sink_s_sptr self) → int

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

pc_input_buffers_full_avg(vector_sink_s_sptr self) -> pmt_vector_float

vector_sink_s_sptr.pc_noutput_items_avg(vector_sink_s_sptr self) → float

vector_sink_s_sptr.pc_nproduced_avg(vector_sink_s_sptr self) → float

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

pc_output_buffers_full_avg(vector_sink_s_sptr self) -> pmt_vector_float

vector_sink_s_sptr.pc_throughput_avg(vector_sink_s_sptr self) → float

vector_sink_s_sptr.pc_work_time_avg(vector_sink_s_sptr self) → float

vector_sink_s_sptr.pc_work_time_total(vector_sink_s_sptr self) → float

vector_sink_s_sptr.reset(vector_sink_s_sptr self)

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

vector_sink_s_sptr.set_min_noutput_items(vector_sink_s_sptr self, int m)

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

vector_sink_s_sptr.tags(vector_sink_s_sptr self) → tags_vector_t

vector_sink_s_sptr.thread_priority(vector_sink_s_sptr self) → int

gnuradio.blocks.vector_source_b(std::vector< unsigned char, std::allocator< unsigned char > > const & data, bool repeat=False, int vlen=1, tags_vector_t tags=std::vector< gr::tag_t >()) → vector_source_b_sptr

vector_source_b_sptr.active_thread_priority(vector_source_b_sptr self) → int

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

declare_sample_delay(vector_source_b_sptr self, unsigned int delay)

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

vector_source_b_sptr.min_noutput_items(vector_source_b_sptr self) → int

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

pc_input_buffers_full_avg(vector_source_b_sptr self) -> pmt_vector_float

vector_source_b_sptr.pc_noutput_items_avg(vector_source_b_sptr self) → float

vector_source_b_sptr.pc_nproduced_avg(vector_source_b_sptr self) → float

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

pc_output_buffers_full_avg(vector_source_b_sptr self) -> pmt_vector_float

vector_source_b_sptr.pc_throughput_avg(vector_source_b_sptr self) → float

vector_source_b_sptr.pc_work_time_avg(vector_source_b_sptr self) → float

vector_source_b_sptr.pc_work_time_total(vector_source_b_sptr self) → float

vector_source_b_sptr.rewind(vector_source_b_sptr self)

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

vector_source_b_sptr.set_data(vector_source_b_sptr self, std::vector< unsigned char, std::allocator< unsigned char > > const & data, tags_vector_t tags=std::vector< gr::tag_t >())

vector_source_b_sptr.set_min_noutput_items(vector_source_b_sptr self, int m)

vector_source_b_sptr.set_repeat(vector_source_b_sptr self, bool repeat)

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

vector_source_b_sptr.thread_priority(vector_source_b_sptr self) → int

gnuradio.blocks.vector_source_c(pmt_vector_cfloat data, bool repeat=False, int vlen=1, tags_vector_t tags=std::vector< gr::tag_t >()) → vector_source_c_sptr

vector_source_c_sptr.active_thread_priority(vector_source_c_sptr self) → int

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

declare_sample_delay(vector_source_c_sptr self, unsigned int delay)

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

vector_source_c_sptr.min_noutput_items(vector_source_c_sptr self) → int

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

pc_input_buffers_full_avg(vector_source_c_sptr self) -> pmt_vector_float

vector_source_c_sptr.pc_noutput_items_avg(vector_source_c_sptr self) → float

vector_source_c_sptr.pc_nproduced_avg(vector_source_c_sptr self) → float

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

pc_output_buffers_full_avg(vector_source_c_sptr self) -> pmt_vector_float

vector_source_c_sptr.pc_throughput_avg(vector_source_c_sptr self) → float

vector_source_c_sptr.pc_work_time_avg(vector_source_c_sptr self) → float

vector_source_c_sptr.pc_work_time_total(vector_source_c_sptr self) → float

vector_source_c_sptr.rewind(vector_source_c_sptr self)

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

vector_source_c_sptr.set_data(vector_source_c_sptr self, pmt_vector_cfloat data, tags_vector_t tags=std::vector< gr::tag_t >())

vector_source_c_sptr.set_min_noutput_items(vector_source_c_sptr self, int m)

vector_source_c_sptr.set_repeat(vector_source_c_sptr self, bool repeat)

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

vector_source_c_sptr.thread_priority(vector_source_c_sptr self) → int

gnuradio.blocks.vector_source_f(pmt_vector_float data, bool repeat=False, int vlen=1, tags_vector_t tags=std::vector< gr::tag_t >()) → vector_source_f_sptr

vector_source_f_sptr.active_thread_priority(vector_source_f_sptr self) → int

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

declare_sample_delay(vector_source_f_sptr self, unsigned int delay)

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

vector_source_f_sptr.min_noutput_items(vector_source_f_sptr self) → int

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

pc_input_buffers_full_avg(vector_source_f_sptr self) -> pmt_vector_float

vector_source_f_sptr.pc_noutput_items_avg(vector_source_f_sptr self) → float

vector_source_f_sptr.pc_nproduced_avg(vector_source_f_sptr self) → float

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

pc_output_buffers_full_avg(vector_source_f_sptr self) -> pmt_vector_float

vector_source_f_sptr.pc_throughput_avg(vector_source_f_sptr self) → float

vector_source_f_sptr.pc_work_time_avg(vector_source_f_sptr self) → float

vector_source_f_sptr.pc_work_time_total(vector_source_f_sptr self) → float

vector_source_f_sptr.rewind(vector_source_f_sptr self)

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

vector_source_f_sptr.set_data(vector_source_f_sptr self, pmt_vector_float data, tags_vector_t tags=std::vector< gr::tag_t >())

vector_source_f_sptr.set_min_noutput_items(vector_source_f_sptr self, int m)

vector_source_f_sptr.set_repeat(vector_source_f_sptr self, bool repeat)

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

vector_source_f_sptr.thread_priority(vector_source_f_sptr self) → int

gnuradio.blocks.vector_source_i(std::vector< int, std::allocator< int > > const & data, bool repeat=False, int vlen=1, tags_vector_t tags=std::vector< gr::tag_t >()) → vector_source_i_sptr

vector_source_i_sptr.active_thread_priority(vector_source_i_sptr self) → int

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

declare_sample_delay(vector_source_i_sptr self, unsigned int delay)

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

vector_source_i_sptr.min_noutput_items(vector_source_i_sptr self) → int

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

pc_input_buffers_full_avg(vector_source_i_sptr self) -> pmt_vector_float

vector_source_i_sptr.pc_noutput_items_avg(vector_source_i_sptr self) → float

vector_source_i_sptr.pc_nproduced_avg(vector_source_i_sptr self) → float

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

pc_output_buffers_full_avg(vector_source_i_sptr self) -> pmt_vector_float

vector_source_i_sptr.pc_throughput_avg(vector_source_i_sptr self) → float

vector_source_i_sptr.pc_work_time_avg(vector_source_i_sptr self) → float

vector_source_i_sptr.pc_work_time_total(vector_source_i_sptr self) → float

vector_source_i_sptr.rewind(vector_source_i_sptr self)

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

vector_source_i_sptr.set_data(vector_source_i_sptr self, std::vector< int, std::allocator< int > > const & data, tags_vector_t tags=std::vector< gr::tag_t >())

vector_source_i_sptr.set_min_noutput_items(vector_source_i_sptr self, int m)

vector_source_i_sptr.set_repeat(vector_source_i_sptr self, bool repeat)

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

vector_source_i_sptr.thread_priority(vector_source_i_sptr self) → int

gnuradio.blocks.vector_source_s(std::vector< short, std::allocator< short > > const & data, bool repeat=False, int vlen=1, tags_vector_t tags=std::vector< gr::tag_t >()) → vector_source_s_sptr

vector_source_s_sptr.active_thread_priority(vector_source_s_sptr self) → int

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

declare_sample_delay(vector_source_s_sptr self, unsigned int delay)

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

vector_source_s_sptr.min_noutput_items(vector_source_s_sptr self) → int

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

pc_input_buffers_full_avg(vector_source_s_sptr self) -> pmt_vector_float

vector_source_s_sptr.pc_noutput_items_avg(vector_source_s_sptr self) → float

vector_source_s_sptr.pc_nproduced_avg(vector_source_s_sptr self) → float

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

pc_output_buffers_full_avg(vector_source_s_sptr self) -> pmt_vector_float

vector_source_s_sptr.pc_throughput_avg(vector_source_s_sptr self) → float

vector_source_s_sptr.pc_work_time_avg(vector_source_s_sptr self) → float

vector_source_s_sptr.pc_work_time_total(vector_source_s_sptr self) → float

vector_source_s_sptr.rewind(vector_source_s_sptr self)

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

vector_source_s_sptr.set_data(vector_source_s_sptr self, std::vector< short, std::allocator< short > > const & data, tags_vector_t tags=std::vector< gr::tag_t >())

vector_source_s_sptr.set_min_noutput_items(vector_source_s_sptr self, int m)

vector_source_s_sptr.set_repeat(vector_source_s_sptr self, bool repeat)

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

vector_source_s_sptr.thread_priority(vector_source_s_sptr self) → int

gnuradio.blocks.vector_to_stream(size_t itemsize, size_t nitems_per_block) → vector_to_stream_sptr

vector_to_stream_sptr.active_thread_priority(vector_to_stream_sptr self) → int

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

declare_sample_delay(vector_to_stream_sptr self, unsigned int delay)

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

vector_to_stream_sptr.min_noutput_items(vector_to_stream_sptr self) → int

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

pc_input_buffers_full_avg(vector_to_stream_sptr self) -> pmt_vector_float

vector_to_stream_sptr.pc_noutput_items_avg(vector_to_stream_sptr self) → float

vector_to_stream_sptr.pc_nproduced_avg(vector_to_stream_sptr self) → float

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

pc_output_buffers_full_avg(vector_to_stream_sptr self) -> pmt_vector_float

vector_to_stream_sptr.pc_throughput_avg(vector_to_stream_sptr self) → float

vector_to_stream_sptr.pc_work_time_avg(vector_to_stream_sptr self) → float

vector_to_stream_sptr.pc_work_time_total(vector_to_stream_sptr self) → float

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

vector_to_stream_sptr.set_min_noutput_items(vector_to_stream_sptr self, int m)

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

vector_to_stream_sptr.thread_priority(vector_to_stream_sptr self) → int

gnuradio.blocks.vector_to_streams(size_t itemsize, size_t nstreams) → vector_to_streams_sptr

vector_to_streams_sptr.active_thread_priority(vector_to_streams_sptr self) → int

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

declare_sample_delay(vector_to_streams_sptr self, unsigned int delay)

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

vector_to_streams_sptr.min_noutput_items(vector_to_streams_sptr self) → int

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

pc_input_buffers_full_avg(vector_to_streams_sptr self) -> pmt_vector_float

vector_to_streams_sptr.pc_noutput_items_avg(vector_to_streams_sptr self) → float

vector_to_streams_sptr.pc_nproduced_avg(vector_to_streams_sptr self) → float

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

pc_output_buffers_full_avg(vector_to_streams_sptr self) -> pmt_vector_float

vector_to_streams_sptr.pc_throughput_avg(vector_to_streams_sptr self) → float

vector_to_streams_sptr.pc_work_time_avg(vector_to_streams_sptr self) → float

vector_to_streams_sptr.pc_work_time_total(vector_to_streams_sptr self) → float

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

vector_to_streams_sptr.set_min_noutput_items(vector_to_streams_sptr self, int m)

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

vector_to_streams_sptr.thread_priority(vector_to_streams_sptr self) → int

gnuradio.blocks.wavfile_sink(char const * filename, int n_channels, unsigned int sample_rate, int bits_per_sample=16) → wavfile_sink_sptr

wavfile_sink_sptr.active_thread_priority(wavfile_sink_sptr self) → int

wavfile_sink_sptr.close(wavfile_sink_sptr self)

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

declare_sample_delay(wavfile_sink_sptr self, unsigned int delay)

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

wavfile_sink_sptr.min_noutput_items(wavfile_sink_sptr self) → int

wavfile_sink_sptr.open(wavfile_sink_sptr self, char const * filename) → bool

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

pc_input_buffers_full_avg(wavfile_sink_sptr self) -> pmt_vector_float

wavfile_sink_sptr.pc_noutput_items_avg(wavfile_sink_sptr self) → float

wavfile_sink_sptr.pc_nproduced_avg(wavfile_sink_sptr self) → float

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

pc_output_buffers_full_avg(wavfile_sink_sptr self) -> pmt_vector_float

wavfile_sink_sptr.pc_throughput_avg(wavfile_sink_sptr self) → float

wavfile_sink_sptr.pc_work_time_avg(wavfile_sink_sptr self) → float

wavfile_sink_sptr.pc_work_time_total(wavfile_sink_sptr self) → float

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

wavfile_sink_sptr.set_bits_per_sample(wavfile_sink_sptr self, int bits_per_sample)

wavfile_sink_sptr.set_min_noutput_items(wavfile_sink_sptr self, int m)

wavfile_sink_sptr.set_sample_rate(wavfile_sink_sptr self, unsigned int sample_rate)

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

wavfile_sink_sptr.thread_priority(wavfile_sink_sptr self) → int

gnuradio.blocks.wavfile_source(char const * filename, bool repeat=False) → wavfile_source_sptr

wavfile_source_sptr.active_thread_priority(wavfile_source_sptr self) → int

wavfile_source_sptr.bits_per_sample(wavfile_source_sptr self) → int

wavfile_source_sptr.channels(wavfile_source_sptr self) → int

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

declare_sample_delay(wavfile_source_sptr self, unsigned int delay)

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

wavfile_source_sptr.min_noutput_items(wavfile_source_sptr self) → int

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

pc_input_buffers_full_avg(wavfile_source_sptr self) -> pmt_vector_float

wavfile_source_sptr.pc_noutput_items_avg(wavfile_source_sptr self) → float

wavfile_source_sptr.pc_nproduced_avg(wavfile_source_sptr self) → float

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

pc_output_buffers_full_avg(wavfile_source_sptr self) -> pmt_vector_float

wavfile_source_sptr.pc_throughput_avg(wavfile_source_sptr self) → float

wavfile_source_sptr.pc_work_time_avg(wavfile_source_sptr self) → float

wavfile_source_sptr.pc_work_time_total(wavfile_source_sptr self) → float

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

wavfile_source_sptr.sample_rate(wavfile_source_sptr self) → unsigned int

wavfile_source_sptr.set_min_noutput_items(wavfile_source_sptr self, int m)

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

wavfile_source_sptr.thread_priority(wavfile_source_sptr self) → int

gnuradio.blocks.xor_bb(size_t vlen=1) → xor_bb_sptr

xor_bb_sptr.active_thread_priority(xor_bb_sptr self) → int

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

declare_sample_delay(xor_bb_sptr self, unsigned int delay)

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

xor_bb_sptr.min_noutput_items(xor_bb_sptr self) → int

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

pc_input_buffers_full_avg(xor_bb_sptr self) -> pmt_vector_float

xor_bb_sptr.pc_noutput_items_avg(xor_bb_sptr self) → float

xor_bb_sptr.pc_nproduced_avg(xor_bb_sptr self) → float

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

pc_output_buffers_full_avg(xor_bb_sptr self) -> pmt_vector_float

xor_bb_sptr.pc_throughput_avg(xor_bb_sptr self) → float

xor_bb_sptr.pc_work_time_avg(xor_bb_sptr self) → float

xor_bb_sptr.pc_work_time_total(xor_bb_sptr self) → float

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

xor_bb_sptr.set_min_noutput_items(xor_bb_sptr self, int m)

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

xor_bb_sptr.thread_priority(xor_bb_sptr self) → int

gnuradio.blocks.xor_ii(size_t vlen=1) → xor_ii_sptr

xor_ii_sptr.active_thread_priority(xor_ii_sptr self) → int

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

declare_sample_delay(xor_ii_sptr self, unsigned int delay)

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

xor_ii_sptr.min_noutput_items(xor_ii_sptr self) → int

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

pc_input_buffers_full_avg(xor_ii_sptr self) -> pmt_vector_float

xor_ii_sptr.pc_noutput_items_avg(xor_ii_sptr self) → float

xor_ii_sptr.pc_nproduced_avg(xor_ii_sptr self) → float

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

pc_output_buffers_full_avg(xor_ii_sptr self) -> pmt_vector_float

xor_ii_sptr.pc_throughput_avg(xor_ii_sptr self) → float

xor_ii_sptr.pc_work_time_avg(xor_ii_sptr self) → float

xor_ii_sptr.pc_work_time_total(xor_ii_sptr self) → float

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

xor_ii_sptr.set_min_noutput_items(xor_ii_sptr self, int m)

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

xor_ii_sptr.thread_priority(xor_ii_sptr self) → int

gnuradio.blocks.xor_ss(size_t vlen=1) → xor_ss_sptr

xor_ss_sptr.active_thread_priority(xor_ss_sptr self) → int

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

declare_sample_delay(xor_ss_sptr self, unsigned int delay)

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

xor_ss_sptr.min_noutput_items(xor_ss_sptr self) → int

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

pc_input_buffers_full_avg(xor_ss_sptr self) -> pmt_vector_float

xor_ss_sptr.pc_noutput_items_avg(xor_ss_sptr self) → float

xor_ss_sptr.pc_nproduced_avg(xor_ss_sptr self) → float

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

pc_output_buffers_full_avg(xor_ss_sptr self) -> pmt_vector_float

xor_ss_sptr.pc_throughput_avg(xor_ss_sptr self) → float

xor_ss_sptr.pc_work_time_avg(xor_ss_sptr self) → float

xor_ss_sptr.pc_work_time_total(xor_ss_sptr self) → float

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

xor_ss_sptr.set_min_noutput_items(xor_ss_sptr self, int m)

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

xor_ss_sptr.thread_priority(xor_ss_sptr self) → int