gnuradio.digital

Blocks and utilities for digital modulation and demodulation.

gnuradio.digital.additive_scrambler_bb(int mask, int seed, int len, int count=0, int bits_per_byte=1, std::string const & reset_tag_key="") → additive_scrambler_bb_sptr
additive_scrambler_bb_sptr.active_thread_priority(additive_scrambler_bb_sptr self) → int
additive_scrambler_bb_sptr.bits_per_byte(additive_scrambler_bb_sptr self) → int
additive_scrambler_bb_sptr.count(additive_scrambler_bb_sptr self) → int
additive_scrambler_bb_sptr.declare_sample_delay(additive_scrambler_bb_sptr self, int which, int delay)

declare_sample_delay(additive_scrambler_bb_sptr self, unsigned int delay)

additive_scrambler_bb_sptr.len(additive_scrambler_bb_sptr self) → int
additive_scrambler_bb_sptr.mask(additive_scrambler_bb_sptr self) → int
additive_scrambler_bb_sptr.message_subscribers(additive_scrambler_bb_sptr self, swig_int_ptr which_port) → swig_int_ptr
additive_scrambler_bb_sptr.min_noutput_items(additive_scrambler_bb_sptr self) → int
additive_scrambler_bb_sptr.pc_input_buffers_full_avg(additive_scrambler_bb_sptr self, int which) → float

