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 const header_len, int const items_per_symbol=1, int const guard_interval=0, std::string const & length_tag_key="frame_len", std::string const & trigger_tag_key="", bool const output_symbols=False, size_t const 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 >(), size_t const header_padding=0) → 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