gnuradio.blocks: Streams Operators

gnuradio.blocks.vector_insert_b(std::vector< unsigned char, std::allocator< unsigned char > > const & data, int periodicity, int offset=0) → vector_insert_b_sptr

source of unsigned char’s that gets its data from a vector

Constructor Specific Documentation:

Make vector insert block.

Parameters:

• data – vector of data to insert
• periodicity – number of samples between when to send
• offset – initial item offset of first insert

vector_insert_b_sptr.active_thread_priority(vector_insert_b_sptr self) → int

vector_insert_b_sptr.declare_sample_delay(vector_insert_b_sptr self, int which, int delay)

declare_sample_delay(vector_insert_b_sptr self, unsigned int delay)

vector_insert_b_sptr.message_subscribers(vector_insert_b_sptr self, swig_int_ptr which_port) → swig_int_ptr

vector_insert_b_sptr.min_noutput_items(vector_insert_b_sptr self) → int

vector_insert_b_sptr.pc_input_buffers_full_avg(vector_insert_b_sptr self, int which) → float

pc_input_buffers_full_avg(vector_insert_b_sptr self) -> pmt_vector_float

vector_insert_b_sptr.pc_noutput_items_avg(vector_insert_b_sptr self) → float

vector_insert_b_sptr.pc_nproduced_avg(vector_insert_b_sptr self) → float

vector_insert_b_sptr.pc_output_buffers_full_avg(vector_insert_b_sptr self, int which) → float

pc_output_buffers_full_avg(vector_insert_b_sptr self) -> pmt_vector_float

vector_insert_b_sptr.pc_work_time_avg(vector_insert_b_sptr self) → float

vector_insert_b_sptr.pc_work_time_total(vector_insert_b_sptr self) → float

vector_insert_b_sptr.rewind(vector_insert_b_sptr self)

vector_insert_b_sptr.sample_delay(vector_insert_b_sptr self, int which) → unsigned int

vector_insert_b_sptr.set_data(vector_insert_b_sptr self, std::vector< unsigned char, std::allocator< unsigned char > > const & data)

vector_insert_b_sptr.set_min_noutput_items(vector_insert_b_sptr self, int m)

vector_insert_b_sptr.set_thread_priority(vector_insert_b_sptr self, int priority) → int

vector_insert_b_sptr.thread_priority(vector_insert_b_sptr self) → int

gnuradio.blocks.vector_insert_c(pmt_vector_cfloat data, int periodicity, int offset=0) → vector_insert_c_sptr

source of gr_complex’s that gets its data from a vector

Constructor Specific Documentation:

Make vector insert block.

Parameters:

• data – vector of data to insert
• periodicity – number of samples between when to send
• offset – initial item offset of first insert

vector_insert_c_sptr.active_thread_priority(vector_insert_c_sptr self) → int

vector_insert_c_sptr.declare_sample_delay(vector_insert_c_sptr self, int which, int delay)

declare_sample_delay(vector_insert_c_sptr self, unsigned int delay)

vector_insert_c_sptr.message_subscribers(vector_insert_c_sptr self, swig_int_ptr which_port) → swig_int_ptr

vector_insert_c_sptr.min_noutput_items(vector_insert_c_sptr self) → int

vector_insert_c_sptr.pc_input_buffers_full_avg(vector_insert_c_sptr self, int which) → float

pc_input_buffers_full_avg(vector_insert_c_sptr self) -> pmt_vector_float

vector_insert_c_sptr.pc_noutput_items_avg(vector_insert_c_sptr self) → float

vector_insert_c_sptr.pc_nproduced_avg(vector_insert_c_sptr self) → float

vector_insert_c_sptr.pc_output_buffers_full_avg(vector_insert_c_sptr self, int which) → float

pc_output_buffers_full_avg(vector_insert_c_sptr self) -> pmt_vector_float

vector_insert_c_sptr.pc_work_time_avg(vector_insert_c_sptr self) → float

vector_insert_c_sptr.pc_work_time_total(vector_insert_c_sptr self) → float

vector_insert_c_sptr.rewind(vector_insert_c_sptr self)

vector_insert_c_sptr.sample_delay(vector_insert_c_sptr self, int which) → unsigned int

vector_insert_c_sptr.set_data(vector_insert_c_sptr self, pmt_vector_cfloat data)

vector_insert_c_sptr.set_min_noutput_items(vector_insert_c_sptr self, int m)

vector_insert_c_sptr.set_thread_priority(vector_insert_c_sptr self, int priority) → int

vector_insert_c_sptr.thread_priority(vector_insert_c_sptr self) → int

gnuradio.blocks.vector_insert_f(pmt_vector_float data, int periodicity, int offset=0) → vector_insert_f_sptr

source of float’s that gets its data from a vector

Constructor Specific Documentation:

Make vector insert block.

Parameters:

• data – vector of data to insert
• periodicity – number of samples between when to send
• offset – initial item offset of first insert

vector_insert_f_sptr.active_thread_priority(vector_insert_f_sptr self) → int

vector_insert_f_sptr.declare_sample_delay(vector_insert_f_sptr self, int which, int delay)

declare_sample_delay(vector_insert_f_sptr self, unsigned int delay)

vector_insert_f_sptr.message_subscribers(vector_insert_f_sptr self, swig_int_ptr which_port) → swig_int_ptr

vector_insert_f_sptr.min_noutput_items(vector_insert_f_sptr self) → int

vector_insert_f_sptr.pc_input_buffers_full_avg(vector_insert_f_sptr self, int which) → float

pc_input_buffers_full_avg(vector_insert_f_sptr self) -> pmt_vector_float

vector_insert_f_sptr.pc_noutput_items_avg(vector_insert_f_sptr self) → float

vector_insert_f_sptr.pc_nproduced_avg(vector_insert_f_sptr self) → float

vector_insert_f_sptr.pc_output_buffers_full_avg(vector_insert_f_sptr self, int which) → float

pc_output_buffers_full_avg(vector_insert_f_sptr self) -> pmt_vector_float

vector_insert_f_sptr.pc_work_time_avg(vector_insert_f_sptr self) → float

vector_insert_f_sptr.pc_work_time_total(vector_insert_f_sptr self) → float

