gnuradio.blocks: Data Type Converters

gnuradio.blocks.char_to_float(size_t vlen=1, float scale=1.0) → char_to_float_sptr

Convert stream of chars to a stream of float.

Converts length vectors of input char samples to floats and applies a scaling factor of

Constructor Specific Documentation:

Build a chars to float stream converter block.

Parameters:

• vlen – vector length of data streams.
• scale – a scalar divider to change the output signal scale.

char_to_float_sptr.active_thread_priority(char_to_float_sptr self) → int

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

declare_sample_delay(char_to_float_sptr self, unsigned int delay)

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

char_to_float_sptr.min_noutput_items(char_to_float_sptr self) → int

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

pc_input_buffers_full_avg(char_to_float_sptr self) -> pmt_vector_float

char_to_float_sptr.pc_noutput_items_avg(char_to_float_sptr self) → float

char_to_float_sptr.pc_nproduced_avg(char_to_float_sptr self) → float

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

pc_output_buffers_full_avg(char_to_float_sptr self) -> pmt_vector_float

char_to_float_sptr.pc_throughput_avg(char_to_float_sptr self) → float

char_to_float_sptr.pc_work_time_avg(char_to_float_sptr self) → float

char_to_float_sptr.pc_work_time_total(char_to_float_sptr self) → float

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

char_to_float_sptr.scale(char_to_float_sptr self) → float

Get the scalar divider value.

char_to_float_sptr.set_min_noutput_items(char_to_float_sptr self, int m)

char_to_float_sptr.set_scale(char_to_float_sptr self, float scale)

Set the scalar divider value.

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

char_to_float_sptr.thread_priority(char_to_float_sptr self) → int

gnuradio.blocks.char_to_short(size_t vlen=1) → char_to_short_sptr

Convert stream of chars to a stream of shorts.

Converts length vectors of input char samples to shorts, multiplying each element by 256:

Constructor Specific Documentation:

Parameters:vlen –

char_to_short_sptr.active_thread_priority(char_to_short_sptr self) → int

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

declare_sample_delay(char_to_short_sptr self, unsigned int delay)

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

char_to_short_sptr.min_noutput_items(char_to_short_sptr self) → int

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

pc_input_buffers_full_avg(char_to_short_sptr self) -> pmt_vector_float

char_to_short_sptr.pc_noutput_items_avg(char_to_short_sptr self) → float

char_to_short_sptr.pc_nproduced_avg(char_to_short_sptr self) → float

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

pc_output_buffers_full_avg(char_to_short_sptr self) -> pmt_vector_float

char_to_short_sptr.pc_throughput_avg(char_to_short_sptr self) → float

char_to_short_sptr.pc_work_time_avg(char_to_short_sptr self) → float

char_to_short_sptr.pc_work_time_total(char_to_short_sptr self) → float

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

char_to_short_sptr.set_min_noutput_items(char_to_short_sptr self, int m)

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

char_to_short_sptr.thread_priority(char_to_short_sptr self) → int

gnuradio.blocks.complex_to_arg(size_t vlen=1) → complex_to_arg_sptr

complex in, arg (arctan) out (float)

Constructor Specific Documentation:

Build a complex to arg block.

Parameters:vlen – vector len (default 1)

complex_to_arg_sptr.active_thread_priority(complex_to_arg_sptr self) → int

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

declare_sample_delay(complex_to_arg_sptr self, unsigned int delay)

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

complex_to_arg_sptr.min_noutput_items(complex_to_arg_sptr self) → int

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

pc_input_buffers_full_avg(complex_to_arg_sptr self) -> pmt_vector_float

complex_to_arg_sptr.pc_noutput_items_avg(complex_to_arg_sptr self) → float

complex_to_arg_sptr.pc_nproduced_avg(complex_to_arg_sptr self) → float

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

pc_output_buffers_full_avg(complex_to_arg_sptr self) -> pmt_vector_float

complex_to_arg_sptr.pc_throughput_avg(complex_to_arg_sptr self) → float

complex_to_arg_sptr.pc_work_time_avg(complex_to_arg_sptr self) → float