pc_input_buffers_full_avg(additive_scrambler_bb_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(additive_scrambler_bb_sptr self) -> pmt_vector_float

additive_scrambler_bb_sptr.pc_throughput_avg(additive_scrambler_bb_sptr self) → float
additive_scrambler_bb_sptr.pc_work_time_avg(additive_scrambler_bb_sptr self) → float
additive_scrambler_bb_sptr.pc_work_time_total(additive_scrambler_bb_sptr self) → float
additive_scrambler_bb_sptr.sample_delay(additive_scrambler_bb_sptr self, int which) → unsigned int
additive_scrambler_bb_sptr.seed(additive_scrambler_bb_sptr self) → int
additive_scrambler_bb_sptr.set_min_noutput_items(additive_scrambler_bb_sptr self, int m)
additive_scrambler_bb_sptr.set_thread_priority(additive_scrambler_bb_sptr self, int priority) → int
additive_scrambler_bb_sptr.thread_priority(additive_scrambler_bb_sptr self) → int
gnuradio.digital.binary_slicer_fb() → binary_slicer_fb_sptr
binary_slicer_fb_sptr.active_thread_priority(binary_slicer_fb_sptr self) → int
binary_slicer_fb_sptr.declare_sample_delay(binary_slicer_fb_sptr self, int which, int delay)

declare_sample_delay(binary_slicer_fb_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(binary_slicer_fb_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(binary_slicer_fb_sptr self) -> pmt_vector_float

binary_slicer_fb_sptr.pc_throughput_avg(binary_slicer_fb_sptr self) → float
binary_slicer_fb_sptr.pc_work_time_avg(binary_slicer_fb_sptr self) → float
binary_slicer_fb_sptr.pc_work_time_total(binary_slicer_fb_sptr self) → float
binary_slicer_fb_sptr.sample_delay(binary_slicer_fb_sptr self, int which) → unsigned int
binary_slicer_fb_sptr.set_min_noutput_items(binary_slicer_fb_sptr self, int m)
binary_slicer_fb_sptr.set_thread_priority(binary_slicer_fb_sptr self, int priority) → int
binary_slicer_fb_sptr.thread_priority(binary_slicer_fb_sptr self) → int
gnuradio.digital.burst_shaper_cc(pmt_vector_cfloat taps, int pre_padding=0, int post_padding=0, bool insert_phasing=False, std::string const & length_tag_name="packet_len") → burst_shaper_cc_sptr
burst_shaper_cc_sptr.active_thread_priority(burst_shaper_cc_sptr self) → int
burst_shaper_cc_sptr.declare_sample_delay(burst_shaper_cc_sptr self, int which, int delay)

declare_sample_delay(burst_shaper_cc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(burst_shaper_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(burst_shaper_cc_sptr self) -> pmt_vector_float

burst_shaper_cc_sptr.pc_throughput_avg(burst_shaper_cc_sptr self) → float
burst_shaper_cc_sptr.pc_work_time_avg(burst_shaper_cc_sptr self) → float
burst_shaper_cc_sptr.pc_work_time_total(burst_shaper_cc_sptr self) → float
burst_shaper_cc_sptr.post_padding(burst_shaper_cc_sptr self) → int
burst_shaper_cc_sptr.pre_padding(burst_shaper_cc_sptr self) → int
burst_shaper_cc_sptr.prefix_length(burst_shaper_cc_sptr self) → int
burst_shaper_cc_sptr.sample_delay(burst_shaper_cc_sptr self, int which) → unsigned int
burst_shaper_cc_sptr.set_min_noutput_items(burst_shaper_cc_sptr self, int m)
burst_shaper_cc_sptr.set_thread_priority(burst_shaper_cc_sptr self, int priority) → int
burst_shaper_cc_sptr.suffix_length(burst_shaper_cc_sptr self) → int
burst_shaper_cc_sptr.thread_priority(burst_shaper_cc_sptr self) → int
gnuradio.digital.burst_shaper_ff(pmt_vector_float taps, int pre_padding=0, int post_padding=0, bool insert_phasing=False, std::string const & length_tag_name="packet_len") → burst_shaper_ff_sptr
burst_shaper_ff_sptr.active_thread_priority(burst_shaper_ff_sptr self) → int
burst_shaper_ff_sptr.declare_sample_delay(burst_shaper_ff_sptr self, int which, int delay)

declare_sample_delay(burst_shaper_ff_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(burst_shaper_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(burst_shaper_ff_sptr self) -> pmt_vector_float

burst_shaper_ff_sptr.pc_throughput_avg(burst_shaper_ff_sptr self) → float
burst_shaper_ff_sptr.pc_work_time_avg(burst_shaper_ff_sptr self) → float
burst_shaper_ff_sptr.pc_work_time_total(burst_shaper_ff_sptr self) → float
burst_shaper_ff_sptr.post_padding(burst_shaper_ff_sptr self) → int
burst_shaper_ff_sptr.pre_padding(burst_shaper_ff_sptr self) → int
burst_shaper_ff_sptr.prefix_length(burst_shaper_ff_sptr self) → int
burst_shaper_ff_sptr.sample_delay(burst_shaper_ff_sptr self, int which) → unsigned int
burst_shaper_ff_sptr.set_min_noutput_items(burst_shaper_ff_sptr self, int m)
burst_shaper_ff_sptr.set_thread_priority(burst_shaper_ff_sptr self, int priority) → int
burst_shaper_ff_sptr.suffix_length(burst_shaper_ff_sptr self) → int
burst_shaper_ff_sptr.thread_priority(burst_shaper_ff_sptr self) → int
gnuradio.digital.chunks_to_symbols_bc(pmt_vector_cfloat symbol_table, int const D=1) → chunks_to_symbols_bc_sptr
chunks_to_symbols_bc_sptr.D(chunks_to_symbols_bc_sptr self) → int
chunks_to_symbols_bc_sptr.active_thread_priority(chunks_to_symbols_bc_sptr self) → int
chunks_to_symbols_bc_sptr.declare_sample_delay(chunks_to_symbols_bc_sptr self, int which, int delay)

declare_sample_delay(chunks_to_symbols_bc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(chunks_to_symbols_bc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(chunks_to_symbols_bc_sptr self) -> pmt_vector_float

chunks_to_symbols_bc_sptr.pc_throughput_avg(chunks_to_symbols_bc_sptr self) → float
chunks_to_symbols_bc_sptr.pc_work_time_avg(chunks_to_symbols_bc_sptr self) → float
chunks_to_symbols_bc_sptr.pc_work_time_total(chunks_to_symbols_bc_sptr self) → float
chunks_to_symbols_bc_sptr.sample_delay(chunks_to_symbols_bc_sptr self, int which) → unsigned int
chunks_to_symbols_bc_sptr.set_min_noutput_items(chunks_to_symbols_bc_sptr self, int m)
chunks_to_symbols_bc_sptr.set_symbol_table(chunks_to_symbols_bc_sptr self, pmt_vector_cfloat symbol_table)
chunks_to_symbols_bc_sptr.set_thread_priority(chunks_to_symbols_bc_sptr self, int priority) → int
chunks_to_symbols_bc_sptr.symbol_table(chunks_to_symbols_bc_sptr self) → pmt_vector_cfloat
chunks_to_symbols_bc_sptr.thread_priority(chunks_to_symbols_bc_sptr self) → int
gnuradio.digital.chunks_to_symbols_bf(pmt_vector_float symbol_table, int const D=1) → chunks_to_symbols_bf_sptr
chunks_to_symbols_bf_sptr.D(chunks_to_symbols_bf_sptr self) → int
chunks_to_symbols_bf_sptr.active_thread_priority(chunks_to_symbols_bf_sptr self) → int
chunks_to_symbols_bf_sptr.declare_sample_delay(chunks_to_symbols_bf_sptr self, int which, int delay)

declare_sample_delay(chunks_to_symbols_bf_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(chunks_to_symbols_bf_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(chunks_to_symbols_bf_sptr self) -> pmt_vector_float

chunks_to_symbols_bf_sptr.pc_throughput_avg(chunks_to_symbols_bf_sptr self) → float
chunks_to_symbols_bf_sptr.pc_work_time_avg(chunks_to_symbols_bf_sptr self) → float
chunks_to_symbols_bf_sptr.pc_work_time_total(chunks_to_symbols_bf_sptr self) → float
chunks_to_symbols_bf_sptr.sample_delay(chunks_to_symbols_bf_sptr self, int which) → unsigned int
chunks_to_symbols_bf_sptr.set_min_noutput_items(chunks_to_symbols_bf_sptr self, int m)
chunks_to_symbols_bf_sptr.set_symbol_table(chunks_to_symbols_bf_sptr self, pmt_vector_float symbol_table)
chunks_to_symbols_bf_sptr.set_thread_priority(chunks_to_symbols_bf_sptr self, int priority) → int
chunks_to_symbols_bf_sptr.symbol_table(chunks_to_symbols_bf_sptr self) → pmt_vector_float
chunks_to_symbols_bf_sptr.thread_priority(chunks_to_symbols_bf_sptr self) → int
gnuradio.digital.chunks_to_symbols_ic(pmt_vector_cfloat symbol_table, int const D=1) → chunks_to_symbols_ic_sptr
chunks_to_symbols_ic_sptr.D(chunks_to_symbols_ic_sptr self) → int
chunks_to_symbols_ic_sptr.active_thread_priority(chunks_to_symbols_ic_sptr self) → int
chunks_to_symbols_ic_sptr.declare_sample_delay(chunks_to_symbols_ic_sptr self, int which, int delay)

declare_sample_delay(chunks_to_symbols_ic_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(chunks_to_symbols_ic_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(chunks_to_symbols_ic_sptr self) -> pmt_vector_float

chunks_to_symbols_ic_sptr.pc_throughput_avg(chunks_to_symbols_ic_sptr self) → float
chunks_to_symbols_ic_sptr.pc_work_time_avg(chunks_to_symbols_ic_sptr self) → float
chunks_to_symbols_ic_sptr.pc_work_time_total(chunks_to_symbols_ic_sptr self) → float
chunks_to_symbols_ic_sptr.sample_delay(chunks_to_symbols_ic_sptr self, int which) → unsigned int
chunks_to_symbols_ic_sptr.set_min_noutput_items(chunks_to_symbols_ic_sptr self, int m)
chunks_to_symbols_ic_sptr.set_symbol_table(chunks_to_symbols_ic_sptr self, pmt_vector_cfloat symbol_table)
chunks_to_symbols_ic_sptr.set_thread_priority(chunks_to_symbols_ic_sptr self, int priority) → int
chunks_to_symbols_ic_sptr.symbol_table(chunks_to_symbols_ic_sptr self) → pmt_vector_cfloat
chunks_to_symbols_ic_sptr.thread_priority(chunks_to_symbols_ic_sptr self) → int
gnuradio.digital.chunks_to_symbols_if(pmt_vector_float symbol_table, int const D=1) → chunks_to_symbols_if_sptr
chunks_to_symbols_if_sptr.D(chunks_to_symbols_if_sptr self) → int
chunks_to_symbols_if_sptr.active_thread_priority(chunks_to_symbols_if_sptr self) → int
chunks_to_symbols_if_sptr.declare_sample_delay(chunks_to_symbols_if_sptr self, int which, int delay)

declare_sample_delay(chunks_to_symbols_if_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(chunks_to_symbols_if_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(chunks_to_symbols_if_sptr self) -> pmt_vector_float

chunks_to_symbols_if_sptr.pc_throughput_avg(chunks_to_symbols_if_sptr self) → float
chunks_to_symbols_if_sptr.pc_work_time_avg(chunks_to_symbols_if_sptr self) → float
chunks_to_symbols_if_sptr.pc_work_time_total(chunks_to_symbols_if_sptr self) → float
chunks_to_symbols_if_sptr.sample_delay(chunks_to_symbols_if_sptr self, int which) → unsigned int
chunks_to_symbols_if_sptr.set_min_noutput_items(chunks_to_symbols_if_sptr self, int m)
chunks_to_symbols_if_sptr.set_symbol_table(chunks_to_symbols_if_sptr self, pmt_vector_float symbol_table)
chunks_to_symbols_if_sptr.set_thread_priority(chunks_to_symbols_if_sptr self, int priority) → int
chunks_to_symbols_if_sptr.symbol_table(chunks_to_symbols_if_sptr self) → pmt_vector_float
chunks_to_symbols_if_sptr.thread_priority(chunks_to_symbols_if_sptr self) → int
gnuradio.digital.chunks_to_symbols_sc(pmt_vector_cfloat symbol_table, int const D=1) → chunks_to_symbols_sc_sptr
chunks_to_symbols_sc_sptr.D(chunks_to_symbols_sc_sptr self) → int
chunks_to_symbols_sc_sptr.active_thread_priority(chunks_to_symbols_sc_sptr self) → int
chunks_to_symbols_sc_sptr.declare_sample_delay(chunks_to_symbols_sc_sptr self, int which, int delay)

declare_sample_delay(chunks_to_symbols_sc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(chunks_to_symbols_sc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(chunks_to_symbols_sc_sptr self) -> pmt_vector_float

chunks_to_symbols_sc_sptr.pc_throughput_avg(chunks_to_symbols_sc_sptr self) → float
chunks_to_symbols_sc_sptr.pc_work_time_avg(chunks_to_symbols_sc_sptr self) → float
chunks_to_symbols_sc_sptr.pc_work_time_total(chunks_to_symbols_sc_sptr self) → float
chunks_to_symbols_sc_sptr.sample_delay(chunks_to_symbols_sc_sptr self, int which) → unsigned int
chunks_to_symbols_sc_sptr.set_min_noutput_items(chunks_to_symbols_sc_sptr self, int m)
chunks_to_symbols_sc_sptr.set_symbol_table(chunks_to_symbols_sc_sptr self, pmt_vector_cfloat symbol_table)
chunks_to_symbols_sc_sptr.set_thread_priority(chunks_to_symbols_sc_sptr self, int priority) → int
chunks_to_symbols_sc_sptr.symbol_table(chunks_to_symbols_sc_sptr self) → pmt_vector_cfloat
chunks_to_symbols_sc_sptr.thread_priority(chunks_to_symbols_sc_sptr self) → int
gnuradio.digital.chunks_to_symbols_sf(pmt_vector_float symbol_table, int const D=1) → chunks_to_symbols_sf_sptr
chunks_to_symbols_sf_sptr.D(chunks_to_symbols_sf_sptr self) → int
chunks_to_symbols_sf_sptr.active_thread_priority(chunks_to_symbols_sf_sptr self) → int
chunks_to_symbols_sf_sptr.declare_sample_delay(chunks_to_symbols_sf_sptr self, int which, int delay)

declare_sample_delay(chunks_to_symbols_sf_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(chunks_to_symbols_sf_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(chunks_to_symbols_sf_sptr self) -> pmt_vector_float

chunks_to_symbols_sf_sptr.pc_throughput_avg(chunks_to_symbols_sf_sptr self) → float
chunks_to_symbols_sf_sptr.pc_work_time_avg(chunks_to_symbols_sf_sptr self) → float
chunks_to_symbols_sf_sptr.pc_work_time_total(chunks_to_symbols_sf_sptr self) → float
chunks_to_symbols_sf_sptr.sample_delay(chunks_to_symbols_sf_sptr self, int which) → unsigned int
chunks_to_symbols_sf_sptr.set_min_noutput_items(chunks_to_symbols_sf_sptr self, int m)
chunks_to_symbols_sf_sptr.set_symbol_table(chunks_to_symbols_sf_sptr self, pmt_vector_float symbol_table)
chunks_to_symbols_sf_sptr.set_thread_priority(chunks_to_symbols_sf_sptr self, int priority) → int
chunks_to_symbols_sf_sptr.symbol_table(chunks_to_symbols_sf_sptr self) → pmt_vector_float
chunks_to_symbols_sf_sptr.thread_priority(chunks_to_symbols_sf_sptr self) → int
gnuradio.digital.clock_recovery_mm_cc(float omega, float gain_omega, float mu, float gain_mu, float omega_relative_limit) → clock_recovery_mm_cc_sptr
clock_recovery_mm_cc_sptr.active_thread_priority(clock_recovery_mm_cc_sptr self) → int
clock_recovery_mm_cc_sptr.declare_sample_delay(clock_recovery_mm_cc_sptr self, int which, int delay)

declare_sample_delay(clock_recovery_mm_cc_sptr self, unsigned int delay)

clock_recovery_mm_cc_sptr.gain_mu(clock_recovery_mm_cc_sptr self) → float
clock_recovery_mm_cc_sptr.gain_omega(clock_recovery_mm_cc_sptr self) → float
clock_recovery_mm_cc_sptr.message_subscribers(clock_recovery_mm_cc_sptr self, swig_int_ptr which_port) → swig_int_ptr
clock_recovery_mm_cc_sptr.min_noutput_items(clock_recovery_mm_cc_sptr self) → int
clock_recovery_mm_cc_sptr.mu(clock_recovery_mm_cc_sptr self) → float
clock_recovery_mm_cc_sptr.omega(clock_recovery_mm_cc_sptr self) → float
clock_recovery_mm_cc_sptr.pc_input_buffers_full_avg(clock_recovery_mm_cc_sptr self, int which) → float

pc_input_buffers_full_avg(clock_recovery_mm_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(clock_recovery_mm_cc_sptr self) -> pmt_vector_float

clock_recovery_mm_cc_sptr.pc_throughput_avg(clock_recovery_mm_cc_sptr self) → float
clock_recovery_mm_cc_sptr.pc_work_time_avg(clock_recovery_mm_cc_sptr self) → float
clock_recovery_mm_cc_sptr.pc_work_time_total(clock_recovery_mm_cc_sptr self) → float
clock_recovery_mm_cc_sptr.sample_delay(clock_recovery_mm_cc_sptr self, int which) → unsigned int
clock_recovery_mm_cc_sptr.set_gain_mu(clock_recovery_mm_cc_sptr self, float gain_mu)
clock_recovery_mm_cc_sptr.set_gain_omega(clock_recovery_mm_cc_sptr self, float gain_omega)
clock_recovery_mm_cc_sptr.set_min_noutput_items(clock_recovery_mm_cc_sptr self, int m)
clock_recovery_mm_cc_sptr.set_mu(clock_recovery_mm_cc_sptr self, float mu)
clock_recovery_mm_cc_sptr.set_omega(clock_recovery_mm_cc_sptr self, float omega)
clock_recovery_mm_cc_sptr.set_thread_priority(clock_recovery_mm_cc_sptr self, int priority) → int
clock_recovery_mm_cc_sptr.set_verbose(clock_recovery_mm_cc_sptr self, bool verbose)
clock_recovery_mm_cc_sptr.thread_priority(clock_recovery_mm_cc_sptr self) → int
gnuradio.digital.clock_recovery_mm_ff(float omega, float gain_omega, float mu, float gain_mu, float omega_relative_limit) → clock_recovery_mm_ff_sptr
clock_recovery_mm_ff_sptr.active_thread_priority(clock_recovery_mm_ff_sptr self) → int
clock_recovery_mm_ff_sptr.declare_sample_delay(clock_recovery_mm_ff_sptr self, int which, int delay)

declare_sample_delay(clock_recovery_mm_ff_sptr self, unsigned int delay)

clock_recovery_mm_ff_sptr.gain_mu(clock_recovery_mm_ff_sptr self) → float
clock_recovery_mm_ff_sptr.gain_omega(clock_recovery_mm_ff_sptr self) → float
clock_recovery_mm_ff_sptr.message_subscribers(clock_recovery_mm_ff_sptr self, swig_int_ptr which_port) → swig_int_ptr
clock_recovery_mm_ff_sptr.min_noutput_items(clock_recovery_mm_ff_sptr self) → int
clock_recovery_mm_ff_sptr.mu(clock_recovery_mm_ff_sptr self) → float
clock_recovery_mm_ff_sptr.omega(clock_recovery_mm_ff_sptr self) → float
clock_recovery_mm_ff_sptr.pc_input_buffers_full_avg(clock_recovery_mm_ff_sptr self, int which) → float

pc_input_buffers_full_avg(clock_recovery_mm_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(clock_recovery_mm_ff_sptr self) -> pmt_vector_float

clock_recovery_mm_ff_sptr.pc_throughput_avg(clock_recovery_mm_ff_sptr self) → float
clock_recovery_mm_ff_sptr.pc_work_time_avg(clock_recovery_mm_ff_sptr self) → float
clock_recovery_mm_ff_sptr.pc_work_time_total(clock_recovery_mm_ff_sptr self) → float
clock_recovery_mm_ff_sptr.sample_delay(clock_recovery_mm_ff_sptr self, int which) → unsigned int
clock_recovery_mm_ff_sptr.set_gain_mu(clock_recovery_mm_ff_sptr self, float gain_mu)
clock_recovery_mm_ff_sptr.set_gain_omega(clock_recovery_mm_ff_sptr self, float gain_omega)
clock_recovery_mm_ff_sptr.set_min_noutput_items(clock_recovery_mm_ff_sptr self, int m)
clock_recovery_mm_ff_sptr.set_mu(clock_recovery_mm_ff_sptr self, float mu)
clock_recovery_mm_ff_sptr.set_omega(clock_recovery_mm_ff_sptr self, float omega)
clock_recovery_mm_ff_sptr.set_thread_priority(clock_recovery_mm_ff_sptr self, int priority) → int
clock_recovery_mm_ff_sptr.set_verbose(clock_recovery_mm_ff_sptr self, bool verbose)
clock_recovery_mm_ff_sptr.thread_priority(clock_recovery_mm_ff_sptr self) → int
gnuradio.digital.cma_equalizer_cc(int num_taps, float modulus, float mu, int sps) → cma_equalizer_cc_sptr
cma_equalizer_cc_sptr.active_thread_priority(cma_equalizer_cc_sptr self) → int
cma_equalizer_cc_sptr.declare_sample_delay(cma_equalizer_cc_sptr self, int which, int delay)

declare_sample_delay(cma_equalizer_cc_sptr self, unsigned int delay)

cma_equalizer_cc_sptr.gain(cma_equalizer_cc_sptr self) → float
cma_equalizer_cc_sptr.message_subscribers(cma_equalizer_cc_sptr self, swig_int_ptr which_port) → swig_int_ptr
cma_equalizer_cc_sptr.min_noutput_items(cma_equalizer_cc_sptr self) → int
cma_equalizer_cc_sptr.modulus(cma_equalizer_cc_sptr self) → float
cma_equalizer_cc_sptr.pc_input_buffers_full_avg(cma_equalizer_cc_sptr self, int which) → float

pc_input_buffers_full_avg(cma_equalizer_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(cma_equalizer_cc_sptr self) -> pmt_vector_float

cma_equalizer_cc_sptr.pc_throughput_avg(cma_equalizer_cc_sptr self) → float
cma_equalizer_cc_sptr.pc_work_time_avg(cma_equalizer_cc_sptr self) → float
cma_equalizer_cc_sptr.pc_work_time_total(cma_equalizer_cc_sptr self) → float
cma_equalizer_cc_sptr.sample_delay(cma_equalizer_cc_sptr self, int which) → unsigned int
cma_equalizer_cc_sptr.set_gain(cma_equalizer_cc_sptr self, float mu)
cma_equalizer_cc_sptr.set_min_noutput_items(cma_equalizer_cc_sptr self, int m)
cma_equalizer_cc_sptr.set_modulus(cma_equalizer_cc_sptr self, float mod)
cma_equalizer_cc_sptr.set_taps(cma_equalizer_cc_sptr self, pmt_vector_cfloat taps)
cma_equalizer_cc_sptr.set_thread_priority(cma_equalizer_cc_sptr self, int priority) → int
cma_equalizer_cc_sptr.taps(cma_equalizer_cc_sptr self) → pmt_vector_cfloat
cma_equalizer_cc_sptr.thread_priority(cma_equalizer_cc_sptr self) → int
gnuradio.digital.constellation_decoder_cb(constellation_sptr constellation) → constellation_decoder_cb_sptr
constellation_decoder_cb_sptr.active_thread_priority(constellation_decoder_cb_sptr self) → int
constellation_decoder_cb_sptr.declare_sample_delay(constellation_decoder_cb_sptr self, int which, int delay)

declare_sample_delay(constellation_decoder_cb_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(constellation_decoder_cb_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(constellation_decoder_cb_sptr self) -> pmt_vector_float

constellation_decoder_cb_sptr.pc_throughput_avg(constellation_decoder_cb_sptr self) → float
constellation_decoder_cb_sptr.pc_work_time_avg(constellation_decoder_cb_sptr self) → float
constellation_decoder_cb_sptr.pc_work_time_total(constellation_decoder_cb_sptr self) → float
constellation_decoder_cb_sptr.sample_delay(constellation_decoder_cb_sptr self, int which) → unsigned int
constellation_decoder_cb_sptr.set_min_noutput_items(constellation_decoder_cb_sptr self, int m)
constellation_decoder_cb_sptr.set_thread_priority(constellation_decoder_cb_sptr self, int priority) → int
constellation_decoder_cb_sptr.thread_priority(constellation_decoder_cb_sptr self) → int
gnuradio.digital.constellation_receiver_cb(constellation_sptr constellation, float loop_bw, float fmin, float fmax) → constellation_receiver_cb_sptr
constellation_receiver_cb_sptr.active_thread_priority(constellation_receiver_cb_sptr self) → int
constellation_receiver_cb_sptr.advance_loop(constellation_receiver_cb_sptr self, float error)
constellation_receiver_cb_sptr.declare_sample_delay(constellation_receiver_cb_sptr self, int which, int delay)

declare_sample_delay(constellation_receiver_cb_sptr self, unsigned int delay)

constellation_receiver_cb_sptr.frequency_limit(constellation_receiver_cb_sptr self)
constellation_receiver_cb_sptr.get_alpha(constellation_receiver_cb_sptr self) → float
constellation_receiver_cb_sptr.get_beta(constellation_receiver_cb_sptr self) → float
constellation_receiver_cb_sptr.get_damping_factor(constellation_receiver_cb_sptr self) → float
constellation_receiver_cb_sptr.get_frequency(constellation_receiver_cb_sptr self) → float
constellation_receiver_cb_sptr.get_loop_bandwidth(constellation_receiver_cb_sptr self) → float
constellation_receiver_cb_sptr.get_max_freq(constellation_receiver_cb_sptr self) → float
constellation_receiver_cb_sptr.get_min_freq(constellation_receiver_cb_sptr self) → float
constellation_receiver_cb_sptr.get_phase(constellation_receiver_cb_sptr self) → float
constellation_receiver_cb_sptr.message_subscribers(constellation_receiver_cb_sptr self, swig_int_ptr which_port) → swig_int_ptr
constellation_receiver_cb_sptr.min_noutput_items(constellation_receiver_cb_sptr self) → int
constellation_receiver_cb_sptr.pc_input_buffers_full_avg(constellation_receiver_cb_sptr self, int which) → float

pc_input_buffers_full_avg(constellation_receiver_cb_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(constellation_receiver_cb_sptr self) -> pmt_vector_float

constellation_receiver_cb_sptr.pc_throughput_avg(constellation_receiver_cb_sptr self) → float
constellation_receiver_cb_sptr.pc_work_time_avg(constellation_receiver_cb_sptr self) → float
constellation_receiver_cb_sptr.pc_work_time_total(constellation_receiver_cb_sptr self) → float
constellation_receiver_cb_sptr.phase_error_tracking(constellation_receiver_cb_sptr self, float phase_error)
constellation_receiver_cb_sptr.phase_wrap(constellation_receiver_cb_sptr self)
constellation_receiver_cb_sptr.sample_delay(constellation_receiver_cb_sptr self, int which) → unsigned int
constellation_receiver_cb_sptr.set_alpha(constellation_receiver_cb_sptr self, float alpha)
constellation_receiver_cb_sptr.set_beta(constellation_receiver_cb_sptr self, float beta)
constellation_receiver_cb_sptr.set_damping_factor(constellation_receiver_cb_sptr self, float df)
constellation_receiver_cb_sptr.set_frequency(constellation_receiver_cb_sptr self, float freq)
constellation_receiver_cb_sptr.set_loop_bandwidth(constellation_receiver_cb_sptr self, float bw)
constellation_receiver_cb_sptr.set_max_freq(constellation_receiver_cb_sptr self, float freq)
constellation_receiver_cb_sptr.set_min_freq(constellation_receiver_cb_sptr self, float freq)
constellation_receiver_cb_sptr.set_min_noutput_items(constellation_receiver_cb_sptr self, int m)
constellation_receiver_cb_sptr.set_phase(constellation_receiver_cb_sptr self, float phase)
constellation_receiver_cb_sptr.set_thread_priority(constellation_receiver_cb_sptr self, int priority) → int
constellation_receiver_cb_sptr.thread_priority(constellation_receiver_cb_sptr self) → int
constellation_receiver_cb_sptr.update_gains(constellation_receiver_cb_sptr self)
gnuradio.digital.constellation_soft_decoder_cf(constellation_sptr constellation) → constellation_soft_decoder_cf_sptr
constellation_soft_decoder_cf_sptr.active_thread_priority(constellation_soft_decoder_cf_sptr self) → int
constellation_soft_decoder_cf_sptr.declare_sample_delay(constellation_soft_decoder_cf_sptr self, int which, int delay)

declare_sample_delay(constellation_soft_decoder_cf_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(constellation_soft_decoder_cf_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(constellation_soft_decoder_cf_sptr self) -> pmt_vector_float

constellation_soft_decoder_cf_sptr.pc_throughput_avg(constellation_soft_decoder_cf_sptr self) → float
constellation_soft_decoder_cf_sptr.pc_work_time_avg(constellation_soft_decoder_cf_sptr self) → float
constellation_soft_decoder_cf_sptr.pc_work_time_total(constellation_soft_decoder_cf_sptr self) → float
constellation_soft_decoder_cf_sptr.sample_delay(constellation_soft_decoder_cf_sptr self, int which) → unsigned int
constellation_soft_decoder_cf_sptr.set_min_noutput_items(constellation_soft_decoder_cf_sptr self, int m)
constellation_soft_decoder_cf_sptr.set_thread_priority(constellation_soft_decoder_cf_sptr self, int priority) → int
constellation_soft_decoder_cf_sptr.thread_priority(constellation_soft_decoder_cf_sptr self) → int
gnuradio.digital.correlate_access_code_bb(std::string const & access_code, int threshold) → correlate_access_code_bb_sptr
correlate_access_code_bb_sptr.active_thread_priority(correlate_access_code_bb_sptr self) → int
correlate_access_code_bb_sptr.declare_sample_delay(correlate_access_code_bb_sptr self, int which, int delay)

declare_sample_delay(correlate_access_code_bb_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(correlate_access_code_bb_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(correlate_access_code_bb_sptr self) -> pmt_vector_float

correlate_access_code_bb_sptr.pc_throughput_avg(correlate_access_code_bb_sptr self) → float
correlate_access_code_bb_sptr.pc_work_time_avg(correlate_access_code_bb_sptr self) → float
correlate_access_code_bb_sptr.pc_work_time_total(correlate_access_code_bb_sptr self) → float
correlate_access_code_bb_sptr.sample_delay(correlate_access_code_bb_sptr self, int which) → unsigned int
correlate_access_code_bb_sptr.set_access_code(correlate_access_code_bb_sptr self, std::string const & access_code) → bool
correlate_access_code_bb_sptr.set_min_noutput_items(correlate_access_code_bb_sptr self, int m)
correlate_access_code_bb_sptr.set_thread_priority(correlate_access_code_bb_sptr self, int priority) → int
correlate_access_code_bb_sptr.thread_priority(correlate_access_code_bb_sptr self) → int
gnuradio.digital.correlate_access_code_bb_ts(std::string const & access_code, int threshold, std::string const & tag_name) → correlate_access_code_bb_ts_sptr
correlate_access_code_bb_ts_sptr.access_code(correlate_access_code_bb_ts_sptr self) → unsigned long long
correlate_access_code_bb_ts_sptr.active_thread_priority(correlate_access_code_bb_ts_sptr self) → int
correlate_access_code_bb_ts_sptr.declare_sample_delay(correlate_access_code_bb_ts_sptr self, int which, int delay)

declare_sample_delay(correlate_access_code_bb_ts_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(correlate_access_code_bb_ts_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(correlate_access_code_bb_ts_sptr self) -> pmt_vector_float

correlate_access_code_bb_ts_sptr.pc_throughput_avg(correlate_access_code_bb_ts_sptr self) → float
correlate_access_code_bb_ts_sptr.pc_work_time_avg(correlate_access_code_bb_ts_sptr self) → float
correlate_access_code_bb_ts_sptr.pc_work_time_total(correlate_access_code_bb_ts_sptr self) → float
correlate_access_code_bb_ts_sptr.sample_delay(correlate_access_code_bb_ts_sptr self, int which) → unsigned int
correlate_access_code_bb_ts_sptr.set_access_code(correlate_access_code_bb_ts_sptr self, std::string const & access_code) → bool
correlate_access_code_bb_ts_sptr.set_min_noutput_items(correlate_access_code_bb_ts_sptr self, int m)
correlate_access_code_bb_ts_sptr.set_thread_priority(correlate_access_code_bb_ts_sptr self, int priority) → int
correlate_access_code_bb_ts_sptr.thread_priority(correlate_access_code_bb_ts_sptr self) → int
gnuradio.digital.correlate_access_code_ff_ts(std::string const & access_code, int threshold, std::string const & tag_name) → correlate_access_code_ff_ts_sptr
correlate_access_code_ff_ts_sptr.access_code(correlate_access_code_ff_ts_sptr self) → unsigned long long
correlate_access_code_ff_ts_sptr.active_thread_priority(correlate_access_code_ff_ts_sptr self) → int
correlate_access_code_ff_ts_sptr.declare_sample_delay(correlate_access_code_ff_ts_sptr self, int which, int delay)

declare_sample_delay(correlate_access_code_ff_ts_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(correlate_access_code_ff_ts_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(correlate_access_code_ff_ts_sptr self) -> pmt_vector_float

correlate_access_code_ff_ts_sptr.pc_throughput_avg(correlate_access_code_ff_ts_sptr self) → float
correlate_access_code_ff_ts_sptr.pc_work_time_avg(correlate_access_code_ff_ts_sptr self) → float
correlate_access_code_ff_ts_sptr.pc_work_time_total(correlate_access_code_ff_ts_sptr self) → float
correlate_access_code_ff_ts_sptr.sample_delay(correlate_access_code_ff_ts_sptr self, int which) → unsigned int
correlate_access_code_ff_ts_sptr.set_access_code(correlate_access_code_ff_ts_sptr self, std::string const & access_code) → bool
correlate_access_code_ff_ts_sptr.set_min_noutput_items(correlate_access_code_ff_ts_sptr self, int m)
correlate_access_code_ff_ts_sptr.set_thread_priority(correlate_access_code_ff_ts_sptr self, int priority) → int
correlate_access_code_ff_ts_sptr.thread_priority(correlate_access_code_ff_ts_sptr self) → int
gnuradio.digital.correlate_access_code_tag_bb(std::string const & access_code, int threshold, std::string const & tag_name) → correlate_access_code_tag_bb_sptr
correlate_access_code_tag_bb_sptr.active_thread_priority(correlate_access_code_tag_bb_sptr self) → int
correlate_access_code_tag_bb_sptr.declare_sample_delay(correlate_access_code_tag_bb_sptr self, int which, int delay)

declare_sample_delay(correlate_access_code_tag_bb_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(correlate_access_code_tag_bb_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(correlate_access_code_tag_bb_sptr self) -> pmt_vector_float

correlate_access_code_tag_bb_sptr.pc_throughput_avg(correlate_access_code_tag_bb_sptr self) → float
correlate_access_code_tag_bb_sptr.pc_work_time_avg(correlate_access_code_tag_bb_sptr self) → float
correlate_access_code_tag_bb_sptr.pc_work_time_total(correlate_access_code_tag_bb_sptr self) → float
correlate_access_code_tag_bb_sptr.sample_delay(correlate_access_code_tag_bb_sptr self, int which) → unsigned int
correlate_access_code_tag_bb_sptr.set_access_code(correlate_access_code_tag_bb_sptr self, std::string const & access_code) → bool
correlate_access_code_tag_bb_sptr.set_min_noutput_items(correlate_access_code_tag_bb_sptr self, int m)
correlate_access_code_tag_bb_sptr.set_thread_priority(correlate_access_code_tag_bb_sptr self, int priority) → int
correlate_access_code_tag_bb_sptr.thread_priority(correlate_access_code_tag_bb_sptr self) → int
gnuradio.digital.correlate_and_sync_cc(pmt_vector_cfloat symbols, pmt_vector_float filter, unsigned int sps, unsigned int nfilts=32) → correlate_and_sync_cc_sptr
correlate_and_sync_cc_sptr.active_thread_priority(correlate_and_sync_cc_sptr self) → int
correlate_and_sync_cc_sptr.declare_sample_delay(correlate_and_sync_cc_sptr self, int which, int delay)

declare_sample_delay(correlate_and_sync_cc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(correlate_and_sync_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(correlate_and_sync_cc_sptr self) -> pmt_vector_float

correlate_and_sync_cc_sptr.pc_throughput_avg(correlate_and_sync_cc_sptr self) → float
correlate_and_sync_cc_sptr.pc_work_time_avg(correlate_and_sync_cc_sptr self) → float
correlate_and_sync_cc_sptr.pc_work_time_total(correlate_and_sync_cc_sptr self) → float
correlate_and_sync_cc_sptr.sample_delay(correlate_and_sync_cc_sptr self, int which) → unsigned int
correlate_and_sync_cc_sptr.set_min_noutput_items(correlate_and_sync_cc_sptr self, int m)
correlate_and_sync_cc_sptr.set_symbols(correlate_and_sync_cc_sptr self, pmt_vector_cfloat symbols)
correlate_and_sync_cc_sptr.set_thread_priority(correlate_and_sync_cc_sptr self, int priority) → int
correlate_and_sync_cc_sptr.symbols(correlate_and_sync_cc_sptr self) → pmt_vector_cfloat
correlate_and_sync_cc_sptr.thread_priority(correlate_and_sync_cc_sptr self) → int
gnuradio.digital.corr_est_cc(pmt_vector_cfloat symbols, float sps, unsigned int mark_delay, float threshold=0.9) → corr_est_cc_sptr
corr_est_cc_sptr.active_thread_priority(corr_est_cc_sptr self) → int
corr_est_cc_sptr.declare_sample_delay(corr_est_cc_sptr self, int which, int delay)

declare_sample_delay(corr_est_cc_sptr self, unsigned int delay)

corr_est_cc_sptr.mark_delay(corr_est_cc_sptr self) → unsigned int
corr_est_cc_sptr.message_subscribers(corr_est_cc_sptr self, swig_int_ptr which_port) → swig_int_ptr
corr_est_cc_sptr.min_noutput_items(corr_est_cc_sptr self) → int
corr_est_cc_sptr.pc_input_buffers_full_avg(corr_est_cc_sptr self, int which) → float

pc_input_buffers_full_avg(corr_est_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(corr_est_cc_sptr self) -> pmt_vector_float

corr_est_cc_sptr.pc_throughput_avg(corr_est_cc_sptr self) → float
corr_est_cc_sptr.pc_work_time_avg(corr_est_cc_sptr self) → float
corr_est_cc_sptr.pc_work_time_total(corr_est_cc_sptr self) → float
corr_est_cc_sptr.sample_delay(corr_est_cc_sptr self, int which) → unsigned int
corr_est_cc_sptr.set_mark_delay(corr_est_cc_sptr self, unsigned int mark_delay)
corr_est_cc_sptr.set_min_noutput_items(corr_est_cc_sptr self, int m)
corr_est_cc_sptr.set_symbols(corr_est_cc_sptr self, pmt_vector_cfloat symbols)
corr_est_cc_sptr.set_thread_priority(corr_est_cc_sptr self, int priority) → int
corr_est_cc_sptr.set_threshold(corr_est_cc_sptr self, float threshold)
corr_est_cc_sptr.symbols(corr_est_cc_sptr self) → pmt_vector_cfloat
corr_est_cc_sptr.thread_priority(corr_est_cc_sptr self) → int
corr_est_cc_sptr.threshold(corr_est_cc_sptr self) → float
gnuradio.digital.costas_loop_cc(float loop_bw, int order, bool use_snr=False) → costas_loop_cc_sptr
costas_loop_cc_sptr.active_thread_priority(costas_loop_cc_sptr self) → int
costas_loop_cc_sptr.advance_loop(costas_loop_cc_sptr self, float error)
costas_loop_cc_sptr.declare_sample_delay(costas_loop_cc_sptr self, int which, int delay)

declare_sample_delay(costas_loop_cc_sptr self, unsigned int delay)

costas_loop_cc_sptr.error(costas_loop_cc_sptr self) → float
costas_loop_cc_sptr.frequency_limit(costas_loop_cc_sptr self)
costas_loop_cc_sptr.get_alpha(costas_loop_cc_sptr self) → float
costas_loop_cc_sptr.get_beta(costas_loop_cc_sptr self) → float
costas_loop_cc_sptr.get_damping_factor(costas_loop_cc_sptr self) → float
costas_loop_cc_sptr.get_frequency(costas_loop_cc_sptr self) → float
costas_loop_cc_sptr.get_loop_bandwidth(costas_loop_cc_sptr self) → float
costas_loop_cc_sptr.get_max_freq(costas_loop_cc_sptr self) → float
costas_loop_cc_sptr.get_min_freq(costas_loop_cc_sptr self) → float
costas_loop_cc_sptr.get_phase(costas_loop_cc_sptr self) → float
costas_loop_cc_sptr.message_subscribers(costas_loop_cc_sptr self, swig_int_ptr which_port) → swig_int_ptr
costas_loop_cc_sptr.min_noutput_items(costas_loop_cc_sptr self) → int
costas_loop_cc_sptr.pc_input_buffers_full_avg(costas_loop_cc_sptr self, int which) → float

pc_input_buffers_full_avg(costas_loop_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(costas_loop_cc_sptr self) -> pmt_vector_float

costas_loop_cc_sptr.pc_throughput_avg(costas_loop_cc_sptr self) → float
costas_loop_cc_sptr.pc_work_time_avg(costas_loop_cc_sptr self) → float
costas_loop_cc_sptr.pc_work_time_total(costas_loop_cc_sptr self) → float
costas_loop_cc_sptr.phase_wrap(costas_loop_cc_sptr self)
costas_loop_cc_sptr.sample_delay(costas_loop_cc_sptr self, int which) → unsigned int
costas_loop_cc_sptr.set_alpha(costas_loop_cc_sptr self, float alpha)
costas_loop_cc_sptr.set_beta(costas_loop_cc_sptr self, float beta)
costas_loop_cc_sptr.set_damping_factor(costas_loop_cc_sptr self, float df)
costas_loop_cc_sptr.set_frequency(costas_loop_cc_sptr self, float freq)
costas_loop_cc_sptr.set_loop_bandwidth(costas_loop_cc_sptr self, float bw)
costas_loop_cc_sptr.set_max_freq(costas_loop_cc_sptr self, float freq)
costas_loop_cc_sptr.set_min_freq(costas_loop_cc_sptr self, float freq)
costas_loop_cc_sptr.set_min_noutput_items(costas_loop_cc_sptr self, int m)
costas_loop_cc_sptr.set_phase(costas_loop_cc_sptr self, float phase)
costas_loop_cc_sptr.set_thread_priority(costas_loop_cc_sptr self, int priority) → int
costas_loop_cc_sptr.thread_priority(costas_loop_cc_sptr self) → int
costas_loop_cc_sptr.update_gains(costas_loop_cc_sptr self)
gnuradio.digital.cpmmod_bc(gr::analog::cpm::cpm_type type, float h, int samples_per_sym, int L, double beta=0.3) → cpmmod_bc_sptr
cpmmod_bc_sptr.beta(cpmmod_bc_sptr self) → double
cpmmod_bc_sptr.make_gmskmod_bc(cpmmod_bc_sptr self, int samples_per_sym=2, int L=4, double beta=0.3) → cpmmod_bc_sptr
cpmmod_bc_sptr.message_subscribers(cpmmod_bc_sptr self, swig_int_ptr which_port) → swig_int_ptr
cpmmod_bc_sptr.samples_per_sym(cpmmod_bc_sptr self) → int
cpmmod_bc_sptr.taps(cpmmod_bc_sptr self) → pmt_vector_float
gnuradio.digital.crc32_async_bb(bool check=False) → crc32_async_bb_sptr
crc32_async_bb_sptr.active_thread_priority(crc32_async_bb_sptr self) → int
crc32_async_bb_sptr.declare_sample_delay(crc32_async_bb_sptr self, int which, int delay)

declare_sample_delay(crc32_async_bb_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(crc32_async_bb_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(crc32_async_bb_sptr self) -> pmt_vector_float

crc32_async_bb_sptr.pc_throughput_avg(crc32_async_bb_sptr self) → float
crc32_async_bb_sptr.pc_work_time_avg(crc32_async_bb_sptr self) → float
crc32_async_bb_sptr.pc_work_time_total(crc32_async_bb_sptr self) → float
crc32_async_bb_sptr.sample_delay(crc32_async_bb_sptr self, int which) → unsigned int
crc32_async_bb_sptr.set_min_noutput_items(crc32_async_bb_sptr self, int m)
crc32_async_bb_sptr.set_thread_priority(crc32_async_bb_sptr self, int priority) → int
crc32_async_bb_sptr.thread_priority(crc32_async_bb_sptr self) → int
gnuradio.digital.crc32_bb(bool check=False, std::string const & lengthtagname="packet_len", bool packed=True) → crc32_bb_sptr
crc32_bb_sptr.active_thread_priority(crc32_bb_sptr self) → int
crc32_bb_sptr.declare_sample_delay(crc32_bb_sptr self, int which, int delay)

declare_sample_delay(crc32_bb_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(crc32_bb_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(crc32_bb_sptr self) -> pmt_vector_float

crc32_bb_sptr.pc_throughput_avg(crc32_bb_sptr self) → float
crc32_bb_sptr.pc_work_time_avg(crc32_bb_sptr self) → float
crc32_bb_sptr.pc_work_time_total(crc32_bb_sptr self) → float
crc32_bb_sptr.sample_delay(crc32_bb_sptr self, int which) → unsigned int
crc32_bb_sptr.set_min_noutput_items(crc32_bb_sptr self, int m)
crc32_bb_sptr.set_thread_priority(crc32_bb_sptr self, int priority) → int
crc32_bb_sptr.thread_priority(crc32_bb_sptr self) → int
gnuradio.digital.descrambler_bb(int mask, int seed, int len) → descrambler_bb_sptr
descrambler_bb_sptr.active_thread_priority(descrambler_bb_sptr self) → int
descrambler_bb_sptr.declare_sample_delay(descrambler_bb_sptr self, int which, int delay)

declare_sample_delay(descrambler_bb_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(descrambler_bb_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(descrambler_bb_sptr self) -> pmt_vector_float

descrambler_bb_sptr.pc_throughput_avg(descrambler_bb_sptr self) → float
descrambler_bb_sptr.pc_work_time_avg(descrambler_bb_sptr self) → float
descrambler_bb_sptr.pc_work_time_total(descrambler_bb_sptr self) → float
descrambler_bb_sptr.sample_delay(descrambler_bb_sptr self, int which) → unsigned int
descrambler_bb_sptr.set_min_noutput_items(descrambler_bb_sptr self, int m)
descrambler_bb_sptr.set_thread_priority(descrambler_bb_sptr self, int priority) → int
descrambler_bb_sptr.thread_priority(descrambler_bb_sptr self) → int
gnuradio.digital.diff_decoder_bb(unsigned int modulus) → diff_decoder_bb_sptr
diff_decoder_bb_sptr.active_thread_priority(diff_decoder_bb_sptr self) → int
diff_decoder_bb_sptr.declare_sample_delay(diff_decoder_bb_sptr self, int which, int delay)

declare_sample_delay(diff_decoder_bb_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(diff_decoder_bb_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(diff_decoder_bb_sptr self) -> pmt_vector_float

diff_decoder_bb_sptr.pc_throughput_avg(diff_decoder_bb_sptr self) → float
diff_decoder_bb_sptr.pc_work_time_avg(diff_decoder_bb_sptr self) → float
diff_decoder_bb_sptr.pc_work_time_total(diff_decoder_bb_sptr self) → float
diff_decoder_bb_sptr.sample_delay(diff_decoder_bb_sptr self, int which) → unsigned int
diff_decoder_bb_sptr.set_min_noutput_items(diff_decoder_bb_sptr self, int m)
diff_decoder_bb_sptr.set_thread_priority(diff_decoder_bb_sptr self, int priority) → int
diff_decoder_bb_sptr.thread_priority(diff_decoder_bb_sptr self) → int
gnuradio.digital.diff_encoder_bb(unsigned int modulus) → diff_encoder_bb_sptr
diff_encoder_bb_sptr.active_thread_priority(diff_encoder_bb_sptr self) → int
diff_encoder_bb_sptr.declare_sample_delay(diff_encoder_bb_sptr self, int which, int delay)

declare_sample_delay(diff_encoder_bb_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(diff_encoder_bb_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(diff_encoder_bb_sptr self) -> pmt_vector_float

diff_encoder_bb_sptr.pc_throughput_avg(diff_encoder_bb_sptr self) → float
diff_encoder_bb_sptr.pc_work_time_avg(diff_encoder_bb_sptr self) → float
diff_encoder_bb_sptr.pc_work_time_total(diff_encoder_bb_sptr self) → float
diff_encoder_bb_sptr.sample_delay(diff_encoder_bb_sptr self, int which) → unsigned int
diff_encoder_bb_sptr.set_min_noutput_items(diff_encoder_bb_sptr self, int m)
diff_encoder_bb_sptr.set_thread_priority(diff_encoder_bb_sptr self, int priority) → int
diff_encoder_bb_sptr.thread_priority(diff_encoder_bb_sptr self) → int
gnuradio.digital.diff_phasor_cc() → diff_phasor_cc_sptr
diff_phasor_cc_sptr.active_thread_priority(diff_phasor_cc_sptr self) → int
diff_phasor_cc_sptr.declare_sample_delay(diff_phasor_cc_sptr self, int which, int delay)

declare_sample_delay(diff_phasor_cc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(diff_phasor_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(diff_phasor_cc_sptr self) -> pmt_vector_float

diff_phasor_cc_sptr.pc_throughput_avg(diff_phasor_cc_sptr self) → float
diff_phasor_cc_sptr.pc_work_time_avg(diff_phasor_cc_sptr self) → float
diff_phasor_cc_sptr.pc_work_time_total(diff_phasor_cc_sptr self) → float
diff_phasor_cc_sptr.sample_delay(diff_phasor_cc_sptr self, int which) → unsigned int
diff_phasor_cc_sptr.set_min_noutput_items(diff_phasor_cc_sptr self, int m)
diff_phasor_cc_sptr.set_thread_priority(diff_phasor_cc_sptr self, int priority) → int
diff_phasor_cc_sptr.thread_priority(diff_phasor_cc_sptr self) → int
gnuradio.digital.fll_band_edge_cc(float samps_per_sym, float rolloff, int filter_size, float bandwidth) → fll_band_edge_cc_sptr
fll_band_edge_cc_sptr.active_thread_priority(fll_band_edge_cc_sptr self) → int
fll_band_edge_cc_sptr.advance_loop(fll_band_edge_cc_sptr self, float error)
fll_band_edge_cc_sptr.declare_sample_delay(fll_band_edge_cc_sptr self, int which, int delay)

declare_sample_delay(fll_band_edge_cc_sptr self, unsigned int delay)

fll_band_edge_cc_sptr.filter_size(fll_band_edge_cc_sptr self) → int
fll_band_edge_cc_sptr.frequency_limit(fll_band_edge_cc_sptr self)
fll_band_edge_cc_sptr.get_alpha(fll_band_edge_cc_sptr self) → float
fll_band_edge_cc_sptr.get_beta(fll_band_edge_cc_sptr self) → float
fll_band_edge_cc_sptr.get_damping_factor(fll_band_edge_cc_sptr self) → float
fll_band_edge_cc_sptr.get_frequency(fll_band_edge_cc_sptr self) → float
fll_band_edge_cc_sptr.get_loop_bandwidth(fll_band_edge_cc_sptr self) → float
fll_band_edge_cc_sptr.get_max_freq(fll_band_edge_cc_sptr self) → float
fll_band_edge_cc_sptr.get_min_freq(fll_band_edge_cc_sptr self) → float
fll_band_edge_cc_sptr.get_phase(fll_band_edge_cc_sptr self) → float
fll_band_edge_cc_sptr.message_subscribers(fll_band_edge_cc_sptr self, swig_int_ptr which_port) → swig_int_ptr
fll_band_edge_cc_sptr.min_noutput_items(fll_band_edge_cc_sptr self) → int
fll_band_edge_cc_sptr.pc_input_buffers_full_avg(fll_band_edge_cc_sptr self, int which) → float

pc_input_buffers_full_avg(fll_band_edge_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(fll_band_edge_cc_sptr self) -> pmt_vector_float

fll_band_edge_cc_sptr.pc_throughput_avg(fll_band_edge_cc_sptr self) → float
fll_band_edge_cc_sptr.pc_work_time_avg(fll_band_edge_cc_sptr self) → float
fll_band_edge_cc_sptr.pc_work_time_total(fll_band_edge_cc_sptr self) → float
fll_band_edge_cc_sptr.phase_wrap(fll_band_edge_cc_sptr self)
fll_band_edge_cc_sptr.print_taps(fll_band_edge_cc_sptr self)
fll_band_edge_cc_sptr.rolloff(fll_band_edge_cc_sptr self) → float
fll_band_edge_cc_sptr.sample_delay(fll_band_edge_cc_sptr self, int which) → unsigned int
fll_band_edge_cc_sptr.samples_per_symbol(fll_band_edge_cc_sptr self) → float
fll_band_edge_cc_sptr.set_alpha(fll_band_edge_cc_sptr self, float alpha)
fll_band_edge_cc_sptr.set_beta(fll_band_edge_cc_sptr self, float beta)
fll_band_edge_cc_sptr.set_damping_factor(fll_band_edge_cc_sptr self, float df)
fll_band_edge_cc_sptr.set_filter_size(fll_band_edge_cc_sptr self, int filter_size)
fll_band_edge_cc_sptr.set_frequency(fll_band_edge_cc_sptr self, float freq)
fll_band_edge_cc_sptr.set_loop_bandwidth(fll_band_edge_cc_sptr self, float bw)
fll_band_edge_cc_sptr.set_max_freq(fll_band_edge_cc_sptr self, float freq)
fll_band_edge_cc_sptr.set_min_freq(fll_band_edge_cc_sptr self, float freq)
fll_band_edge_cc_sptr.set_min_noutput_items(fll_band_edge_cc_sptr self, int m)
fll_band_edge_cc_sptr.set_phase(fll_band_edge_cc_sptr self, float phase)
fll_band_edge_cc_sptr.set_rolloff(fll_band_edge_cc_sptr self, float rolloff)
fll_band_edge_cc_sptr.set_samples_per_symbol(fll_band_edge_cc_sptr self, float sps)
fll_band_edge_cc_sptr.set_thread_priority(fll_band_edge_cc_sptr self, int priority) → int
fll_band_edge_cc_sptr.thread_priority(fll_band_edge_cc_sptr self) → int
fll_band_edge_cc_sptr.update_gains(fll_band_edge_cc_sptr self)
gnuradio.digital.framer_sink_1(msg_queue_sptr target_queue) → framer_sink_1_sptr
framer_sink_1_sptr.active_thread_priority(framer_sink_1_sptr self) → int
framer_sink_1_sptr.declare_sample_delay(framer_sink_1_sptr self, int which, int delay)

declare_sample_delay(framer_sink_1_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(framer_sink_1_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(framer_sink_1_sptr self) -> pmt_vector_float

framer_sink_1_sptr.pc_throughput_avg(framer_sink_1_sptr self) → float
framer_sink_1_sptr.pc_work_time_avg(framer_sink_1_sptr self) → float
framer_sink_1_sptr.pc_work_time_total(framer_sink_1_sptr self) → float
framer_sink_1_sptr.sample_delay(framer_sink_1_sptr self, int which) → unsigned int
framer_sink_1_sptr.set_min_noutput_items(framer_sink_1_sptr self, int m)
framer_sink_1_sptr.set_thread_priority(framer_sink_1_sptr self, int priority) → int
framer_sink_1_sptr.thread_priority(framer_sink_1_sptr self) → int
gnuradio.digital.glfsr_source_b(int degree, bool repeat=True, int mask=0, int seed=1) → glfsr_source_b_sptr
glfsr_source_b_sptr.active_thread_priority(glfsr_source_b_sptr self) → int
glfsr_source_b_sptr.declare_sample_delay(glfsr_source_b_sptr self, int which, int delay)

declare_sample_delay(glfsr_source_b_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(glfsr_source_b_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(glfsr_source_b_sptr self) -> pmt_vector_float

glfsr_source_b_sptr.pc_throughput_avg(glfsr_source_b_sptr self) → float
glfsr_source_b_sptr.pc_work_time_avg(glfsr_source_b_sptr self) → float
glfsr_source_b_sptr.pc_work_time_total(glfsr_source_b_sptr self) → float
glfsr_source_b_sptr.period(glfsr_source_b_sptr self) → unsigned int
glfsr_source_b_sptr.sample_delay(glfsr_source_b_sptr self, int which) → unsigned int
glfsr_source_b_sptr.set_min_noutput_items(glfsr_source_b_sptr self, int m)
glfsr_source_b_sptr.set_thread_priority(glfsr_source_b_sptr self, int priority) → int
glfsr_source_b_sptr.thread_priority(glfsr_source_b_sptr self) → int
gnuradio.digital.glfsr_source_f(int degree, bool repeat=True, int mask=0, int seed=1) → glfsr_source_f_sptr
glfsr_source_f_sptr.active_thread_priority(glfsr_source_f_sptr self) → int
glfsr_source_f_sptr.declare_sample_delay(glfsr_source_f_sptr self, int which, int delay)

declare_sample_delay(glfsr_source_f_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(glfsr_source_f_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(glfsr_source_f_sptr self) -> pmt_vector_float

glfsr_source_f_sptr.pc_throughput_avg(glfsr_source_f_sptr self) → float
glfsr_source_f_sptr.pc_work_time_avg(glfsr_source_f_sptr self) → float
glfsr_source_f_sptr.pc_work_time_total(glfsr_source_f_sptr self) → float
glfsr_source_f_sptr.period(glfsr_source_f_sptr self) → unsigned int
glfsr_source_f_sptr.sample_delay(glfsr_source_f_sptr self, int which) → unsigned int
glfsr_source_f_sptr.set_min_noutput_items(glfsr_source_f_sptr self, int m)
glfsr_source_f_sptr.set_thread_priority(glfsr_source_f_sptr self, int priority) → int
glfsr_source_f_sptr.thread_priority(glfsr_source_f_sptr self) → int
gnuradio.digital.hdlc_deframer_bp(int length_min, int length_max) → hdlc_deframer_bp_sptr
hdlc_deframer_bp_sptr.active_thread_priority(hdlc_deframer_bp_sptr self) → int
hdlc_deframer_bp_sptr.declare_sample_delay(hdlc_deframer_bp_sptr self, int which, int delay)

declare_sample_delay(hdlc_deframer_bp_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(hdlc_deframer_bp_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(hdlc_deframer_bp_sptr self) -> pmt_vector_float

hdlc_deframer_bp_sptr.pc_throughput_avg(hdlc_deframer_bp_sptr self) → float
hdlc_deframer_bp_sptr.pc_work_time_avg(hdlc_deframer_bp_sptr self) → float
hdlc_deframer_bp_sptr.pc_work_time_total(hdlc_deframer_bp_sptr self) → float
hdlc_deframer_bp_sptr.sample_delay(hdlc_deframer_bp_sptr self, int which) → unsigned int
hdlc_deframer_bp_sptr.set_min_noutput_items(hdlc_deframer_bp_sptr self, int m)
hdlc_deframer_bp_sptr.set_thread_priority(hdlc_deframer_bp_sptr self, int priority) → int
hdlc_deframer_bp_sptr.thread_priority(hdlc_deframer_bp_sptr self) → int
gnuradio.digital.hdlc_framer_pb(std::string const frame_tag_name) → hdlc_framer_pb_sptr
hdlc_framer_pb_sptr.active_thread_priority(hdlc_framer_pb_sptr self) → int
hdlc_framer_pb_sptr.declare_sample_delay(hdlc_framer_pb_sptr self, int which, int delay)

declare_sample_delay(hdlc_framer_pb_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(hdlc_framer_pb_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(hdlc_framer_pb_sptr self) -> pmt_vector_float

hdlc_framer_pb_sptr.pc_throughput_avg(hdlc_framer_pb_sptr self) → float
hdlc_framer_pb_sptr.pc_work_time_avg(hdlc_framer_pb_sptr self) → float
hdlc_framer_pb_sptr.pc_work_time_total(hdlc_framer_pb_sptr self) → float
hdlc_framer_pb_sptr.sample_delay(hdlc_framer_pb_sptr self, int which) → unsigned int
hdlc_framer_pb_sptr.set_min_noutput_items(hdlc_framer_pb_sptr self, int m)
hdlc_framer_pb_sptr.set_thread_priority(hdlc_framer_pb_sptr self, int priority) → int
hdlc_framer_pb_sptr.thread_priority(hdlc_framer_pb_sptr self) → int
gnuradio.digital.header_payload_demux(int header_len, int items_per_symbol=1, int guard_interval=0, std::string const & length_tag_key="frame_len", std::string const & trigger_tag_key="", bool output_symbols=False, size_t itemsize=sizeof(gr_complex), std::string const & timing_tag_key="", double const samp_rate=1.0, std::vector< std::string, std::allocator< std::string > > const & special_tags=std::vector< std::string >()) → header_payload_demux_sptr
header_payload_demux_sptr.active_thread_priority(header_payload_demux_sptr self) → int
header_payload_demux_sptr.declare_sample_delay(header_payload_demux_sptr self, int which, int delay)

declare_sample_delay(header_payload_demux_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(header_payload_demux_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(header_payload_demux_sptr self) -> pmt_vector_float

header_payload_demux_sptr.pc_throughput_avg(header_payload_demux_sptr self) → float
header_payload_demux_sptr.pc_work_time_avg(header_payload_demux_sptr self) → float
header_payload_demux_sptr.pc_work_time_total(header_payload_demux_sptr self) → float
header_payload_demux_sptr.sample_delay(header_payload_demux_sptr self, int which) → unsigned int
header_payload_demux_sptr.set_min_noutput_items(header_payload_demux_sptr self, int m)
header_payload_demux_sptr.set_thread_priority(header_payload_demux_sptr self, int priority) → int
header_payload_demux_sptr.thread_priority(header_payload_demux_sptr self) → int
gnuradio.digital.kurtotic_equalizer_cc(int num_taps, float mu) → kurtotic_equalizer_cc_sptr
kurtotic_equalizer_cc_sptr.active_thread_priority(kurtotic_equalizer_cc_sptr self) → int
kurtotic_equalizer_cc_sptr.declare_sample_delay(kurtotic_equalizer_cc_sptr self, int which, int delay)

declare_sample_delay(kurtotic_equalizer_cc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(kurtotic_equalizer_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(kurtotic_equalizer_cc_sptr self) -> pmt_vector_float

kurtotic_equalizer_cc_sptr.pc_throughput_avg(kurtotic_equalizer_cc_sptr self) → float
kurtotic_equalizer_cc_sptr.pc_work_time_avg(kurtotic_equalizer_cc_sptr self) → float
kurtotic_equalizer_cc_sptr.pc_work_time_total(kurtotic_equalizer_cc_sptr self) → float
kurtotic_equalizer_cc_sptr.sample_delay(kurtotic_equalizer_cc_sptr self, int which) → unsigned int
kurtotic_equalizer_cc_sptr.set_gain(kurtotic_equalizer_cc_sptr self, float mu)
kurtotic_equalizer_cc_sptr.set_min_noutput_items(kurtotic_equalizer_cc_sptr self, int m)
kurtotic_equalizer_cc_sptr.set_thread_priority(kurtotic_equalizer_cc_sptr self, int priority) → int
kurtotic_equalizer_cc_sptr.thread_priority(kurtotic_equalizer_cc_sptr self) → int
gnuradio.digital.lms_dd_equalizer_cc(int num_taps, float mu, int sps, constellation_sptr cnst) → lms_dd_equalizer_cc_sptr
lms_dd_equalizer_cc_sptr.active_thread_priority(lms_dd_equalizer_cc_sptr self) → int
lms_dd_equalizer_cc_sptr.declare_sample_delay(lms_dd_equalizer_cc_sptr self, int which, int delay)

declare_sample_delay(lms_dd_equalizer_cc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(lms_dd_equalizer_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(lms_dd_equalizer_cc_sptr self) -> pmt_vector_float

lms_dd_equalizer_cc_sptr.pc_throughput_avg(lms_dd_equalizer_cc_sptr self) → float
lms_dd_equalizer_cc_sptr.pc_work_time_avg(lms_dd_equalizer_cc_sptr self) → float
lms_dd_equalizer_cc_sptr.pc_work_time_total(lms_dd_equalizer_cc_sptr self) → float
lms_dd_equalizer_cc_sptr.sample_delay(lms_dd_equalizer_cc_sptr self, int which) → unsigned int
lms_dd_equalizer_cc_sptr.set_gain(lms_dd_equalizer_cc_sptr self, float mu)
lms_dd_equalizer_cc_sptr.set_min_noutput_items(lms_dd_equalizer_cc_sptr self, int m)
lms_dd_equalizer_cc_sptr.set_taps(lms_dd_equalizer_cc_sptr self, pmt_vector_cfloat taps)
lms_dd_equalizer_cc_sptr.set_thread_priority(lms_dd_equalizer_cc_sptr self, int priority) → int
lms_dd_equalizer_cc_sptr.taps(lms_dd_equalizer_cc_sptr self) → pmt_vector_cfloat
lms_dd_equalizer_cc_sptr.thread_priority(lms_dd_equalizer_cc_sptr self) → int
gnuradio.digital.map_bb(std::vector< int, std::allocator< int > > const & map) → map_bb_sptr
map_bb_sptr.active_thread_priority(map_bb_sptr self) → int
map_bb_sptr.declare_sample_delay(map_bb_sptr self, int which, int delay)

declare_sample_delay(map_bb_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(map_bb_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(map_bb_sptr self) -> pmt_vector_float

map_bb_sptr.pc_throughput_avg(map_bb_sptr self) → float
map_bb_sptr.pc_work_time_avg(map_bb_sptr self) → float
map_bb_sptr.pc_work_time_total(map_bb_sptr self) → float
map_bb_sptr.sample_delay(map_bb_sptr self, int which) → unsigned int
map_bb_sptr.set_map(map_bb_sptr self, std::vector< int, std::allocator< int > > const & map)
map_bb_sptr.set_min_noutput_items(map_bb_sptr self, int m)
map_bb_sptr.set_thread_priority(map_bb_sptr self, int priority) → int
map_bb_sptr.thread_priority(map_bb_sptr self) → int
gnuradio.digital.mpsk_receiver_cc(unsigned int M, float theta, float loop_bw, float fmin, float fmax, float mu, float gain_mu, float omega, float gain_omega, float omega_rel) → mpsk_receiver_cc_sptr
mpsk_receiver_cc_sptr.active_thread_priority(mpsk_receiver_cc_sptr self) → int
mpsk_receiver_cc_sptr.advance_loop(mpsk_receiver_cc_sptr self, float error)
mpsk_receiver_cc_sptr.declare_sample_delay(mpsk_receiver_cc_sptr self, int which, int delay)

declare_sample_delay(mpsk_receiver_cc_sptr self, unsigned int delay)

mpsk_receiver_cc_sptr.frequency_limit(mpsk_receiver_cc_sptr self)
mpsk_receiver_cc_sptr.gain_mu(mpsk_receiver_cc_sptr self) → float
mpsk_receiver_cc_sptr.gain_omega(mpsk_receiver_cc_sptr self) → float
mpsk_receiver_cc_sptr.gain_omega_rel(mpsk_receiver_cc_sptr self) → float
mpsk_receiver_cc_sptr.get_alpha(mpsk_receiver_cc_sptr self) → float
mpsk_receiver_cc_sptr.get_beta(mpsk_receiver_cc_sptr self) → float
mpsk_receiver_cc_sptr.get_damping_factor(mpsk_receiver_cc_sptr self) → float
mpsk_receiver_cc_sptr.get_frequency(mpsk_receiver_cc_sptr self) → float
mpsk_receiver_cc_sptr.get_loop_bandwidth(mpsk_receiver_cc_sptr self) → float
mpsk_receiver_cc_sptr.get_max_freq(mpsk_receiver_cc_sptr self) → float
mpsk_receiver_cc_sptr.get_min_freq(mpsk_receiver_cc_sptr self) → float
mpsk_receiver_cc_sptr.get_phase(mpsk_receiver_cc_sptr self) → float
mpsk_receiver_cc_sptr.message_subscribers(mpsk_receiver_cc_sptr self, swig_int_ptr which_port) → swig_int_ptr
mpsk_receiver_cc_sptr.min_noutput_items(mpsk_receiver_cc_sptr self) → int
mpsk_receiver_cc_sptr.modulation_order(mpsk_receiver_cc_sptr self) → float
mpsk_receiver_cc_sptr.mu(mpsk_receiver_cc_sptr self) → float
mpsk_receiver_cc_sptr.omega(mpsk_receiver_cc_sptr self) → float
mpsk_receiver_cc_sptr.pc_input_buffers_full_avg(mpsk_receiver_cc_sptr self, int which) → float

pc_input_buffers_full_avg(mpsk_receiver_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(mpsk_receiver_cc_sptr self) -> pmt_vector_float

mpsk_receiver_cc_sptr.pc_throughput_avg(mpsk_receiver_cc_sptr self) → float
mpsk_receiver_cc_sptr.pc_work_time_avg(mpsk_receiver_cc_sptr self) → float
mpsk_receiver_cc_sptr.pc_work_time_total(mpsk_receiver_cc_sptr self) → float
mpsk_receiver_cc_sptr.phase_wrap(mpsk_receiver_cc_sptr self)
mpsk_receiver_cc_sptr.sample_delay(mpsk_receiver_cc_sptr self, int which) → unsigned int
mpsk_receiver_cc_sptr.set_alpha(mpsk_receiver_cc_sptr self, float alpha)
mpsk_receiver_cc_sptr.set_beta(mpsk_receiver_cc_sptr self, float beta)
mpsk_receiver_cc_sptr.set_damping_factor(mpsk_receiver_cc_sptr self, float df)
mpsk_receiver_cc_sptr.set_frequency(mpsk_receiver_cc_sptr self, float freq)
mpsk_receiver_cc_sptr.set_gain_mu(mpsk_receiver_cc_sptr self, float gain_mu)
mpsk_receiver_cc_sptr.set_gain_omega(mpsk_receiver_cc_sptr self, float gain_omega)
mpsk_receiver_cc_sptr.set_gain_omega_rel(mpsk_receiver_cc_sptr self, float omega_rel)
mpsk_receiver_cc_sptr.set_loop_bandwidth(mpsk_receiver_cc_sptr self, float bw)
mpsk_receiver_cc_sptr.set_max_freq(mpsk_receiver_cc_sptr self, float freq)
mpsk_receiver_cc_sptr.set_min_freq(mpsk_receiver_cc_sptr self, float freq)
mpsk_receiver_cc_sptr.set_min_noutput_items(mpsk_receiver_cc_sptr self, int m)
mpsk_receiver_cc_sptr.set_modulation_order(mpsk_receiver_cc_sptr self, unsigned int M)
mpsk_receiver_cc_sptr.set_mu(mpsk_receiver_cc_sptr self, float mu)
mpsk_receiver_cc_sptr.set_omega(mpsk_receiver_cc_sptr self, float omega)
mpsk_receiver_cc_sptr.set_phase(mpsk_receiver_cc_sptr self, float phase)
mpsk_receiver_cc_sptr.set_theta(mpsk_receiver_cc_sptr self, float theta)
mpsk_receiver_cc_sptr.set_thread_priority(mpsk_receiver_cc_sptr self, int priority) → int
mpsk_receiver_cc_sptr.theta(mpsk_receiver_cc_sptr self) → float
mpsk_receiver_cc_sptr.thread_priority(mpsk_receiver_cc_sptr self) → int
mpsk_receiver_cc_sptr.update_gains(mpsk_receiver_cc_sptr self)
gnuradio.digital.mpsk_snr_est_cc(gr::digital::snr_est_type_t type, int tag_nsamples=10000, double alpha=0.001) → mpsk_snr_est_cc_sptr
mpsk_snr_est_cc_sptr.active_thread_priority(mpsk_snr_est_cc_sptr self) → int
mpsk_snr_est_cc_sptr.alpha(mpsk_snr_est_cc_sptr self) → double
mpsk_snr_est_cc_sptr.declare_sample_delay(mpsk_snr_est_cc_sptr self, int which, int delay)

declare_sample_delay(mpsk_snr_est_cc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(mpsk_snr_est_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(mpsk_snr_est_cc_sptr self) -> pmt_vector_float

mpsk_snr_est_cc_sptr.pc_throughput_avg(mpsk_snr_est_cc_sptr self) → float
mpsk_snr_est_cc_sptr.pc_work_time_avg(mpsk_snr_est_cc_sptr self) → float
mpsk_snr_est_cc_sptr.pc_work_time_total(mpsk_snr_est_cc_sptr self) → float
mpsk_snr_est_cc_sptr.sample_delay(mpsk_snr_est_cc_sptr self, int which) → unsigned int
mpsk_snr_est_cc_sptr.set_alpha(mpsk_snr_est_cc_sptr self, double alpha)
mpsk_snr_est_cc_sptr.set_min_noutput_items(mpsk_snr_est_cc_sptr self, int m)
mpsk_snr_est_cc_sptr.set_tag_nsample(mpsk_snr_est_cc_sptr self, int n)
mpsk_snr_est_cc_sptr.set_thread_priority(mpsk_snr_est_cc_sptr self, int priority) → int
mpsk_snr_est_cc_sptr.set_type(mpsk_snr_est_cc_sptr self, gr::digital::snr_est_type_t t)
mpsk_snr_est_cc_sptr.snr(mpsk_snr_est_cc_sptr self) → double
mpsk_snr_est_cc_sptr.tag_nsample(mpsk_snr_est_cc_sptr self) → int
mpsk_snr_est_cc_sptr.thread_priority(mpsk_snr_est_cc_sptr self) → int
gnuradio.digital.msk_timing_recovery_cc(float sps, float gain, float limit, int osps) → msk_timing_recovery_cc_sptr
msk_timing_recovery_cc_sptr.active_thread_priority(msk_timing_recovery_cc_sptr self) → int
msk_timing_recovery_cc_sptr.declare_sample_delay(msk_timing_recovery_cc_sptr self, int which, int delay)

declare_sample_delay(msk_timing_recovery_cc_sptr self, unsigned int delay)

msk_timing_recovery_cc_sptr.get_gain(msk_timing_recovery_cc_sptr self) → float
msk_timing_recovery_cc_sptr.get_limit(msk_timing_recovery_cc_sptr self) → float
msk_timing_recovery_cc_sptr.get_sps(msk_timing_recovery_cc_sptr self) → float
msk_timing_recovery_cc_sptr.message_subscribers(msk_timing_recovery_cc_sptr self, swig_int_ptr which_port) → swig_int_ptr
msk_timing_recovery_cc_sptr.min_noutput_items(msk_timing_recovery_cc_sptr self) → int
msk_timing_recovery_cc_sptr.pc_input_buffers_full_avg(msk_timing_recovery_cc_sptr self, int which) → float

pc_input_buffers_full_avg(msk_timing_recovery_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(msk_timing_recovery_cc_sptr self) -> pmt_vector_float

msk_timing_recovery_cc_sptr.pc_throughput_avg(msk_timing_recovery_cc_sptr self) → float
msk_timing_recovery_cc_sptr.pc_work_time_avg(msk_timing_recovery_cc_sptr self) → float
msk_timing_recovery_cc_sptr.pc_work_time_total(msk_timing_recovery_cc_sptr self) → float
msk_timing_recovery_cc_sptr.sample_delay(msk_timing_recovery_cc_sptr self, int which) → unsigned int
msk_timing_recovery_cc_sptr.set_gain(msk_timing_recovery_cc_sptr self, float gain)
msk_timing_recovery_cc_sptr.set_limit(msk_timing_recovery_cc_sptr self, float limit)
msk_timing_recovery_cc_sptr.set_min_noutput_items(msk_timing_recovery_cc_sptr self, int m)
msk_timing_recovery_cc_sptr.set_sps(msk_timing_recovery_cc_sptr self, float sps)
msk_timing_recovery_cc_sptr.set_thread_priority(msk_timing_recovery_cc_sptr self, int priority) → int
msk_timing_recovery_cc_sptr.thread_priority(msk_timing_recovery_cc_sptr self) → int
gnuradio.digital.ofdm_carrier_allocator_cvc(int fft_len, std::vector< std::vector< int, std::allocator< int > >, std::allocator< std::vector< int, std::allocator< int > > > > const & occupied_carriers, std::vector< std::vector< int, std::allocator< int > >, std::allocator< std::vector< int, std::allocator< int > > > > const & pilot_carriers, gr_vector_vector_complexf pilot_symbols, gr_vector_vector_complexf sync_words, std::string const & len_tag_key="packet_len", bool const output_is_shifted=True) → ofdm_carrier_allocator_cvc_sptr
ofdm_carrier_allocator_cvc_sptr.active_thread_priority(ofdm_carrier_allocator_cvc_sptr self) → int
ofdm_carrier_allocator_cvc_sptr.declare_sample_delay(ofdm_carrier_allocator_cvc_sptr self, int which, int delay)

declare_sample_delay(ofdm_carrier_allocator_cvc_sptr self, unsigned int delay)

ofdm_carrier_allocator_cvc_sptr.fft_len(ofdm_carrier_allocator_cvc_sptr self) → int const
ofdm_carrier_allocator_cvc_sptr.len_tag_key(ofdm_carrier_allocator_cvc_sptr self) → std::string
ofdm_carrier_allocator_cvc_sptr.message_subscribers(ofdm_carrier_allocator_cvc_sptr self, swig_int_ptr which_port) → swig_int_ptr
ofdm_carrier_allocator_cvc_sptr.min_noutput_items(ofdm_carrier_allocator_cvc_sptr self) → int
ofdm_carrier_allocator_cvc_sptr.occupied_carriers(ofdm_carrier_allocator_cvc_sptr self) → std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >
ofdm_carrier_allocator_cvc_sptr.pc_input_buffers_full_avg(ofdm_carrier_allocator_cvc_sptr self, int which) → float

pc_input_buffers_full_avg(ofdm_carrier_allocator_cvc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(ofdm_carrier_allocator_cvc_sptr self) -> pmt_vector_float

ofdm_carrier_allocator_cvc_sptr.pc_throughput_avg(ofdm_carrier_allocator_cvc_sptr self) → float
ofdm_carrier_allocator_cvc_sptr.pc_work_time_avg(ofdm_carrier_allocator_cvc_sptr self) → float
ofdm_carrier_allocator_cvc_sptr.pc_work_time_total(ofdm_carrier_allocator_cvc_sptr self) → float
ofdm_carrier_allocator_cvc_sptr.sample_delay(ofdm_carrier_allocator_cvc_sptr self, int which) → unsigned int
ofdm_carrier_allocator_cvc_sptr.set_min_noutput_items(ofdm_carrier_allocator_cvc_sptr self, int m)
ofdm_carrier_allocator_cvc_sptr.set_thread_priority(ofdm_carrier_allocator_cvc_sptr self, int priority) → int
ofdm_carrier_allocator_cvc_sptr.thread_priority(ofdm_carrier_allocator_cvc_sptr self) → int
gnuradio.digital.ofdm_chanest_vcvc(pmt_vector_cfloat sync_symbol1, pmt_vector_cfloat sync_symbol2, int n_data_symbols, int eq_noise_red_len=0, int max_carr_offset=-1, bool force_one_sync_symbol=False) → ofdm_chanest_vcvc_sptr
ofdm_chanest_vcvc_sptr.active_thread_priority(ofdm_chanest_vcvc_sptr self) → int
ofdm_chanest_vcvc_sptr.declare_sample_delay(ofdm_chanest_vcvc_sptr self, int which, int delay)

declare_sample_delay(ofdm_chanest_vcvc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(ofdm_chanest_vcvc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(ofdm_chanest_vcvc_sptr self) -> pmt_vector_float

ofdm_chanest_vcvc_sptr.pc_throughput_avg(ofdm_chanest_vcvc_sptr self) → float
ofdm_chanest_vcvc_sptr.pc_work_time_avg(ofdm_chanest_vcvc_sptr self) → float
ofdm_chanest_vcvc_sptr.pc_work_time_total(ofdm_chanest_vcvc_sptr self) → float
ofdm_chanest_vcvc_sptr.sample_delay(ofdm_chanest_vcvc_sptr self, int which) → unsigned int
ofdm_chanest_vcvc_sptr.set_min_noutput_items(ofdm_chanest_vcvc_sptr self, int m)
ofdm_chanest_vcvc_sptr.set_thread_priority(ofdm_chanest_vcvc_sptr self, int priority) → int
ofdm_chanest_vcvc_sptr.thread_priority(ofdm_chanest_vcvc_sptr self) → int
gnuradio.digital.ofdm_cyclic_prefixer(size_t input_size, size_t output_size, int rolloff_len=0, std::string const & len_tag_key="") → ofdm_cyclic_prefixer_sptr
ofdm_cyclic_prefixer_sptr.active_thread_priority(ofdm_cyclic_prefixer_sptr self) → int
ofdm_cyclic_prefixer_sptr.declare_sample_delay(ofdm_cyclic_prefixer_sptr self, int which, int delay)

declare_sample_delay(ofdm_cyclic_prefixer_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(ofdm_cyclic_prefixer_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(ofdm_cyclic_prefixer_sptr self) -> pmt_vector_float

ofdm_cyclic_prefixer_sptr.pc_throughput_avg(ofdm_cyclic_prefixer_sptr self) → float
ofdm_cyclic_prefixer_sptr.pc_work_time_avg(ofdm_cyclic_prefixer_sptr self) → float
ofdm_cyclic_prefixer_sptr.pc_work_time_total(ofdm_cyclic_prefixer_sptr self) → float
ofdm_cyclic_prefixer_sptr.sample_delay(ofdm_cyclic_prefixer_sptr self, int which) → unsigned int
ofdm_cyclic_prefixer_sptr.set_min_noutput_items(ofdm_cyclic_prefixer_sptr self, int m)
ofdm_cyclic_prefixer_sptr.set_thread_priority(ofdm_cyclic_prefixer_sptr self, int priority) → int
ofdm_cyclic_prefixer_sptr.thread_priority(ofdm_cyclic_prefixer_sptr self) → int
gnuradio.digital.ofdm_equalizer_base(*args, **kwargs)

Proxy of C++ gr::digital::ofdm_equalizer_base class

ofdm_equalizer_base_sptr.base(ofdm_equalizer_base_sptr self) → ofdm_equalizer_base_sptr
ofdm_equalizer_base_sptr.equalize(*args, **kwargs)
equalize(ofdm_equalizer_base_sptr self, gr_complex * frame, int n_sym, pmt_vector_cfloat initial_taps=std::vector< gr_complex >(), tags_vector_t tags=std::vector< gr::tag_t >())
ofdm_equalizer_base_sptr.fft_len(ofdm_equalizer_base_sptr self) → int
ofdm_equalizer_base_sptr.get_channel_state(ofdm_equalizer_base_sptr self, pmt_vector_cfloat taps)
ofdm_equalizer_base_sptr.reset(ofdm_equalizer_base_sptr self)
gnuradio.digital.ofdm_equalizer_simpledfe(int fft_len, constellation_sptr constellation, std::vector< std::vector< int, std::allocator< int > >, std::allocator< std::vector< int, std::allocator< int > > > > const & occupied_carriers=std::vector< std::vector< int > >(), std::vector< std::vector< int, std::allocator< int > >, std::allocator< std::vector< int, std::allocator< int > > > > const & pilot_carriers=std::vector< std::vector< int > >(), gr_vector_vector_complexf pilot_symbols=std::vector< std::vector< gr_complex > >(), int symbols_skipped=0, float alpha=0.1, bool input_is_shifted=True) → ofdm_equalizer_simpledfe_sptr
ofdm_equalizer_simpledfe_sptr.base(ofdm_equalizer_simpledfe_sptr self) → ofdm_equalizer_base_sptr
ofdm_equalizer_simpledfe_sptr.equalize(*args, **kwargs)
equalize(ofdm_equalizer_simpledfe_sptr self, gr_complex * frame, int n_sym, pmt_vector_cfloat initial_taps=std::vector< gr_complex >(), tags_vector_t tags=std::vector< gr::tag_t >())
ofdm_equalizer_simpledfe_sptr.fft_len(ofdm_equalizer_simpledfe_sptr self) → int
ofdm_equalizer_simpledfe_sptr.get_channel_state(ofdm_equalizer_simpledfe_sptr self, pmt_vector_cfloat taps)
ofdm_equalizer_simpledfe_sptr.reset(ofdm_equalizer_simpledfe_sptr self)
gnuradio.digital.ofdm_equalizer_static(int fft_len, std::vector< std::vector< int, std::allocator< int > >, std::allocator< std::vector< int, std::allocator< int > > > > const & occupied_carriers=std::vector< std::vector< int > >(), std::vector< std::vector< int, std::allocator< int > >, std::allocator< std::vector< int, std::allocator< int > > > > const & pilot_carriers=std::vector< std::vector< int > >(), gr_vector_vector_complexf pilot_symbols=std::vector< std::vector< gr_complex > >(), int symbols_skipped=0, bool input_is_shifted=True) → ofdm_equalizer_static_sptr
ofdm_equalizer_static_sptr.base(ofdm_equalizer_static_sptr self) → ofdm_equalizer_base_sptr
ofdm_equalizer_static_sptr.equalize(*args, **kwargs)
equalize(ofdm_equalizer_static_sptr self, gr_complex * frame, int n_sym, pmt_vector_cfloat initial_taps=std::vector< gr_complex >(), tags_vector_t tags=std::vector< gr::tag_t >())
ofdm_equalizer_static_sptr.fft_len(ofdm_equalizer_static_sptr self) → int
ofdm_equalizer_static_sptr.get_channel_state(ofdm_equalizer_static_sptr self, pmt_vector_cfloat taps)
ofdm_equalizer_static_sptr.reset(ofdm_equalizer_static_sptr self)
gnuradio.digital.ofdm_frame_acquisition(unsigned int occupied_carriers, unsigned int fft_length, unsigned int cplen, pmt_vector_cfloat known_symbol, unsigned int max_fft_shift_len=4) → ofdm_frame_acquisition_sptr
ofdm_frame_acquisition_sptr.active_thread_priority(ofdm_frame_acquisition_sptr self) → int
ofdm_frame_acquisition_sptr.declare_sample_delay(ofdm_frame_acquisition_sptr self, int which, int delay)

declare_sample_delay(ofdm_frame_acquisition_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(ofdm_frame_acquisition_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(ofdm_frame_acquisition_sptr self) -> pmt_vector_float

ofdm_frame_acquisition_sptr.pc_throughput_avg(ofdm_frame_acquisition_sptr self) → float
ofdm_frame_acquisition_sptr.pc_work_time_avg(ofdm_frame_acquisition_sptr self) → float
ofdm_frame_acquisition_sptr.pc_work_time_total(ofdm_frame_acquisition_sptr self) → float
ofdm_frame_acquisition_sptr.sample_delay(ofdm_frame_acquisition_sptr self, int which) → unsigned int
ofdm_frame_acquisition_sptr.set_min_noutput_items(ofdm_frame_acquisition_sptr self, int m)
ofdm_frame_acquisition_sptr.set_thread_priority(ofdm_frame_acquisition_sptr self, int priority) → int
ofdm_frame_acquisition_sptr.snr(ofdm_frame_acquisition_sptr self) → float
ofdm_frame_acquisition_sptr.thread_priority(ofdm_frame_acquisition_sptr self) → int
gnuradio.digital.ofdm_frame_equalizer_vcvc(ofdm_equalizer_base_sptr equalizer, int cp_len, std::string const & tsb_key="frame_len", bool propagate_channel_state=False, int fixed_frame_len=0) → ofdm_frame_equalizer_vcvc_sptr
ofdm_frame_equalizer_vcvc_sptr.active_thread_priority(ofdm_frame_equalizer_vcvc_sptr self) → int
ofdm_frame_equalizer_vcvc_sptr.declare_sample_delay(ofdm_frame_equalizer_vcvc_sptr self, int which, int delay)

declare_sample_delay(ofdm_frame_equalizer_vcvc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(ofdm_frame_equalizer_vcvc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(ofdm_frame_equalizer_vcvc_sptr self) -> pmt_vector_float

ofdm_frame_equalizer_vcvc_sptr.pc_throughput_avg(ofdm_frame_equalizer_vcvc_sptr self) → float
ofdm_frame_equalizer_vcvc_sptr.pc_work_time_avg(ofdm_frame_equalizer_vcvc_sptr self) → float
ofdm_frame_equalizer_vcvc_sptr.pc_work_time_total(ofdm_frame_equalizer_vcvc_sptr self) → float
ofdm_frame_equalizer_vcvc_sptr.sample_delay(ofdm_frame_equalizer_vcvc_sptr self, int which) → unsigned int
ofdm_frame_equalizer_vcvc_sptr.set_min_noutput_items(ofdm_frame_equalizer_vcvc_sptr self, int m)
ofdm_frame_equalizer_vcvc_sptr.set_thread_priority(ofdm_frame_equalizer_vcvc_sptr self, int priority) → int
ofdm_frame_equalizer_vcvc_sptr.thread_priority(ofdm_frame_equalizer_vcvc_sptr self) → int
gnuradio.digital.ofdm_frame_sink(pmt_vector_cfloat sym_position, std::vector< char, std::allocator< char > > const & sym_value_out, msg_queue_sptr target_queue, int occupied_tones, float phase_gain=0.25, float freq_gain=0.25*0.25/4) → ofdm_frame_sink_sptr
ofdm_frame_sink_sptr.active_thread_priority(ofdm_frame_sink_sptr self) → int
ofdm_frame_sink_sptr.declare_sample_delay(ofdm_frame_sink_sptr self, int which, int delay)

declare_sample_delay(ofdm_frame_sink_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(ofdm_frame_sink_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(ofdm_frame_sink_sptr self) -> pmt_vector_float

ofdm_frame_sink_sptr.pc_throughput_avg(ofdm_frame_sink_sptr self) → float
ofdm_frame_sink_sptr.pc_work_time_avg(ofdm_frame_sink_sptr self) → float
ofdm_frame_sink_sptr.pc_work_time_total(ofdm_frame_sink_sptr self) → float
ofdm_frame_sink_sptr.sample_delay(ofdm_frame_sink_sptr self, int which) → unsigned int
ofdm_frame_sink_sptr.set_min_noutput_items(ofdm_frame_sink_sptr self, int m)
ofdm_frame_sink_sptr.set_thread_priority(ofdm_frame_sink_sptr self, int priority) → int
ofdm_frame_sink_sptr.thread_priority(ofdm_frame_sink_sptr self) → int
gnuradio.digital.ofdm_insert_preamble(int fft_length, gr_vector_vector_complexf preamble) → ofdm_insert_preamble_sptr
ofdm_insert_preamble_sptr.active_thread_priority(ofdm_insert_preamble_sptr self) → int
ofdm_insert_preamble_sptr.declare_sample_delay(ofdm_insert_preamble_sptr self, int which, int delay)

declare_sample_delay(ofdm_insert_preamble_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(ofdm_insert_preamble_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(ofdm_insert_preamble_sptr self) -> pmt_vector_float

ofdm_insert_preamble_sptr.pc_throughput_avg(ofdm_insert_preamble_sptr self) → float
ofdm_insert_preamble_sptr.pc_work_time_avg(ofdm_insert_preamble_sptr self) → float
ofdm_insert_preamble_sptr.pc_work_time_total(ofdm_insert_preamble_sptr self) → float
ofdm_insert_preamble_sptr.sample_delay(ofdm_insert_preamble_sptr self, int which) → unsigned int
ofdm_insert_preamble_sptr.set_min_noutput_items(ofdm_insert_preamble_sptr self, int m)
ofdm_insert_preamble_sptr.set_thread_priority(ofdm_insert_preamble_sptr self, int priority) → int
ofdm_insert_preamble_sptr.thread_priority(ofdm_insert_preamble_sptr self) → int
gnuradio.digital.ofdm_mapper_bcv(pmt_vector_cfloat constellation, unsigned int msgq_limit, unsigned int occupied_carriers, unsigned int fft_length) → ofdm_mapper_bcv_sptr
ofdm_mapper_bcv_sptr.active_thread_priority(ofdm_mapper_bcv_sptr self) → int
ofdm_mapper_bcv_sptr.declare_sample_delay(ofdm_mapper_bcv_sptr self, int which, int delay)

declare_sample_delay(ofdm_mapper_bcv_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(ofdm_mapper_bcv_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(ofdm_mapper_bcv_sptr self) -> pmt_vector_float

ofdm_mapper_bcv_sptr.pc_throughput_avg(ofdm_mapper_bcv_sptr self) → float
ofdm_mapper_bcv_sptr.pc_work_time_avg(ofdm_mapper_bcv_sptr self) → float
ofdm_mapper_bcv_sptr.pc_work_time_total(ofdm_mapper_bcv_sptr self) → float
ofdm_mapper_bcv_sptr.sample_delay(ofdm_mapper_bcv_sptr self, int which) → unsigned int
ofdm_mapper_bcv_sptr.set_min_noutput_items(ofdm_mapper_bcv_sptr self, int m)
ofdm_mapper_bcv_sptr.set_thread_priority(ofdm_mapper_bcv_sptr self, int priority) → int
ofdm_mapper_bcv_sptr.thread_priority(ofdm_mapper_bcv_sptr self) → int
gnuradio.digital.ofdm_sampler(unsigned int fft_length, unsigned int symbol_length, unsigned int timeout=1000) → ofdm_sampler_sptr
ofdm_sampler_sptr.active_thread_priority(ofdm_sampler_sptr self) → int
ofdm_sampler_sptr.declare_sample_delay(ofdm_sampler_sptr self, int which, int delay)

declare_sample_delay(ofdm_sampler_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(ofdm_sampler_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(ofdm_sampler_sptr self) -> pmt_vector_float

ofdm_sampler_sptr.pc_throughput_avg(ofdm_sampler_sptr self) → float
ofdm_sampler_sptr.pc_work_time_avg(ofdm_sampler_sptr self) → float
ofdm_sampler_sptr.pc_work_time_total(ofdm_sampler_sptr self) → float
ofdm_sampler_sptr.sample_delay(ofdm_sampler_sptr self, int which) → unsigned int
ofdm_sampler_sptr.set_min_noutput_items(ofdm_sampler_sptr self, int m)
ofdm_sampler_sptr.set_thread_priority(ofdm_sampler_sptr self, int priority) → int
ofdm_sampler_sptr.thread_priority(ofdm_sampler_sptr self) → int
gnuradio.digital.ofdm_serializer_vcc(int fft_len, std::vector< std::vector< int, std::allocator< int > >, std::allocator< std::vector< int, std::allocator< int > > > > const & occupied_carriers, std::string const & len_tag_key="frame_len", std::string const & packet_len_tag_key="", int symbols_skipped=0, std::string const & carr_offset_key="", bool input_is_shifted=True) → ofdm_serializer_vcc_sptr
make(ofdm_carrier_allocator_cvc_sptr allocator, std::string const & packet_len_tag_key=””, int symbols_skipped=0, std::string const & carr_offset_key=””, bool input_is_shifted=True) -> ofdm_serializer_vcc_sptr
ofdm_serializer_vcc_sptr.active_thread_priority(ofdm_serializer_vcc_sptr self) → int
ofdm_serializer_vcc_sptr.declare_sample_delay(ofdm_serializer_vcc_sptr self, int which, int delay)

declare_sample_delay(ofdm_serializer_vcc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(ofdm_serializer_vcc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(ofdm_serializer_vcc_sptr self) -> pmt_vector_float

ofdm_serializer_vcc_sptr.pc_throughput_avg(ofdm_serializer_vcc_sptr self) → float
ofdm_serializer_vcc_sptr.pc_work_time_avg(ofdm_serializer_vcc_sptr self) → float
ofdm_serializer_vcc_sptr.pc_work_time_total(ofdm_serializer_vcc_sptr self) → float
ofdm_serializer_vcc_sptr.sample_delay(ofdm_serializer_vcc_sptr self, int which) → unsigned int
ofdm_serializer_vcc_sptr.set_min_noutput_items(ofdm_serializer_vcc_sptr self, int m)
ofdm_serializer_vcc_sptr.set_thread_priority(ofdm_serializer_vcc_sptr self, int priority) → int
ofdm_serializer_vcc_sptr.thread_priority(ofdm_serializer_vcc_sptr self) → int
gnuradio.digital.ofdm_sync_sc_cfb(int fft_len, int cp_len, bool use_even_carriers=False) → ofdm_sync_sc_cfb_sptr
ofdm_sync_sc_cfb_sptr.message_subscribers(ofdm_sync_sc_cfb_sptr self, swig_int_ptr which_port) → swig_int_ptr
gnuradio.digital.packet_header_default(long header_len, std::string const & len_tag_key="packet_len", std::string const & num_tag_key="packet_num", int bits_per_byte=1) → packet_header_default_sptr
packet_header_default_sptr.base(packet_header_default_sptr self) → packet_header_default_sptr
packet_header_default_sptr.formatter(packet_header_default_sptr self) → packet_header_default_sptr
packet_header_default_sptr.header_formatter(packet_header_default_sptr self, long packet_len, unsigned char * out, tags_vector_t tags=std::vector< gr::tag_t >()) → bool
packet_header_default_sptr.header_len(packet_header_default_sptr self) → long
packet_header_default_sptr.header_parser(packet_header_default_sptr self, unsigned char const * header, tags_vector_t tags) → bool
packet_header_default_sptr.len_tag_key(packet_header_default_sptr self) → swig_int_ptr
packet_header_default_sptr.set_header_num(packet_header_default_sptr self, unsigned int header_num)
gnuradio.digital.packet_headergenerator_bb(packet_header_default_sptr header_formatter, std::string const & len_tag_key="packet_len") → packet_headergenerator_bb_sptr

make(long header_len, std::string const & len_tag_key=”packet_len”) -> packet_headergenerator_bb_sptr

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

declare_sample_delay(packet_headergenerator_bb_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(packet_headergenerator_bb_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(packet_headergenerator_bb_sptr self) -> pmt_vector_float

packet_headergenerator_bb_sptr.pc_throughput_avg(packet_headergenerator_bb_sptr self) → float
packet_headergenerator_bb_sptr.pc_work_time_avg(packet_headergenerator_bb_sptr self) → float
packet_headergenerator_bb_sptr.pc_work_time_total(packet_headergenerator_bb_sptr self) → float
packet_headergenerator_bb_sptr.sample_delay(packet_headergenerator_bb_sptr self, int which) → unsigned int
packet_headergenerator_bb_sptr.set_header_formatter(packet_headergenerator_bb_sptr self, packet_header_default_sptr header_formatter)
packet_headergenerator_bb_sptr.set_min_noutput_items(packet_headergenerator_bb_sptr self, int m)
packet_headergenerator_bb_sptr.set_thread_priority(packet_headergenerator_bb_sptr self, int priority) → int
packet_headergenerator_bb_sptr.thread_priority(packet_headergenerator_bb_sptr self) → int
gnuradio.digital.packet_header_ofdm(std::vector< std::vector< int, std::allocator< int > >, std::allocator< std::vector< int, std::allocator< int > > > > const & occupied_carriers, int n_syms, std::string const & len_tag_key="packet_len", std::string const & frame_len_tag_key="frame_len", std::string const & num_tag_key="packet_num", int bits_per_header_sym=1, int bits_per_payload_sym=1, bool scramble_header=False) → packet_header_ofdm_sptr
packet_header_ofdm_sptr.base(packet_header_ofdm_sptr self) → packet_header_default_sptr
packet_header_ofdm_sptr.formatter(packet_header_ofdm_sptr self) → packet_header_default_sptr
packet_header_ofdm_sptr.header_formatter(packet_header_ofdm_sptr self, long packet_len, unsigned char * out, tags_vector_t tags=std::vector< gr::tag_t >()) → bool
packet_header_ofdm_sptr.header_len(packet_header_ofdm_sptr self) → long
packet_header_ofdm_sptr.header_parser(packet_header_ofdm_sptr self, unsigned char const * header, tags_vector_t tags) → bool
packet_header_ofdm_sptr.len_tag_key(packet_header_ofdm_sptr self) → swig_int_ptr
packet_header_ofdm_sptr.set_header_num(packet_header_ofdm_sptr self, unsigned int header_num)
gnuradio.digital.packet_headerparser_b(packet_header_default_sptr header_formatter) → packet_headerparser_b_sptr

make(long header_len, std::string const & len_tag_key) -> packet_headerparser_b_sptr

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

declare_sample_delay(packet_headerparser_b_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(packet_headerparser_b_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(packet_headerparser_b_sptr self) -> pmt_vector_float

packet_headerparser_b_sptr.pc_throughput_avg(packet_headerparser_b_sptr self) → float
packet_headerparser_b_sptr.pc_work_time_avg(packet_headerparser_b_sptr self) → float
packet_headerparser_b_sptr.pc_work_time_total(packet_headerparser_b_sptr self) → float
packet_headerparser_b_sptr.sample_delay(packet_headerparser_b_sptr self, int which) → unsigned int
packet_headerparser_b_sptr.set_min_noutput_items(packet_headerparser_b_sptr self, int m)
packet_headerparser_b_sptr.set_thread_priority(packet_headerparser_b_sptr self, int priority) → int
packet_headerparser_b_sptr.thread_priority(packet_headerparser_b_sptr self) → int
gnuradio.digital.packet_sink(std::vector< unsigned char, std::allocator< unsigned char > > const & sync_vector, msg_queue_sptr target_queue, int threshold=-1) → packet_sink_sptr
packet_sink_sptr.active_thread_priority(packet_sink_sptr self) → int
packet_sink_sptr.carrier_sensed(packet_sink_sptr self) → bool
packet_sink_sptr.declare_sample_delay(packet_sink_sptr self, int which, int delay)

declare_sample_delay(packet_sink_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(packet_sink_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(packet_sink_sptr self) -> pmt_vector_float

packet_sink_sptr.pc_throughput_avg(packet_sink_sptr self) → float
packet_sink_sptr.pc_work_time_avg(packet_sink_sptr self) → float
packet_sink_sptr.pc_work_time_total(packet_sink_sptr self) → float
packet_sink_sptr.sample_delay(packet_sink_sptr self, int which) → unsigned int
packet_sink_sptr.set_min_noutput_items(packet_sink_sptr self, int m)
packet_sink_sptr.set_thread_priority(packet_sink_sptr self, int priority) → int
packet_sink_sptr.thread_priority(packet_sink_sptr self) → int
gnuradio.digital.pfb_clock_sync_ccf(double sps, float loop_bw, pmt_vector_float taps, unsigned int filter_size=32, float init_phase=0, float max_rate_deviation=1.5, int osps=1) → pfb_clock_sync_ccf_sptr
pfb_clock_sync_ccf_sptr.active_thread_priority(pfb_clock_sync_ccf_sptr self) → int
pfb_clock_sync_ccf_sptr.alpha(pfb_clock_sync_ccf_sptr self) → float
pfb_clock_sync_ccf_sptr.beta(pfb_clock_sync_ccf_sptr self) → float
pfb_clock_sync_ccf_sptr.channel_taps(pfb_clock_sync_ccf_sptr self, int channel) → pmt_vector_float
pfb_clock_sync_ccf_sptr.clock_rate(pfb_clock_sync_ccf_sptr self) → float
pfb_clock_sync_ccf_sptr.damping_factor(pfb_clock_sync_ccf_sptr self) → float
pfb_clock_sync_ccf_sptr.declare_sample_delay(pfb_clock_sync_ccf_sptr self, int which, int delay)

declare_sample_delay(pfb_clock_sync_ccf_sptr self, unsigned int delay)

pfb_clock_sync_ccf_sptr.diff_channel_taps(pfb_clock_sync_ccf_sptr self, int channel) → pmt_vector_float
pfb_clock_sync_ccf_sptr.diff_taps(pfb_clock_sync_ccf_sptr self) → std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >
pfb_clock_sync_ccf_sptr.diff_taps_as_string(pfb_clock_sync_ccf_sptr self) → std::string
pfb_clock_sync_ccf_sptr.error(pfb_clock_sync_ccf_sptr self) → float
pfb_clock_sync_ccf_sptr.loop_bandwidth(pfb_clock_sync_ccf_sptr self) → float
pfb_clock_sync_ccf_sptr.message_subscribers(pfb_clock_sync_ccf_sptr self, swig_int_ptr which_port) → swig_int_ptr
pfb_clock_sync_ccf_sptr.min_noutput_items(pfb_clock_sync_ccf_sptr self) → int
pfb_clock_sync_ccf_sptr.pc_input_buffers_full_avg(pfb_clock_sync_ccf_sptr self, int which) → float

pc_input_buffers_full_avg(pfb_clock_sync_ccf_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(pfb_clock_sync_ccf_sptr self) -> pmt_vector_float

pfb_clock_sync_ccf_sptr.pc_throughput_avg(pfb_clock_sync_ccf_sptr self) → float
pfb_clock_sync_ccf_sptr.pc_work_time_avg(pfb_clock_sync_ccf_sptr self) → float
pfb_clock_sync_ccf_sptr.pc_work_time_total(pfb_clock_sync_ccf_sptr self) → float
pfb_clock_sync_ccf_sptr.phase(pfb_clock_sync_ccf_sptr self) → float
pfb_clock_sync_ccf_sptr.rate(pfb_clock_sync_ccf_sptr self) → float
pfb_clock_sync_ccf_sptr.sample_delay(pfb_clock_sync_ccf_sptr self, int which) → unsigned int
pfb_clock_sync_ccf_sptr.set_alpha(pfb_clock_sync_ccf_sptr self, float alpha)
pfb_clock_sync_ccf_sptr.set_beta(pfb_clock_sync_ccf_sptr self, float beta)
pfb_clock_sync_ccf_sptr.set_damping_factor(pfb_clock_sync_ccf_sptr self, float df)
pfb_clock_sync_ccf_sptr.set_loop_bandwidth(pfb_clock_sync_ccf_sptr self, float bw)
pfb_clock_sync_ccf_sptr.set_max_rate_deviation(pfb_clock_sync_ccf_sptr self, float m)
pfb_clock_sync_ccf_sptr.set_min_noutput_items(pfb_clock_sync_ccf_sptr self, int m)
pfb_clock_sync_ccf_sptr.set_taps(*args, **kwargs)
set_taps(pfb_clock_sync_ccf_sptr self, pmt_vector_float taps, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > & ourtaps, std::vector< gr::filter::kernel::fir_filter_ccf *,std::allocator< gr::filter::kernel::fir_filter_ccf * > > & ourfilter)
pfb_clock_sync_ccf_sptr.set_thread_priority(pfb_clock_sync_ccf_sptr self, int priority) → int
pfb_clock_sync_ccf_sptr.taps(pfb_clock_sync_ccf_sptr self) → std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >
pfb_clock_sync_ccf_sptr.taps_as_string(pfb_clock_sync_ccf_sptr self) → std::string
pfb_clock_sync_ccf_sptr.thread_priority(pfb_clock_sync_ccf_sptr self) → int
pfb_clock_sync_ccf_sptr.update_gains(pfb_clock_sync_ccf_sptr self)
pfb_clock_sync_ccf_sptr.update_taps(pfb_clock_sync_ccf_sptr self, pmt_vector_float taps)
gnuradio.digital.pfb_clock_sync_fff(double sps, float gain, pmt_vector_float taps, unsigned int filter_size=32, float init_phase=0, float max_rate_deviation=1.5, int osps=1) → pfb_clock_sync_fff_sptr
pfb_clock_sync_fff_sptr.active_thread_priority(pfb_clock_sync_fff_sptr self) → int
pfb_clock_sync_fff_sptr.alpha(pfb_clock_sync_fff_sptr self) → float
pfb_clock_sync_fff_sptr.beta(pfb_clock_sync_fff_sptr self) → float
pfb_clock_sync_fff_sptr.channel_taps(pfb_clock_sync_fff_sptr self, int channel) → pmt_vector_float
pfb_clock_sync_fff_sptr.clock_rate(pfb_clock_sync_fff_sptr self) → float
pfb_clock_sync_fff_sptr.damping_factor(pfb_clock_sync_fff_sptr self) → float
pfb_clock_sync_fff_sptr.declare_sample_delay(pfb_clock_sync_fff_sptr self, int which, int delay)

declare_sample_delay(pfb_clock_sync_fff_sptr self, unsigned int delay)

pfb_clock_sync_fff_sptr.diff_channel_taps(pfb_clock_sync_fff_sptr self, int channel) → pmt_vector_float
pfb_clock_sync_fff_sptr.diff_taps(pfb_clock_sync_fff_sptr self) → std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >
pfb_clock_sync_fff_sptr.diff_taps_as_string(pfb_clock_sync_fff_sptr self) → std::string
pfb_clock_sync_fff_sptr.loop_bandwidth(pfb_clock_sync_fff_sptr self) → float
pfb_clock_sync_fff_sptr.message_subscribers(pfb_clock_sync_fff_sptr self, swig_int_ptr which_port) → swig_int_ptr
pfb_clock_sync_fff_sptr.min_noutput_items(pfb_clock_sync_fff_sptr self) → int
pfb_clock_sync_fff_sptr.pc_input_buffers_full_avg(pfb_clock_sync_fff_sptr self, int which) → float

pc_input_buffers_full_avg(pfb_clock_sync_fff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(pfb_clock_sync_fff_sptr self) -> pmt_vector_float

pfb_clock_sync_fff_sptr.pc_throughput_avg(pfb_clock_sync_fff_sptr self) → float
pfb_clock_sync_fff_sptr.pc_work_time_avg(pfb_clock_sync_fff_sptr self) → float
pfb_clock_sync_fff_sptr.pc_work_time_total(pfb_clock_sync_fff_sptr self) → float
pfb_clock_sync_fff_sptr.sample_delay(pfb_clock_sync_fff_sptr self, int which) → unsigned int
pfb_clock_sync_fff_sptr.set_alpha(pfb_clock_sync_fff_sptr self, float alpha)
pfb_clock_sync_fff_sptr.set_beta(pfb_clock_sync_fff_sptr self, float beta)
pfb_clock_sync_fff_sptr.set_damping_factor(pfb_clock_sync_fff_sptr self, float df)
pfb_clock_sync_fff_sptr.set_loop_bandwidth(pfb_clock_sync_fff_sptr self, float bw)
pfb_clock_sync_fff_sptr.set_max_rate_deviation(pfb_clock_sync_fff_sptr self, float m)
pfb_clock_sync_fff_sptr.set_min_noutput_items(pfb_clock_sync_fff_sptr self, int m)
pfb_clock_sync_fff_sptr.set_taps(*args, **kwargs)
set_taps(pfb_clock_sync_fff_sptr self, pmt_vector_float taps, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > & ourtaps, std::vector< gr::filter::kernel::fir_filter_fff *,std::allocator< gr::filter::kernel::fir_filter_fff * > > & ourfilter)
pfb_clock_sync_fff_sptr.set_thread_priority(pfb_clock_sync_fff_sptr self, int priority) → int
pfb_clock_sync_fff_sptr.taps(pfb_clock_sync_fff_sptr self) → std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >
pfb_clock_sync_fff_sptr.taps_as_string(pfb_clock_sync_fff_sptr self) → std::string
pfb_clock_sync_fff_sptr.thread_priority(pfb_clock_sync_fff_sptr self) → int
pfb_clock_sync_fff_sptr.update_gains(pfb_clock_sync_fff_sptr self)
pfb_clock_sync_fff_sptr.update_taps(pfb_clock_sync_fff_sptr self, pmt_vector_float taps)
gnuradio.digital.pn_correlator_cc(int degree, int mask=0, int seed=1) → pn_correlator_cc_sptr
pn_correlator_cc_sptr.active_thread_priority(pn_correlator_cc_sptr self) → int
pn_correlator_cc_sptr.declare_sample_delay(pn_correlator_cc_sptr self, int which, int delay)

declare_sample_delay(pn_correlator_cc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(pn_correlator_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(pn_correlator_cc_sptr self) -> pmt_vector_float

pn_correlator_cc_sptr.pc_throughput_avg(pn_correlator_cc_sptr self) → float
pn_correlator_cc_sptr.pc_work_time_avg(pn_correlator_cc_sptr self) → float
pn_correlator_cc_sptr.pc_work_time_total(pn_correlator_cc_sptr self) → float
pn_correlator_cc_sptr.sample_delay(pn_correlator_cc_sptr self, int which) → unsigned int
pn_correlator_cc_sptr.set_min_noutput_items(pn_correlator_cc_sptr self, int m)
pn_correlator_cc_sptr.set_thread_priority(pn_correlator_cc_sptr self, int priority) → int
pn_correlator_cc_sptr.thread_priority(pn_correlator_cc_sptr self) → int
gnuradio.digital.probe_density_b(double alpha) → probe_density_b_sptr
probe_density_b_sptr.active_thread_priority(probe_density_b_sptr self) → int
probe_density_b_sptr.declare_sample_delay(probe_density_b_sptr self, int which, int delay)

declare_sample_delay(probe_density_b_sptr self, unsigned int delay)

probe_density_b_sptr.density(probe_density_b_sptr self) → double
probe_density_b_sptr.message_subscribers(probe_density_b_sptr self, swig_int_ptr which_port) → swig_int_ptr
probe_density_b_sptr.min_noutput_items(probe_density_b_sptr self) → int
probe_density_b_sptr.pc_input_buffers_full_avg(probe_density_b_sptr self, int which) → float

pc_input_buffers_full_avg(probe_density_b_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(probe_density_b_sptr self) -> pmt_vector_float

probe_density_b_sptr.pc_throughput_avg(probe_density_b_sptr self) → float
probe_density_b_sptr.pc_work_time_avg(probe_density_b_sptr self) → float
probe_density_b_sptr.pc_work_time_total(probe_density_b_sptr self) → float
probe_density_b_sptr.sample_delay(probe_density_b_sptr self, int which) → unsigned int
probe_density_b_sptr.set_alpha(probe_density_b_sptr self, double alpha)
probe_density_b_sptr.set_min_noutput_items(probe_density_b_sptr self, int m)
probe_density_b_sptr.set_thread_priority(probe_density_b_sptr self, int priority) → int
probe_density_b_sptr.thread_priority(probe_density_b_sptr self) → int
gnuradio.digital.probe_mpsk_snr_est_c(gr::digital::snr_est_type_t type, int msg_nsamples=10000, double alpha=0.001) → probe_mpsk_snr_est_c_sptr
probe_mpsk_snr_est_c_sptr.active_thread_priority(probe_mpsk_snr_est_c_sptr self) → int
probe_mpsk_snr_est_c_sptr.alpha(probe_mpsk_snr_est_c_sptr self) → double
probe_mpsk_snr_est_c_sptr.declare_sample_delay(probe_mpsk_snr_est_c_sptr self, int which, int delay)

declare_sample_delay(probe_mpsk_snr_est_c_sptr self, unsigned int delay)

probe_mpsk_snr_est_c_sptr.message_subscribers(probe_mpsk_snr_est_c_sptr self, swig_int_ptr which_port) → swig_int_ptr
probe_mpsk_snr_est_c_sptr.min_noutput_items(probe_mpsk_snr_est_c_sptr self) → int
probe_mpsk_snr_est_c_sptr.msg_nsample(probe_mpsk_snr_est_c_sptr self) → int
probe_mpsk_snr_est_c_sptr.noise(probe_mpsk_snr_est_c_sptr self) → double
probe_mpsk_snr_est_c_sptr.pc_input_buffers_full_avg(probe_mpsk_snr_est_c_sptr self, int which) → float

pc_input_buffers_full_avg(probe_mpsk_snr_est_c_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(probe_mpsk_snr_est_c_sptr self) -> pmt_vector_float

probe_mpsk_snr_est_c_sptr.pc_throughput_avg(probe_mpsk_snr_est_c_sptr self) → float
probe_mpsk_snr_est_c_sptr.pc_work_time_avg(probe_mpsk_snr_est_c_sptr self) → float
probe_mpsk_snr_est_c_sptr.pc_work_time_total(probe_mpsk_snr_est_c_sptr self) → float
probe_mpsk_snr_est_c_sptr.sample_delay(probe_mpsk_snr_est_c_sptr self, int which) → unsigned int
probe_mpsk_snr_est_c_sptr.set_alpha(probe_mpsk_snr_est_c_sptr self, double alpha)
probe_mpsk_snr_est_c_sptr.set_min_noutput_items(probe_mpsk_snr_est_c_sptr self, int m)
probe_mpsk_snr_est_c_sptr.set_msg_nsample(probe_mpsk_snr_est_c_sptr self, int n)
probe_mpsk_snr_est_c_sptr.set_thread_priority(probe_mpsk_snr_est_c_sptr self, int priority) → int
probe_mpsk_snr_est_c_sptr.set_type(probe_mpsk_snr_est_c_sptr self, gr::digital::snr_est_type_t t)
probe_mpsk_snr_est_c_sptr.signal(probe_mpsk_snr_est_c_sptr self) → double
probe_mpsk_snr_est_c_sptr.snr(probe_mpsk_snr_est_c_sptr self) → double
probe_mpsk_snr_est_c_sptr.thread_priority(probe_mpsk_snr_est_c_sptr self) → int
gnuradio.digital.scrambler_bb(int mask, int seed, int len) → scrambler_bb_sptr
scrambler_bb_sptr.active_thread_priority(scrambler_bb_sptr self) → int
scrambler_bb_sptr.declare_sample_delay(scrambler_bb_sptr self, int which, int delay)

declare_sample_delay(scrambler_bb_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(scrambler_bb_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(scrambler_bb_sptr self) -> pmt_vector_float

scrambler_bb_sptr.pc_throughput_avg(scrambler_bb_sptr self) → float
scrambler_bb_sptr.pc_work_time_avg(scrambler_bb_sptr self) → float
scrambler_bb_sptr.pc_work_time_total(scrambler_bb_sptr self) → float
scrambler_bb_sptr.sample_delay(scrambler_bb_sptr self, int which) → unsigned int
scrambler_bb_sptr.set_min_noutput_items(scrambler_bb_sptr self, int m)
scrambler_bb_sptr.set_thread_priority(scrambler_bb_sptr self, int priority) → int
scrambler_bb_sptr.thread_priority(scrambler_bb_sptr self) → int
gnuradio.digital.simple_correlator(int payload_bytesize) → simple_correlator_sptr
simple_correlator_sptr.active_thread_priority(simple_correlator_sptr self) → int
simple_correlator_sptr.declare_sample_delay(simple_correlator_sptr self, int which, int delay)

declare_sample_delay(simple_correlator_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(simple_correlator_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(simple_correlator_sptr self) -> pmt_vector_float

simple_correlator_sptr.pc_throughput_avg(simple_correlator_sptr self) → float
simple_correlator_sptr.pc_work_time_avg(simple_correlator_sptr self) → float
simple_correlator_sptr.pc_work_time_total(simple_correlator_sptr self) → float
simple_correlator_sptr.sample_delay(simple_correlator_sptr self, int which) → unsigned int
simple_correlator_sptr.set_min_noutput_items(simple_correlator_sptr self, int m)
simple_correlator_sptr.set_thread_priority(simple_correlator_sptr self, int priority) → int
simple_correlator_sptr.thread_priority(simple_correlator_sptr self) → int
gnuradio.digital.simple_framer(int payload_bytesize) → simple_framer_sptr
simple_framer_sptr.active_thread_priority(simple_framer_sptr self) → int
simple_framer_sptr.declare_sample_delay(simple_framer_sptr self, int which, int delay)

declare_sample_delay(simple_framer_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(simple_framer_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(simple_framer_sptr self) -> pmt_vector_float

simple_framer_sptr.pc_throughput_avg(simple_framer_sptr self) → float
simple_framer_sptr.pc_work_time_avg(simple_framer_sptr self) → float
simple_framer_sptr.pc_work_time_total(simple_framer_sptr self) → float
simple_framer_sptr.sample_delay(simple_framer_sptr self, int which) → unsigned int
simple_framer_sptr.set_min_noutput_items(simple_framer_sptr self, int m)
simple_framer_sptr.set_thread_priority(simple_framer_sptr self, int priority) → int
simple_framer_sptr.thread_priority(simple_framer_sptr self) → int

Previous topic

gnuradio.comedi

Next topic

gnuradio.dtv

This Page