vector_insert_f_sptr.rewind(vector_insert_f_sptr self)

vector_insert_f_sptr.sample_delay(vector_insert_f_sptr self, int which) → unsigned int

vector_insert_f_sptr.set_data(vector_insert_f_sptr self, pmt_vector_float data)

vector_insert_f_sptr.set_min_noutput_items(vector_insert_f_sptr self, int m)

vector_insert_f_sptr.set_thread_priority(vector_insert_f_sptr self, int priority) → int

vector_insert_f_sptr.thread_priority(vector_insert_f_sptr self) → int

gnuradio.blocks.vector_insert_i(std::vector< int, std::allocator< int > > const & data, int periodicity, int offset=0) → vector_insert_i_sptr

source of int’s that gets its data from a vector

Constructor Specific Documentation:

Make vector insert block.

Parameters:

• data – vector of data to insert
• periodicity – number of samples between when to send
• offset – initial item offset of first insert

vector_insert_i_sptr.active_thread_priority(vector_insert_i_sptr self) → int

vector_insert_i_sptr.declare_sample_delay(vector_insert_i_sptr self, int which, int delay)

declare_sample_delay(vector_insert_i_sptr self, unsigned int delay)

vector_insert_i_sptr.message_subscribers(vector_insert_i_sptr self, swig_int_ptr which_port) → swig_int_ptr

vector_insert_i_sptr.min_noutput_items(vector_insert_i_sptr self) → int

vector_insert_i_sptr.pc_input_buffers_full_avg(vector_insert_i_sptr self, int which) → float

pc_input_buffers_full_avg(vector_insert_i_sptr self) -> pmt_vector_float

vector_insert_i_sptr.pc_noutput_items_avg(vector_insert_i_sptr self) → float

vector_insert_i_sptr.pc_nproduced_avg(vector_insert_i_sptr self) → float

vector_insert_i_sptr.pc_output_buffers_full_avg(vector_insert_i_sptr self, int which) → float

pc_output_buffers_full_avg(vector_insert_i_sptr self) -> pmt_vector_float

vector_insert_i_sptr.pc_work_time_avg(vector_insert_i_sptr self) → float

vector_insert_i_sptr.pc_work_time_total(vector_insert_i_sptr self) → float

vector_insert_i_sptr.rewind(vector_insert_i_sptr self)

vector_insert_i_sptr.sample_delay(vector_insert_i_sptr self, int which) → unsigned int

vector_insert_i_sptr.set_data(vector_insert_i_sptr self, std::vector< int, std::allocator< int > > const & data)

vector_insert_i_sptr.set_min_noutput_items(vector_insert_i_sptr self, int m)

vector_insert_i_sptr.set_thread_priority(vector_insert_i_sptr self, int priority) → int

vector_insert_i_sptr.thread_priority(vector_insert_i_sptr self) → int

gnuradio.blocks.vector_insert_s(std::vector< short, std::allocator< short > > const & data, int periodicity, int offset=0) → vector_insert_s_sptr

source of short’s that gets its data from a vector

Constructor Specific Documentation:

Make vector insert block.

Parameters:

• data – vector of data to insert
• periodicity – number of samples between when to send
• offset – initial item offset of first insert

vector_insert_s_sptr.active_thread_priority(vector_insert_s_sptr self) → int

vector_insert_s_sptr.declare_sample_delay(vector_insert_s_sptr self, int which, int delay)

declare_sample_delay(vector_insert_s_sptr self, unsigned int delay)

vector_insert_s_sptr.message_subscribers(vector_insert_s_sptr self, swig_int_ptr which_port) → swig_int_ptr

vector_insert_s_sptr.min_noutput_items(vector_insert_s_sptr self) → int

vector_insert_s_sptr.pc_input_buffers_full_avg(vector_insert_s_sptr self, int which) → float

pc_input_buffers_full_avg(vector_insert_s_sptr self) -> pmt_vector_float

vector_insert_s_sptr.pc_noutput_items_avg(vector_insert_s_sptr self) → float

vector_insert_s_sptr.pc_nproduced_avg(vector_insert_s_sptr self) → float

vector_insert_s_sptr.pc_output_buffers_full_avg(vector_insert_s_sptr self, int which) → float

pc_output_buffers_full_avg(vector_insert_s_sptr self) -> pmt_vector_float

vector_insert_s_sptr.pc_work_time_avg(vector_insert_s_sptr self) → float

vector_insert_s_sptr.pc_work_time_total(vector_insert_s_sptr self) → float

vector_insert_s_sptr.rewind(vector_insert_s_sptr self)

vector_insert_s_sptr.sample_delay(vector_insert_s_sptr self, int which) → unsigned int

vector_insert_s_sptr.set_data(vector_insert_s_sptr self, std::vector< short, std::allocator< short > > const & data)

vector_insert_s_sptr.set_min_noutput_items(vector_insert_s_sptr self, int m)

vector_insert_s_sptr.set_thread_priority(vector_insert_s_sptr self, int priority) → int

vector_insert_s_sptr.thread_priority(vector_insert_s_sptr self) → int

gnuradio.blocks.deinterleave(size_t itemsize) → deinterleave_sptr

deinterleave a single input into N outputs

Constructor Specific Documentation:

Make a deinterleave block.

Parameters:itemsize – stream itemsize

deinterleave_sptr.active_thread_priority(deinterleave_sptr self) → int

deinterleave_sptr.declare_sample_delay(deinterleave_sptr self, int which, int delay)

declare_sample_delay(deinterleave_sptr self, unsigned int delay)

deinterleave_sptr.message_subscribers(deinterleave_sptr self, swig_int_ptr which_port) → swig_int_ptr

deinterleave_sptr.min_noutput_items(deinterleave_sptr self) → int

deinterleave_sptr.pc_input_buffers_full_avg(deinterleave_sptr self, int which) → float

pc_input_buffers_full_avg(deinterleave_sptr self) -> pmt_vector_float

deinterleave_sptr.pc_noutput_items_avg(deinterleave_sptr self) → float

deinterleave_sptr.pc_nproduced_avg(deinterleave_sptr self) → float