complex_to_arg_sptr.pc_work_time_total(complex_to_arg_sptr self) → float

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

complex_to_arg_sptr.set_min_noutput_items(complex_to_arg_sptr self, int m)

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

complex_to_arg_sptr.thread_priority(complex_to_arg_sptr self) → int

gnuradio.blocks.complex_to_float(size_t vlen=1) → complex_to_float_sptr

Convert a stream of gr_complex to 1 or 2 streams of float.

If a single output stream is attached, this will output the real part of the input complex samples. If a second output stream is connected, output[0] is the real part and output[1] is the imaginary part.

Constructor Specific Documentation:

Build a complex to float block.

Parameters:vlen – vector len (default 1)

complex_to_float_sptr.active_thread_priority(complex_to_float_sptr self) → int

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

declare_sample_delay(complex_to_float_sptr self, unsigned int delay)

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

complex_to_float_sptr.min_noutput_items(complex_to_float_sptr self) → int

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

pc_input_buffers_full_avg(complex_to_float_sptr self) -> pmt_vector_float

complex_to_float_sptr.pc_noutput_items_avg(complex_to_float_sptr self) → float

complex_to_float_sptr.pc_nproduced_avg(complex_to_float_sptr self) → float

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

pc_output_buffers_full_avg(complex_to_float_sptr self) -> pmt_vector_float

complex_to_float_sptr.pc_throughput_avg(complex_to_float_sptr self) → float

complex_to_float_sptr.pc_work_time_avg(complex_to_float_sptr self) → float

complex_to_float_sptr.pc_work_time_total(complex_to_float_sptr self) → float

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

complex_to_float_sptr.set_min_noutput_items(complex_to_float_sptr self, int m)

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

complex_to_float_sptr.thread_priority(complex_to_float_sptr self) → int

gnuradio.blocks.complex_to_imag(size_t vlen=1) → complex_to_imag_sptr

