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

Previous topic

gnuradio.blocks: Miscellaneous

Next topic

gnuradio.analog: Peak Detectors

This Page