deinterleave_sptr.pc_output_buffers_full_avg(deinterleave_sptr self, int which) → float

pc_output_buffers_full_avg(deinterleave_sptr self) -> pmt_vector_float

deinterleave_sptr.pc_work_time_avg(deinterleave_sptr self) → float

deinterleave_sptr.pc_work_time_total(deinterleave_sptr self) → float

deinterleave_sptr.sample_delay(deinterleave_sptr self, int which) → unsigned int

deinterleave_sptr.set_min_noutput_items(deinterleave_sptr self, int m)

deinterleave_sptr.set_thread_priority(deinterleave_sptr self, int priority) → int

deinterleave_sptr.thread_priority(deinterleave_sptr self) → int

gnuradio.blocks.endian_swap(size_t item_size_bytes=1) → endian_swap_sptr

Convert stream of items into thier byte swapped version.

Constructor Specific Documentation:

Make an endian swap block.

Parameters:item_size_bytes – number of bytes per item, 1=no-op, 2=uint16_t, 4=uint32_t, 8=uint64_t

endian_swap_sptr.active_thread_priority(endian_swap_sptr self) → int

endian_swap_sptr.declare_sample_delay(endian_swap_sptr self, int which, int delay)

declare_sample_delay(endian_swap_sptr self, unsigned int delay)

endian_swap_sptr.message_subscribers(endian_swap_sptr self, swig_int_ptr which_port) → swig_int_ptr

endian_swap_sptr.min_noutput_items(endian_swap_sptr self) → int

endian_swap_sptr.pc_input_buffers_full_avg(endian_swap_sptr self, int which) → float

pc_input_buffers_full_avg(endian_swap_sptr self) -> pmt_vector_float

endian_swap_sptr.pc_noutput_items_avg(endian_swap_sptr self) → float

endian_swap_sptr.pc_nproduced_avg(endian_swap_sptr self) → float

endian_swap_sptr.pc_output_buffers_full_avg(endian_swap_sptr self, int which) → float

pc_output_buffers_full_avg(endian_swap_sptr self) -> pmt_vector_float

endian_swap_sptr.pc_work_time_avg(endian_swap_sptr self) → float

endian_swap_sptr.pc_work_time_total(endian_swap_sptr self) → float

endian_swap_sptr.sample_delay(endian_swap_sptr self, int which) → unsigned int

endian_swap_sptr.set_min_noutput_items(endian_swap_sptr self, int m)

endian_swap_sptr.set_thread_priority(endian_swap_sptr self, int priority) → int

endian_swap_sptr.thread_priority(endian_swap_sptr self) → int

gnuradio.blocks.interleave(size_t itemsize) → interleave_sptr

interleave N inputs into a single output

Constructor Specific Documentation:

Make a stream interleave block.

Parameters:itemsize – stream itemsize

interleave_sptr.active_thread_priority(interleave_sptr self) → int

interleave_sptr.declare_sample_delay(interleave_sptr self, int which, int delay)

declare_sample_delay(interleave_sptr self, unsigned int delay)

interleave_sptr.message_subscribers(interleave_sptr self, swig_int_ptr which_port) → swig_int_ptr

interleave_sptr.min_noutput_items(interleave_sptr self) → int

interleave_sptr.pc_input_buffers_full_avg(interleave_sptr self, int which) → float

pc_input_buffers_full_avg(interleave_sptr self) -> pmt_vector_float

interleave_sptr.pc_noutput_items_avg(interleave_sptr self) → float

interleave_sptr.pc_nproduced_avg(interleave_sptr self) → float

interleave_sptr.pc_output_buffers_full_avg(interleave_sptr self, int which) → float

pc_output_buffers_full_avg(interleave_sptr self) -> pmt_vector_float

interleave_sptr.pc_work_time_avg(interleave_sptr self) → float

interleave_sptr.pc_work_time_total(interleave_sptr self) → float

interleave_sptr.sample_delay(interleave_sptr self, int which) → unsigned int

interleave_sptr.set_min_noutput_items(interleave_sptr self, int m)

interleave_sptr.set_thread_priority(interleave_sptr self, int priority) → int

interleave_sptr.thread_priority(interleave_sptr self) → int

gnuradio.blocks.keep_m_in_n(size_t itemsize, int m, int n, int offset) → keep_m_in_n_sptr

decimate a stream, keeping items out of every .

Constructor Specific Documentation:

Make a keep m in n block.

Parameters:

• itemsize – stream itemsize
• m – number of items to take in block of items
• n – block size in items
• offset – initial item offset into the stream

keep_m_in_n_sptr.active_thread_priority(keep_m_in_n_sptr self) → int

keep_m_in_n_sptr.declare_sample_delay(keep_m_in_n_sptr self, int which, int delay)

declare_sample_delay(keep_m_in_n_sptr self, unsigned int delay)

keep_m_in_n_sptr.message_subscribers(keep_m_in_n_sptr self, swig_int_ptr which_port) → swig_int_ptr

keep_m_in_n_sptr.min_noutput_items(keep_m_in_n_sptr self) → int

keep_m_in_n_sptr.pc_input_buffers_full_avg(keep_m_in_n_sptr self, int which) → float

pc_input_buffers_full_avg(keep_m_in_n_sptr self) -> pmt_vector_float

keep_m_in_n_sptr.pc_noutput_items_avg(keep_m_in_n_sptr self) → float

keep_m_in_n_sptr.pc_nproduced_avg(keep_m_in_n_sptr self) → float

keep_m_in_n_sptr.pc_output_buffers_full_avg(keep_m_in_n_sptr self, int which) → float

pc_output_buffers_full_avg(keep_m_in_n_sptr self) -> pmt_vector_float

keep_m_in_n_sptr.pc_work_time_avg(keep_m_in_n_sptr self) → float

keep_m_in_n_sptr.pc_work_time_total(keep_m_in_n_sptr self) → float

keep_m_in_n_sptr.sample_delay(keep_m_in_n_sptr self, int which) → unsigned int

keep_m_in_n_sptr.set_m(keep_m_in_n_sptr self, int m)

keep_m_in_n_sptr.set_min_noutput_items(keep_m_in_n_sptr self, int m)