Produces the imaginary part (as a float0 of a complex stream.

Constructor Specific Documentation:

Build a complex to imaginary part block.

Parameters:vlen – vector len (default 1)

complex_to_imag_sptr.active_thread_priority(complex_to_imag_sptr self) → int

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

declare_sample_delay(complex_to_imag_sptr self, unsigned int delay)

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

complex_to_imag_sptr.min_noutput_items(complex_to_imag_sptr self) → int

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

pc_input_buffers_full_avg(complex_to_imag_sptr self) -> pmt_vector_float

complex_to_imag_sptr.pc_noutput_items_avg(complex_to_imag_sptr self) → float

complex_to_imag_sptr.pc_nproduced_avg(complex_to_imag_sptr self) → float

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

pc_output_buffers_full_avg(complex_to_imag_sptr self) -> pmt_vector_float

complex_to_imag_sptr.pc_throughput_avg(complex_to_imag_sptr self) → float

complex_to_imag_sptr.pc_work_time_avg(complex_to_imag_sptr self) → float

complex_to_imag_sptr.pc_work_time_total(complex_to_imag_sptr self) → float

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

complex_to_imag_sptr.set_min_noutput_items(complex_to_imag_sptr self, int m)

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

complex_to_imag_sptr.thread_priority(complex_to_imag_sptr self) → int

gnuradio.blocks.complex_to_interleaved_short(bool vector=False) → complex_to_interleaved_short_sptr

Convert stream of complex to a stream of interleaved shorts.

The output stream contains shorts with twice as many output items as input items. For every complex input item, we produce two output shorts that contain the real part and imaginary part converted to shorts:

Constructor Specific Documentation:

Build a complex to interleaved shorts block.

Parameters:vector –

complex_to_interleaved_short_sptr.active_thread_priority(complex_to_interleaved_short_sptr self) → int

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

declare_sample_delay(complex_to_interleaved_short_sptr self, unsigned int delay)

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

complex_to_interleaved_short_sptr.min_noutput_items(complex_to_interleaved_short_sptr self) → int

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

pc_input_buffers_full_avg(complex_to_interleaved_short_sptr self) -> pmt_vector_float

complex_to_interleaved_short_sptr.pc_noutput_items_avg(complex_to_interleaved_short_sptr self) → float

complex_to_interleaved_short_sptr.pc_nproduced_avg(complex_to_interleaved_short_sptr self) → float

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

pc_output_buffers_full_avg(complex_to_interleaved_short_sptr self) -> pmt_vector_float

complex_to_interleaved_short_sptr.pc_throughput_avg(complex_to_interleaved_short_sptr self) → float

complex_to_interleaved_short_sptr.pc_work_time_avg(complex_to_interleaved_short_sptr self) → float

complex_to_interleaved_short_sptr.pc_work_time_total(complex_to_interleaved_short_sptr self) → float

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

complex_to_interleaved_short_sptr.set_min_noutput_items(complex_to_interleaved_short_sptr self, int m)

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

complex_to_interleaved_short_sptr.thread_priority(complex_to_interleaved_short_sptr self) → int

gnuradio.blocks.complex_to_mag(size_t vlen=1) → complex_to_mag_sptr

complex in, magnitude out (float)

Calculates the magnitude of the complex samples:

Or: The input stream can be a vector of length , and for each vector, each item is converted using the above function. So above, m is from 0 to noutput_items*vlen for each call to work.

Constructor Specific Documentation:

Build a complex to magnitude block.

Parameters:vlen – vector len (default 1)

complex_to_mag_sptr.active_thread_priority(complex_to_mag_sptr self) → int

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

declare_sample_delay(complex_to_mag_sptr self, unsigned int delay)

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

complex_to_mag_sptr.min_noutput_items(complex_to_mag_sptr self) → int

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

pc_input_buffers_full_avg(complex_to_mag_sptr self) -> pmt_vector_float

complex_to_mag_sptr.pc_noutput_items_avg(complex_to_mag_sptr self) → float

complex_to_mag_sptr.pc_nproduced_avg(complex_to_mag_sptr self) → float

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

pc_output_buffers_full_avg(complex_to_mag_sptr self) -> pmt_vector_float

complex_to_mag_sptr.pc_throughput_avg(complex_to_mag_sptr self) → float

complex_to_mag_sptr.pc_work_time_avg(complex_to_mag_sptr self) → float

complex_to_mag_sptr.pc_work_time_total(complex_to_mag_sptr self) → float

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

complex_to_mag_sptr.set_min_noutput_items(complex_to_mag_sptr self, int m)

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

complex_to_mag_sptr.thread_priority(complex_to_mag_sptr self) → int

gnuradio.blocks.complex_to_mag_squared(size_t vlen=1) → complex_to_mag_squared_sptr

complex in, magnitude squared out (float)

Calculates the magnitude squared of the complex samples:

Or: The input stream can be a vector of length , and for each vector, each item is converted using the above function. So above, m is from 0 to noutput_items*vlen for each call to work.

Constructor Specific Documentation:

Build a complex to magnitude squared block.

Parameters:vlen – vector len (default 1)

complex_to_mag_squared_sptr.active_thread_priority(complex_to_mag_squared_sptr self) → int

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

declare_sample_delay(complex_to_mag_squared_sptr self, unsigned int delay)

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

complex_to_mag_squared_sptr.min_noutput_items(complex_to_mag_squared_sptr self) → int

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

pc_input_buffers_full_avg(complex_to_mag_squared_sptr self) -> pmt_vector_float

complex_to_mag_squared_sptr.pc_noutput_items_avg(complex_to_mag_squared_sptr self) → float

complex_to_mag_squared_sptr.pc_nproduced_avg(complex_to_mag_squared_sptr self) → float

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

pc_output_buffers_full_avg(complex_to_mag_squared_sptr self) -> pmt_vector_float

complex_to_mag_squared_sptr.pc_throughput_avg(complex_to_mag_squared_sptr self) → float

complex_to_mag_squared_sptr.pc_work_time_avg(complex_to_mag_squared_sptr self) → float

complex_to_mag_squared_sptr.pc_work_time_total(complex_to_mag_squared_sptr self) → float

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

complex_to_mag_squared_sptr.set_min_noutput_items(complex_to_mag_squared_sptr self, int m)

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

complex_to_mag_squared_sptr.thread_priority(complex_to_mag_squared_sptr self) → int

gnuradio.blocks.complex_to_real(size_t vlen=1) → complex_to_real_sptr

Produces the real part (as a float0 of a complex stream.

Constructor Specific Documentation:

Build a complex to real part block.

Parameters:vlen – vector len (default 1)

complex_to_real_sptr.active_thread_priority(complex_to_real_sptr self) → int

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

declare_sample_delay(complex_to_real_sptr self, unsigned int delay)

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

complex_to_real_sptr.min_noutput_items(complex_to_real_sptr self) → int

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

pc_input_buffers_full_avg(complex_to_real_sptr self) -> pmt_vector_float

complex_to_real_sptr.pc_noutput_items_avg(complex_to_real_sptr self) → float

complex_to_real_sptr.pc_nproduced_avg(complex_to_real_sptr self) → float

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

pc_output_buffers_full_avg(complex_to_real_sptr self) -> pmt_vector_float

complex_to_real_sptr.pc_throughput_avg(complex_to_real_sptr self) → float

complex_to_real_sptr.pc_work_time_avg(complex_to_real_sptr self) → float

complex_to_real_sptr.pc_work_time_total(complex_to_real_sptr self) → float

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

complex_to_real_sptr.set_min_noutput_items(complex_to_real_sptr self, int m)

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

complex_to_real_sptr.thread_priority(complex_to_real_sptr self) → int

gnuradio.blocks.float_to_char(size_t vlen=1, float scale=1.0) → float_to_char_sptr

Convert stream of floats to a stream of char.

Constructor Specific Documentation:

Build a float to char block.

Parameters:

• vlen – vector length of data streams.
• scale – a scalar multiplier to change the output signal scale.

float_to_char_sptr.active_thread_priority(float_to_char_sptr self) → int

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

declare_sample_delay(float_to_char_sptr self, unsigned int delay)

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

float_to_char_sptr.min_noutput_items(float_to_char_sptr self) → int

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

pc_input_buffers_full_avg(float_to_char_sptr self) -> pmt_vector_float

float_to_char_sptr.pc_noutput_items_avg(float_to_char_sptr self) → float

float_to_char_sptr.pc_nproduced_avg(float_to_char_sptr self) → float

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

pc_output_buffers_full_avg(float_to_char_sptr self) -> pmt_vector_float

float_to_char_sptr.pc_throughput_avg(float_to_char_sptr self) → float

float_to_char_sptr.pc_work_time_avg(float_to_char_sptr self) → float

float_to_char_sptr.pc_work_time_total(float_to_char_sptr self) → float

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

float_to_char_sptr.scale(float_to_char_sptr self) → float

Get the scalar multiplier value.

float_to_char_sptr.set_min_noutput_items(float_to_char_sptr self, int m)

float_to_char_sptr.set_scale(float_to_char_sptr self, float scale)

Set the scalar multiplier value.

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

float_to_char_sptr.thread_priority(float_to_char_sptr self) → int

gnuradio.blocks.float_to_complex(size_t vlen=1) → float_to_complex_sptr

one or two floats in, complex out

Constructor Specific Documentation:

Build a float to complex block.

Parameters:vlen – vector len (default 1)

float_to_complex_sptr.active_thread_priority(float_to_complex_sptr self) → int

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

declare_sample_delay(float_to_complex_sptr self, unsigned int delay)

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

float_to_complex_sptr.min_noutput_items(float_to_complex_sptr self) → int

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

pc_input_buffers_full_avg(float_to_complex_sptr self) -> pmt_vector_float

float_to_complex_sptr.pc_noutput_items_avg(float_to_complex_sptr self) → float

float_to_complex_sptr.pc_nproduced_avg(float_to_complex_sptr self) → float

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

pc_output_buffers_full_avg(float_to_complex_sptr self) -> pmt_vector_float

float_to_complex_sptr.pc_throughput_avg(float_to_complex_sptr self) → float

float_to_complex_sptr.pc_work_time_avg(float_to_complex_sptr self) → float

float_to_complex_sptr.pc_work_time_total(float_to_complex_sptr self) → float

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

float_to_complex_sptr.set_min_noutput_items(float_to_complex_sptr self, int m)

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

float_to_complex_sptr.thread_priority(float_to_complex_sptr self) → int

gnuradio.blocks.float_to_int(size_t vlen=1, float scale=1.0) → float_to_int_sptr

Convert stream of floats to a stream of ints.

Constructor Specific Documentation:

Build a float to int block.

Parameters:

• vlen – vector length of data streams.
• scale – a scalar multiplier to change the output signal scale.

float_to_int_sptr.active_thread_priority(float_to_int_sptr self) → int

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

declare_sample_delay(float_to_int_sptr self, unsigned int delay)

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

float_to_int_sptr.min_noutput_items(float_to_int_sptr self) → int

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

pc_input_buffers_full_avg(float_to_int_sptr self) -> pmt_vector_float

float_to_int_sptr.pc_noutput_items_avg(float_to_int_sptr self) → float

float_to_int_sptr.pc_nproduced_avg(float_to_int_sptr self) → float

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

pc_output_buffers_full_avg(float_to_int_sptr self) -> pmt_vector_float

float_to_int_sptr.pc_throughput_avg(float_to_int_sptr self) → float

float_to_int_sptr.pc_work_time_avg(float_to_int_sptr self) → float

float_to_int_sptr.pc_work_time_total(float_to_int_sptr self) → float

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

float_to_int_sptr.scale(float_to_int_sptr self) → float

Get the scalar multiplier value.

float_to_int_sptr.set_min_noutput_items(float_to_int_sptr self, int m)

float_to_int_sptr.set_scale(float_to_int_sptr self, float scale)

Set the scalar multiplier value.

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

float_to_int_sptr.thread_priority(float_to_int_sptr self) → int

gnuradio.blocks.float_to_short(size_t vlen=1, float scale=1.0) → float_to_short_sptr

Convert stream of floats to a stream of shorts.

Constructor Specific Documentation:

Build a float to short block.

Parameters:

• vlen – vector length of data streams.
• scale – a scalar multiplier to change the output signal scale.

float_to_short_sptr.active_thread_priority(float_to_short_sptr self) → int

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

declare_sample_delay(float_to_short_sptr self, unsigned int delay)

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

float_to_short_sptr.min_noutput_items(float_to_short_sptr self) → int

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

pc_input_buffers_full_avg(float_to_short_sptr self) -> pmt_vector_float

float_to_short_sptr.pc_noutput_items_avg(float_to_short_sptr self) → float

float_to_short_sptr.pc_nproduced_avg(float_to_short_sptr self) → float

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

pc_output_buffers_full_avg(float_to_short_sptr self) -> pmt_vector_float

float_to_short_sptr.pc_throughput_avg(float_to_short_sptr self) → float

float_to_short_sptr.pc_work_time_avg(float_to_short_sptr self) → float

float_to_short_sptr.pc_work_time_total(float_to_short_sptr self) → float

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

float_to_short_sptr.scale(float_to_short_sptr self) → float

Get the scalar multiplier value.

float_to_short_sptr.set_min_noutput_items(float_to_short_sptr self, int m)

float_to_short_sptr.set_scale(float_to_short_sptr self, float scale)

Set the scalar multiplier value.

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

float_to_short_sptr.thread_priority(float_to_short_sptr self) → int

gnuradio.blocks.float_to_uchar() → float_to_uchar_sptr

Convert stream of floats to a stream of unsigned chars.

Constructor Specific Documentation:

Build a float to uchar block.

float_to_uchar_sptr.active_thread_priority(float_to_uchar_sptr self) → int

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

declare_sample_delay(float_to_uchar_sptr self, unsigned int delay)

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

float_to_uchar_sptr.min_noutput_items(float_to_uchar_sptr self) → int

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

pc_input_buffers_full_avg(float_to_uchar_sptr self) -> pmt_vector_float

float_to_uchar_sptr.pc_noutput_items_avg(float_to_uchar_sptr self) → float

float_to_uchar_sptr.pc_nproduced_avg(float_to_uchar_sptr self) → float

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

pc_output_buffers_full_avg(float_to_uchar_sptr self) -> pmt_vector_float

float_to_uchar_sptr.pc_throughput_avg(float_to_uchar_sptr self) → float

float_to_uchar_sptr.pc_work_time_avg(float_to_uchar_sptr self) → float

float_to_uchar_sptr.pc_work_time_total(float_to_uchar_sptr self) → float

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

float_to_uchar_sptr.set_min_noutput_items(float_to_uchar_sptr self, int m)

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

float_to_uchar_sptr.thread_priority(float_to_uchar_sptr self) → int

gnuradio.blocks.int_to_float(size_t vlen=1, float scale=1.0) → int_to_float_sptr

Convert stream of ints to a stream of floats.

Constructor Specific Documentation:

Build an int to float block.

Parameters:

• vlen – vector length of data streams.
• scale – a scalar divider to change the output signal scale.

int_to_float_sptr.active_thread_priority(int_to_float_sptr self) → int

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

declare_sample_delay(int_to_float_sptr self, unsigned int delay)

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

int_to_float_sptr.min_noutput_items(int_to_float_sptr self) → int

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

pc_input_buffers_full_avg(int_to_float_sptr self) -> pmt_vector_float

int_to_float_sptr.pc_noutput_items_avg(int_to_float_sptr self) → float

int_to_float_sptr.pc_nproduced_avg(int_to_float_sptr self) → float

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

pc_output_buffers_full_avg(int_to_float_sptr self) -> pmt_vector_float

int_to_float_sptr.pc_throughput_avg(int_to_float_sptr self) → float

int_to_float_sptr.pc_work_time_avg(int_to_float_sptr self) → float

int_to_float_sptr.pc_work_time_total(int_to_float_sptr self) → float

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

int_to_float_sptr.scale(int_to_float_sptr self) → float

Get the scalar divider value.

int_to_float_sptr.set_min_noutput_items(int_to_float_sptr self, int m)

int_to_float_sptr.set_scale(int_to_float_sptr self, float scale)

Set the scalar divider value.

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

int_to_float_sptr.thread_priority(int_to_float_sptr self) → int

gnuradio.blocks.interleaved_short_to_complex(bool vector_input=False, bool swap=False) → interleaved_short_to_complex_sptr

Convert stream of interleaved shorts to a stream of complex.

Constructor Specific Documentation:

Build an interleaved short to complex block.

Parameters:

• vector_input –
• swap –

interleaved_short_to_complex_sptr.active_thread_priority(interleaved_short_to_complex_sptr self) → int

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

declare_sample_delay(interleaved_short_to_complex_sptr self, unsigned int delay)

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

interleaved_short_to_complex_sptr.min_noutput_items(interleaved_short_to_complex_sptr self) → int

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

pc_input_buffers_full_avg(interleaved_short_to_complex_sptr self) -> pmt_vector_float

interleaved_short_to_complex_sptr.pc_noutput_items_avg(interleaved_short_to_complex_sptr self) → float

interleaved_short_to_complex_sptr.pc_nproduced_avg(interleaved_short_to_complex_sptr self) → float

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

pc_output_buffers_full_avg(interleaved_short_to_complex_sptr self) -> pmt_vector_float

interleaved_short_to_complex_sptr.pc_throughput_avg(interleaved_short_to_complex_sptr self) → float

interleaved_short_to_complex_sptr.pc_work_time_avg(interleaved_short_to_complex_sptr self) → float

interleaved_short_to_complex_sptr.pc_work_time_total(interleaved_short_to_complex_sptr self) → float

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

interleaved_short_to_complex_sptr.set_min_noutput_items(interleaved_short_to_complex_sptr self, int m)

interleaved_short_to_complex_sptr.set_swap(interleaved_short_to_complex_sptr self, bool swap)

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

interleaved_short_to_complex_sptr.thread_priority(interleaved_short_to_complex_sptr self) → int

gnuradio.blocks.short_to_char(size_t vlen=1) → short_to_char_sptr

Convert stream of shorts to a stream of chars.

This block strips off the least significant byte from the short value.

[0x00ff, 0x0ff0, 0xff00] => [0x00, 0x0f, 0xff]

Converts length vectors of input short samples to chars, dividing each element by 256.

Constructor Specific Documentation:

Build a short to char block.

Parameters:vlen – vector length of data streams.

short_to_char_sptr.active_thread_priority(short_to_char_sptr self) → int

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

declare_sample_delay(short_to_char_sptr self, unsigned int delay)

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

short_to_char_sptr.min_noutput_items(short_to_char_sptr self) → int

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

pc_input_buffers_full_avg(short_to_char_sptr self) -> pmt_vector_float

short_to_char_sptr.pc_noutput_items_avg(short_to_char_sptr self) → float

short_to_char_sptr.pc_nproduced_avg(short_to_char_sptr self) → float

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

pc_output_buffers_full_avg(short_to_char_sptr self) -> pmt_vector_float

short_to_char_sptr.pc_throughput_avg(short_to_char_sptr self) → float

short_to_char_sptr.pc_work_time_avg(short_to_char_sptr self) → float

short_to_char_sptr.pc_work_time_total(short_to_char_sptr self) → float

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

short_to_char_sptr.set_min_noutput_items(short_to_char_sptr self, int m)

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

short_to_char_sptr.thread_priority(short_to_char_sptr self) → int

gnuradio.blocks.short_to_float(size_t vlen=1, float scale=1.0) → short_to_float_sptr

Convert stream of shorts to a stream of floats.

Constructor Specific Documentation:

Build a short to float block.

Parameters:

• vlen – vector length of data streams.
• scale – a scalar divider to change the output signal scale.

short_to_float_sptr.active_thread_priority(short_to_float_sptr self) → int

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

declare_sample_delay(short_to_float_sptr self, unsigned int delay)

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

short_to_float_sptr.min_noutput_items(short_to_float_sptr self) → int

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

pc_input_buffers_full_avg(short_to_float_sptr self) -> pmt_vector_float

short_to_float_sptr.pc_noutput_items_avg(short_to_float_sptr self) → float

short_to_float_sptr.pc_nproduced_avg(short_to_float_sptr self) → float

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

pc_output_buffers_full_avg(short_to_float_sptr self) -> pmt_vector_float

short_to_float_sptr.pc_throughput_avg(short_to_float_sptr self) → float

short_to_float_sptr.pc_work_time_avg(short_to_float_sptr self) → float

short_to_float_sptr.pc_work_time_total(short_to_float_sptr self) → float

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

short_to_float_sptr.scale(short_to_float_sptr self) → float

Get the scalar divider value.

short_to_float_sptr.set_min_noutput_items(short_to_float_sptr self, int m)

short_to_float_sptr.set_scale(short_to_float_sptr self, float scale)

Set the scalar divider value.

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

short_to_float_sptr.thread_priority(short_to_float_sptr self) → int

gnuradio.blocks.uchar_to_float() → uchar_to_float_sptr

Convert stream of unsigned chars to a stream of floats.

Constructor Specific Documentation:

Build a uchar to float block.

uchar_to_float_sptr.active_thread_priority(uchar_to_float_sptr self) → int

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

declare_sample_delay(uchar_to_float_sptr self, unsigned int delay)

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

uchar_to_float_sptr.min_noutput_items(uchar_to_float_sptr self) → int

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

pc_input_buffers_full_avg(uchar_to_float_sptr self) -> pmt_vector_float

uchar_to_float_sptr.pc_noutput_items_avg(uchar_to_float_sptr self) → float

uchar_to_float_sptr.pc_nproduced_avg(uchar_to_float_sptr self) → float

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

pc_output_buffers_full_avg(uchar_to_float_sptr self) -> pmt_vector_float

uchar_to_float_sptr.pc_throughput_avg(uchar_to_float_sptr self) → float

uchar_to_float_sptr.pc_work_time_avg(uchar_to_float_sptr self) → float

uchar_to_float_sptr.pc_work_time_total(uchar_to_float_sptr self) → float

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

uchar_to_float_sptr.set_min_noutput_items(uchar_to_float_sptr self, int m)

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

uchar_to_float_sptr.thread_priority(uchar_to_float_sptr self) → int