gnuradio.gr: Miscellaneous Blocks

gnuradio.gr.copy(size_t itemsize) → gr_copy_sptr

output[i] = input[i]

When enabled (default), this block copies its input to its output. When disabled, this block drops its input on the floor.

gr_copy_sptr.enabled(self) → bool

gr_copy_sptr.set_enabled(self, bool enabled)

gnuradio.gr.delay(size_t itemsize, int delay) → gr_delay_sptr

delay the input by a certain number of samples

gr_delay_sptr.delay(self) → int

gr_delay_sptr.set_delay(self, int delay)

gnuradio.gr.kludge_copy(size_t itemsize) → gr_kludge_copy_sptr

output[i] = input[i]

This is a short term kludge to work around a problem with the hierarchical block impl.

gnuradio.gr.nop(size_t sizeof_stream_item) → gr_nop_sptr

Does nothing. Used for testing only.

gnuradio.gr.pa_2x2_phase_combiner() → gr_pa_2x2_phase_combiner_sptr

pa_2x2 phase combiner

Anntenas are arranged like this:

2 3 0 1

dx and dy are lambda/2.

gr_pa_2x2_phase_combiner_sptr.set_theta(self, float theta)

gr_pa_2x2_phase_combiner_sptr.theta(self) → float

gnuradio.gr.repeat(size_t itemsize, int interp) → gr_repeat_sptr

Repeat a sample ‘interp’ times in output stream.

gnuradio.gr.threshold_ff(float lo, float hi, float initial_state = 0) → gr_threshold_ff_sptr

Please fix my documentation.

gr_threshold_ff_sptr.hi(self) → float

gr_threshold_ff_sptr.last_state(self) → float

gr_threshold_ff_sptr.lo(self) → float

gr_threshold_ff_sptr.set_hi(self, float hi)

gr_threshold_ff_sptr.set_last_state(self, float last_state)

gr_threshold_ff_sptr.set_lo(self, float lo)

gnuradio.gr.throttle(size_t itemsize, double samples_per_sec) → sptr

throttle flow of samples such that the average rate does not exceed samples_per_sec.

input: one stream of itemsize; output: one stream of itemsize

N.B. this should only be used in GUI apps where there is no other rate limiting block. It is not intended nor effective at precisely controlling the rate of samples. That should be controlled by a source or sink tied to sample clock. E.g., a USRP or audio card.

gr_throttle_sptr.set_sample_rate(self, double rate)

Sets the sample rate in samples per second.

gnuradio.gr.channel_model(double noise_voltage = 0.0, double frequency_offset = 0.0, double epsilon = 1.0, std::vector<(gr_complex, std::allocator<(gr_complex)>)> taps = std::vector< gr_complex >(1, 1), double noise_seed = 3021) → gr_channel_model_sptr

channel simulator

gr_channel_model_sptr.disconnect_all(self)

gr_channel_model_sptr.frequency_offset(self) → double

gr_channel_model_sptr.lock(self)

gr_channel_model_sptr.noise_voltage(self) → double

gr_channel_model_sptr.primitive_connect(self, gr_basic_block_sptr block)

primitive_connect(self, gr_basic_block_sptr src, int src_port, gr_basic_block_sptr dst, int dst_port)

gr_channel_model_sptr.primitive_disconnect(self, gr_basic_block_sptr block)

primitive_disconnect(self, gr_basic_block_sptr src, int src_port, gr_basic_block_sptr dst, int dst_port)

gr_channel_model_sptr.set_frequency_offset(self, double frequency_offset)

gr_channel_model_sptr.set_noise_voltage(self, double noise_voltage)

gr_channel_model_sptr.set_taps(self, std::vector<(gr_complex, std::allocator<(gr_complex)>)> taps)

gr_channel_model_sptr.set_timing_offset(self, double epsilon)

gr_channel_model_sptr.taps(self) → std::vector<(gr_complex,std::allocator<(gr_complex)>)>

gr_channel_model_sptr.timing_offset(self) → double

gr_channel_model_sptr.to_hier_block2(self) → gr_hier_block2_sptr

gr_channel_model_sptr.unlock(self)