keep_m_in_n_sptr.set_n(keep_m_in_n_sptr self, int n)

keep_m_in_n_sptr.set_offset(keep_m_in_n_sptr self, int offset)

keep_m_in_n_sptr.set_thread_priority(keep_m_in_n_sptr self, int priority) → int

keep_m_in_n_sptr.thread_priority(keep_m_in_n_sptr self) → int

gnuradio.blocks.keep_one_in_n(size_t itemsize, int n) → keep_one_in_n_sptr

decimate a stream, keeping one item out of every .

Constructor Specific Documentation:

Make a keep one in n block.

Parameters:

• itemsize – stream itemsize
• n – block size in items

keep_one_in_n_sptr.active_thread_priority(keep_one_in_n_sptr self) → int

keep_one_in_n_sptr.declare_sample_delay(keep_one_in_n_sptr self, int which, int delay)

declare_sample_delay(keep_one_in_n_sptr self, unsigned int delay)

keep_one_in_n_sptr.message_subscribers(keep_one_in_n_sptr self, swig_int_ptr which_port) → swig_int_ptr

keep_one_in_n_sptr.min_noutput_items(keep_one_in_n_sptr self) → int

keep_one_in_n_sptr.pc_input_buffers_full_avg(keep_one_in_n_sptr self, int which) → float

pc_input_buffers_full_avg(keep_one_in_n_sptr self) -> pmt_vector_float

keep_one_in_n_sptr.pc_noutput_items_avg(keep_one_in_n_sptr self) → float

keep_one_in_n_sptr.pc_nproduced_avg(keep_one_in_n_sptr self) → float

keep_one_in_n_sptr.pc_output_buffers_full_avg(keep_one_in_n_sptr self, int which) → float

pc_output_buffers_full_avg(keep_one_in_n_sptr self) -> pmt_vector_float

keep_one_in_n_sptr.pc_work_time_avg(keep_one_in_n_sptr self) → float

keep_one_in_n_sptr.pc_work_time_total(keep_one_in_n_sptr self) → float

keep_one_in_n_sptr.sample_delay(keep_one_in_n_sptr self, int which) → unsigned int

keep_one_in_n_sptr.set_min_noutput_items(keep_one_in_n_sptr self, int m)

keep_one_in_n_sptr.set_n(keep_one_in_n_sptr self, int n)

keep_one_in_n_sptr.set_thread_priority(keep_one_in_n_sptr self, int priority) → int

keep_one_in_n_sptr.thread_priority(keep_one_in_n_sptr self) → int

gnuradio.blocks.patterned_interleaver(size_t itemsize, std::vector< int, std::allocator< int > > pattern) → patterned_interleaver_sptr

Interleave items based on the provided vector .

Constructor Specific Documentation:

Make a patterned interleaver block.

Parameters:

• itemsize – stream itemsize
• pattern – vector that represents the interleaving pattern

patterned_interleaver_sptr.active_thread_priority(patterned_interleaver_sptr self) → int

patterned_interleaver_sptr.declare_sample_delay(patterned_interleaver_sptr self, int which, int delay)

declare_sample_delay(patterned_interleaver_sptr self, unsigned int delay)

patterned_interleaver_sptr.message_subscribers(patterned_interleaver_sptr self, swig_int_ptr which_port) → swig_int_ptr

patterned_interleaver_sptr.min_noutput_items(patterned_interleaver_sptr self) → int

patterned_interleaver_sptr.pc_input_buffers_full_avg(patterned_interleaver_sptr self, int which) → float

pc_input_buffers_full_avg(patterned_interleaver_sptr self) -> pmt_vector_float

patterned_interleaver_sptr.pc_noutput_items_avg(patterned_interleaver_sptr self) → float

patterned_interleaver_sptr.pc_nproduced_avg(patterned_interleaver_sptr self) → float

patterned_interleaver_sptr.pc_output_buffers_full_avg(patterned_interleaver_sptr self, int which) → float

pc_output_buffers_full_avg(patterned_interleaver_sptr self) -> pmt_vector_float

patterned_interleaver_sptr.pc_work_time_avg(patterned_interleaver_sptr self) → float

patterned_interleaver_sptr.pc_work_time_total(patterned_interleaver_sptr self) → float

patterned_interleaver_sptr.sample_delay(patterned_interleaver_sptr self, int which) → unsigned int

patterned_interleaver_sptr.set_min_noutput_items(patterned_interleaver_sptr self, int m)

patterned_interleaver_sptr.set_thread_priority(patterned_interleaver_sptr self, int priority) → int

patterned_interleaver_sptr.thread_priority(patterned_interleaver_sptr self) → int

gnuradio.blocks.regenerate_bb(int period, unsigned int max_regen=500) → regenerate_bb_sptr

Detect the peak of a signal and repeat every period samples.

If a peak is detected, this block outputs a 1 repeated every period samples until reset by detection of another 1 on the input or stopped after max_regen regenerations have occurred.

Note that if max_regen=(-1)/ULONG_MAX then the regeneration will run forever.

Constructor Specific Documentation:

Make a regenerate block.

Parameters:

• period – The number of samples between regenerations
• max_regen – The maximum number of regenerations to perform; if set to ULONG_MAX, it will regenerate continuously.

regenerate_bb_sptr.active_thread_priority(regenerate_bb_sptr self) → int

regenerate_bb_sptr.declare_sample_delay(regenerate_bb_sptr self, int which, int delay)

declare_sample_delay(regenerate_bb_sptr self, unsigned int delay)

regenerate_bb_sptr.max_regen(regenerate_bb_sptr self) → unsigned int

return the maximum regeneration count.

regenerate_bb_sptr.message_subscribers(regenerate_bb_sptr self, swig_int_ptr which_port) → swig_int_ptr

regenerate_bb_sptr.min_noutput_items(regenerate_bb_sptr self) → int

regenerate_bb_sptr.pc_input_buffers_full_avg(regenerate_bb_sptr self, int which) → float

pc_input_buffers_full_avg(regenerate_bb_sptr self) -> pmt_vector_float

regenerate_bb_sptr.pc_noutput_items_avg(regenerate_bb_sptr self) → float

regenerate_bb_sptr.pc_nproduced_avg(regenerate_bb_sptr self) → float

