gnuradio.blocks: Level Controllers

gnuradio.blocks.moving_average_cc(int length, gr_complex scale, int max_iter=4096) → moving_average_cc_sptr

output is the moving sum of the last N samples, scaled by the scale factor

Constructor Specific Documentation:

Create a moving average block.

Parameters:
  • length – Number of samples to use in the average.
  • scale – scale factor for the result.
  • max_iter – limits how long we go without flushing the accumulator This is necessary to avoid numerical instability for float and complex.
moving_average_cc_sptr.active_thread_priority(moving_average_cc_sptr self) → int
moving_average_cc_sptr.declare_sample_delay(moving_average_cc_sptr self, int which, int delay)

declare_sample_delay(moving_average_cc_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(moving_average_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(moving_average_cc_sptr self) -> pmt_vector_float

moving_average_cc_sptr.pc_throughput_avg(moving_average_cc_sptr self) → float
moving_average_cc_sptr.pc_work_time_avg(moving_average_cc_sptr self) → float
moving_average_cc_sptr.pc_work_time_total(moving_average_cc_sptr self) → float
moving_average_cc_sptr.sample_delay(moving_average_cc_sptr self, int which) → unsigned int
moving_average_cc_sptr.scale(moving_average_cc_sptr self) → gr_complex

Get the scale factor being used.

moving_average_cc_sptr.set_length(moving_average_cc_sptr self, int length)

Set the length.

moving_average_cc_sptr.set_length_and_scale(moving_average_cc_sptr self, int length, gr_complex scale)

Set both the length and the scale factor together.

moving_average_cc_sptr.set_min_noutput_items(moving_average_cc_sptr self, int m)
moving_average_cc_sptr.set_scale(moving_average_cc_sptr self, gr_complex scale)

Set the scale factor.

moving_average_cc_sptr.set_thread_priority(moving_average_cc_sptr self, int priority) → int
moving_average_cc_sptr.thread_priority(moving_average_cc_sptr self) → int
gnuradio.blocks.moving_average_ff(int length, float scale, int max_iter=4096) → moving_average_ff_sptr

output is the moving sum of the last N samples, scaled by the scale factor

Constructor Specific Documentation:

Create a moving average block.

Parameters:
  • length – Number of samples to use in the average.
  • scale – scale factor for the result.
  • max_iter – limits how long we go without flushing the accumulator This is necessary to avoid numerical instability for float and complex.
moving_average_ff_sptr.active_thread_priority(moving_average_ff_sptr self) → int
moving_average_ff_sptr.declare_sample_delay(moving_average_ff_sptr self, int which, int delay)

declare_sample_delay(moving_average_ff_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(moving_average_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(moving_average_ff_sptr self) -> pmt_vector_float

moving_average_ff_sptr.pc_throughput_avg(moving_average_ff_sptr self) → float
moving_average_ff_sptr.pc_work_time_avg(moving_average_ff_sptr self) → float
moving_average_ff_sptr.pc_work_time_total(moving_average_ff_sptr self) → float
moving_average_ff_sptr.sample_delay(moving_average_ff_sptr self, int which) → unsigned int
moving_average_ff_sptr.scale(moving_average_ff_sptr self) → float

Get the scale factor being used.

moving_average_ff_sptr.set_length(moving_average_ff_sptr self, int length)

Set the length.

moving_average_ff_sptr.set_length_and_scale(moving_average_ff_sptr self, int length, float scale)

Set both the length and the scale factor together.

moving_average_ff_sptr.set_min_noutput_items(moving_average_ff_sptr self, int m)
moving_average_ff_sptr.set_scale(moving_average_ff_sptr self, float scale)

Set the scale factor.

moving_average_ff_sptr.set_thread_priority(moving_average_ff_sptr self, int priority) → int
moving_average_ff_sptr.thread_priority(moving_average_ff_sptr self) → int
gnuradio.blocks.moving_average_ii(int length, int scale, int max_iter=4096) → moving_average_ii_sptr

output is the moving sum of the last N samples, scaled by the scale factor

Constructor Specific Documentation:

Create a moving average block.

Parameters:
  • length – Number of samples to use in the average.
  • scale – scale factor for the result.
  • max_iter – limits how long we go without flushing the accumulator This is necessary to avoid numerical instability for float and complex.
moving_average_ii_sptr.active_thread_priority(moving_average_ii_sptr self) → int
moving_average_ii_sptr.declare_sample_delay(moving_average_ii_sptr self, int which, int delay)

declare_sample_delay(moving_average_ii_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(moving_average_ii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(moving_average_ii_sptr self) -> pmt_vector_float

moving_average_ii_sptr.pc_throughput_avg(moving_average_ii_sptr self) → float
moving_average_ii_sptr.pc_work_time_avg(moving_average_ii_sptr self) → float
moving_average_ii_sptr.pc_work_time_total(moving_average_ii_sptr self) → float
moving_average_ii_sptr.sample_delay(moving_average_ii_sptr self, int which) → unsigned int
moving_average_ii_sptr.scale(moving_average_ii_sptr self) → int

Get the scale factor being used.

moving_average_ii_sptr.set_length(moving_average_ii_sptr self, int length)

Set the length.

moving_average_ii_sptr.set_length_and_scale(moving_average_ii_sptr self, int length, int scale)

Set both the length and the scale factor together.

moving_average_ii_sptr.set_min_noutput_items(moving_average_ii_sptr self, int m)
moving_average_ii_sptr.set_scale(moving_average_ii_sptr self, int scale)

Set the scale factor.

moving_average_ii_sptr.set_thread_priority(moving_average_ii_sptr self, int priority) → int
moving_average_ii_sptr.thread_priority(moving_average_ii_sptr self) → int
gnuradio.blocks.moving_average_ss(int length, short scale, int max_iter=4096) → moving_average_ss_sptr

output is the moving sum of the last N samples, scaled by the scale factor

Constructor Specific Documentation:

Create a moving average block.

Parameters:
  • length – Number of samples to use in the average.
  • scale – scale factor for the result.
  • max_iter – limits how long we go without flushing the accumulator This is necessary to avoid numerical instability for float and complex.
moving_average_ss_sptr.active_thread_priority(moving_average_ss_sptr self) → int
moving_average_ss_sptr.declare_sample_delay(moving_average_ss_sptr self, int which, int delay)

declare_sample_delay(moving_average_ss_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(moving_average_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(moving_average_ss_sptr self) -> pmt_vector_float

moving_average_ss_sptr.pc_throughput_avg(moving_average_ss_sptr self) → float
moving_average_ss_sptr.pc_work_time_avg(moving_average_ss_sptr self) → float
moving_average_ss_sptr.pc_work_time_total(moving_average_ss_sptr self) → float
moving_average_ss_sptr.sample_delay(moving_average_ss_sptr self, int which) → unsigned int
moving_average_ss_sptr.scale(moving_average_ss_sptr self) → short

Get the scale factor being used.

moving_average_ss_sptr.set_length(moving_average_ss_sptr self, int length)

Set the length.

moving_average_ss_sptr.set_length_and_scale(moving_average_ss_sptr self, int length, short scale)

Set both the length and the scale factor together.

moving_average_ss_sptr.set_min_noutput_items(moving_average_ss_sptr self, int m)
moving_average_ss_sptr.set_scale(moving_average_ss_sptr self, short scale)

Set the scale factor.

moving_average_ss_sptr.set_thread_priority(moving_average_ss_sptr self, int priority) → int
moving_average_ss_sptr.thread_priority(moving_average_ss_sptr self) → int
gnuradio.blocks.mute_cc(bool mute=False) → mute_cc_sptr

output = input or zero if muted.

Constructor Specific Documentation:

Parameters:mute
mute_cc_sptr.active_thread_priority(mute_cc_sptr self) → int
mute_cc_sptr.declare_sample_delay(mute_cc_sptr self, int which, int delay)

declare_sample_delay(mute_cc_sptr self, unsigned int delay)

mute_cc_sptr.message_subscribers(mute_cc_sptr self, swig_int_ptr which_port) → swig_int_ptr
mute_cc_sptr.min_noutput_items(mute_cc_sptr self) → int
mute_cc_sptr.mute(mute_cc_sptr self) → bool
mute_cc_sptr.pc_input_buffers_full_avg(mute_cc_sptr self, int which) → float

pc_input_buffers_full_avg(mute_cc_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(mute_cc_sptr self) -> pmt_vector_float

mute_cc_sptr.pc_throughput_avg(mute_cc_sptr self) → float
mute_cc_sptr.pc_work_time_avg(mute_cc_sptr self) → float
mute_cc_sptr.pc_work_time_total(mute_cc_sptr self) → float
mute_cc_sptr.sample_delay(mute_cc_sptr self, int which) → unsigned int
mute_cc_sptr.set_min_noutput_items(mute_cc_sptr self, int m)
mute_cc_sptr.set_mute(mute_cc_sptr self, bool mute=False)
mute_cc_sptr.set_thread_priority(mute_cc_sptr self, int priority) → int
mute_cc_sptr.thread_priority(mute_cc_sptr self) → int
gnuradio.blocks.mute_ff(bool mute=False) → mute_ff_sptr

output = input or zero if muted.

Constructor Specific Documentation:

Parameters:mute
mute_ff_sptr.active_thread_priority(mute_ff_sptr self) → int
mute_ff_sptr.declare_sample_delay(mute_ff_sptr self, int which, int delay)

declare_sample_delay(mute_ff_sptr self, unsigned int delay)

mute_ff_sptr.message_subscribers(mute_ff_sptr self, swig_int_ptr which_port) → swig_int_ptr
mute_ff_sptr.min_noutput_items(mute_ff_sptr self) → int
mute_ff_sptr.mute(mute_ff_sptr self) → bool
mute_ff_sptr.pc_input_buffers_full_avg(mute_ff_sptr self, int which) → float

pc_input_buffers_full_avg(mute_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(mute_ff_sptr self) -> pmt_vector_float

mute_ff_sptr.pc_throughput_avg(mute_ff_sptr self) → float
mute_ff_sptr.pc_work_time_avg(mute_ff_sptr self) → float
mute_ff_sptr.pc_work_time_total(mute_ff_sptr self) → float
mute_ff_sptr.sample_delay(mute_ff_sptr self, int which) → unsigned int
mute_ff_sptr.set_min_noutput_items(mute_ff_sptr self, int m)
mute_ff_sptr.set_mute(mute_ff_sptr self, bool mute=False)
mute_ff_sptr.set_thread_priority(mute_ff_sptr self, int priority) → int
mute_ff_sptr.thread_priority(mute_ff_sptr self) → int
gnuradio.blocks.mute_ii(bool mute=False) → mute_ii_sptr

output = input or zero if muted.

Constructor Specific Documentation:

Parameters:mute
mute_ii_sptr.active_thread_priority(mute_ii_sptr self) → int
mute_ii_sptr.declare_sample_delay(mute_ii_sptr self, int which, int delay)

declare_sample_delay(mute_ii_sptr self, unsigned int delay)

mute_ii_sptr.message_subscribers(mute_ii_sptr self, swig_int_ptr which_port) → swig_int_ptr
mute_ii_sptr.min_noutput_items(mute_ii_sptr self) → int
mute_ii_sptr.mute(mute_ii_sptr self) → bool
mute_ii_sptr.pc_input_buffers_full_avg(mute_ii_sptr self, int which) → float

pc_input_buffers_full_avg(mute_ii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(mute_ii_sptr self) -> pmt_vector_float

mute_ii_sptr.pc_throughput_avg(mute_ii_sptr self) → float
mute_ii_sptr.pc_work_time_avg(mute_ii_sptr self) → float
mute_ii_sptr.pc_work_time_total(mute_ii_sptr self) → float
mute_ii_sptr.sample_delay(mute_ii_sptr self, int which) → unsigned int
mute_ii_sptr.set_min_noutput_items(mute_ii_sptr self, int m)
mute_ii_sptr.set_mute(mute_ii_sptr self, bool mute=False)
mute_ii_sptr.set_thread_priority(mute_ii_sptr self, int priority) → int
mute_ii_sptr.thread_priority(mute_ii_sptr self) → int
gnuradio.blocks.mute_ss(bool mute=False) → mute_ss_sptr

output = input or zero if muted.

Constructor Specific Documentation:

Parameters:mute
mute_ss_sptr.active_thread_priority(mute_ss_sptr self) → int
mute_ss_sptr.declare_sample_delay(mute_ss_sptr self, int which, int delay)

declare_sample_delay(mute_ss_sptr self, unsigned int delay)

mute_ss_sptr.message_subscribers(mute_ss_sptr self, swig_int_ptr which_port) → swig_int_ptr
mute_ss_sptr.min_noutput_items(mute_ss_sptr self) → int
mute_ss_sptr.mute(mute_ss_sptr self) → bool
mute_ss_sptr.pc_input_buffers_full_avg(mute_ss_sptr self, int which) → float

pc_input_buffers_full_avg(mute_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(mute_ss_sptr self) -> pmt_vector_float

mute_ss_sptr.pc_throughput_avg(mute_ss_sptr self) → float
mute_ss_sptr.pc_work_time_avg(mute_ss_sptr self) → float
mute_ss_sptr.pc_work_time_total(mute_ss_sptr self) → float
mute_ss_sptr.sample_delay(mute_ss_sptr self, int which) → unsigned int
mute_ss_sptr.set_min_noutput_items(mute_ss_sptr self, int m)
mute_ss_sptr.set_mute(mute_ss_sptr self, bool mute=False)
mute_ss_sptr.set_thread_priority(mute_ss_sptr self, int priority) → int
mute_ss_sptr.thread_priority(mute_ss_sptr self) → int
gnuradio.blocks.sample_and_hold_bb() → sample_and_hold_bb_sptr

sample and hold circuit

Samples the data stream (input stream 0) and holds the value if the control signal is 1 (intput stream 1).

Constructor Specific Documentation:

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

declare_sample_delay(sample_and_hold_bb_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(sample_and_hold_bb_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(sample_and_hold_bb_sptr self) -> pmt_vector_float

sample_and_hold_bb_sptr.pc_throughput_avg(sample_and_hold_bb_sptr self) → float
sample_and_hold_bb_sptr.pc_work_time_avg(sample_and_hold_bb_sptr self) → float
sample_and_hold_bb_sptr.pc_work_time_total(sample_and_hold_bb_sptr self) → float
sample_and_hold_bb_sptr.sample_delay(sample_and_hold_bb_sptr self, int which) → unsigned int
sample_and_hold_bb_sptr.set_min_noutput_items(sample_and_hold_bb_sptr self, int m)
sample_and_hold_bb_sptr.set_thread_priority(sample_and_hold_bb_sptr self, int priority) → int
sample_and_hold_bb_sptr.thread_priority(sample_and_hold_bb_sptr self) → int
gnuradio.blocks.sample_and_hold_ff() → sample_and_hold_ff_sptr

sample and hold circuit

Samples the data stream (input stream 0) and holds the value if the control signal is 1 (intput stream 1).

Constructor Specific Documentation:

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

declare_sample_delay(sample_and_hold_ff_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(sample_and_hold_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(sample_and_hold_ff_sptr self) -> pmt_vector_float

sample_and_hold_ff_sptr.pc_throughput_avg(sample_and_hold_ff_sptr self) → float
sample_and_hold_ff_sptr.pc_work_time_avg(sample_and_hold_ff_sptr self) → float
sample_and_hold_ff_sptr.pc_work_time_total(sample_and_hold_ff_sptr self) → float
sample_and_hold_ff_sptr.sample_delay(sample_and_hold_ff_sptr self, int which) → unsigned int
sample_and_hold_ff_sptr.set_min_noutput_items(sample_and_hold_ff_sptr self, int m)
sample_and_hold_ff_sptr.set_thread_priority(sample_and_hold_ff_sptr self, int priority) → int
sample_and_hold_ff_sptr.thread_priority(sample_and_hold_ff_sptr self) → int
gnuradio.blocks.sample_and_hold_ii() → sample_and_hold_ii_sptr

sample and hold circuit

Samples the data stream (input stream 0) and holds the value if the control signal is 1 (intput stream 1).

Constructor Specific Documentation:

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

declare_sample_delay(sample_and_hold_ii_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(sample_and_hold_ii_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(sample_and_hold_ii_sptr self) -> pmt_vector_float

sample_and_hold_ii_sptr.pc_throughput_avg(sample_and_hold_ii_sptr self) → float
sample_and_hold_ii_sptr.pc_work_time_avg(sample_and_hold_ii_sptr self) → float
sample_and_hold_ii_sptr.pc_work_time_total(sample_and_hold_ii_sptr self) → float
sample_and_hold_ii_sptr.sample_delay(sample_and_hold_ii_sptr self, int which) → unsigned int
sample_and_hold_ii_sptr.set_min_noutput_items(sample_and_hold_ii_sptr self, int m)
sample_and_hold_ii_sptr.set_thread_priority(sample_and_hold_ii_sptr self, int priority) → int
sample_and_hold_ii_sptr.thread_priority(sample_and_hold_ii_sptr self) → int
gnuradio.blocks.sample_and_hold_ss() → sample_and_hold_ss_sptr

sample and hold circuit

Samples the data stream (input stream 0) and holds the value if the control signal is 1 (intput stream 1).

Constructor Specific Documentation:

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

declare_sample_delay(sample_and_hold_ss_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(sample_and_hold_ss_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(sample_and_hold_ss_sptr self) -> pmt_vector_float

sample_and_hold_ss_sptr.pc_throughput_avg(sample_and_hold_ss_sptr self) → float
sample_and_hold_ss_sptr.pc_work_time_avg(sample_and_hold_ss_sptr self) → float
sample_and_hold_ss_sptr.pc_work_time_total(sample_and_hold_ss_sptr self) → float
sample_and_hold_ss_sptr.sample_delay(sample_and_hold_ss_sptr self, int which) → unsigned int
sample_and_hold_ss_sptr.set_min_noutput_items(sample_and_hold_ss_sptr self, int m)
sample_and_hold_ss_sptr.set_thread_priority(sample_and_hold_ss_sptr self, int priority) → int
sample_and_hold_ss_sptr.thread_priority(sample_and_hold_ss_sptr self) → int
gnuradio.blocks.threshold_ff(float lo, float hi, float initial_state=0) → threshold_ff_sptr

Output a 1 or zero based on a threshold value.

Test the incoming signal against a threshold. If the signal excedes the value, it will output a 1 until the signal falls below the value.

Constructor Specific Documentation:

Parameters:
  • lo
  • hi
  • initial_state
threshold_ff_sptr.active_thread_priority(threshold_ff_sptr self) → int
threshold_ff_sptr.declare_sample_delay(threshold_ff_sptr self, int which, int delay)

declare_sample_delay(threshold_ff_sptr self, unsigned int delay)

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

pc_input_buffers_full_avg(threshold_ff_sptr self) -> pmt_vector_float

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

pc_output_buffers_full_avg(threshold_ff_sptr self) -> pmt_vector_float

threshold_ff_sptr.pc_throughput_avg(threshold_ff_sptr self) → float
threshold_ff_sptr.pc_work_time_avg(threshold_ff_sptr self) → float
threshold_ff_sptr.pc_work_time_total(threshold_ff_sptr self) → float
threshold_ff_sptr.sample_delay(threshold_ff_sptr self, int which) → unsigned int
threshold_ff_sptr.set_hi(threshold_ff_sptr self, float hi)
threshold_ff_sptr.set_last_state(threshold_ff_sptr self, float last_state)
threshold_ff_sptr.set_lo(threshold_ff_sptr self, float lo)
threshold_ff_sptr.set_min_noutput_items(threshold_ff_sptr self, int m)
threshold_ff_sptr.set_thread_priority(threshold_ff_sptr self, int priority) → int
threshold_ff_sptr.thread_priority(threshold_ff_sptr self) → int

Previous topic

gnuradio.blocks: Byte Operators

Next topic

gnuradio.blocks: Streams Operators

This Page