gnuradio.blocks: Streams Operators

gnuradio.blocks.vector_insert_b(__dummy_0__ data, int periodicity, int offset = 0) → 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(self) → int
vector_insert_b_sptr.rewind(self)
vector_insert_b_sptr.set_data(self, __dummy_0__ data)
vector_insert_b_sptr.set_thread_priority(self, int priority) → int
vector_insert_b_sptr.thread_priority(self) → int
gnuradio.blocks.vector_insert_c(std::vector<(gr_complex, std::allocator<(gr_complex)>)> data, int periodicity, int offset = 0) → 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(self) → int
vector_insert_c_sptr.rewind(self)
vector_insert_c_sptr.set_data(self, std::vector<(gr_complex, std::allocator<(gr_complex)>)> data)
vector_insert_c_sptr.set_thread_priority(self, int priority) → int
vector_insert_c_sptr.thread_priority(self) → int
gnuradio.blocks.vector_insert_f(pmt_vector_float data, int periodicity, int offset = 0) → 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(self) → int
vector_insert_f_sptr.rewind(self)
vector_insert_f_sptr.set_data(self, pmt_vector_float data)
vector_insert_f_sptr.set_thread_priority(self, int priority) → int
vector_insert_f_sptr.thread_priority(self) → int
gnuradio.blocks.vector_insert_i(__dummy_5__ data, int periodicity, int offset = 0) → 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(self) → int
vector_insert_i_sptr.rewind(self)
vector_insert_i_sptr.set_data(self, __dummy_5__ data)
vector_insert_i_sptr.set_thread_priority(self, int priority) → int
vector_insert_i_sptr.thread_priority(self) → int
gnuradio.blocks.vector_insert_s(__dummy_4__ data, int periodicity, int offset = 0) → 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(self) → int
vector_insert_s_sptr.rewind(self)
vector_insert_s_sptr.set_data(self, __dummy_4__ data)
vector_insert_s_sptr.set_thread_priority(self, int priority) → int
vector_insert_s_sptr.thread_priority(self) → int
gnuradio.blocks.deinterleave(size_t itemsize) → sptr

deinterleave a single input into N outputs

Constructor Specific Documentation:

Make a deinterleave block.

Parameters:itemsize – stream itemsize
deinterleave_sptr.active_thread_priority(self) → int
deinterleave_sptr.set_thread_priority(self, int priority) → int
deinterleave_sptr.thread_priority(self) → int
gnuradio.blocks.endian_swap(size_t item_size_bytes = 1) → 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(self) → int
endian_swap_sptr.set_thread_priority(self, int priority) → int
endian_swap_sptr.thread_priority(self) → int
gnuradio.blocks.interleave(size_t itemsize) → 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(self) → int
interleave_sptr.set_thread_priority(self, int priority) → int
interleave_sptr.thread_priority(self) → int
gnuradio.blocks.keep_m_in_n(size_t itemsize, int m, int n, int offset) → 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(self) → int
keep_m_in_n_sptr.set_m(self, int m)
keep_m_in_n_sptr.set_n(self, int n)
keep_m_in_n_sptr.set_offset(self, int offset)
keep_m_in_n_sptr.set_thread_priority(self, int priority) → int
keep_m_in_n_sptr.thread_priority(self) → int
gnuradio.blocks.keep_one_in_n(size_t itemsize, int 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(self) → int
keep_one_in_n_sptr.set_n(self, int n)
keep_one_in_n_sptr.set_thread_priority(self, int priority) → int
keep_one_in_n_sptr.thread_priority(self) → int
gnuradio.blocks.patterned_interleaver(size_t itemsize, __dummy_5__ pattern) → 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(self) → int
patterned_interleaver_sptr.set_thread_priority(self, int priority) → int
patterned_interleaver_sptr.thread_priority(self) → int
gnuradio.blocks.regenerate_bb(int period, unsigned int max_regen = 500) → 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(self) → int
regenerate_bb_sptr.max_regen(self) → unsigned int

return the maximum regeneration count.

regenerate_bb_sptr.period(self) → int

return the regeneration period.

regenerate_bb_sptr.set_max_regen(self, unsigned int regen)

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

regenerate_bb_sptr.set_period(self, int period)

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

regenerate_bb_sptr.set_thread_priority(self, int priority) → int
regenerate_bb_sptr.thread_priority(self) → int
gnuradio.blocks.repeat(size_t itemsize, int 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(self) → int
repeat_sptr.set_thread_priority(self, int priority) → int
repeat_sptr.thread_priority(self) → int
gnuradio.blocks.stream_mux(size_t itemsize, __dummy_5__ lengths) → 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(self) → int
stream_mux_sptr.set_thread_priority(self, int priority) → int
stream_mux_sptr.thread_priority(self) → int
gnuradio.blocks.stream_to_streams(size_t itemsize, size_t nstreams) → 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(self) → int
stream_to_streams_sptr.set_thread_priority(self, int priority) → int
stream_to_streams_sptr.thread_priority(self) → int
gnuradio.blocks.stream_to_vector(size_t itemsize, size_t nitems_per_block) → 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(self) → int
stream_to_vector_sptr.set_thread_priority(self, int priority) → int
stream_to_vector_sptr.thread_priority(self) → int
gnuradio.blocks.streams_to_stream(size_t itemsize, size_t nstreams) → 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(self) → int
streams_to_stream_sptr.set_thread_priority(self, int priority) → int
streams_to_stream_sptr.thread_priority(self) → int
gnuradio.blocks.streams_to_vector(size_t itemsize, size_t nstreams) → 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(self) → int
streams_to_vector_sptr.set_thread_priority(self, int priority) → int
streams_to_vector_sptr.thread_priority(self) → int
gnuradio.blocks.stretch_ff(float lo, size_t vlen = 1) → 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(self) → int
stretch_ff_sptr.lo(self) → float
stretch_ff_sptr.set_lo(self, float lo)
stretch_ff_sptr.set_thread_priority(self, int priority) → int
stretch_ff_sptr.thread_priority(self) → int
stretch_ff_sptr.vlen(self) → size_t
gnuradio.blocks.tagged_stream_mux(size_t itemsize, string lengthtagname) → 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.

Constructor Specific Documentation:

Make a tagged stream mux block.

Parameters:
  • itemsize – Items size (number of bytes per item)
  • lengthtagname – Length tag key
tagged_stream_mux_sptr.active_thread_priority(self) → int
tagged_stream_mux_sptr.set_thread_priority(self, int priority) → int
tagged_stream_mux_sptr.thread_priority(self) → int
gnuradio.blocks.vector_map(size_t item_size, gr_vsize_t in_vlens, gr_vvvsize_t mapping) → 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(self) → int
vector_map_sptr.set_mapping(self, gr_vvvsize_t mapping)
vector_map_sptr.set_thread_priority(self, int priority) → int
vector_map_sptr.thread_priority(self) → int
gnuradio.blocks.vector_to_stream(size_t itemsize, size_t nitems_per_block) → 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(self) → int
vector_to_stream_sptr.set_thread_priority(self, int priority) → int
vector_to_stream_sptr.thread_priority(self) → int
gnuradio.blocks.vector_to_streams(size_t itemsize, size_t nstreams) → 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(self) → int
vector_to_streams_sptr.set_thread_priority(self, int priority) → int
vector_to_streams_sptr.thread_priority(self) → int

Previous topic

gnuradio.blocks: Level Controllers

Next topic

gnuradio.blocks: ControlPort

This Page