regenerate_bb_sptr.pc_output_buffers_full_avg(regenerate_bb_sptr self, int which) → float

pc_output_buffers_full_avg(regenerate_bb_sptr self) -> pmt_vector_float

regenerate_bb_sptr.pc_work_time_avg(regenerate_bb_sptr self) → float

regenerate_bb_sptr.pc_work_time_total(regenerate_bb_sptr self) → float

regenerate_bb_sptr.period(regenerate_bb_sptr self) → int

return the regeneration period.

regenerate_bb_sptr.sample_delay(regenerate_bb_sptr self, int which) → unsigned int

regenerate_bb_sptr.set_max_regen(regenerate_bb_sptr self, unsigned int regen)

Reset the maximum regeneration count; this will reset the current regen.

regenerate_bb_sptr.set_min_noutput_items(regenerate_bb_sptr self, int m)

regenerate_bb_sptr.set_period(regenerate_bb_sptr self, int period)

Reset the period of regenerations; this will reset the current regen.

regenerate_bb_sptr.set_thread_priority(regenerate_bb_sptr self, int priority) → int

regenerate_bb_sptr.thread_priority(regenerate_bb_sptr self) → int

gnuradio.blocks.repeat(size_t itemsize, int repeat) → repeat_sptr

repeat each input times

Constructor Specific Documentation:

Make a repeat block.

Parameters:

• itemsize – stream itemsize
• repeat – number of times to repeat the input

repeat_sptr.active_thread_priority(repeat_sptr self) → int

repeat_sptr.declare_sample_delay(repeat_sptr self, int which, int delay)

declare_sample_delay(repeat_sptr self, unsigned int delay)

repeat_sptr.message_subscribers(repeat_sptr self, swig_int_ptr which_port) → swig_int_ptr

repeat_sptr.min_noutput_items(repeat_sptr self) → int

repeat_sptr.pc_input_buffers_full_avg(repeat_sptr self, int which) → float

pc_input_buffers_full_avg(repeat_sptr self) -> pmt_vector_float

repeat_sptr.pc_noutput_items_avg(repeat_sptr self) → float

repeat_sptr.pc_nproduced_avg(repeat_sptr self) → float

repeat_sptr.pc_output_buffers_full_avg(repeat_sptr self, int which) → float

pc_output_buffers_full_avg(repeat_sptr self) -> pmt_vector_float

repeat_sptr.pc_work_time_avg(repeat_sptr self) → float

repeat_sptr.pc_work_time_total(repeat_sptr self) → float

repeat_sptr.sample_delay(repeat_sptr self, int which) → unsigned int

repeat_sptr.set_min_noutput_items(repeat_sptr self, int m)

repeat_sptr.set_thread_priority(repeat_sptr self, int priority) → int

repeat_sptr.thread_priority(repeat_sptr self) → int

gnuradio.blocks.stream_mux(size_t itemsize, std::vector< int, std::allocator< int > > const & lengths) → stream_mux_sptr

Stream muxing block to multiplex many streams into one with a specified format.

Muxes N streams together producing an output stream that contains N0 items from the first stream, N1 items from the second, etc. and repeats:

[N0, N1, N2, ..., Nm, N0, N1, ...]

Constructor Specific Documentation:

Creates a stream muxing block to multiplex many streams into one with a specified format.

Parameters:

• itemsize – the item size of the stream
• lengths – a vector (list/tuple) specifying the number of items from each stream the mux together. Warning: this requires that at least as many items per stream are available or the system will wait indefinitely for the items.

stream_mux_sptr.active_thread_priority(stream_mux_sptr self) → int

stream_mux_sptr.declare_sample_delay(stream_mux_sptr self, int which, int delay)

declare_sample_delay(stream_mux_sptr self, unsigned int delay)

stream_mux_sptr.message_subscribers(stream_mux_sptr self, swig_int_ptr which_port) → swig_int_ptr

stream_mux_sptr.min_noutput_items(stream_mux_sptr self) → int

stream_mux_sptr.pc_input_buffers_full_avg(stream_mux_sptr self, int which) → float

pc_input_buffers_full_avg(stream_mux_sptr self) -> pmt_vector_float

stream_mux_sptr.pc_noutput_items_avg(stream_mux_sptr self) → float

stream_mux_sptr.pc_nproduced_avg(stream_mux_sptr self) → float

stream_mux_sptr.pc_output_buffers_full_avg(stream_mux_sptr self, int which) → float

pc_output_buffers_full_avg(stream_mux_sptr self) -> pmt_vector_float

stream_mux_sptr.pc_work_time_avg(stream_mux_sptr self) → float

stream_mux_sptr.pc_work_time_total(stream_mux_sptr self) → float

stream_mux_sptr.sample_delay(stream_mux_sptr self, int which) → unsigned int

stream_mux_sptr.set_min_noutput_items(stream_mux_sptr self, int m)

stream_mux_sptr.set_thread_priority(stream_mux_sptr self, int priority) → int

stream_mux_sptr.thread_priority(stream_mux_sptr self) → int

gnuradio.blocks.stream_to_streams(size_t itemsize, size_t nstreams) → stream_to_streams_sptr

convert a stream of items into a N streams of items

Converts a stream of N items into N streams of 1 item. Repeat ad infinitum.

Constructor Specific Documentation:

Make a stream-to-streams block.

Parameters:

• itemsize – the item size of the stream
• nstreams – number of streams to split input into

stream_to_streams_sptr.active_thread_priority(stream_to_streams_sptr self) → int

stream_to_streams_sptr.declare_sample_delay(stream_to_streams_sptr self, int which, int delay)

declare_sample_delay(stream_to_streams_sptr self, unsigned int delay)

stream_to_streams_sptr.message_subscribers(stream_to_streams_sptr self, swig_int_ptr which_port) → swig_int_ptr

stream_to_streams_sptr.min_noutput_items(stream_to_streams_sptr self) → int

stream_to_streams_sptr.pc_input_buffers_full_avg(stream_to_streams_sptr self, int which) → float

pc_input_buffers_full_avg(stream_to_streams_sptr self) -> pmt_vector_float

