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_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_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_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_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_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_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_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_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_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_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_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_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_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