gnuradio.analog

Blocks and utilities for analog modulation and demodulation.

gnuradio.analog.agc2_cc(float attack_rate=1e-1, float decay_rate=1e-2, float reference=1.0, float gain=1.0) → agc2_cc_sptr
agc2_cc_sptr.active_thread_priority(agc2_cc_sptr self) → int
agc2_cc_sptr.attack_rate(agc2_cc_sptr self) → float
agc2_cc_sptr.decay_rate(agc2_cc_sptr self) → float
agc2_cc_sptr.declare_sample_delay(agc2_cc_sptr self, int which, int delay)

declare_sample_delay(agc2_cc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(agc2_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(agc2_cc_sptr self) -> pmt_vector_float

agc2_cc_sptr.pc_throughput_avg(agc2_cc_sptr self) → float
agc2_cc_sptr.pc_work_time_avg(agc2_cc_sptr self) → float
agc2_cc_sptr.pc_work_time_total(agc2_cc_sptr self) → float
agc2_cc_sptr.reference(agc2_cc_sptr self) → float
agc2_cc_sptr.sample_delay(agc2_cc_sptr self, int which) → unsigned int
agc2_cc_sptr.set_attack_rate(agc2_cc_sptr self, float rate)
agc2_cc_sptr.set_decay_rate(agc2_cc_sptr self, float rate)
agc2_cc_sptr.set_gain(agc2_cc_sptr self, float gain)
agc2_cc_sptr.set_max_gain(agc2_cc_sptr self, float max_gain)
agc2_cc_sptr.set_min_noutput_items(agc2_cc_sptr self, int m)
agc2_cc_sptr.set_reference(agc2_cc_sptr self, float reference)
agc2_cc_sptr.set_thread_priority(agc2_cc_sptr self, int priority) → int
agc2_cc_sptr.thread_priority(agc2_cc_sptr self) → int
gnuradio.analog.agc2_ff(float attack_rate=1e-1, float decay_rate=1e-2, float reference=1.0, float gain=1.0) → agc2_ff_sptr
agc2_ff_sptr.active_thread_priority(agc2_ff_sptr self) → int
agc2_ff_sptr.attack_rate(agc2_ff_sptr self) → float
agc2_ff_sptr.decay_rate(agc2_ff_sptr self) → float
agc2_ff_sptr.declare_sample_delay(agc2_ff_sptr self, int which, int delay)

declare_sample_delay(agc2_ff_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(agc2_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(agc2_ff_sptr self) -> pmt_vector_float

agc2_ff_sptr.pc_throughput_avg(agc2_ff_sptr self) → float
agc2_ff_sptr.pc_work_time_avg(agc2_ff_sptr self) → float
agc2_ff_sptr.pc_work_time_total(agc2_ff_sptr self) → float
agc2_ff_sptr.reference(agc2_ff_sptr self) → float
agc2_ff_sptr.sample_delay(agc2_ff_sptr self, int which) → unsigned int
agc2_ff_sptr.set_attack_rate(agc2_ff_sptr self, float rate)
agc2_ff_sptr.set_decay_rate(agc2_ff_sptr self, float rate)
agc2_ff_sptr.set_gain(agc2_ff_sptr self, float gain)
agc2_ff_sptr.set_max_gain(agc2_ff_sptr self, float max_gain)
agc2_ff_sptr.set_min_noutput_items(agc2_ff_sptr self, int m)
agc2_ff_sptr.set_reference(agc2_ff_sptr self, float reference)
agc2_ff_sptr.set_thread_priority(agc2_ff_sptr self, int priority) → int
agc2_ff_sptr.thread_priority(agc2_ff_sptr self) → int
gnuradio.analog.agc3_cc(float attack_rate=1e-1, float decay_rate=1e-2, float reference=1.0, float gain=1.0, int iir_update_decim=1) → agc3_cc_sptr
agc3_cc_sptr.active_thread_priority(agc3_cc_sptr self) → int
agc3_cc_sptr.attack_rate(agc3_cc_sptr self) → float
agc3_cc_sptr.decay_rate(agc3_cc_sptr self) → float
agc3_cc_sptr.declare_sample_delay(agc3_cc_sptr self, int which, int delay)

declare_sample_delay(agc3_cc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(agc3_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(agc3_cc_sptr self) -> pmt_vector_float

agc3_cc_sptr.pc_throughput_avg(agc3_cc_sptr self) → float
agc3_cc_sptr.pc_work_time_avg(agc3_cc_sptr self) → float
agc3_cc_sptr.pc_work_time_total(agc3_cc_sptr self) → float
agc3_cc_sptr.reference(agc3_cc_sptr self) → float
agc3_cc_sptr.sample_delay(agc3_cc_sptr self, int which) → unsigned int
agc3_cc_sptr.set_attack_rate(agc3_cc_sptr self, float rate)
agc3_cc_sptr.set_decay_rate(agc3_cc_sptr self, float rate)
agc3_cc_sptr.set_gain(agc3_cc_sptr self, float gain)
agc3_cc_sptr.set_max_gain(agc3_cc_sptr self, float max_gain)
agc3_cc_sptr.set_min_noutput_items(agc3_cc_sptr self, int m)
agc3_cc_sptr.set_reference(agc3_cc_sptr self, float reference)
agc3_cc_sptr.set_thread_priority(agc3_cc_sptr self, int priority) → int
agc3_cc_sptr.thread_priority(agc3_cc_sptr self) → int
gnuradio.analog.agc_cc(float rate=1e-4, float reference=1.0, float gain=1.0) → agc_cc_sptr
agc_cc_sptr.active_thread_priority(agc_cc_sptr self) → int
agc_cc_sptr.declare_sample_delay(agc_cc_sptr self, int which, int delay)

declare_sample_delay(agc_cc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(agc_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(agc_cc_sptr self) -> pmt_vector_float

agc_cc_sptr.pc_throughput_avg(agc_cc_sptr self) → float
agc_cc_sptr.pc_work_time_avg(agc_cc_sptr self) → float
agc_cc_sptr.pc_work_time_total(agc_cc_sptr self) → float
agc_cc_sptr.rate(agc_cc_sptr self) → float
agc_cc_sptr.reference(agc_cc_sptr self) → float
agc_cc_sptr.sample_delay(agc_cc_sptr self, int which) → unsigned int
agc_cc_sptr.set_gain(agc_cc_sptr self, float gain)
agc_cc_sptr.set_max_gain(agc_cc_sptr self, float max_gain)
agc_cc_sptr.set_min_noutput_items(agc_cc_sptr self, int m)
agc_cc_sptr.set_rate(agc_cc_sptr self, float rate)
agc_cc_sptr.set_reference(agc_cc_sptr self, float reference)
agc_cc_sptr.set_thread_priority(agc_cc_sptr self, int priority) → int
agc_cc_sptr.thread_priority(agc_cc_sptr self) → int
gnuradio.analog.agc_ff(float rate=1e-4, float reference=1.0, float gain=1.0) → agc_ff_sptr
agc_ff_sptr.active_thread_priority(agc_ff_sptr self) → int
agc_ff_sptr.declare_sample_delay(agc_ff_sptr self, int which, int delay)

declare_sample_delay(agc_ff_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(agc_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(agc_ff_sptr self) -> pmt_vector_float

agc_ff_sptr.pc_throughput_avg(agc_ff_sptr self) → float
agc_ff_sptr.pc_work_time_avg(agc_ff_sptr self) → float
agc_ff_sptr.pc_work_time_total(agc_ff_sptr self) → float
agc_ff_sptr.rate(agc_ff_sptr self) → float
agc_ff_sptr.reference(agc_ff_sptr self) → float
agc_ff_sptr.sample_delay(agc_ff_sptr self, int which) → unsigned int
agc_ff_sptr.set_gain(agc_ff_sptr self, float gain)
agc_ff_sptr.set_max_gain(agc_ff_sptr self, float max_gain)
agc_ff_sptr.set_min_noutput_items(agc_ff_sptr self, int m)
agc_ff_sptr.set_rate(agc_ff_sptr self, float rate)
agc_ff_sptr.set_reference(agc_ff_sptr self, float reference)
agc_ff_sptr.set_thread_priority(agc_ff_sptr self, int priority) → int
agc_ff_sptr.thread_priority(agc_ff_sptr self) → int
gnuradio.analog.cpfsk_bc(float k, float ampl, int samples_per_sym) → cpfsk_bc_sptr
cpfsk_bc_sptr.active_thread_priority(cpfsk_bc_sptr self) → int
cpfsk_bc_sptr.amplitude(cpfsk_bc_sptr self) → float
cpfsk_bc_sptr.declare_sample_delay(cpfsk_bc_sptr self, int which, int delay)

declare_sample_delay(cpfsk_bc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(cpfsk_bc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(cpfsk_bc_sptr self) -> pmt_vector_float

cpfsk_bc_sptr.pc_throughput_avg(cpfsk_bc_sptr self) → float
cpfsk_bc_sptr.pc_work_time_avg(cpfsk_bc_sptr self) → float
cpfsk_bc_sptr.pc_work_time_total(cpfsk_bc_sptr self) → float
cpfsk_bc_sptr.phase(cpfsk_bc_sptr self) → float
cpfsk_bc_sptr.sample_delay(cpfsk_bc_sptr self, int which) → unsigned int
cpfsk_bc_sptr.set_amplitude(cpfsk_bc_sptr self, float amplitude)
cpfsk_bc_sptr.set_min_noutput_items(cpfsk_bc_sptr self, int m)
cpfsk_bc_sptr.set_thread_priority(cpfsk_bc_sptr self, int priority) → int
cpfsk_bc_sptr.thread_priority(cpfsk_bc_sptr self) → int
gnuradio.analog.ctcss_squelch_ff(int rate, float freq, float level, int len, int ramp, bool gate) → ctcss_squelch_ff_sptr
ctcss_squelch_ff_sptr.active_thread_priority(ctcss_squelch_ff_sptr self) → int
ctcss_squelch_ff_sptr.declare_sample_delay(ctcss_squelch_ff_sptr self, int which, int delay)

declare_sample_delay(ctcss_squelch_ff_sptr self, unsigned int delay)

ctcss_squelch_ff_sptr.frequency(ctcss_squelch_ff_sptr self) → float
ctcss_squelch_ff_sptr.gate(ctcss_squelch_ff_sptr self) → bool
ctcss_squelch_ff_sptr.len(ctcss_squelch_ff_sptr self) → int
ctcss_squelch_ff_sptr.level(ctcss_squelch_ff_sptr self) → float
ctcss_squelch_ff_sptr.message_subscribers(ctcss_squelch_ff_sptr self, swig_int_ptr which_port) → swig_int_ptr
ctcss_squelch_ff_sptr.min_noutput_items(ctcss_squelch_ff_sptr self) → int
ctcss_squelch_ff_sptr.pc_input_buffers_full_avg(ctcss_squelch_ff_sptr self, int which) → float

pc_input_buffers_full_avg(ctcss_squelch_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(ctcss_squelch_ff_sptr self) -> pmt_vector_float

ctcss_squelch_ff_sptr.pc_throughput_avg(ctcss_squelch_ff_sptr self) → float
ctcss_squelch_ff_sptr.pc_work_time_avg(ctcss_squelch_ff_sptr self) → float
ctcss_squelch_ff_sptr.pc_work_time_total(ctcss_squelch_ff_sptr self) → float
ctcss_squelch_ff_sptr.ramp(ctcss_squelch_ff_sptr self) → int
ctcss_squelch_ff_sptr.sample_delay(ctcss_squelch_ff_sptr self, int which) → unsigned int
ctcss_squelch_ff_sptr.set_frequency(ctcss_squelch_ff_sptr self, float frequency)
ctcss_squelch_ff_sptr.set_gate(ctcss_squelch_ff_sptr self, bool gate)
ctcss_squelch_ff_sptr.set_level(ctcss_squelch_ff_sptr self, float level)
ctcss_squelch_ff_sptr.set_min_noutput_items(ctcss_squelch_ff_sptr self, int m)
ctcss_squelch_ff_sptr.set_ramp(ctcss_squelch_ff_sptr self, int ramp)
ctcss_squelch_ff_sptr.set_thread_priority(ctcss_squelch_ff_sptr self, int priority) → int
ctcss_squelch_ff_sptr.squelch_range(ctcss_squelch_ff_sptr self) → pmt_vector_float
ctcss_squelch_ff_sptr.thread_priority(ctcss_squelch_ff_sptr self) → int
ctcss_squelch_ff_sptr.unmuted(ctcss_squelch_ff_sptr self) → bool
gnuradio.analog.dpll_bb(float period, float gain) → dpll_bb_sptr
dpll_bb_sptr.active_thread_priority(dpll_bb_sptr self) → int
dpll_bb_sptr.decision_threshold(dpll_bb_sptr self) → float
dpll_bb_sptr.declare_sample_delay(dpll_bb_sptr self, int which, int delay)

declare_sample_delay(dpll_bb_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(dpll_bb_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(dpll_bb_sptr self) -> pmt_vector_float

dpll_bb_sptr.pc_throughput_avg(dpll_bb_sptr self) → float
dpll_bb_sptr.pc_work_time_avg(dpll_bb_sptr self) → float
dpll_bb_sptr.pc_work_time_total(dpll_bb_sptr self) → float
dpll_bb_sptr.phase(dpll_bb_sptr self) → float
dpll_bb_sptr.sample_delay(dpll_bb_sptr self, int which) → unsigned int
dpll_bb_sptr.set_decision_threshold(dpll_bb_sptr self, float thresh)
dpll_bb_sptr.set_gain(dpll_bb_sptr self, float gain)
dpll_bb_sptr.set_min_noutput_items(dpll_bb_sptr self, int m)
dpll_bb_sptr.set_thread_priority(dpll_bb_sptr self, int priority) → int
dpll_bb_sptr.thread_priority(dpll_bb_sptr self) → int
gnuradio.analog.fastnoise_source_c(gr::analog::noise_type_t type, float ampl, long seed=0, long samples=1024*16) → fastnoise_source_c_sptr
fastnoise_source_c_sptr.active_thread_priority(fastnoise_source_c_sptr self) → int
fastnoise_source_c_sptr.amplitude(fastnoise_source_c_sptr self) → float
fastnoise_source_c_sptr.declare_sample_delay(fastnoise_source_c_sptr self, int which, int delay)

declare_sample_delay(fastnoise_source_c_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(fastnoise_source_c_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(fastnoise_source_c_sptr self) -> pmt_vector_float

fastnoise_source_c_sptr.pc_throughput_avg(fastnoise_source_c_sptr self) → float
fastnoise_source_c_sptr.pc_work_time_avg(fastnoise_source_c_sptr self) → float
fastnoise_source_c_sptr.pc_work_time_total(fastnoise_source_c_sptr self) → float
fastnoise_source_c_sptr.sample(fastnoise_source_c_sptr self) → gr_complex
fastnoise_source_c_sptr.sample_delay(fastnoise_source_c_sptr self, int which) → unsigned int
fastnoise_source_c_sptr.sample_unbiased(fastnoise_source_c_sptr self) → gr_complex
fastnoise_source_c_sptr.set_amplitude(fastnoise_source_c_sptr self, float ampl)
fastnoise_source_c_sptr.set_min_noutput_items(fastnoise_source_c_sptr self, int m)
fastnoise_source_c_sptr.set_thread_priority(fastnoise_source_c_sptr self, int priority) → int
fastnoise_source_c_sptr.set_type(fastnoise_source_c_sptr self, gr::analog::noise_type_t type)
fastnoise_source_c_sptr.thread_priority(fastnoise_source_c_sptr self) → int
gnuradio.analog.fastnoise_source_f(gr::analog::noise_type_t type, float ampl, long seed=0, long samples=1024*16) → fastnoise_source_f_sptr
fastnoise_source_f_sptr.active_thread_priority(fastnoise_source_f_sptr self) → int
fastnoise_source_f_sptr.amplitude(fastnoise_source_f_sptr self) → float
fastnoise_source_f_sptr.declare_sample_delay(fastnoise_source_f_sptr self, int which, int delay)

declare_sample_delay(fastnoise_source_f_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(fastnoise_source_f_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(fastnoise_source_f_sptr self) -> pmt_vector_float

fastnoise_source_f_sptr.pc_throughput_avg(fastnoise_source_f_sptr self) → float
fastnoise_source_f_sptr.pc_work_time_avg(fastnoise_source_f_sptr self) → float
fastnoise_source_f_sptr.pc_work_time_total(fastnoise_source_f_sptr self) → float
fastnoise_source_f_sptr.sample(fastnoise_source_f_sptr self) → float
fastnoise_source_f_sptr.sample_delay(fastnoise_source_f_sptr self, int which) → unsigned int
fastnoise_source_f_sptr.sample_unbiased(fastnoise_source_f_sptr self) → float
fastnoise_source_f_sptr.set_amplitude(fastnoise_source_f_sptr self, float ampl)
fastnoise_source_f_sptr.set_min_noutput_items(fastnoise_source_f_sptr self, int m)
fastnoise_source_f_sptr.set_thread_priority(fastnoise_source_f_sptr self, int priority) → int
fastnoise_source_f_sptr.set_type(fastnoise_source_f_sptr self, gr::analog::noise_type_t type)
fastnoise_source_f_sptr.thread_priority(fastnoise_source_f_sptr self) → int
gnuradio.analog.fastnoise_source_i(gr::analog::noise_type_t type, float ampl, long seed=0, long samples=1024*16) → fastnoise_source_i_sptr
fastnoise_source_i_sptr.active_thread_priority(fastnoise_source_i_sptr self) → int
fastnoise_source_i_sptr.amplitude(fastnoise_source_i_sptr self) → float
fastnoise_source_i_sptr.declare_sample_delay(fastnoise_source_i_sptr self, int which, int delay)

declare_sample_delay(fastnoise_source_i_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(fastnoise_source_i_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(fastnoise_source_i_sptr self) -> pmt_vector_float

fastnoise_source_i_sptr.pc_throughput_avg(fastnoise_source_i_sptr self) → float
fastnoise_source_i_sptr.pc_work_time_avg(fastnoise_source_i_sptr self) → float
fastnoise_source_i_sptr.pc_work_time_total(fastnoise_source_i_sptr self) → float
fastnoise_source_i_sptr.sample(fastnoise_source_i_sptr self) → int
fastnoise_source_i_sptr.sample_delay(fastnoise_source_i_sptr self, int which) → unsigned int
fastnoise_source_i_sptr.sample_unbiased(fastnoise_source_i_sptr self) → int
fastnoise_source_i_sptr.set_amplitude(fastnoise_source_i_sptr self, float ampl)
fastnoise_source_i_sptr.set_min_noutput_items(fastnoise_source_i_sptr self, int m)
fastnoise_source_i_sptr.set_thread_priority(fastnoise_source_i_sptr self, int priority) → int
fastnoise_source_i_sptr.set_type(fastnoise_source_i_sptr self, gr::analog::noise_type_t type)
fastnoise_source_i_sptr.thread_priority(fastnoise_source_i_sptr self) → int
gnuradio.analog.fastnoise_source_s(gr::analog::noise_type_t type, float ampl, long seed=0, long samples=1024*16) → fastnoise_source_s_sptr
fastnoise_source_s_sptr.active_thread_priority(fastnoise_source_s_sptr self) → int
fastnoise_source_s_sptr.amplitude(fastnoise_source_s_sptr self) → float
fastnoise_source_s_sptr.declare_sample_delay(fastnoise_source_s_sptr self, int which, int delay)

declare_sample_delay(fastnoise_source_s_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(fastnoise_source_s_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(fastnoise_source_s_sptr self) -> pmt_vector_float

fastnoise_source_s_sptr.pc_throughput_avg(fastnoise_source_s_sptr self) → float
fastnoise_source_s_sptr.pc_work_time_avg(fastnoise_source_s_sptr self) → float
fastnoise_source_s_sptr.pc_work_time_total(fastnoise_source_s_sptr self) → float
fastnoise_source_s_sptr.sample(fastnoise_source_s_sptr self) → short
fastnoise_source_s_sptr.sample_delay(fastnoise_source_s_sptr self, int which) → unsigned int
fastnoise_source_s_sptr.sample_unbiased(fastnoise_source_s_sptr self) → short
fastnoise_source_s_sptr.set_amplitude(fastnoise_source_s_sptr self, float ampl)
fastnoise_source_s_sptr.set_min_noutput_items(fastnoise_source_s_sptr self, int m)
fastnoise_source_s_sptr.set_thread_priority(fastnoise_source_s_sptr self, int priority) → int
fastnoise_source_s_sptr.set_type(fastnoise_source_s_sptr self, gr::analog::noise_type_t type)
fastnoise_source_s_sptr.thread_priority(fastnoise_source_s_sptr self) → int
gnuradio.analog.feedforward_agc_cc(int nsamples, float reference) → feedforward_agc_cc_sptr
feedforward_agc_cc_sptr.active_thread_priority(feedforward_agc_cc_sptr self) → int
feedforward_agc_cc_sptr.declare_sample_delay(feedforward_agc_cc_sptr self, int which, int delay)

declare_sample_delay(feedforward_agc_cc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(feedforward_agc_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(feedforward_agc_cc_sptr self) -> pmt_vector_float

feedforward_agc_cc_sptr.pc_throughput_avg(feedforward_agc_cc_sptr self) → float
feedforward_agc_cc_sptr.pc_work_time_avg(feedforward_agc_cc_sptr self) → float
feedforward_agc_cc_sptr.pc_work_time_total(feedforward_agc_cc_sptr self) → float
feedforward_agc_cc_sptr.sample_delay(feedforward_agc_cc_sptr self, int which) → unsigned int
feedforward_agc_cc_sptr.set_min_noutput_items(feedforward_agc_cc_sptr self, int m)
feedforward_agc_cc_sptr.set_thread_priority(feedforward_agc_cc_sptr self, int priority) → int
feedforward_agc_cc_sptr.thread_priority(feedforward_agc_cc_sptr self) → int
gnuradio.analog.fmdet_cf(float samplerate, float freq_low, float freq_high, float scl) → fmdet_cf_sptr
fmdet_cf_sptr.active_thread_priority(fmdet_cf_sptr self) → int
fmdet_cf_sptr.bias(fmdet_cf_sptr self) → float
fmdet_cf_sptr.declare_sample_delay(fmdet_cf_sptr self, int which, int delay)

declare_sample_delay(fmdet_cf_sptr self, unsigned int delay)

fmdet_cf_sptr.freq(fmdet_cf_sptr self) → float
fmdet_cf_sptr.freq_high(fmdet_cf_sptr self) → float
fmdet_cf_sptr.freq_low(fmdet_cf_sptr self) → float
fmdet_cf_sptr.message_subscribers(fmdet_cf_sptr self, swig_int_ptr which_port) → swig_int_ptr
fmdet_cf_sptr.min_noutput_items(fmdet_cf_sptr self) → int
fmdet_cf_sptr.pc_input_buffers_full_avg(fmdet_cf_sptr self, int which) → float

pc_input_buffers_full_avg(fmdet_cf_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(fmdet_cf_sptr self) -> pmt_vector_float

fmdet_cf_sptr.pc_throughput_avg(fmdet_cf_sptr self) → float
fmdet_cf_sptr.pc_work_time_avg(fmdet_cf_sptr self) → float
fmdet_cf_sptr.pc_work_time_total(fmdet_cf_sptr self) → float
fmdet_cf_sptr.sample_delay(fmdet_cf_sptr self, int which) → unsigned int
fmdet_cf_sptr.scale(fmdet_cf_sptr self) → float
fmdet_cf_sptr.set_freq_range(fmdet_cf_sptr self, float freq_low, float freq_high)
fmdet_cf_sptr.set_min_noutput_items(fmdet_cf_sptr self, int m)
fmdet_cf_sptr.set_scale(fmdet_cf_sptr self, float scl)
fmdet_cf_sptr.set_thread_priority(fmdet_cf_sptr self, int priority) → int
fmdet_cf_sptr.thread_priority(fmdet_cf_sptr self) → int
gnuradio.analog.frequency_modulator_fc(float sensitivity) → frequency_modulator_fc_sptr
frequency_modulator_fc_sptr.active_thread_priority(frequency_modulator_fc_sptr self) → int
frequency_modulator_fc_sptr.declare_sample_delay(frequency_modulator_fc_sptr self, int which, int delay)

declare_sample_delay(frequency_modulator_fc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(frequency_modulator_fc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(frequency_modulator_fc_sptr self) -> pmt_vector_float

frequency_modulator_fc_sptr.pc_throughput_avg(frequency_modulator_fc_sptr self) → float
frequency_modulator_fc_sptr.pc_work_time_avg(frequency_modulator_fc_sptr self) → float
frequency_modulator_fc_sptr.pc_work_time_total(frequency_modulator_fc_sptr self) → float
frequency_modulator_fc_sptr.sample_delay(frequency_modulator_fc_sptr self, int which) → unsigned int
frequency_modulator_fc_sptr.sensitivity(frequency_modulator_fc_sptr self) → float
frequency_modulator_fc_sptr.set_min_noutput_items(frequency_modulator_fc_sptr self, int m)
frequency_modulator_fc_sptr.set_sensitivity(frequency_modulator_fc_sptr self, float sens)
frequency_modulator_fc_sptr.set_thread_priority(frequency_modulator_fc_sptr self, int priority) → int
frequency_modulator_fc_sptr.thread_priority(frequency_modulator_fc_sptr self) → int
gnuradio.analog.noise_source_c(gr::analog::noise_type_t type, float ampl, long seed=0) → noise_source_c_sptr
noise_source_c_sptr.active_thread_priority(noise_source_c_sptr self) → int
noise_source_c_sptr.amplitude(noise_source_c_sptr self) → float
noise_source_c_sptr.declare_sample_delay(noise_source_c_sptr self, int which, int delay)

declare_sample_delay(noise_source_c_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(noise_source_c_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(noise_source_c_sptr self) -> pmt_vector_float

noise_source_c_sptr.pc_throughput_avg(noise_source_c_sptr self) → float
noise_source_c_sptr.pc_work_time_avg(noise_source_c_sptr self) → float
noise_source_c_sptr.pc_work_time_total(noise_source_c_sptr self) → float
noise_source_c_sptr.sample_delay(noise_source_c_sptr self, int which) → unsigned int
noise_source_c_sptr.set_amplitude(noise_source_c_sptr self, float ampl)
noise_source_c_sptr.set_min_noutput_items(noise_source_c_sptr self, int m)
noise_source_c_sptr.set_thread_priority(noise_source_c_sptr self, int priority) → int
noise_source_c_sptr.set_type(noise_source_c_sptr self, gr::analog::noise_type_t type)
noise_source_c_sptr.thread_priority(noise_source_c_sptr self) → int
gnuradio.analog.noise_source_f(gr::analog::noise_type_t type, float ampl, long seed=0) → noise_source_f_sptr
noise_source_f_sptr.active_thread_priority(noise_source_f_sptr self) → int
noise_source_f_sptr.amplitude(noise_source_f_sptr self) → float
noise_source_f_sptr.declare_sample_delay(noise_source_f_sptr self, int which, int delay)

declare_sample_delay(noise_source_f_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(noise_source_f_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(noise_source_f_sptr self) -> pmt_vector_float

noise_source_f_sptr.pc_throughput_avg(noise_source_f_sptr self) → float
noise_source_f_sptr.pc_work_time_avg(noise_source_f_sptr self) → float
noise_source_f_sptr.pc_work_time_total(noise_source_f_sptr self) → float
noise_source_f_sptr.sample_delay(noise_source_f_sptr self, int which) → unsigned int
noise_source_f_sptr.set_amplitude(noise_source_f_sptr self, float ampl)
noise_source_f_sptr.set_min_noutput_items(noise_source_f_sptr self, int m)
noise_source_f_sptr.set_thread_priority(noise_source_f_sptr self, int priority) → int
noise_source_f_sptr.set_type(noise_source_f_sptr self, gr::analog::noise_type_t type)
noise_source_f_sptr.thread_priority(noise_source_f_sptr self) → int
gnuradio.analog.noise_source_i(gr::analog::noise_type_t type, float ampl, long seed=0) → noise_source_i_sptr
noise_source_i_sptr.active_thread_priority(noise_source_i_sptr self) → int
noise_source_i_sptr.amplitude(noise_source_i_sptr self) → float
noise_source_i_sptr.declare_sample_delay(noise_source_i_sptr self, int which, int delay)

declare_sample_delay(noise_source_i_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(noise_source_i_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(noise_source_i_sptr self) -> pmt_vector_float

noise_source_i_sptr.pc_throughput_avg(noise_source_i_sptr self) → float
noise_source_i_sptr.pc_work_time_avg(noise_source_i_sptr self) → float
noise_source_i_sptr.pc_work_time_total(noise_source_i_sptr self) → float
noise_source_i_sptr.sample_delay(noise_source_i_sptr self, int which) → unsigned int
noise_source_i_sptr.set_amplitude(noise_source_i_sptr self, float ampl)
noise_source_i_sptr.set_min_noutput_items(noise_source_i_sptr self, int m)
noise_source_i_sptr.set_thread_priority(noise_source_i_sptr self, int priority) → int
noise_source_i_sptr.set_type(noise_source_i_sptr self, gr::analog::noise_type_t type)
noise_source_i_sptr.thread_priority(noise_source_i_sptr self) → int
gnuradio.analog.noise_source_s(gr::analog::noise_type_t type, float ampl, long seed=0) → noise_source_s_sptr
noise_source_s_sptr.active_thread_priority(noise_source_s_sptr self) → int
noise_source_s_sptr.amplitude(noise_source_s_sptr self) → float
noise_source_s_sptr.declare_sample_delay(noise_source_s_sptr self, int which, int delay)

declare_sample_delay(noise_source_s_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(noise_source_s_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(noise_source_s_sptr self) -> pmt_vector_float

noise_source_s_sptr.pc_throughput_avg(noise_source_s_sptr self) → float
noise_source_s_sptr.pc_work_time_avg(noise_source_s_sptr self) → float
noise_source_s_sptr.pc_work_time_total(noise_source_s_sptr self) → float
noise_source_s_sptr.sample_delay(noise_source_s_sptr self, int which) → unsigned int
noise_source_s_sptr.set_amplitude(noise_source_s_sptr self, float ampl)
noise_source_s_sptr.set_min_noutput_items(noise_source_s_sptr self, int m)
noise_source_s_sptr.set_thread_priority(noise_source_s_sptr self, int priority) → int
noise_source_s_sptr.set_type(noise_source_s_sptr self, gr::analog::noise_type_t type)
noise_source_s_sptr.thread_priority(noise_source_s_sptr self) → int
gnuradio.analog.phase_modulator_fc(double sensitivity) → phase_modulator_fc_sptr
phase_modulator_fc_sptr.active_thread_priority(phase_modulator_fc_sptr self) → int
phase_modulator_fc_sptr.declare_sample_delay(phase_modulator_fc_sptr self, int which, int delay)

declare_sample_delay(phase_modulator_fc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(phase_modulator_fc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(phase_modulator_fc_sptr self) -> pmt_vector_float

phase_modulator_fc_sptr.pc_throughput_avg(phase_modulator_fc_sptr self) → float
phase_modulator_fc_sptr.pc_work_time_avg(phase_modulator_fc_sptr self) → float
phase_modulator_fc_sptr.pc_work_time_total(phase_modulator_fc_sptr self) → float
phase_modulator_fc_sptr.phase(phase_modulator_fc_sptr self) → double
phase_modulator_fc_sptr.sample_delay(phase_modulator_fc_sptr self, int which) → unsigned int
phase_modulator_fc_sptr.sensitivity(phase_modulator_fc_sptr self) → double
phase_modulator_fc_sptr.set_min_noutput_items(phase_modulator_fc_sptr self, int m)
phase_modulator_fc_sptr.set_phase(phase_modulator_fc_sptr self, double p)
phase_modulator_fc_sptr.set_sensitivity(phase_modulator_fc_sptr self, double s)
phase_modulator_fc_sptr.set_thread_priority(phase_modulator_fc_sptr self, int priority) → int
phase_modulator_fc_sptr.thread_priority(phase_modulator_fc_sptr self) → int
gnuradio.analog.pll_carriertracking_cc(float loop_bw, float max_freq, float min_freq) → pll_carriertracking_cc_sptr
pll_carriertracking_cc_sptr.active_thread_priority(pll_carriertracking_cc_sptr self) → int
pll_carriertracking_cc_sptr.advance_loop(pll_carriertracking_cc_sptr self, float error)
pll_carriertracking_cc_sptr.declare_sample_delay(pll_carriertracking_cc_sptr self, int which, int delay)

declare_sample_delay(pll_carriertracking_cc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(pll_carriertracking_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(pll_carriertracking_cc_sptr self) -> pmt_vector_float

pll_carriertracking_cc_sptr.pc_throughput_avg(pll_carriertracking_cc_sptr self) → float
pll_carriertracking_cc_sptr.pc_work_time_avg(pll_carriertracking_cc_sptr self) → float
pll_carriertracking_cc_sptr.pc_work_time_total(pll_carriertracking_cc_sptr self) → float
pll_carriertracking_cc_sptr.phase_wrap(pll_carriertracking_cc_sptr self)
pll_carriertracking_cc_sptr.sample_delay(pll_carriertracking_cc_sptr self, int which) → unsigned int
pll_carriertracking_cc_sptr.set_alpha(pll_carriertracking_cc_sptr self, float alpha)
pll_carriertracking_cc_sptr.set_beta(pll_carriertracking_cc_sptr self, float beta)
pll_carriertracking_cc_sptr.set_damping_factor(pll_carriertracking_cc_sptr self, float df)
pll_carriertracking_cc_sptr.set_frequency(pll_carriertracking_cc_sptr self, float freq)
pll_carriertracking_cc_sptr.set_lock_threshold(pll_carriertracking_cc_sptr self, float arg2) → float
pll_carriertracking_cc_sptr.set_loop_bandwidth(pll_carriertracking_cc_sptr self, float bw)
pll_carriertracking_cc_sptr.set_max_freq(pll_carriertracking_cc_sptr self, float freq)
pll_carriertracking_cc_sptr.set_min_freq(pll_carriertracking_cc_sptr self, float freq)
pll_carriertracking_cc_sptr.set_min_noutput_items(pll_carriertracking_cc_sptr self, int m)
pll_carriertracking_cc_sptr.set_phase(pll_carriertracking_cc_sptr self, float phase)
pll_carriertracking_cc_sptr.set_thread_priority(pll_carriertracking_cc_sptr self, int priority) → int
pll_carriertracking_cc_sptr.squelch_enable(pll_carriertracking_cc_sptr self, bool arg2) → bool
pll_carriertracking_cc_sptr.thread_priority(pll_carriertracking_cc_sptr self) → int
pll_carriertracking_cc_sptr.update_gains(pll_carriertracking_cc_sptr self)
gnuradio.analog.pll_freqdet_cf(float loop_bw, float max_freq, float min_freq) → pll_freqdet_cf_sptr
pll_freqdet_cf_sptr.active_thread_priority(pll_freqdet_cf_sptr self) → int
pll_freqdet_cf_sptr.advance_loop(pll_freqdet_cf_sptr self, float error)
pll_freqdet_cf_sptr.declare_sample_delay(pll_freqdet_cf_sptr self, int which, int delay)

declare_sample_delay(pll_freqdet_cf_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(pll_freqdet_cf_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(pll_freqdet_cf_sptr self) -> pmt_vector_float

pll_freqdet_cf_sptr.pc_throughput_avg(pll_freqdet_cf_sptr self) → float
pll_freqdet_cf_sptr.pc_work_time_avg(pll_freqdet_cf_sptr self) → float
pll_freqdet_cf_sptr.pc_work_time_total(pll_freqdet_cf_sptr self) → float
pll_freqdet_cf_sptr.phase_wrap(pll_freqdet_cf_sptr self)
pll_freqdet_cf_sptr.sample_delay(pll_freqdet_cf_sptr self, int which) → unsigned int
pll_freqdet_cf_sptr.set_alpha(pll_freqdet_cf_sptr self, float alpha)
pll_freqdet_cf_sptr.set_beta(pll_freqdet_cf_sptr self, float beta)
pll_freqdet_cf_sptr.set_damping_factor(pll_freqdet_cf_sptr self, float df)
pll_freqdet_cf_sptr.set_frequency(pll_freqdet_cf_sptr self, float freq)
pll_freqdet_cf_sptr.set_loop_bandwidth(pll_freqdet_cf_sptr self, float bw)
pll_freqdet_cf_sptr.set_max_freq(pll_freqdet_cf_sptr self, float freq)
pll_freqdet_cf_sptr.set_min_freq(pll_freqdet_cf_sptr self, float freq)
pll_freqdet_cf_sptr.set_min_noutput_items(pll_freqdet_cf_sptr self, int m)
pll_freqdet_cf_sptr.set_phase(pll_freqdet_cf_sptr self, float phase)
pll_freqdet_cf_sptr.set_thread_priority(pll_freqdet_cf_sptr self, int priority) → int
pll_freqdet_cf_sptr.thread_priority(pll_freqdet_cf_sptr self) → int
pll_freqdet_cf_sptr.update_gains(pll_freqdet_cf_sptr self)
gnuradio.analog.pll_refout_cc(float loop_bw, float max_freq, float min_freq) → pll_refout_cc_sptr
pll_refout_cc_sptr.active_thread_priority(pll_refout_cc_sptr self) → int
pll_refout_cc_sptr.advance_loop(pll_refout_cc_sptr self, float error)
pll_refout_cc_sptr.declare_sample_delay(pll_refout_cc_sptr self, int which, int delay)

declare_sample_delay(pll_refout_cc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(pll_refout_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(pll_refout_cc_sptr self) -> pmt_vector_float

pll_refout_cc_sptr.pc_throughput_avg(pll_refout_cc_sptr self) → float
pll_refout_cc_sptr.pc_work_time_avg(pll_refout_cc_sptr self) → float
pll_refout_cc_sptr.pc_work_time_total(pll_refout_cc_sptr self) → float
pll_refout_cc_sptr.phase_wrap(pll_refout_cc_sptr self)
pll_refout_cc_sptr.sample_delay(pll_refout_cc_sptr self, int which) → unsigned int
pll_refout_cc_sptr.set_alpha(pll_refout_cc_sptr self, float alpha)
pll_refout_cc_sptr.set_beta(pll_refout_cc_sptr self, float beta)
pll_refout_cc_sptr.set_damping_factor(pll_refout_cc_sptr self, float df)
pll_refout_cc_sptr.set_frequency(pll_refout_cc_sptr self, float freq)
pll_refout_cc_sptr.set_loop_bandwidth(pll_refout_cc_sptr self, float bw)
pll_refout_cc_sptr.set_max_freq(pll_refout_cc_sptr self, float freq)
pll_refout_cc_sptr.set_min_freq(pll_refout_cc_sptr self, float freq)
pll_refout_cc_sptr.set_min_noutput_items(pll_refout_cc_sptr self, int m)
pll_refout_cc_sptr.set_phase(pll_refout_cc_sptr self, float phase)
pll_refout_cc_sptr.set_thread_priority(pll_refout_cc_sptr self, int priority) → int
pll_refout_cc_sptr.thread_priority(pll_refout_cc_sptr self) → int
pll_refout_cc_sptr.update_gains(pll_refout_cc_sptr self)
gnuradio.analog.probe_avg_mag_sqrd_c(double threshold_db, double alpha=0.0001) → probe_avg_mag_sqrd_c_sptr
probe_avg_mag_sqrd_c_sptr.active_thread_priority(probe_avg_mag_sqrd_c_sptr self) → int
probe_avg_mag_sqrd_c_sptr.declare_sample_delay(probe_avg_mag_sqrd_c_sptr self, int which, int delay)

declare_sample_delay(probe_avg_mag_sqrd_c_sptr self, unsigned int delay)

probe_avg_mag_sqrd_c_sptr.level(probe_avg_mag_sqrd_c_sptr self) → double
probe_avg_mag_sqrd_c_sptr.message_subscribers(probe_avg_mag_sqrd_c_sptr self, swig_int_ptr which_port) → swig_int_ptr
probe_avg_mag_sqrd_c_sptr.min_noutput_items(probe_avg_mag_sqrd_c_sptr self) → int
probe_avg_mag_sqrd_c_sptr.pc_input_buffers_full_avg(probe_avg_mag_sqrd_c_sptr self, int which) → float

pc_input_buffers_full_avg(probe_avg_mag_sqrd_c_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(probe_avg_mag_sqrd_c_sptr self) -> pmt_vector_float

probe_avg_mag_sqrd_c_sptr.pc_throughput_avg(probe_avg_mag_sqrd_c_sptr self) → float
probe_avg_mag_sqrd_c_sptr.pc_work_time_avg(probe_avg_mag_sqrd_c_sptr self) → float
probe_avg_mag_sqrd_c_sptr.pc_work_time_total(probe_avg_mag_sqrd_c_sptr self) → float
probe_avg_mag_sqrd_c_sptr.reset(probe_avg_mag_sqrd_c_sptr self)
probe_avg_mag_sqrd_c_sptr.sample_delay(probe_avg_mag_sqrd_c_sptr self, int which) → unsigned int
probe_avg_mag_sqrd_c_sptr.set_alpha(probe_avg_mag_sqrd_c_sptr self, double alpha)
probe_avg_mag_sqrd_c_sptr.set_min_noutput_items(probe_avg_mag_sqrd_c_sptr self, int m)
probe_avg_mag_sqrd_c_sptr.set_thread_priority(probe_avg_mag_sqrd_c_sptr self, int priority) → int
probe_avg_mag_sqrd_c_sptr.set_threshold(probe_avg_mag_sqrd_c_sptr self, double decibels)
probe_avg_mag_sqrd_c_sptr.thread_priority(probe_avg_mag_sqrd_c_sptr self) → int
probe_avg_mag_sqrd_c_sptr.threshold(probe_avg_mag_sqrd_c_sptr self) → double
probe_avg_mag_sqrd_c_sptr.unmuted(probe_avg_mag_sqrd_c_sptr self) → bool
gnuradio.analog.probe_avg_mag_sqrd_cf(double threshold_db, double alpha=0.0001) → probe_avg_mag_sqrd_cf_sptr
probe_avg_mag_sqrd_cf_sptr.active_thread_priority(probe_avg_mag_sqrd_cf_sptr self) → int
probe_avg_mag_sqrd_cf_sptr.declare_sample_delay(probe_avg_mag_sqrd_cf_sptr self, int which, int delay)

declare_sample_delay(probe_avg_mag_sqrd_cf_sptr self, unsigned int delay)

probe_avg_mag_sqrd_cf_sptr.level(probe_avg_mag_sqrd_cf_sptr self) → double
probe_avg_mag_sqrd_cf_sptr.message_subscribers(probe_avg_mag_sqrd_cf_sptr self, swig_int_ptr which_port) → swig_int_ptr
probe_avg_mag_sqrd_cf_sptr.min_noutput_items(probe_avg_mag_sqrd_cf_sptr self) → int
probe_avg_mag_sqrd_cf_sptr.pc_input_buffers_full_avg(probe_avg_mag_sqrd_cf_sptr self, int which) → float

pc_input_buffers_full_avg(probe_avg_mag_sqrd_cf_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(probe_avg_mag_sqrd_cf_sptr self) -> pmt_vector_float

probe_avg_mag_sqrd_cf_sptr.pc_throughput_avg(probe_avg_mag_sqrd_cf_sptr self) → float
probe_avg_mag_sqrd_cf_sptr.pc_work_time_avg(probe_avg_mag_sqrd_cf_sptr self) → float
probe_avg_mag_sqrd_cf_sptr.pc_work_time_total(probe_avg_mag_sqrd_cf_sptr self) → float
probe_avg_mag_sqrd_cf_sptr.reset(probe_avg_mag_sqrd_cf_sptr self)
probe_avg_mag_sqrd_cf_sptr.sample_delay(probe_avg_mag_sqrd_cf_sptr self, int which) → unsigned int
probe_avg_mag_sqrd_cf_sptr.set_alpha(probe_avg_mag_sqrd_cf_sptr self, double alpha)
probe_avg_mag_sqrd_cf_sptr.set_min_noutput_items(probe_avg_mag_sqrd_cf_sptr self, int m)
probe_avg_mag_sqrd_cf_sptr.set_thread_priority(probe_avg_mag_sqrd_cf_sptr self, int priority) → int
probe_avg_mag_sqrd_cf_sptr.set_threshold(probe_avg_mag_sqrd_cf_sptr self, double decibels)
probe_avg_mag_sqrd_cf_sptr.thread_priority(probe_avg_mag_sqrd_cf_sptr self) → int
probe_avg_mag_sqrd_cf_sptr.threshold(probe_avg_mag_sqrd_cf_sptr self) → double
probe_avg_mag_sqrd_cf_sptr.unmuted(probe_avg_mag_sqrd_cf_sptr self) → bool
gnuradio.analog.probe_avg_mag_sqrd_f(double threshold_db, double alpha=0.0001) → probe_avg_mag_sqrd_f_sptr
probe_avg_mag_sqrd_f_sptr.active_thread_priority(probe_avg_mag_sqrd_f_sptr self) → int
probe_avg_mag_sqrd_f_sptr.declare_sample_delay(probe_avg_mag_sqrd_f_sptr self, int which, int delay)

declare_sample_delay(probe_avg_mag_sqrd_f_sptr self, unsigned int delay)

probe_avg_mag_sqrd_f_sptr.level(probe_avg_mag_sqrd_f_sptr self) → double
probe_avg_mag_sqrd_f_sptr.message_subscribers(probe_avg_mag_sqrd_f_sptr self, swig_int_ptr which_port) → swig_int_ptr
probe_avg_mag_sqrd_f_sptr.min_noutput_items(probe_avg_mag_sqrd_f_sptr self) → int
probe_avg_mag_sqrd_f_sptr.pc_input_buffers_full_avg(probe_avg_mag_sqrd_f_sptr self, int which) → float

pc_input_buffers_full_avg(probe_avg_mag_sqrd_f_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(probe_avg_mag_sqrd_f_sptr self) -> pmt_vector_float

probe_avg_mag_sqrd_f_sptr.pc_throughput_avg(probe_avg_mag_sqrd_f_sptr self) → float
probe_avg_mag_sqrd_f_sptr.pc_work_time_avg(probe_avg_mag_sqrd_f_sptr self) → float
probe_avg_mag_sqrd_f_sptr.pc_work_time_total(probe_avg_mag_sqrd_f_sptr self) → float
probe_avg_mag_sqrd_f_sptr.reset(probe_avg_mag_sqrd_f_sptr self)
probe_avg_mag_sqrd_f_sptr.sample_delay(probe_avg_mag_sqrd_f_sptr self, int which) → unsigned int
probe_avg_mag_sqrd_f_sptr.set_alpha(probe_avg_mag_sqrd_f_sptr self, double alpha)
probe_avg_mag_sqrd_f_sptr.set_min_noutput_items(probe_avg_mag_sqrd_f_sptr self, int m)
probe_avg_mag_sqrd_f_sptr.set_thread_priority(probe_avg_mag_sqrd_f_sptr self, int priority) → int
probe_avg_mag_sqrd_f_sptr.set_threshold(probe_avg_mag_sqrd_f_sptr self, double decibels)
probe_avg_mag_sqrd_f_sptr.thread_priority(probe_avg_mag_sqrd_f_sptr self) → int
probe_avg_mag_sqrd_f_sptr.threshold(probe_avg_mag_sqrd_f_sptr self) → double
probe_avg_mag_sqrd_f_sptr.unmuted(probe_avg_mag_sqrd_f_sptr self) → bool
gnuradio.analog.pwr_squelch_cc(double db, double alpha=0.0001, int ramp=0, bool gate=False) → pwr_squelch_cc_sptr
pwr_squelch_cc_sptr.active_thread_priority(pwr_squelch_cc_sptr self) → int
pwr_squelch_cc_sptr.declare_sample_delay(pwr_squelch_cc_sptr self, int which, int delay)

declare_sample_delay(pwr_squelch_cc_sptr self, unsigned int delay)

pwr_squelch_cc_sptr.gate(pwr_squelch_cc_sptr self) → bool
pwr_squelch_cc_sptr.message_subscribers(pwr_squelch_cc_sptr self, swig_int_ptr which_port) → swig_int_ptr
pwr_squelch_cc_sptr.min_noutput_items(pwr_squelch_cc_sptr self) → int
pwr_squelch_cc_sptr.pc_input_buffers_full_avg(pwr_squelch_cc_sptr self, int which) → float

pc_input_buffers_full_avg(pwr_squelch_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(pwr_squelch_cc_sptr self) -> pmt_vector_float

pwr_squelch_cc_sptr.pc_throughput_avg(pwr_squelch_cc_sptr self) → float
pwr_squelch_cc_sptr.pc_work_time_avg(pwr_squelch_cc_sptr self) → float
pwr_squelch_cc_sptr.pc_work_time_total(pwr_squelch_cc_sptr self) → float
pwr_squelch_cc_sptr.ramp(pwr_squelch_cc_sptr self) → int
pwr_squelch_cc_sptr.sample_delay(pwr_squelch_cc_sptr self, int which) → unsigned int
pwr_squelch_cc_sptr.set_alpha(pwr_squelch_cc_sptr self, double alpha)
pwr_squelch_cc_sptr.set_gate(pwr_squelch_cc_sptr self, bool gate)
pwr_squelch_cc_sptr.set_min_noutput_items(pwr_squelch_cc_sptr self, int m)
pwr_squelch_cc_sptr.set_ramp(pwr_squelch_cc_sptr self, int ramp)
pwr_squelch_cc_sptr.set_thread_priority(pwr_squelch_cc_sptr self, int priority) → int
pwr_squelch_cc_sptr.set_threshold(pwr_squelch_cc_sptr self, double db)
pwr_squelch_cc_sptr.squelch_range(pwr_squelch_cc_sptr self) → pmt_vector_float
pwr_squelch_cc_sptr.thread_priority(pwr_squelch_cc_sptr self) → int
pwr_squelch_cc_sptr.threshold(pwr_squelch_cc_sptr self) → double
pwr_squelch_cc_sptr.unmuted(pwr_squelch_cc_sptr self) → bool
gnuradio.analog.pwr_squelch_ff(double db, double alpha=0.0001, int ramp=0, bool gate=False) → pwr_squelch_ff_sptr
pwr_squelch_ff_sptr.active_thread_priority(pwr_squelch_ff_sptr self) → int
pwr_squelch_ff_sptr.declare_sample_delay(pwr_squelch_ff_sptr self, int which, int delay)

declare_sample_delay(pwr_squelch_ff_sptr self, unsigned int delay)

pwr_squelch_ff_sptr.gate(pwr_squelch_ff_sptr self) → bool
pwr_squelch_ff_sptr.message_subscribers(pwr_squelch_ff_sptr self, swig_int_ptr which_port) → swig_int_ptr
pwr_squelch_ff_sptr.min_noutput_items(pwr_squelch_ff_sptr self) → int
pwr_squelch_ff_sptr.pc_input_buffers_full_avg(pwr_squelch_ff_sptr self, int which) → float

pc_input_buffers_full_avg(pwr_squelch_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(pwr_squelch_ff_sptr self) -> pmt_vector_float

pwr_squelch_ff_sptr.pc_throughput_avg(pwr_squelch_ff_sptr self) → float
pwr_squelch_ff_sptr.pc_work_time_avg(pwr_squelch_ff_sptr self) → float
pwr_squelch_ff_sptr.pc_work_time_total(pwr_squelch_ff_sptr self) → float
pwr_squelch_ff_sptr.ramp(pwr_squelch_ff_sptr self) → int
pwr_squelch_ff_sptr.sample_delay(pwr_squelch_ff_sptr self, int which) → unsigned int
pwr_squelch_ff_sptr.set_alpha(pwr_squelch_ff_sptr self, double alpha)
pwr_squelch_ff_sptr.set_gate(pwr_squelch_ff_sptr self, bool gate)
pwr_squelch_ff_sptr.set_min_noutput_items(pwr_squelch_ff_sptr self, int m)
pwr_squelch_ff_sptr.set_ramp(pwr_squelch_ff_sptr self, int ramp)
pwr_squelch_ff_sptr.set_thread_priority(pwr_squelch_ff_sptr self, int priority) → int
pwr_squelch_ff_sptr.set_threshold(pwr_squelch_ff_sptr self, double db)
pwr_squelch_ff_sptr.squelch_range(pwr_squelch_ff_sptr self) → pmt_vector_float
pwr_squelch_ff_sptr.thread_priority(pwr_squelch_ff_sptr self) → int
pwr_squelch_ff_sptr.threshold(pwr_squelch_ff_sptr self) → double
pwr_squelch_ff_sptr.unmuted(pwr_squelch_ff_sptr self) → bool
gnuradio.analog.quadrature_demod_cf(float gain) → quadrature_demod_cf_sptr
quadrature_demod_cf_sptr.active_thread_priority(quadrature_demod_cf_sptr self) → int
quadrature_demod_cf_sptr.declare_sample_delay(quadrature_demod_cf_sptr self, int which, int delay)

declare_sample_delay(quadrature_demod_cf_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(quadrature_demod_cf_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(quadrature_demod_cf_sptr self) -> pmt_vector_float

quadrature_demod_cf_sptr.pc_throughput_avg(quadrature_demod_cf_sptr self) → float
quadrature_demod_cf_sptr.pc_work_time_avg(quadrature_demod_cf_sptr self) → float
quadrature_demod_cf_sptr.pc_work_time_total(quadrature_demod_cf_sptr self) → float
quadrature_demod_cf_sptr.sample_delay(quadrature_demod_cf_sptr self, int which) → unsigned int
quadrature_demod_cf_sptr.set_gain(quadrature_demod_cf_sptr self, float gain)
quadrature_demod_cf_sptr.set_min_noutput_items(quadrature_demod_cf_sptr self, int m)
quadrature_demod_cf_sptr.set_thread_priority(quadrature_demod_cf_sptr self, int priority) → int
quadrature_demod_cf_sptr.thread_priority(quadrature_demod_cf_sptr self) → int
gnuradio.analog.rail_ff(float lo, float hi) → rail_ff_sptr
rail_ff_sptr.active_thread_priority(rail_ff_sptr self) → int
rail_ff_sptr.declare_sample_delay(rail_ff_sptr self, int which, int delay)

declare_sample_delay(rail_ff_sptr self, unsigned int delay)

rail_ff_sptr.hi(rail_ff_sptr self) → float
rail_ff_sptr.lo(rail_ff_sptr self) → float
rail_ff_sptr.message_subscribers(rail_ff_sptr self, swig_int_ptr which_port) → swig_int_ptr
rail_ff_sptr.min_noutput_items(rail_ff_sptr self) → int
rail_ff_sptr.pc_input_buffers_full_avg(rail_ff_sptr self, int which) → float

pc_input_buffers_full_avg(rail_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(rail_ff_sptr self) -> pmt_vector_float

rail_ff_sptr.pc_throughput_avg(rail_ff_sptr self) → float
rail_ff_sptr.pc_work_time_avg(rail_ff_sptr self) → float
rail_ff_sptr.pc_work_time_total(rail_ff_sptr self) → float
rail_ff_sptr.sample_delay(rail_ff_sptr self, int which) → unsigned int
rail_ff_sptr.set_hi(rail_ff_sptr self, float hi)
rail_ff_sptr.set_lo(rail_ff_sptr self, float lo)
rail_ff_sptr.set_min_noutput_items(rail_ff_sptr self, int m)
rail_ff_sptr.set_thread_priority(rail_ff_sptr self, int priority) → int
rail_ff_sptr.thread_priority(rail_ff_sptr self) → int
gnuradio.analog.sig_source_c(double sampling_freq, gr::analog::gr_waveform_t waveform, double wave_freq, double ampl, gr_complex offset=0) → sig_source_c_sptr
sig_source_c_sptr.active_thread_priority(sig_source_c_sptr self) → int
sig_source_c_sptr.amplitude(sig_source_c_sptr self) → double
sig_source_c_sptr.declare_sample_delay(sig_source_c_sptr self, int which, int delay)

declare_sample_delay(sig_source_c_sptr self, unsigned int delay)

sig_source_c_sptr.frequency(sig_source_c_sptr self) → double
sig_source_c_sptr.message_subscribers(sig_source_c_sptr self, swig_int_ptr which_port) → swig_int_ptr
sig_source_c_sptr.min_noutput_items(sig_source_c_sptr self) → int
sig_source_c_sptr.offset(sig_source_c_sptr self) → gr_complex
sig_source_c_sptr.pc_input_buffers_full_avg(sig_source_c_sptr self, int which) → float

pc_input_buffers_full_avg(sig_source_c_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(sig_source_c_sptr self) -> pmt_vector_float

sig_source_c_sptr.pc_throughput_avg(sig_source_c_sptr self) → float
sig_source_c_sptr.pc_work_time_avg(sig_source_c_sptr self) → float
sig_source_c_sptr.pc_work_time_total(sig_source_c_sptr self) → float
sig_source_c_sptr.sample_delay(sig_source_c_sptr self, int which) → unsigned int
sig_source_c_sptr.sampling_freq(sig_source_c_sptr self) → double
sig_source_c_sptr.set_amplitude(sig_source_c_sptr self, double ampl)
sig_source_c_sptr.set_frequency(sig_source_c_sptr self, double frequency)
sig_source_c_sptr.set_min_noutput_items(sig_source_c_sptr self, int m)
sig_source_c_sptr.set_offset(sig_source_c_sptr self, gr_complex offset)
sig_source_c_sptr.set_sampling_freq(sig_source_c_sptr self, double sampling_freq)
sig_source_c_sptr.set_thread_priority(sig_source_c_sptr self, int priority) → int
sig_source_c_sptr.set_waveform(sig_source_c_sptr self, gr::analog::gr_waveform_t waveform)
sig_source_c_sptr.thread_priority(sig_source_c_sptr self) → int
sig_source_c_sptr.waveform(sig_source_c_sptr self) → gr::analog::gr_waveform_t
gnuradio.analog.sig_source_f(double sampling_freq, gr::analog::gr_waveform_t waveform, double wave_freq, double ampl, float offset=0) → sig_source_f_sptr
sig_source_f_sptr.active_thread_priority(sig_source_f_sptr self) → int
sig_source_f_sptr.amplitude(sig_source_f_sptr self) → double
sig_source_f_sptr.declare_sample_delay(sig_source_f_sptr self, int which, int delay)

declare_sample_delay(sig_source_f_sptr self, unsigned int delay)

sig_source_f_sptr.frequency(sig_source_f_sptr self) → double
sig_source_f_sptr.message_subscribers(sig_source_f_sptr self, swig_int_ptr which_port) → swig_int_ptr
sig_source_f_sptr.min_noutput_items(sig_source_f_sptr self) → int
sig_source_f_sptr.offset(sig_source_f_sptr self) → float
sig_source_f_sptr.pc_input_buffers_full_avg(sig_source_f_sptr self, int which) → float

pc_input_buffers_full_avg(sig_source_f_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(sig_source_f_sptr self) -> pmt_vector_float

sig_source_f_sptr.pc_throughput_avg(sig_source_f_sptr self) → float
sig_source_f_sptr.pc_work_time_avg(sig_source_f_sptr self) → float
sig_source_f_sptr.pc_work_time_total(sig_source_f_sptr self) → float
sig_source_f_sptr.sample_delay(sig_source_f_sptr self, int which) → unsigned int
sig_source_f_sptr.sampling_freq(sig_source_f_sptr self) → double
sig_source_f_sptr.set_amplitude(sig_source_f_sptr self, double ampl)
sig_source_f_sptr.set_frequency(sig_source_f_sptr self, double frequency)
sig_source_f_sptr.set_min_noutput_items(sig_source_f_sptr self, int m)
sig_source_f_sptr.set_offset(sig_source_f_sptr self, float offset)
sig_source_f_sptr.set_sampling_freq(sig_source_f_sptr self, double sampling_freq)
sig_source_f_sptr.set_thread_priority(sig_source_f_sptr self, int priority) → int
sig_source_f_sptr.set_waveform(sig_source_f_sptr self, gr::analog::gr_waveform_t waveform)
sig_source_f_sptr.thread_priority(sig_source_f_sptr self) → int
sig_source_f_sptr.waveform(sig_source_f_sptr self) → gr::analog::gr_waveform_t
gnuradio.analog.sig_source_i(double sampling_freq, gr::analog::gr_waveform_t waveform, double wave_freq, double ampl, int offset=0) → sig_source_i_sptr
sig_source_i_sptr.active_thread_priority(sig_source_i_sptr self) → int
sig_source_i_sptr.amplitude(sig_source_i_sptr self) → double
sig_source_i_sptr.declare_sample_delay(sig_source_i_sptr self, int which, int delay)

declare_sample_delay(sig_source_i_sptr self, unsigned int delay)

sig_source_i_sptr.frequency(sig_source_i_sptr self) → double
sig_source_i_sptr.message_subscribers(sig_source_i_sptr self, swig_int_ptr which_port) → swig_int_ptr
sig_source_i_sptr.min_noutput_items(sig_source_i_sptr self) → int
sig_source_i_sptr.offset(sig_source_i_sptr self) → int
sig_source_i_sptr.pc_input_buffers_full_avg(sig_source_i_sptr self, int which) → float

pc_input_buffers_full_avg(sig_source_i_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(sig_source_i_sptr self) -> pmt_vector_float

sig_source_i_sptr.pc_throughput_avg(sig_source_i_sptr self) → float
sig_source_i_sptr.pc_work_time_avg(sig_source_i_sptr self) → float
sig_source_i_sptr.pc_work_time_total(sig_source_i_sptr self) → float
sig_source_i_sptr.sample_delay(sig_source_i_sptr self, int which) → unsigned int
sig_source_i_sptr.sampling_freq(sig_source_i_sptr self) → double
sig_source_i_sptr.set_amplitude(sig_source_i_sptr self, double ampl)
sig_source_i_sptr.set_frequency(sig_source_i_sptr self, double frequency)
sig_source_i_sptr.set_min_noutput_items(sig_source_i_sptr self, int m)
sig_source_i_sptr.set_offset(sig_source_i_sptr self, int offset)
sig_source_i_sptr.set_sampling_freq(sig_source_i_sptr self, double sampling_freq)
sig_source_i_sptr.set_thread_priority(sig_source_i_sptr self, int priority) → int
sig_source_i_sptr.set_waveform(sig_source_i_sptr self, gr::analog::gr_waveform_t waveform)
sig_source_i_sptr.thread_priority(sig_source_i_sptr self) → int
sig_source_i_sptr.waveform(sig_source_i_sptr self) → gr::analog::gr_waveform_t
gnuradio.analog.sig_source_s(double sampling_freq, gr::analog::gr_waveform_t waveform, double wave_freq, double ampl, short offset=0) → sig_source_s_sptr
sig_source_s_sptr.active_thread_priority(sig_source_s_sptr self) → int
sig_source_s_sptr.amplitude(sig_source_s_sptr self) → double
sig_source_s_sptr.declare_sample_delay(sig_source_s_sptr self, int which, int delay)

declare_sample_delay(sig_source_s_sptr self, unsigned int delay)

sig_source_s_sptr.frequency(sig_source_s_sptr self) → double
sig_source_s_sptr.message_subscribers(sig_source_s_sptr self, swig_int_ptr which_port) → swig_int_ptr
sig_source_s_sptr.min_noutput_items(sig_source_s_sptr self) → int
sig_source_s_sptr.offset(sig_source_s_sptr self) → short
sig_source_s_sptr.pc_input_buffers_full_avg(sig_source_s_sptr self, int which) → float

pc_input_buffers_full_avg(sig_source_s_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(sig_source_s_sptr self) -> pmt_vector_float

sig_source_s_sptr.pc_throughput_avg(sig_source_s_sptr self) → float
sig_source_s_sptr.pc_work_time_avg(sig_source_s_sptr self) → float
sig_source_s_sptr.pc_work_time_total(sig_source_s_sptr self) → float
sig_source_s_sptr.sample_delay(sig_source_s_sptr self, int which) → unsigned int
sig_source_s_sptr.sampling_freq(sig_source_s_sptr self) → double
sig_source_s_sptr.set_amplitude(sig_source_s_sptr self, double ampl)
sig_source_s_sptr.set_frequency(sig_source_s_sptr self, double frequency)
sig_source_s_sptr.set_min_noutput_items(sig_source_s_sptr self, int m)
sig_source_s_sptr.set_offset(sig_source_s_sptr self, short offset)
sig_source_s_sptr.set_sampling_freq(sig_source_s_sptr self, double sampling_freq)
sig_source_s_sptr.set_thread_priority(sig_source_s_sptr self, int priority) → int
sig_source_s_sptr.set_waveform(sig_source_s_sptr self, gr::analog::gr_waveform_t waveform)
sig_source_s_sptr.thread_priority(sig_source_s_sptr self) → int
sig_source_s_sptr.waveform(sig_source_s_sptr self) → gr::analog::gr_waveform_t
gnuradio.analog.simple_squelch_cc(double threshold_db, double alpha) → simple_squelch_cc_sptr
simple_squelch_cc_sptr.active_thread_priority(simple_squelch_cc_sptr self) → int
simple_squelch_cc_sptr.declare_sample_delay(simple_squelch_cc_sptr self, int which, int delay)

declare_sample_delay(simple_squelch_cc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(simple_squelch_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(simple_squelch_cc_sptr self) -> pmt_vector_float

simple_squelch_cc_sptr.pc_throughput_avg(simple_squelch_cc_sptr self) → float
simple_squelch_cc_sptr.pc_work_time_avg(simple_squelch_cc_sptr self) → float
simple_squelch_cc_sptr.pc_work_time_total(simple_squelch_cc_sptr self) → float
simple_squelch_cc_sptr.sample_delay(simple_squelch_cc_sptr self, int which) → unsigned int
simple_squelch_cc_sptr.set_alpha(simple_squelch_cc_sptr self, double alpha)
simple_squelch_cc_sptr.set_min_noutput_items(simple_squelch_cc_sptr self, int m)
simple_squelch_cc_sptr.set_thread_priority(simple_squelch_cc_sptr self, int priority) → int
simple_squelch_cc_sptr.set_threshold(simple_squelch_cc_sptr self, double decibels)
simple_squelch_cc_sptr.squelch_range(simple_squelch_cc_sptr self) → pmt_vector_float
simple_squelch_cc_sptr.thread_priority(simple_squelch_cc_sptr self) → int
simple_squelch_cc_sptr.threshold(simple_squelch_cc_sptr self) → double
simple_squelch_cc_sptr.unmuted(simple_squelch_cc_sptr self) → bool

Previous topic

gnuradio.audio

Next topic

gnuradio.blocks

This Page