stream_to_streams_sptr.pc_noutput_items_avg(stream_to_streams_sptr self) → float

stream_to_streams_sptr.pc_nproduced_avg(stream_to_streams_sptr self) → float

stream_to_streams_sptr.pc_output_buffers_full_avg(stream_to_streams_sptr self, int which) → float

pc_output_buffers_full_avg(stream_to_streams_sptr self) -> pmt_vector_float

stream_to_streams_sptr.pc_work_time_avg(stream_to_streams_sptr self) → float

stream_to_streams_sptr.pc_work_time_total(stream_to_streams_sptr self) → float

stream_to_streams_sptr.sample_delay(stream_to_streams_sptr self, int which) → unsigned int

stream_to_streams_sptr.set_min_noutput_items(stream_to_streams_sptr self, int m)

stream_to_streams_sptr.set_thread_priority(stream_to_streams_sptr self, int priority) → int

stream_to_streams_sptr.thread_priority(stream_to_streams_sptr self) → int

gnuradio.blocks.stream_to_vector(size_t itemsize, size_t nitems_per_block) → stream_to_vector_sptr

convert a stream of items into a stream of gnuradio/blocks containing nitems_per_block

Constructor Specific Documentation:

Make a stream-to-vector block.

Parameters:

• itemsize – the item size of the stream
• nitems_per_block – number of items to but into each vector (vector size)

stream_to_vector_sptr.active_thread_priority(stream_to_vector_sptr self) → int

stream_to_vector_sptr.declare_sample_delay(stream_to_vector_sptr self, int which, int delay)

declare_sample_delay(stream_to_vector_sptr self, unsigned int delay)

stream_to_vector_sptr.message_subscribers(stream_to_vector_sptr self, swig_int_ptr which_port) → swig_int_ptr

stream_to_vector_sptr.min_noutput_items(stream_to_vector_sptr self) → int

stream_to_vector_sptr.pc_input_buffers_full_avg(stream_to_vector_sptr self, int which) → float

pc_input_buffers_full_avg(stream_to_vector_sptr self) -> pmt_vector_float

stream_to_vector_sptr.pc_noutput_items_avg(stream_to_vector_sptr self) → float

stream_to_vector_sptr.pc_nproduced_avg(stream_to_vector_sptr self) → float

stream_to_vector_sptr.pc_output_buffers_full_avg(stream_to_vector_sptr self, int which) → float

pc_output_buffers_full_avg(stream_to_vector_sptr self) -> pmt_vector_float

stream_to_vector_sptr.pc_work_time_avg(stream_to_vector_sptr self) → float

stream_to_vector_sptr.pc_work_time_total(stream_to_vector_sptr self) → float

stream_to_vector_sptr.sample_delay(stream_to_vector_sptr self, int which) → unsigned int

stream_to_vector_sptr.set_min_noutput_items(stream_to_vector_sptr self, int m)

stream_to_vector_sptr.set_thread_priority(stream_to_vector_sptr self, int priority) → int

stream_to_vector_sptr.thread_priority(stream_to_vector_sptr self) → int

gnuradio.blocks.streams_to_stream(size_t itemsize, size_t nstreams) → streams_to_stream_sptr

Convert N streams of 1 item into a 1 stream of N items.

Convert N streams of 1 item into 1 stream of N items. Repeat ad infinitum.

Constructor Specific Documentation:

Make a streams-to-stream block.

Parameters:

• itemsize – the item size of the stream
• nstreams – number of streams to combine

streams_to_stream_sptr.active_thread_priority(streams_to_stream_sptr self) → int

streams_to_stream_sptr.declare_sample_delay(streams_to_stream_sptr self, int which, int delay)

declare_sample_delay(streams_to_stream_sptr self, unsigned int delay)

streams_to_stream_sptr.message_subscribers(streams_to_stream_sptr self, swig_int_ptr which_port) → swig_int_ptr

streams_to_stream_sptr.min_noutput_items(streams_to_stream_sptr self) → int

streams_to_stream_sptr.pc_input_buffers_full_avg(streams_to_stream_sptr self, int which) → float

pc_input_buffers_full_avg(streams_to_stream_sptr self) -> pmt_vector_float

streams_to_stream_sptr.pc_noutput_items_avg(streams_to_stream_sptr self) → float

streams_to_stream_sptr.pc_nproduced_avg(streams_to_stream_sptr self) → float

streams_to_stream_sptr.pc_output_buffers_full_avg(streams_to_stream_sptr self, int which) → float

pc_output_buffers_full_avg(streams_to_stream_sptr self) -> pmt_vector_float

streams_to_stream_sptr.pc_work_time_avg(streams_to_stream_sptr self) → float

streams_to_stream_sptr.pc_work_time_total(streams_to_stream_sptr self) → float

streams_to_stream_sptr.sample_delay(streams_to_stream_sptr self, int which) → unsigned int

streams_to_stream_sptr.set_min_noutput_items(streams_to_stream_sptr self, int m)

streams_to_stream_sptr.set_thread_priority(streams_to_stream_sptr self, int priority) → int

streams_to_stream_sptr.thread_priority(streams_to_stream_sptr self) → int

gnuradio.blocks.streams_to_vector(size_t itemsize, size_t nstreams) → streams_to_vector_sptr

convert N streams of items to 1 stream of vector length N

Constructor Specific Documentation:

Make a stream-to-vector block.

Parameters:

• itemsize – the item size of the stream
• nstreams – number of streams to combine into a vector (vector size)

streams_to_vector_sptr.active_thread_priority(streams_to_vector_sptr self) → int

streams_to_vector_sptr.declare_sample_delay(streams_to_vector_sptr self, int which, int delay)

declare_sample_delay(streams_to_vector_sptr self, unsigned int delay)

streams_to_vector_sptr.message_subscribers(streams_to_vector_sptr self, swig_int_ptr which_port) → swig_int_ptr

streams_to_vector_sptr.min_noutput_items(streams_to_vector_sptr self) → int

streams_to_vector_sptr.pc_input_buffers_full_avg(streams_to_vector_sptr self, int which) → float

pc_input_buffers_full_avg(streams_to_vector_sptr self) -> pmt_vector_float

