gnuradio.analog: Level Controllers

gnuradio.analog.agc_cc(float rate=1e-4, float reference=1.0, float gain=1.0) → agc_cc_sptr

high performance Automatic Gain Control class

For Power the absolute value of the complex number is used.

Constructor Specific Documentation:

Build a complex value AGC loop block.

Parameters:

• rate – the update rate of the loop.
• reference – reference value to adjust signal power to.
• gain – initial gain value.

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.agc2_cc(float attack_rate=1e-1, float decay_rate=1e-2, float reference=1.0, float gain=1.0) → agc2_cc_sptr

high performance Automatic Gain Control class with attack and decay rates.

For Power the absolute value of the complex number is used.

Constructor Specific Documentation:

Build a complex value AGC loop block with attack and decay rates.

Parameters:

• attack_rate – the update rate of the loop when in attack mode.
• decay_rate – the update rate of the loop when in decay mode.
• reference – reference value to adjust signal power to.
• gain – initial gain value.

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

high performance Automatic Gain Control class with attack and decay rates.

Power is approximated by absolute value

Constructor Specific Documentation:

Build a floating point AGC loop block with attack and decay rates.

Parameters:

• attack_rate – the update rate of the loop when in attack mode.
• decay_rate – the update rate of the loop when in decay mode.
• reference – reference value to adjust signal power to.
• gain – initial gain value.

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.agc_ff(float rate=1e-4, float reference=1.0, float gain=1.0) → agc_ff_sptr

high performance Automatic Gain Control class

Power is approximated by absolute value

Constructor Specific Documentation:

Build a floating point AGC loop block.

Parameters:

• rate – the update rate of the loop.
• reference – reference value to adjust signal power to.
• gain – initial gain value.

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.ctcss_squelch_ff(int rate, float freq, float level, int len, int ramp, bool gate) → ctcss_squelch_ff_sptr

gate or zero output if CTCSS tone not present

Constructor Specific Documentation:

Make CTCSS tone squelch block.

Parameters:

• rate – gain of the internal frequency filters.
• freq – frequency value to use as the squelch tone.
• level – threshold level for the squelch tone.
• len – length of the frequency filters.
• ramp – sets response characteristic.
• gate – if true, no output if no squelch tone. if false, output 0’s if no squelch tone.

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.feedforward_agc_cc(int nsamples, float reference) → feedforward_agc_cc_sptr

Non-causal AGC which computes required gain based on max absolute value over nsamples.

Constructor Specific Documentation:

Build a complex valued feed-forward AGC loop block.

Parameters:

• nsamples – number of samples to look ahead.
• reference – reference value to adjust signal power to.

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.pwr_squelch_cc(double db, double alpha=0.0001, int ramp=0, bool gate=False) → pwr_squelch_cc_sptr

gate or zero output when input power below threshold

Constructor Specific Documentation:

Make power-based squelch block.

Parameters:

• db – threshold (in dB) for power squelch
• alpha – Gain of averaging filter
• ramp – sets response characteristic.
• gate – if true, no output if no squelch tone. if false, output 0’s if no squelch tone.

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

gate or zero output when input power below threshold

Constructor Specific Documentation:

Make power-based squelch block.

Parameters:

• db – threshold (in dB) for power squelch
• alpha – Gain of averaging filter
• ramp – sets response characteristic.
• gate – if true, no output if no squelch tone. if false, output 0’s if no squelch tone.

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.rail_ff(float lo, float hi) → rail_ff_sptr

clips input values to min, max

Constructor Specific Documentation:

Build a rail block.

Parameters:

• lo – the low value to clip to.
• hi – the high value to clip to.

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.simple_squelch_cc(double threshold_db, double alpha) → simple_squelch_cc_sptr

simple squelch block based on average signal power and threshold in dB.

Constructor Specific Documentation:

Make a simple squelch block.

Parameters:

• threshold_db – Threshold for muting.
• alpha – Gain parameter for the running average filter.

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