streams_to_vector_sptr.pc_noutput_items_avg(streams_to_vector_sptr self) → float

streams_to_vector_sptr.pc_nproduced_avg(streams_to_vector_sptr self) → float

streams_to_vector_sptr.pc_output_buffers_full_avg(streams_to_vector_sptr self, int which) → float

pc_output_buffers_full_avg(streams_to_vector_sptr self) -> pmt_vector_float

streams_to_vector_sptr.pc_work_time_avg(streams_to_vector_sptr self) → float

streams_to_vector_sptr.pc_work_time_total(streams_to_vector_sptr self) → float

streams_to_vector_sptr.sample_delay(streams_to_vector_sptr self, int which) → unsigned int

streams_to_vector_sptr.set_min_noutput_items(streams_to_vector_sptr self, int m)

streams_to_vector_sptr.set_thread_priority(streams_to_vector_sptr self, int priority) → int

streams_to_vector_sptr.thread_priority(streams_to_vector_sptr self) → int

gnuradio.blocks.stretch_ff(float lo, size_t vlen=1) → stretch_ff_sptr

adjust y-range of an input vector by mapping to range (max-of-input, stipulated-min). Primarily for spectral signature matching by normalizing spectrum dynamic ranges.

Constructor Specific Documentation:

Make a stretch block.

Parameters:

• lo – Set low value for range.
• vlen – vector length of input stream.

stretch_ff_sptr.active_thread_priority(stretch_ff_sptr self) → int

stretch_ff_sptr.declare_sample_delay(stretch_ff_sptr self, int which, int delay)

declare_sample_delay(stretch_ff_sptr self, unsigned int delay)

stretch_ff_sptr.lo(stretch_ff_sptr self) → float

stretch_ff_sptr.message_subscribers(stretch_ff_sptr self, swig_int_ptr which_port) → swig_int_ptr

stretch_ff_sptr.min_noutput_items(stretch_ff_sptr self) → int

stretch_ff_sptr.pc_input_buffers_full_avg(stretch_ff_sptr self, int which) → float

pc_input_buffers_full_avg(stretch_ff_sptr self) -> pmt_vector_float

stretch_ff_sptr.pc_noutput_items_avg(stretch_ff_sptr self) → float

stretch_ff_sptr.pc_nproduced_avg(stretch_ff_sptr self) → float

stretch_ff_sptr.pc_output_buffers_full_avg(stretch_ff_sptr self, int which) → float

pc_output_buffers_full_avg(stretch_ff_sptr self) -> pmt_vector_float

stretch_ff_sptr.pc_work_time_avg(stretch_ff_sptr self) → float

stretch_ff_sptr.pc_work_time_total(stretch_ff_sptr self) → float

stretch_ff_sptr.sample_delay(stretch_ff_sptr self, int which) → unsigned int

stretch_ff_sptr.set_lo(stretch_ff_sptr self, float lo)

stretch_ff_sptr.set_min_noutput_items(stretch_ff_sptr self, int m)

stretch_ff_sptr.set_thread_priority(stretch_ff_sptr self, int priority) → int

stretch_ff_sptr.thread_priority(stretch_ff_sptr self) → int

stretch_ff_sptr.vlen(stretch_ff_sptr self) → size_t

gnuradio.blocks.tagged_stream_mux(size_t itemsize, std::string const & lengthtagname, unsigned int tag_preserve_head_pos=0) → tagged_stream_mux_sptr

Combines tagged streams.

Takes N streams as input. Each stream is tagged with packet lengths. Packets are output sequentially from each input stream.

The output signal has a new length tag, which is the sum of all individual length tags. The old length tags are discarded.

All other tags are propagated as expected, i.e. they stay associated with the same input item. There are cases when this behaviour is undesirable. One special case is when a tag at the first element (the head item) of one input port must stay on the head item of the output port. To achieve this, set to the port that will receive these special tags.

Constructor Specific Documentation:

Make a tagged stream mux block.

Parameters:

• itemsize – Items size (number of bytes per item)
• lengthtagname – Length tag key
• tag_preserve_head_pos – Preserves the head position of tags on this input port

tagged_stream_mux_sptr.active_thread_priority(tagged_stream_mux_sptr self) → int

tagged_stream_mux_sptr.declare_sample_delay(tagged_stream_mux_sptr self, int which, int delay)

declare_sample_delay(tagged_stream_mux_sptr self, unsigned int delay)

tagged_stream_mux_sptr.message_subscribers(tagged_stream_mux_sptr self, swig_int_ptr which_port) → swig_int_ptr

tagged_stream_mux_sptr.min_noutput_items(tagged_stream_mux_sptr self) → int

tagged_stream_mux_sptr.pc_input_buffers_full_avg(tagged_stream_mux_sptr self, int which) → float

pc_input_buffers_full_avg(tagged_stream_mux_sptr self) -> pmt_vector_float

tagged_stream_mux_sptr.pc_noutput_items_avg(tagged_stream_mux_sptr self) → float

tagged_stream_mux_sptr.pc_nproduced_avg(tagged_stream_mux_sptr self) → float

tagged_stream_mux_sptr.pc_output_buffers_full_avg(tagged_stream_mux_sptr self, int which) → float

pc_output_buffers_full_avg(tagged_stream_mux_sptr self) -> pmt_vector_float

tagged_stream_mux_sptr.pc_work_time_avg(tagged_stream_mux_sptr self) → float

tagged_stream_mux_sptr.pc_work_time_total(tagged_stream_mux_sptr self) → float

tagged_stream_mux_sptr.sample_delay(tagged_stream_mux_sptr self, int which) → unsigned int

tagged_stream_mux_sptr.set_min_noutput_items(tagged_stream_mux_sptr self, int m)

tagged_stream_mux_sptr.set_thread_priority(tagged_stream_mux_sptr self, int priority) → int

tagged_stream_mux_sptr.thread_priority(tagged_stream_mux_sptr self) → int

gnuradio.blocks.vector_map(size_t item_size, gr_vsize_t in_vlens, gr_vvvsize_t mapping) → vector_map_sptr

Maps elements from a set of input vectors to a set of output vectors.

If in[i] is the input vector in the i’th stream then the output vector in the j’th stream is:

out[j][k] = in[mapping[j][k][0]][mapping[j][k][1]]

That is mapping is of the form (out_stream1_mapping, out_stream2_mapping, ...) and out_stream1_mapping is of the form (element1_mapping, element2_mapping, ...) and element1_mapping is of the form (in_stream, in_element).

Constructor Specific Documentation:

Build a vector map block.

Parameters:

• item_size – (integer) size of vector elements
• in_vlens – (vector of integers) number of elements in each input vector
• mapping – (vector of vectors of vectors of integers) how to map elements from input to output vectors

vector_map_sptr.active_thread_priority(vector_map_sptr self) → int

vector_map_sptr.declare_sample_delay(vector_map_sptr self, int which, int delay)

declare_sample_delay(vector_map_sptr self, unsigned int delay)

vector_map_sptr.message_subscribers(vector_map_sptr self, swig_int_ptr which_port) → swig_int_ptr

vector_map_sptr.min_noutput_items(vector_map_sptr self) → int

vector_map_sptr.pc_input_buffers_full_avg(vector_map_sptr self, int which) → float

pc_input_buffers_full_avg(vector_map_sptr self) -> pmt_vector_float

vector_map_sptr.pc_noutput_items_avg(vector_map_sptr self) → float

vector_map_sptr.pc_nproduced_avg(vector_map_sptr self) → float

vector_map_sptr.pc_output_buffers_full_avg(vector_map_sptr self, int which) → float

pc_output_buffers_full_avg(vector_map_sptr self) -> pmt_vector_float

vector_map_sptr.pc_work_time_avg(vector_map_sptr self) → float

vector_map_sptr.pc_work_time_total(vector_map_sptr self) → float

vector_map_sptr.sample_delay(vector_map_sptr self, int which) → unsigned int

vector_map_sptr.set_mapping(vector_map_sptr self, gr_vvvsize_t mapping)

vector_map_sptr.set_min_noutput_items(vector_map_sptr self, int m)

vector_map_sptr.set_thread_priority(vector_map_sptr self, int priority) → int

vector_map_sptr.thread_priority(vector_map_sptr self) → int

gnuradio.blocks.vector_to_stream(size_t itemsize, size_t nitems_per_block) → vector_to_stream_sptr

convert a stream of gnuradio/blocks of nitems_per_block items into a stream of items

Constructor Specific Documentation:

Make vector-to-stream block

Parameters:

• itemsize – the item size of the stream
• nitems_per_block – number of items per vector (vector size)

vector_to_stream_sptr.active_thread_priority(vector_to_stream_sptr self) → int

vector_to_stream_sptr.declare_sample_delay(vector_to_stream_sptr self, int which, int delay)

declare_sample_delay(vector_to_stream_sptr self, unsigned int delay)

vector_to_stream_sptr.message_subscribers(vector_to_stream_sptr self, swig_int_ptr which_port) → swig_int_ptr

vector_to_stream_sptr.min_noutput_items(vector_to_stream_sptr self) → int

vector_to_stream_sptr.pc_input_buffers_full_avg(vector_to_stream_sptr self, int which) → float

pc_input_buffers_full_avg(vector_to_stream_sptr self) -> pmt_vector_float

vector_to_stream_sptr.pc_noutput_items_avg(vector_to_stream_sptr self) → float

vector_to_stream_sptr.pc_nproduced_avg(vector_to_stream_sptr self) → float

vector_to_stream_sptr.pc_output_buffers_full_avg(vector_to_stream_sptr self, int which) → float

pc_output_buffers_full_avg(vector_to_stream_sptr self) -> pmt_vector_float

vector_to_stream_sptr.pc_work_time_avg(vector_to_stream_sptr self) → float

vector_to_stream_sptr.pc_work_time_total(vector_to_stream_sptr self) → float

vector_to_stream_sptr.sample_delay(vector_to_stream_sptr self, int which) → unsigned int

vector_to_stream_sptr.set_min_noutput_items(vector_to_stream_sptr self, int m)

vector_to_stream_sptr.set_thread_priority(vector_to_stream_sptr self, int priority) → int

vector_to_stream_sptr.thread_priority(vector_to_stream_sptr self) → int

gnuradio.blocks.vector_to_streams(size_t itemsize, size_t nstreams) → vector_to_streams_sptr

Convert 1 stream of vectors of length N to N streams of items.

Constructor Specific Documentation:

Make vector-to-streams block

Parameters:

• itemsize – the item size of the stream
• nstreams – number of items per vector (vector size and number of streams produced)

vector_to_streams_sptr.active_thread_priority(vector_to_streams_sptr self) → int

vector_to_streams_sptr.declare_sample_delay(vector_to_streams_sptr self, int which, int delay)

declare_sample_delay(vector_to_streams_sptr self, unsigned int delay)

vector_to_streams_sptr.message_subscribers(vector_to_streams_sptr self, swig_int_ptr which_port) → swig_int_ptr

vector_to_streams_sptr.min_noutput_items(vector_to_streams_sptr self) → int

vector_to_streams_sptr.pc_input_buffers_full_avg(vector_to_streams_sptr self, int which) → float

pc_input_buffers_full_avg(vector_to_streams_sptr self) -> pmt_vector_float

vector_to_streams_sptr.pc_noutput_items_avg(vector_to_streams_sptr self) → float

vector_to_streams_sptr.pc_nproduced_avg(vector_to_streams_sptr self) → float

vector_to_streams_sptr.pc_output_buffers_full_avg(vector_to_streams_sptr self, int which) → float

pc_output_buffers_full_avg(vector_to_streams_sptr self) -> pmt_vector_float

vector_to_streams_sptr.pc_work_time_avg(vector_to_streams_sptr self) → float

vector_to_streams_sptr.pc_work_time_total(vector_to_streams_sptr self) → float

vector_to_streams_sptr.sample_delay(vector_to_streams_sptr self, int which) → unsigned int

vector_to_streams_sptr.set_min_noutput_items(vector_to_streams_sptr self, int m)

vector_to_streams_sptr.set_thread_priority(vector_to_streams_sptr self, int priority) → int

vector_to_streams_sptr.thread_priority(vector_to_streams_sptr self) → int