| db_flexrf::_1200_common | |
| db_flexrf::_1800_common | |
| db_flexrf::_2400_common | |
| db_flexrf::_400_common | |
| db_flexrf::_900_common | |
| db_flexrf::_AD4360_common | |
| db_wbx::_ADF410X_common | |
| python::powermate::_contour_remapper | |
| db_wbx::_lo_common | |
| gnuradio::blks2impl::logpwrfft::_logpwrfft_base | ! Create a log10(abs(fft)) stream chain, with real or complex input |
| python::powermate::_powermate_remapper | |
| gnuradio::gr::prefs::_prefs | Derive our 'real class' from the stubbed out base class that has support for SWIG directors |
| radar_mono::_queue_watcher_thread | |
| gnuradio::blks2impl::pkt::_queue_watcher_thread | |
| gnuradio::blksimpl::pkt::_queue_watcher_thread | |
| gnuradio::blks2impl::rational_resampler::_rational_resampler_base | Base class for all rational resampler variants |
| gnuradio::blksimpl::rational_resampler::_rational_resampler_base | Base class for all rational resampler variants |
| python::form::abstract_converter | |
| ssbagc::agc | |
| gnuradio::blks2impl::am_demod::am_demod_cf | Generalized AM demodulation block with audio filtering |
| gnuradio::blksimpl::am_demod::am_demod_cf | Generalized AM demodulation block with audio filtering |
| gnuradio::blks2impl::filterbank::analysis_filterbank | Uniformly modulated polyphase DFT filter bank: analysis |
| gnuradio::blksimpl::filterbank::analysis_filterbank | Uniformly modulated polyphase DFT filter bank: analysis |
| python::powermate::App | |
| multi_usrp_oscope::app_flow_graph | |
| usrp_psr_receiver::app_flow_graph | |
| usrp_ra_receiver::app_flow_graph | |
| audio_fft::app_top_block | |
| src::usrp_flex_all::app_top_block | |
| src::usrp_flex_band::app_top_block | |
| python::gpio_usrp_fft::app_top_block | |
| src::usrp_flex::app_top_block | This example application demonstrates receiving and demodulating the FLEX pager protocol |
| usrp_fft::app_top_block | |
| usrp_oscope::app_top_block | |
| usrp_rx_nogui::app_top_block | |
| atsc_bit_timing_loop | ATSC BitTimingLoop3 This class accepts a single real input and produces two outputs, the raw symbol (float) and the tag (atsc_syminfo) |
| atsc_data_segment | 832 3 bit symbols. The low 3 bits in the byte hold the symbol |
| atsc_deinterleaver | Deinterleave RS encoded ATSC data ( atsc_mpeg_packet_rs_encoded --> atsc_mpeg_packet_rs_encoded) input: atsc_mpeg_packet_rs_encoded; output: atsc_mpeg_packet_rs_encoded |
| atsc_depad | Depad mpeg ts packets from 256 byte atsc_mpeg_packet to 188 byte char input: atsc_mpeg_packet; output: unsigned char |
| atsc_derandomizer | "dewhiten" incoming mpeg transport stream packets |
| atsc_ds_to_softds | Debug glue routine (atsc_data_segment --> atsc_soft_data_segment) |
| atsc_equalizer | ATSC equalizer (float,syminfo --> float,syminfo) first inputs are data samples, second inputs are tags. first outputs are equalized data samples, second outputs are tags |
| atsc_field_sync_demux | ATSC Field Sync Demux |
| atsc_field_sync_mux | Insert ATSC Field Syncs as required (atsc_data_segment --> atsc_data_segment) |
| atsc_fpll | ATSC FPLL (2nd Version) A/D --> GrFIRfilterFFF ----> GrAtscFPLL ----> |
| atsc_fs_checker | ATSC field sync checker (float,syminfo --> float,syminfo) first output is delayed version of input. second output is set of tags, one-for-one with first output |
| atsc_interleaver | Interleave RS encoded ATSC data ( atsc_mpeg_packet_rs_encoded --> atsc_mpeg_packet_rs_encoded)* input: atsc_mpeg_packet_rs_encoded; output: atsc_mpeg_packet_rs_encoded |
| atsc_mpeg_packet | |
| atsc_mpeg_packet_no_sync | |
| atsc_mpeg_packet_rs_encoded | |
| atsc_pad | Pad mpeg ts packets from 188 byte char to to 256 byte atsc_mpeg_packet input: unsigned char; output: atsc_mpeg_packet |
| atsc_randomizer | "Whiten" incoming mpeg transport stream packets |
| atsc_root_raised_cosine | |
| atsc_root_raised_cosine_bandpass | |
| atsc_rs_decoder | Reed-Solomon decoder for ATSC input: atsc_mpeg_packet_rs_encoded; output: atsc_mpeg_packet_no_sync |
| atsc_rs_encoder | Reed-Solomon encoder for ATSC input: atsc_mpeg_packet_no_sync; output: atsc_mpeg_packet_rs_encoded |
| atsc_soft_data_segment | |
| atsc_trellis_encoder | ATSC 12-way interleaved trellis encoder (atsc_mpeg_packet_rs_encoded --> atsc_data_segment) input: atsc_mpeg_packet_rs_encoded; output: atsc_data_segment |
| atsc_viterbi_decoder | ATSC 12-way interleaved viterbi decoder (atsc_soft_data_segment --> atsc_mpeg_packet_rs_encoded) input: atsc_soft_data_segment; output: atsc_mpeg_packet_rs_encoded |
| atsc_vsbtx_lp | |
| atsci_basic_trellis_encoder | ATSC trellis encoder building block |
| atsci_data_deinterleaver | Atsc convolutional data deinterleaver |
| atsci_data_interleaver | Atsc convolutional data interleaver |
| atsci_equalizer | Abstract base class for ATSC equalizer |
| atsci_equalizer_lms | |
| atsci_equalizer_lms2 | |
| atsci_equalizer_nop | |
| atsci_exp2_lp | |
| atsci_fake_single_viterbi | Single channel viterbi decoder |
| atsci_fs_checker | Abstract base class for ATSC field sync checker |
| atsci_fs_checker_naive | Naive concrete implementation of field sync checker |
| atsci_fs_correlator | Abstract base class for ATSC field sync correlator |
| atsci_fs_correlator_naive | Naive concrete implementation of field sync correlator |
| atsci_interpolator | Interpolator control for segment and symbol sync recovery |
| atsci_randomizer | ATSC data "whitener" |
| atsci_reed_solomon | ATSC Reed-Solomon encoder / decoder |
| atsci_single_viterbi | Single channel viterbi decoder |
| atsci_slicer_agc | Automatic Gain Control class for atsc slicer |
| atsci_sliding_correlator | Look for the PN 511 field sync pattern |
| atsci_sssr | ATSC Segment and Symbol Sync Recovery |
| atsci_trellis_encoder | Fancy, schmancy 12-way interleaved trellis encoder for ATSC |
| atsci_viterbi_decoder | Fancy, schmancy 12-way interleaved viterbi decoder for ATSC |
| audio_alsa_sink | Audio sink using ALSA |
| audio_alsa_source | Audio source using ALSA |
| audio_jack_sink | Audio sink using JACK |
| audio_jack_source | Audio source using JACK |
| audio_oss_sink | Audio sink using OSS |
| audio_oss_source | Audio source using OSS |
| audio_osx_sink | Audio sink using OSX |
| audio_osx_source | Audio source using OSX |
| audio_portaudio_sink | |
| audio_portaudio_source | |
| tx_voice::audio_rx | |
| audio_sink::audio_sink | |
| audio_source::audio_source | |
| rx_voice::audio_tx | |
| audio_windows_sink | Audio sink using winmm mmsystem (win32 only) |
| audio_windows_source | Audio source using winmm mmsystem (win32 only) |
| benchmark_loopback::awgn_channel | |
| gnuradio::gr::basic_flow_graph::basic_flow_graph | Basic_flow_graph -- describe connections between blocks |
| gnuradio::gr::flow_graph::buffer_sizes | Compute buffer sizes to use |
| gnuradio::gr::exceptions::CantHappen | Can't happen |
| gnuradio::blks2impl::channel_model::channel_model | |
| gnuradio::blksimpl::channel_model::channel_model | |
| python::form::checkbox_field | |
| circular_buffer< T > | |
| comedi_sink_s | Sink using COMEDI |
| comedi_source_s | Source using COMEDI |
| gnuradio::gr::hier_block::compose | Compose one or more blocks (primitive or hierarchical) into a new hierarchical block |
| python::scopesink2::constellation_sink | |
| usrp_ra_receiver::continuum_calibration | |
| python::fftsink2::control_panel | |
| python::fftsink2::control_panel::control_panel::LabelText | |
| convolutional_interleaver< symbol_type > | Template class for generic convolutional interleaver |
| gnuradio::blks2impl::cpm::cpm_mod | |
| gnuradio::blksimpl::cpm::cpm_mod | |
| tunnel::cs_mac | Prototype carrier sense MAC |
| gnuradio::blks2impl::nbfm_tx::ctcss_gen_f | |
| gnuradio::blksimpl::nbfm_tx::ctcss_gen_f | |
| gnuradio::blks2impl::d8psk::d8psk_demod | |
| gnuradio::blksimpl::d8psk::d8psk_demod | |
| gnuradio::blks2impl::d8psk::d8psk_mod | |
| gnuradio::blksimpl::d8psk::d8psk_mod | |
| darwin_dev_handle | |
| ra_fftsink::DataEvent | |
| ra_waterfallsink::DataEvent | |
| ra_stripchartsink::DataEvent | |
| python::fftsink::DataEvent | |
| python::fftsink2::DataEvent | |
| python::numbersink::DataEvent | |
| python::numbersink2::DataEvent | |
| python::scopesink::DataEvent | |
| python::scopesink2::DataEvent | |
| python::waterfallsink::DataEvent | |
| python::waterfallsink2::DataEvent | |
| db_base::db_base | Abstract base class for all daughterboards |
| db_basic::db_basic_rx | |
| db_basic::db_basic_tx | |
| db_dbs_rx::db_dbs_rx | |
| db_dtt754::db_dtt754 | |
| db_dtt768::db_dtt768 | |
| db_flexrf::db_flexrf_1200_rx | |
| db_flexrf_mimo::db_flexrf_1200_rx_mimo_a | |
| db_flexrf_mimo::db_flexrf_1200_rx_mimo_b | |
| db_flexrf::db_flexrf_1200_tx | |
| db_flexrf_mimo::db_flexrf_1200_tx_mimo_a | |
| db_flexrf_mimo::db_flexrf_1200_tx_mimo_b | |
| db_flexrf::db_flexrf_1800_rx | |
| db_flexrf_mimo::db_flexrf_1800_rx_mimo_a | |
| db_flexrf_mimo::db_flexrf_1800_rx_mimo_b | |
| db_flexrf::db_flexrf_1800_tx | |
| db_flexrf_mimo::db_flexrf_1800_tx_mimo_a | |
| db_flexrf_mimo::db_flexrf_1800_tx_mimo_b | |
| db_flexrf::db_flexrf_2400_rx | |
| db_flexrf_mimo::db_flexrf_2400_rx_mimo_a | |
| db_flexrf_mimo::db_flexrf_2400_rx_mimo_b | |
| db_flexrf::db_flexrf_2400_tx | |
| db_flexrf_mimo::db_flexrf_2400_tx_mimo_a | |
| db_flexrf_mimo::db_flexrf_2400_tx_mimo_b | |
| db_flexrf::db_flexrf_400_rx | |
| db_flexrf_mimo::db_flexrf_400_rx_mimo_a | |
| db_flexrf_mimo::db_flexrf_400_rx_mimo_b | |
| db_flexrf::db_flexrf_400_tx | |
| db_flexrf_mimo::db_flexrf_400_tx_mimo_a | |
| db_flexrf_mimo::db_flexrf_400_tx_mimo_b | |
| db_flexrf::db_flexrf_900_rx | |
| db_flexrf_mimo::db_flexrf_900_rx_mimo_a | |
| db_flexrf_mimo::db_flexrf_900_rx_mimo_b | |
| db_flexrf::db_flexrf_900_tx | |
| db_flexrf_mimo::db_flexrf_900_tx_mimo_a | |
| db_flexrf_mimo::db_flexrf_900_tx_mimo_b | |
| db_basic::db_lf_rx | |
| db_basic::db_lf_tx | |
| db_tv_rx::db_tv_rx | |
| db_wbx::db_wbx_lo_rx | |
| db_wbx::db_wbx_lo_tx | |
| gnuradio::blks2impl::dbpsk::dbpsk_demod | |
| gnuradio::blksimpl::dbpsk::dbpsk_demod | |
| gnuradio::blks2impl::dbpsk::dbpsk_mod | |
| gnuradio::blksimpl::dbpsk::dbpsk_mod | |
| flexrf_debug_gui::demo_app | |
| tx_debug_gui::demo_app | |
| python::form::demo_app_flow_graph | |
| python::slider::demo_graph | |
| gnuradio::blks2impl::am_demod::demod_10k0a3e_cf | AM demodulation block, 10 KHz channel |
| gnuradio::blksimpl::am_demod::demod_10k0a3e_cf | AM demodulation block, 10 KHz channel |
| gnuradio::blks2impl::fm_demod::demod_200kf3e_cf | WFM demodulation block, mono |
| gnuradio::blksimpl::fm_demod::demod_200kf3e_cf | WFM demodulation block, mono |
| gnuradio::blks2impl::fm_demod::demod_20k0f3e_cf | NBFM demodulation block, 20 KHz channels |
| gnuradio::blksimpl::fm_demod::demod_20k0f3e_cf | NBFM demodulation block, 20 KHz channels |
| gnuradio::blks2impl::pkt::demod_pkts | Wrap an arbitrary digital demodulator in our packet handling framework |
| gnuradio::blksimpl::pkt::demod_pkts | Wrap an arbitrary digital demodulator in our packet handling framework |
| dial_tone_sink::dial_tone_sink | |
| dial_tone_source::dial_tone_source | |
| sssr::digital_correlator | Digital correlator for 1001 and 0110 patterns |
| doxypy::Doxypy | |
| gnuradio::blks2impl::dqpsk::dqpsk_demod | |
| gnuradio::blksimpl::dqpsk::dqpsk_demod | |
| gnuradio::blks2impl::dqpsk::dqpsk_mod | |
| gnuradio::blksimpl::dqpsk::dqpsk_mod | |
| gr_plot_const::draw_constellation | |
| gr_plot_iq::draw_fft | |
| gr_plot_fft_c::draw_fft_c | |
| gr_plot_fft_f::draw_fft_f | |
| gnuradio::gr::basic_flow_graph::edge | |
| gnuradio::gr::basic_flow_graph::endpoint | |
| gnuradio::eng_option::eng_option | |
| fm_tx_2_daughterboards::example_signal_0 | Sinusoid at 600 Hz |
| fm_tx_2_daughterboards::example_signal_1 | North American dial tone (350 + 440 Hz) |
| python::fftsink::fft_sink_base | |
| python::fftsink2::fft_sink_base | |
| python::fftsink::fft_sink_c | |
| python::fftsink2::fft_sink_c | |
| python::fftsink::fft_sink_f | |
| python::fftsink2::fft_sink_f | |
| ra_fftsink::fft_window | |
| python::fftsink::fft_window | |
| python::fftsink2::fft_window | |
| python::form::field | A field in a form |
| src::flex_demod::flex_demod | FLEX pager protocol demodulation block |
| flex_mode | |
| db_flexrf::flexrf_base | Abstract base class for all flexrf boards |
| db_flexrf::flexrf_base_rx | |
| db_flexrf::flexrf_base_tx | |
| flexrf_debug_gui::flexrf_debug_gui | |
| python::form::float_converter | |
| python::form::float_field | |
| gnuradio::gr::flow_graph::flow_graph | Add physical connection info to simple_flow_graph |
| gnuradio::blks2impl::fm_emph::fm_deemph | FM Deemphasis IIR filter |
| gnuradio::blksimpl::fm_emph::fm_deemph | FM Deemphasis IIR filter |
| gnuradio::blks2impl::fm_demod::fm_demod_cf | Generalized FM demodulation block with deemphasis and audio filtering |
| gnuradio::blksimpl::fm_demod::fm_demod_cf | Generalized FM demodulation block with deemphasis and audio filtering |
| gnuradio::blks2impl::fm_emph::fm_preemph | FM Preemphasis IIR filter |
| gnuradio::blksimpl::fm_emph::fm_preemph | FM Preemphasis IIR filter |
| fm_tx4::fm_tx_block | |
| python::form::form | |
| python::powermate::Frame | |
| doxypy::FSM | FSM implements a finite state machine |
| fsm | FSM class |
| fusb_devhandle | Abstract usb device handle |
| fusb_devhandle_darwin | Darwin implementation of fusb_devhandle |
| fusb_devhandle_generic | Generic implementation of fusb_devhandle using only libusb |
| fusb_devhandle_linux | Linux specific implementation of fusb_devhandle using usbdevice_fs |
| fusb_devhandle_ra_wb | Generic implementation of fusb_devhandle using only libusb |
| fusb_devhandle_win32 | Win32 implementation of fusb_devhandle using libusb-win32 |
| fusb_ephandle | Abstract usb end point handle |
| fusb_ephandle_darwin | Darwin implementation of fusb_ephandle |
| fusb_ephandle_generic | Generic implementation of fusb_ephandle using only libusb |
| fusb_ephandle_linux | Linux specific implementation of fusb_ephandle using usbdevice_fs |
| fusb_ephandle_ra_wb | Generic implementation of fusb_ephandle using only libusb |
| fusb_ephandle_win32 | Win32 implementation of fusb_ephandle using libusb-win32 |
| fusb_sysconfig | Factory for creating concrete instances of the appropriate subtype |
| g72x_state | |
| gnuradio::blks2impl::gmsk::gmsk_demod | |
| gnuradio::blksimpl::gmsk::gmsk_demod | |
| gnuradio::blks2impl::gmsk::gmsk_mod | |
| gnuradio::blksimpl::gmsk::gmsk_mod | |
| gpio_and_const_ss | Output = input & constant |
| gr_adaptive_fir_ccf | Adaptive FIR filter with gr_complex input, gr_complex output and float taps |
| gr_add_cc | Output = sum (input_0, input_1, ...) Add across all input streams |
| gr_add_const_cc | Output = input + constant |
| gr_add_const_ff | Output = input + constant |
| gr_add_const_ii | Output = input + constant |
| gr_add_const_sf | Output = input + constant |
| gr_add_const_ss | Output = input + constant |
| gr_add_const_vcc | Output vector = input vector + constant vector |
| gr_add_const_vff | Output vector = input vector + constant vector |
| gr_add_const_vii | Output vector = input vector + constant vector |
| gr_add_const_vss | Output vector = input vector + constant vector |
| gr_add_ff | Output = sum (input_0, input_1, ...) Add across all input streams |
| gr_add_ii | Output = sum (input_0, input_1, ...) Add across all input streams |
| gr_add_ss | Output = sum (input_0, input_1, ...) Add across all input streams |
| gr_add_vcc | Output = sum (input_0, input_1, ...) Add across all input vectors |
| gr_add_vff | Output = sum (input_0, input_1, ...) Add across all input vectors |
| gr_add_vii | Output = sum (input_0, input_1, ...) Add across all input vectors |
| gr_add_vss | Output = sum (input_0, input_1, ...) Add across all input vectors |
| gr_agc2_cc | High performance Automatic Gain Control class For Power the absolute value of the complex number is used |
| gr_agc2_ff | High performance Automatic Gain Control class |
| gr_agc_cc | High performance Automatic Gain Control class For Power the absolute value of the complex number is used |
| gr_agc_ff | High performance Automatic Gain Control class Power is approximated by absolute value |
| gr_align_on_samplenumbers_ss | |
| gr_and_bb | Output = input_0 & input_1 & , ... & input_N) bitwise boolean and across all input streams |
| gr_and_ii | Output = input_0 & input_1 & , ... & input_N) bitwise boolean and across all input streams |
| gr_and_ss | Output = input_0 & input_1 & , ... & input_N) bitwise boolean and across all input streams |
| gr_argmax_fs | |
| gr_argmax_is | |
| gr_argmax_ss | |
| gr_base_error_handler | |
| gr_basic_block | The abstract base class for all signal processing blocks. Basic blocks are the bare abstraction of an entity that has a name and a set of inputs and outputs. These are never instantiated directly; rather, this is the abstract parent class of both gr_hier_block, which is a recursive container, and gr_block, which implements actual signal processing functions |
| gr_bin_statistics_f | Control scanning and record frequency domain statistics |
| gr_binary_slicer_fb | Slice float binary symbol outputting 1 bit output x < 0 --> 0 x >= 0 --> 1 |
| gr_block | The abstract base class for all 'terminal' processing blocks. A signal processing flow is constructed by creating a tree of hierarchical blocks, which at any level may also contain terminal nodes that actually implement signal processing functions. This is the base class for all such leaf nodes |
| gr_block_detail | Implementation details to support the signal processing abstraction This class contains implementation detail that should be "out of sight" of almost all users of GNU Radio. This decoupling also means that we can make changes to the guts without having to recompile everything |
| gr_buffer | Single writer, multiple reader fifo |
| gr_buffer_reader | How we keep track of the readers of a gr_buffer |
| gr_bytes_to_syms | Convert stream of bytes to stream of +/- 1 symbols |
| gr_char_to_float | Convert stream of chars to a stream of float |
| gr_check_counting_s | Sink that checks if its input stream consists of a counting sequence |
| gr_check_lfsr_32k_s | Sink that checks if its input stream consists of a lfsr_32k sequence. This sink is typically used along with gr_lfsr_32k_source_s to test the USRP using its digital loopback mode |
| gr_chunks_to_symbols_bc | Map a stream of symbol indexes (unpacked bytes or shorts) to stream of float or complex onstellation points.in D dimensions (D = 1 by default)input: stream of unsigned char; output: stream of gr_complex |
| gr_chunks_to_symbols_bf | Map a stream of symbol indexes (unpacked bytes or shorts) to stream of float or complex onstellation points.in D dimensions (D = 1 by default) |
| gr_chunks_to_symbols_ic | Map a stream of symbol indexes (unpacked bytes or shorts) to stream of float or complex onstellation points.in D dimensions (D = 1 by default) |
| gr_chunks_to_symbols_if | Map a stream of symbol indexes (unpacked bytes or shorts) to stream of float or complex onstellation points.in D dimensions (D = 1 by default) |
| gr_chunks_to_symbols_sc | Map a stream of symbol indexes (unpacked bytes or shorts) to stream of float or complex onstellation points.in D dimensions (D = 1 by default) |
| gr_chunks_to_symbols_sf | Map a stream of symbol indexes (unpacked bytes or shorts) to stream of float or complex onstellation points.in D dimensions (D = 1 by default) |
| gr_circular_file | |
| gr_clock_recovery_mm_cc | Mueller and Müller (M&M) based clock recovery block with complex input, complex output. This implements the Mueller and Müller (M&M) discrete-time error-tracking synchronizer. The complex version here is based on: Modified Mueller and Muller clock recovery circuit Based: G. R. Danesfahani, T.G. Jeans, "Optimisation of modified Mueller and Muller algorithm," Electronics Letters, Vol. 31, no. 13, 22 June 1995, pp. 1032 - 1033 |
| gr_clock_recovery_mm_ff | Mueller and Müller (M&M) based clock recovery block with float input, float output. This implements the Mueller and Müller (M&M) discrete-time error-tracking synchronizer |
| gr_cma_equalizer_cc | Implements constant modulus adaptive filter on complex stream |
| gr_complex_to_arg | Complex in, angle out (float) |
| gr_complex_to_float | Convert a stream of gr_complex to 1 or 2 streams of float |
| gr_complex_to_imag | Complex in, imaginary out (float) |
| gr_complex_to_interleaved_short | Convert stream of complex to a stream of interleaved shorts |
| gr_complex_to_mag | Complex in, magnitude out (float) |
| gr_complex_to_mag_squared | Complex in, magnitude squared out (float) |
| gr_complex_to_real | Complex in, real out (float) |
| gr_conjugate_cc | Output = complex conjugate of input |
| gr_constellation_decoder_cb | Constellation Decoder |
| gr_correlate_access_code_bb | Examine input for specified access code, one bit at a time. input: stream of bits, 1 bit per input byte (data in LSB) output: stream of bits, 2 bits per output byte (data in LSB, flag in next higher bit) |
| gr_costas_loop_cc | Carrier tracking PLL for QPSK
input: complex; output: complex |
| gr_cpfsk_bc | Perform continuous phase 2-level frequency shift keying modulation on an input stream of unpacked bits |
| gr_cpu | |
| gr_ctcss_squelch_ff | Gate or zero output if ctcss tone not present |
| gr_dd_mpsk_sync_cc | Decision directed M-PSK synchronous demod This block performs joint carrier tracking and symbol timing recovery |
| gr_decode_ccsds_27_fb | A rate 1/2, k=7 convolutional decoder for the CCSDS standard This block performs soft-decision convolutional decoding using the Viterbi algorithm |
| gr_deinterleave | Deinterleave a single input into N outputs |
| gr_delay | Delay the input by a certain number of samples |
| gr_diff_decoder_bb | Y[0] = (x[0] - x[-1]) % M Differential decoder |
| gr_diff_encoder_bb | Y[0] = (x[0] + y[-1]) % M Differential encoder |
| gr_diff_phasor_cc | |
| gr_dispatcher | Invoke callbacks based on select |
| gr_divide_cc | Output = input_0 / input_1 / input_x ...) Divide across all input streams |
| gr_divide_ff | Output = input_0 / input_1 / input_x ...) Divide across all input streams |
| gr_divide_ii | Output = input_0 / input_1 / input_x ...) Divide across all input streams |
| gr_divide_ss | Output = input_0 / input_1 / input_x ...) Divide across all input streams |
| gr_dpll_bb | Detect the peak of a signal If a peak is detected, this block outputs a 1, or it outputs 0's |
| gr_edge | Class representing a connection between to graph endpoints |
| gr_encode_ccsds_27_bb | A rate 1/2, k=7 convolutional encoder for the CCSDS standard This block performs convolutional encoding using the CCSDS standard polynomial ("Voyager") |
| gr_endpoint | Class representing a specific input or output graph endpoint |
| gr_error_handler | Abstract error handler |
| gr_fake_channel_decoder_pp | Remove fake padding from packet input: stream of byte vectors; output: stream of byte vectors |
| gr_fake_channel_encoder_pp | Pad packet with alternating 1,0 pattern. input: stream of byte vectors; output: stream of byte vectors |
| gr_feedforward_agc_cc | Non-causal AGC which computes required gain based on max absolute value over nsamples |
| gr_feval | Base class for evaluating a function: void -> void This class is designed to be subclassed in Python or C++ and is callable from both places. It uses SWIG's "director" feature to implement the magic. It's slow. Don't use it in a performance critical path |
| gr_feval_cc | Base class for evaluating a function: complex -> complex This class is designed to be subclassed in Python or C++ and is callable from both places. It uses SWIG's "director" feature to implement the magic. It's slow. Don't use it in a performance critical path |
| gr_feval_dd | Base class for evaluating a function: double -> double This class is designed to be subclassed in Python or C++ and is callable from both places. It uses SWIG's "director" feature to implement the magic. It's slow. Don't use it in a performance critical path |
| gr_feval_ll | Base class for evaluating a function: long -> long This class is designed to be subclassed in Python or C++ and is callable from both places. It uses SWIG's "director" feature to implement the magic. It's slow. Don't use it in a performance critical path |
| gr_fft_filter_ccc | Fast FFT filter with gr_complex input, gr_complex output and gr_complex taps |
| gr_fft_filter_fff | Fast FFT filter with float input, float output and float taps |
| gr_fft_vcc | Compute forward or reverse FFT. complex vector in / complex vector out. Abstract base class |
| gr_fft_vcc_fftw | Compute forward or reverse FFT. complex vector in / complex vector out. Concrete class that uses FFTW |
| gr_fft_vfc | Compute forward FFT. float vector in / complex vector out |
| gr_file_descriptor_sink | Write stream to file descriptor |
| gr_file_descriptor_source | Read stream from file descriptor |
| gr_file_error_handler | |
| gr_file_sink | Write stream to file |
| gr_file_sink_base | Common base class for file sinks |
| gr_file_source | Read stream from file |
| gr_filter_delay_fc | Filter-Delay Combination Block. The block takes one or two float stream and outputs a complex stream. If only one float stream is input, the real output is a delayed version of this input and the imaginary output is the filtered output. If two floats are connected to the input, then the real output is the delayed version of the first input, and the imaginary output is the filtered output. The delay in the real path accounts for the group delay introduced by the filter in the imaginary path. The filter taps needs to be calculated before initializing this block |
| gr_fir_ccc | Abstract class for FIR with gr_complex input, gr_complex output and gr_complex taps This is the abstract class for a Finite Impulse Response filter |
| gr_fir_ccc_3dnow | 3DNow! version of gr_fir_ccc |
| gr_fir_ccc_3dnowext | |
| gr_fir_ccc_generic | Concrete class for generic implementation of FIR with gr_complex input, gr_complex output and gr_complex taps |
| gr_fir_ccc_info | |
| gr_fir_ccc_simd | Common base class for SIMD versions of gr_fir_ccc This base class handles alignment issues common to SSE and 3DNOW subclasses |
| gr_fir_ccc_sse | SSE version of gr_fir_ccc |
| gr_fir_ccf | Abstract class for FIR with gr_complex input, gr_complex output and float taps This is the abstract class for a Finite Impulse Response filter |
| gr_fir_ccf_3dnow | 3DNow! version of gr_fir_ccf |
| gr_fir_ccf_generic | Concrete class for generic implementation of FIR with gr_complex input, gr_complex output and float taps |
| gr_fir_ccf_info | |
| gr_fir_ccf_simd | Common base class for SIMD versions of gr_fir_ccf This base class handles alignment issues common to SSE and 3DNOW subclasses |
| gr_fir_ccf_sse | SSE version of gr_fir_ccf |
| gr_fir_fcc | Abstract class for FIR with float input, gr_complex output and gr_complex taps This is the abstract class for a Finite Impulse Response filter |
| gr_fir_fcc_3dnow | 3DNow! version of gr_fir_fcc |
| gr_fir_fcc_generic | Concrete class for generic implementation of FIR with float input, gr_complex output and gr_complex taps |
| gr_fir_fcc_info | |
| gr_fir_fcc_simd | Common base class for SIMD versions of gr_fir_fcc This base class handles alignment issues common to SSE and 3DNOW subclasses |
| gr_fir_fcc_sse | SSE version of gr_fir_fcc |
| gr_fir_fff | Abstract class for FIR with float input, float output and float taps This is the abstract class for a Finite Impulse Response filter |
| gr_fir_fff_3dnow | 3DNow! version of gr_fir_fff |
| gr_fir_fff_generic | Concrete class for generic implementation of FIR with float input, float output and float taps |
| gr_fir_fff_info | |
| gr_fir_fff_simd | Common base class for SIMD versions of gr_fir_fff This base class handles alignment issues common to SSE and 3DNOW subclasses |
| gr_fir_fff_sse | SSE version of gr_fir_fff |
| gr_fir_filter_ccc | FIR filter with gr_complex input, gr_complex output and gr_complex taps |
| gr_fir_filter_ccf | FIR filter with gr_complex input, gr_complex output and float taps |
| gr_fir_filter_fcc | FIR filter with float input, gr_complex output and gr_complex taps |
| gr_fir_filter_fff | FIR filter with float input, float output and float taps |
| gr_fir_filter_fsf | FIR filter with float input, short output and float taps |
| gr_fir_filter_scc | FIR filter with short input, gr_complex output and gr_complex taps |
| gr_fir_fsf | Abstract class for FIR with float input, short output and float taps This is the abstract class for a Finite Impulse Response filter |
| gr_fir_fsf_3dnow | 3DNow! version of gr_fir_fsf |
| gr_fir_fsf_generic | Concrete class for generic implementation of FIR with float input, short output and float taps |
| gr_fir_fsf_info | |
| gr_fir_fsf_simd | Common base class for SIMD versions of gr_fir_fsf This base class handles alignment issues common to SSE and 3DNOW subclasses |
| gr_fir_fsf_sse | SSE version of gr_fir_fsf |
| gr_fir_scc | Abstract class for FIR with short input, gr_complex output and gr_complex taps This is the abstract class for a Finite Impulse Response filter |
| gr_fir_scc_3dnow | 3DNow! version of gr_fir_scc |
| gr_fir_scc_3dnowext | 3DNow! Ext version of gr_fir_scc |
| gr_fir_scc_generic | Concrete class for generic implementation of FIR with short input, gr_complex output and gr_complex taps |
| gr_fir_scc_info | |
| gr_fir_scc_simd | Common base class for SIMD versions of gr_fir_scc This base class handles alignment issues common to SSE and 3DNOW subclasses |
| gr_fir_scc_sse | SSE version of gr_fir_scc |
| gr_fir_sysconfig | Abstract base class for configuring the automatic selection of the fastest gr_fir for your platform |
| gr_fir_sysconfig_generic | |
| gr_fir_sysconfig_x86 | |
| gr_fir_util | |
| gr_firdes | Finite Impulse Response (FIR) filter design functions |
| gr_flat_flowgraph | Class specializing gr_flat_flowgraph that has all nodes as gr_blocks, with no hierarchy |
| gr_float_to_char | Convert stream of float to a stream of char |
| gr_float_to_complex | Convert 1 or 2 streams of float to a stream of gr_complex |
| gr_float_to_short | Convert stream of float to a stream of short |
| gr_float_to_uchar | Convert stream of float to a stream of unsigned char |
| gr_flowgraph | Class representing a directed, acyclic graph of basic blocks |
| gr_fractional_interpolator_cc | Interpolating mmse filter with gr_complex input, gr_complex output |
| gr_fractional_interpolator_ff | Interpolating mmse filter with float input, float output |
| gr_framer_sink_1 | Given a stream of bits and access_code flags, assemble packets. input: stream of bytes from gr_correlate_access_code_bb output: none. Pushes assembled packet into target queue |
| gr_freq_xlating_fir_filter_ccc | FIR filter combined with frequency translation with gr_complex input, gr_complex output and gr_complex taps This class efficiently combines a frequency translation (typically "down conversion") with a FIR filter (typically low-pass) and decimation. It is ideally suited for a "channel selection filter" and can be efficiently used to select and decimate a narrow band signal out of wide bandwidth input |
| gr_freq_xlating_fir_filter_ccf | FIR filter combined with frequency translation with gr_complex input, gr_complex output and float taps This class efficiently combines a frequency translation (typically "down conversion") with a FIR filter (typically low-pass) and decimation. It is ideally suited for a "channel selection filter" and can be efficiently used to select and decimate a narrow band signal out of wide bandwidth input |
| gr_freq_xlating_fir_filter_fcc | FIR filter combined with frequency translation with float input, gr_complex output and gr_complex taps This class efficiently combines a frequency translation (typically "down conversion") with a FIR filter (typically low-pass) and decimation. It is ideally suited for a "channel selection filter" and can be efficiently used to select and decimate a narrow band signal out of wide bandwidth input |
| gr_freq_xlating_fir_filter_fcf | FIR filter combined with frequency translation with float input, gr_complex output and float taps This class efficiently combines a frequency translation (typically "down conversion") with a FIR filter (typically low-pass) and decimation. It is ideally suited for a "channel selection filter" and can be efficiently used to select and decimate a narrow band signal out of wide bandwidth input |
| gr_freq_xlating_fir_filter_scc | FIR filter combined with frequency translation with short input, gr_complex output and gr_complex taps This class efficiently combines a frequency translation (typically "down conversion") with a FIR filter (typically low-pass) and decimation. It is ideally suited for a "channel selection filter" and can be efficiently used to select and decimate a narrow band signal out of wide bandwidth input |
| gr_freq_xlating_fir_filter_scf | FIR filter combined with frequency translation with short input, gr_complex output and float taps This class efficiently combines a frequency translation (typically "down conversion") with a FIR filter (typically low-pass) and decimation. It is ideally suited for a "channel selection filter" and can be efficiently used to select and decimate a narrow band signal out of wide bandwidth input |
| gr_frequency_modulator_fc | Frequency modulator block |
| gr_fxpt | Fixed point sine and cosine and friends. fixed pt radians --------- -------- -2**31 -pi 0 0 2**31-1 pi - epsilon |
| gr_fxpt_nco | Numerically Controlled Oscillator (NCO) |
| gr_fxpt_vco | Voltage Controlled Oscillator (VCO) |
| gr_glfsr_source_b | Galois LFSR pseudo-random source |
| gr_glfsr_source_f | Galois LFSR pseudo-random source generating float outputs -1.0 - 1.0 |
| gr_goertzel_fc | Goertzel single-bin DFT calculation |
| gr_head | Copies the first N items to the output then signals done Useful for building test cases |
| gr_hier_block2 | Gr_hier_block2 - Hierarchical container class for gr_block's |
| gr_hier_block2_detail | |
| gr_hilbert_fc | Hilbert transformer. real output is input appropriately delayed. imaginary output is hilbert filtered (90 degree phase shift) version of input |
| gr_iir_filter_ffd | IIR filter with float input, float output and double taps
This filter uses the Direct Form I implementation, where |
| gr_integrate_cc | Output = sum(input[0]...input[n]) Integrate successive samples in input stream and decimate |
| gr_integrate_ff | Output = sum(input[0]...input[n]) Integrate successive samples in input stream and decimate |
| gr_integrate_ii | Output = sum(input[0]...input[n]) Integrate successive samples in input stream and decimate |
| gr_integrate_ss | Output = sum(input[0]...input[n]) Integrate successive samples in input stream and decimate |
| gr_interleave | Interleave N inputs to a single output |
| gr_interleaved_short_to_complex | Convert stream of interleaved shorts to a stream of complex |
| gr_interp_fir_filter_ccc | Interpolating FIR filter with gr_complex input, gr_complex output and gr_complex taps |
| gr_interp_fir_filter_ccf | Interpolating FIR filter with gr_complex input, gr_complex output and float taps |
| gr_interp_fir_filter_fcc | Interpolating FIR filter with float input, gr_complex output and gr_complex taps |
| gr_interp_fir_filter_fff | Interpolating FIR filter with float input, float output and float taps |
| gr_interp_fir_filter_fsf | Interpolating FIR filter with float input, short output and float taps |
| gr_interp_fir_filter_scc | Interpolating FIR filter with short input, gr_complex output and gr_complex taps |
| gr_io_signature | I/o signature for input and output ports |
| gr_keep_one_in_n | Decimate a stream, keeping one item out of every n |
| gr_kludge_copy | Output[i] = input[i] This is a short term kludge to work around a problem with the hierarchical block impl |
| gr_lfsr_32k_source_s | LFSR pseudo-random source with period of 2^15 bits (2^11 shorts) This source is typically used along with gr_check_lfsr_32k_s to test the USRP using its digital loopback mode |
| gr_lms_dfe_cc | Least-Mean-Square Decision Feedback Equalizer (complex in/out) |
| gr_lms_dfe_ff | Least-Mean-Square Decision Feedback Equalizer (float in/out) |
| gr_local_sighandler | Get and set signal handler |
| gr_map_bb | Output[i] = map[input[i]] |
| gr_max_ff | |
| gr_max_ii | |
| gr_max_ss | |
| gr_message | Message class |
| gr_message_sink | Gather received items into messages and insert into msgq |
| gr_message_source | Turn received messages into a stream |
| gr_moving_average_cc | Output is the moving sum of the last N samples, scaled by the scale factor This is necessary to avoid numerical instability for float and complex |
| gr_moving_average_ff | Output is the moving sum of the last N samples, scaled by the scale factor This is necessary to avoid numerical instability for float and complex |
| gr_moving_average_ii | Output is the moving sum of the last N samples, scaled by the scale factor This is necessary to avoid numerical instability for float and complex |
| gr_moving_average_ss | Output is the moving sum of the last N samples, scaled by the scale factor This is necessary to avoid numerical instability for float and complex |
| gr_mpsk_receiver_cc | This block takes care of receiving M-PSK modulated signals through phase, frequency, and symbol synchronization. This block takes care of receiving M-PSK modulated signals through phase, frequency, and symbol synchronization. It performs carrier frequency and phase locking as well as symbol timing recovery. It works with (D)BPSK, (D)QPSK, and (D)8PSK as tested currently. It should also work for OQPSK and PI/4 DQPSK |
| gr_msg_handler | Abstract class of message handlers |
| gr_msg_queue | Thread-safe message queue |
| gr_multiply_cc | Output = prod (input_0, input_1, ...) Multiply across all input streams |
| gr_multiply_const_cc | Output = input * constant |
| gr_multiply_const_ff | Output = input * constant |
| gr_multiply_const_ii | Output = input * constant |
| gr_multiply_const_ss | Output = input * constant |
| gr_multiply_const_vcc | Output vector = input vector * constant vector (element-wise) |
| gr_multiply_const_vff | Output vector = input vector * constant vector (element-wise) |
| gr_multiply_const_vii | Output vector = input vector * constant vector (element-wise) |
| gr_multiply_const_vss | Output vector = input vector * constant vector (element-wise) |
| gr_multiply_ff | Output = prod (input_0, input_1, ...) Multiply across all input streams |
| gr_multiply_ii | Output = prod (input_0, input_1, ...) Multiply across all input streams |
| gr_multiply_ss | Output = prod (input_0, input_1, ...) Multiply across all input streams |
| gr_multiply_vcc | Output = prod (input_0, input_1, ...) Element-wise multiply across all input vectors |
| gr_multiply_vff | Output = prod (input_0, input_1, ...) Element-wise multiply across all input vectors |
| gr_multiply_vii | Output = prod (input_0, input_1, ...) Element-wise multiply across all input vectors |
| gr_multiply_vss | Output = prod (input_0, input_1, ...) Element-wise multiply across all input vectors |
| gr_mute_cc | Output = input or zero if muted |
| gr_mute_ff | Output = input or zero if muted |
| gr_mute_ii | Output = input or zero if muted |
| gr_mute_ss | Output = input or zero if muted |
| gr_nco< o_type, i_type > | Base class template for Numerically Controlled Oscillator (NCO) |
| gr_nlog10_ff | Output = n*log10(input) + k |
| gr_noise_source_c | Random number source |
| gr_noise_source_f | Random number source |
| gr_noise_source_i | Random number source |
| gr_noise_source_s | Random number source |
| gr_nop | Does nothing. Used for testing only |
| gr_not_bb | Output = ~input_0 bitwise boolean not across input stream |
| gr_not_ii | Output = ~input_0 bitwise boolean not across input stream |
| gr_not_ss | Output = ~input_0 bitwise boolean not across input stream |
| gr_null_sink | Bit bucket |
| gr_null_source | A source of zeros |
| gr_or_bb | Output = input_0 | input_1 | , ... | input_N) bitwise boolean or across all input streams |
| gr_or_ii | Output = input_0 | input_1 | , ... | input_N) bitwise boolean or across all input streams |
| gr_or_ss | Output = input_0 | input_1 | , ... | input_N) bitwise boolean or across all input streams |
| gr_oscope_guts | Guts of oscilloscope trigger and buffer module |
| gr_oscope_sink_f | Building block for python oscilloscope module. Accepts 1 to 16 float streams |
| gr_oscope_sink_x | Abstract class for python oscilloscope module. Don't instantiate this. Use gr_oscope_sink_f or gr_oscope_sink_c instead |
| gr_pa_2x2_phase_combiner | Pa_2x2 phase combiner Anntenas are arranged like this: |
| gr_packed_to_unpacked_bb | Convert a stream of packed bytes or shorts to stream of unpacked bytes or shorts. input: stream of unsigned char; output: stream of unsigned char |
| gr_packed_to_unpacked_ii | Convert a stream of packed bytes or shorts to stream of unpacked bytes or shorts. |
| gr_packed_to_unpacked_ss | Convert a stream of packed bytes or shorts to stream of unpacked bytes or shorts. |
| gr_packet_sink | Process received bits looking for packet sync, header, and process bits into packet |
| gr_peak_detector2_fb | Detect the peak of a signal If a peak is detected, this block outputs a 1, or it outputs 0's. A separate debug output may be connected, to view the internal EWMA described below |
| gr_peak_detector_fb | Detect the peak of a signal If a peak is detected, this block outputs a 1, or it outputs 0's |
| gr_peak_detector_ib | Detect the peak of a signal If a peak is detected, this block outputs a 1, or it outputs 0's |
| gr_peak_detector_sb | Detect the peak of a signal If a peak is detected, this block outputs a 1, or it outputs 0's |
| gr_phase_modulator_fc | Phase modulator block output=complex(cos(in*sensitivity),sin(in*sensitivity)) |
| gr_pll_carriertracking_cc | Implements a PLL which locks to the input frequency and outputs the input signal mixed with that carrier. |
| gr_pll_freqdet_cf | Implements a PLL which locks to the input frequency and outputs an estimate of that frequency. Useful for FM Demod. |
| gr_pll_refout_cc | Implements a PLL which locks to the input frequency and outputs a carrier |
| gr_pn_correlator_cc | PN code sequential search correlator |
| gr_preferences | |
| gr_prefs | Base class for representing user preferences a la windows INI files. The real implementation is in Python, and is accessable from C++ via the magic of SWIG directors |
| gr_probe_avg_mag_sqrd_c | Compute avg magnitude squared. input: gr_complex |
| gr_probe_avg_mag_sqrd_cf | Compute avg magnitude squared. |
| gr_probe_avg_mag_sqrd_f | Compute avg magnitude squared. input: float |
| gr_probe_signal_f | Sink that allows a sample to be grabbed from Python |
| gr_pwr_squelch_cc | Gate or zero output when input power below threshold |
| gr_pwr_squelch_ff | Gate or zero output when input power below threshold |
| gr_quadrature_demod_cf | Quadrature demodulator: complex in, float out This can be used to demod FM, FSK, GMSK, etc. The input is complex baseband |
| gr_random | Pseudo random number generator |
| gr_rational_resampler_base_ccc | Rational Resampling Polyphase FIR filter with gr_complex input, gr_complex output and gr_complex taps |
| gr_rational_resampler_base_ccf | Rational Resampling Polyphase FIR filter with gr_complex input, gr_complex output and float taps |
| gr_rational_resampler_base_fcc | Rational Resampling Polyphase FIR filter with float input, gr_complex output and gr_complex taps |
| gr_rational_resampler_base_fff | Rational Resampling Polyphase FIR filter with float input, float output and float taps |
| gr_rational_resampler_base_fsf | Rational Resampling Polyphase FIR filter with float input, short output and float taps |
| gr_rational_resampler_base_scc | Rational Resampling Polyphase FIR filter with short input, gr_complex output and gr_complex taps |
| gr_regenerate_bb | 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 |
| gr_repeat | Repeat a sample 'interp' times in output stream |
| gr_rms_cf | RMS average power |
| gr_rms_ff | RMS average power |
| gr_rotator | |
| gr_sample_and_hold_bb | Sample and hold circuit Samples the data stream (input stream 0) and holds the value if the control signal is 1 (intput stream 1) |
| gr_sample_and_hold_ff | Sample and hold circuit Samples the data stream (input stream 0) and holds the value if the control signal is 1 (intput stream 1) |
| gr_sample_and_hold_ii | Sample and hold circuit Samples the data stream (input stream 0) and holds the value if the control signal is 1 (intput stream 1) |
| gr_sample_and_hold_ss | Sample and hold circuit Samples the data stream (input stream 0) and holds the value if the control signal is 1 (intput stream 1) |
| gr_scheduler_thread | A single thread of execution for the scheduler |
| gr_select_handler | Abstract handler for select based notification |
| gr_short_to_float | Convert stream of short to a stream of float |
| gr_sig_source_c | Signal generator with gr_complex output |
| gr_sig_source_f | Signal generator with float output |
| gr_sig_source_i | Signal generator with int output |
| gr_sig_source_s | Signal generator with short output |
| gr_signal | Representation of signal |
| gr_simple_correlator | Inverse of gr_simple_framer (more or less) |
| gr_simple_framer | Add sync field, seq number and command field to payload |
| gr_simple_squelch_cc | Simple squelch block based on average signal power and threshold in dB |
| gr_single_pole_iir< o_type, i_type, tap_type > | Class template for single pole IIR filter |
| gr_single_pole_iir< gr_complex, i_type, double > | |
| gr_single_pole_iir_filter_cc | Single pole IIR filter with complex input, complex output The input and output satisfy a difference equation of the form |
| gr_single_pole_iir_filter_ff | Single pole IIR filter with float input, float output The input and output satisfy a difference equation of the form |
| gr_single_threaded_scheduler | Simple scheduler for stream computations |
| gr_skiphead | Skips the first N items, from then on copies items to the output Useful for building test cases and sources which have metadata or junk at the start |
| gr_squelch_base_cc | |
| gr_squelch_base_ff | |
| gr_stream_mux | Stream muxing block to multiplex many streams into one with a specified format |
| gr_stream_to_streams | 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 |
| gr_stream_to_vector | Convert a stream of items into a stream of blocks containing nitems_per_block |
| gr_streams_to_stream | 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 |
| gr_streams_to_vector | Convert N streams of items to 1 stream of vector length N |
| gr_sub_cc | Output = input_0 - input_1 - ...) Subtract across all input streams |
| gr_sub_ff | Output = input_0 - input_1 - ...) Subtract across all input streams |
| gr_sub_ii | Output = input_0 - input_1 - ...) Subtract across all input streams |
| gr_sub_ss | Output = input_0 - input_1 - ...) Subtract across all input streams |
| gr_sync_block | Synchronous 1:1 input to output with history Override work to provide the signal processing implementation |
| gr_sync_decimator | Synchronous N:1 input to output with history Override work to provide the signal processing implementation |
| gr_sync_interpolator | Synchronous 1:N input to output with history Override work to provide the signal processing implementation |
| gr_test | Test class for testing runtime system (setting up buffers and such.) This block does not do any usefull actual data processing. It just exposes setting all standard block parameters using the contructor or public methods |
| gr_threshold_ff | Please fix my documentation |
| gr_throttle | 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 |
| gr_timer | Implement timeouts |
| gr_top_block | Top-level hierarchical block representing a flowgraph |
| gr_top_block_impl | Implementation details of gr_top_block |
| gr_uchar_to_float | Convert stream of unsigned chars to a stream of float |
| gr_udp_sink | Write stream to an UDP socket |
| gr_udp_source | Read stream from an UDP socket |
| gr_unpack_k_bits_bb | Converts a byte with k relevent bits to k output bytes with 1 bit in the LSB |
| gr_unpacked_to_packed_bb | Convert a stream of unpacked bytes or shorts into a stream of packed bytes or shorts. input: stream of unsigned char; output: stream of unsigned char |
| gr_unpacked_to_packed_ii | Convert a stream of unpacked bytes or shorts into a stream of packed bytes or shorts. |
| gr_unpacked_to_packed_ss | Convert a stream of unpacked bytes or shorts into a stream of packed bytes or shorts. |
| gr_vco< o_type, i_type > | Base class template for Voltage Controlled Oscillator (VCO) |
| gr_vco_f | VCO - Voltage controlled oscillator |
| gr_vector_sink_b | Unsigned char sink that writes to a vector |
| gr_vector_sink_c | Gr_complex sink that writes to a vector |
| gr_vector_sink_f | Float sink that writes to a vector |
| gr_vector_sink_i | Int sink that writes to a vector |
| gr_vector_sink_s | Short sink that writes to a vector |
| gr_vector_source_b | Source of unsigned char's that gets its data from a vector |
| gr_vector_source_c | Source of gr_complex's that gets its data from a vector |
| gr_vector_source_f | Source of float's that gets its data from a vector |
| gr_vector_source_i | Source of int's that gets its data from a vector |
| gr_vector_source_s | Source of short's that gets its data from a vector |
| gr_vector_to_stream | Convert a stream of blocks of nitems_per_block items into a stream of items |
| gr_vector_to_streams | Convert 1 stream of vectors of length N to N streams of items |
| gr_vmcircbuf | Abstract class to implement doubly mapped virtual memory circular buffers |
| gr_vmcircbuf_createfilemapping | Concrete class to implement circular buffers with mmap and shm_open |
| gr_vmcircbuf_createfilemapping_factory | Concrete factory for circular buffers built using mmap and shm_open |
| gr_vmcircbuf_factory | Abstract factory for creating circular buffers |
| gr_vmcircbuf_mmap_shm_open | Concrete class to implement circular buffers with mmap and shm_open |
| gr_vmcircbuf_mmap_shm_open_factory | Concrete factory for circular buffers built using mmap and shm_open |
| gr_vmcircbuf_mmap_tmpfile | Concrete class to implement circular buffers with mmap and shm_open |
| gr_vmcircbuf_mmap_tmpfile_factory | Concrete factory for circular buffers built using mmap and shm_open |
| gr_vmcircbuf_sysconfig | |
| gr_vmcircbuf_sysv_shm | Concrete class to implement circular buffers with mmap and shm_open |
| gr_vmcircbuf_sysv_shm_factory | Concrete factory for circular buffers built using mmap and shm_open |
| gr_wavfile_sink | Read stream from a Microsoft PCM (.wav) file, output floats |
| gr_wavfile_source | Read stream from a Microsoft PCM (.wav) file, output floats |
| gr_xor_bb | Output = input_0 ^ input_1 ^ , ... ^ input_N) bitwise boolean xor across all input streams |
| gr_xor_ii | Output = input_0 ^ input_1 ^ , ... ^ input_N) bitwise boolean xor across all input streams |
| gr_xor_ss | Output = input_0 ^ input_1 ^ , ... ^ input_N) bitwise boolean xor across all input streams |
| radio::graph | |
| python::scopesink::graph_window | |
| python::scopesink2::graph_window | |
| gri_agc2_cc | High performance Automatic Gain Control class For Power the absolute value of the complex number is used |
| gri_agc2_ff | High performance Automatic Gain Control class with attack and decay rate Power is approximated by absolute value |
| gri_agc_cc | High performance Automatic Gain Control class For Power the absolute value of the complex number is used |
| gri_agc_ff | High performance Automatic Gain Control class Power is approximated by absolute value |
| gri_fft_complex | FFT: complex in, complex out |
| gri_fft_real_fwd | FFT: real in, complex out |
| gri_fft_real_rev | FFT: complex in, float out |
| gri_glfsr | Galois Linear Feedback Shift Register using specified polynomial mask Generates a maximal length pseudo-random sequence of length 2^degree-1 |
| gri_goertzel | Implements Goertzel single-bin DFT calculation |
| gri_iir< i_type, o_type, tap_type > | Base class template for Infinite Impulse Response filter (IIR) |
| gri_lfsr_15_1_0 | Linear Feedback Shift Register using primitive polynomial x^15 + x + 1 Generates a maximal length pseudo-random sequence of length 2^15 - 1 bits |
| gri_lfsr_32k | Generate pseudo-random sequence of length 32768 bits. This is based on gri_lfsr_15_1_0 with an extra 0 added at the end of the sequence |
| gri_logger | Non-blocking logging to a file |
| gri_mmse_fir_interpolator | Compute intermediate samples between signal samples x(k*Ts) This implements a Mininum Mean Squared Error interpolator with 8 taps. It is suitable for signals where the bandwidth of interest B = 1/(4*Ts) Where Ts is the time between samples |
| gri_mmse_fir_interpolator_cc | Compute intermediate samples between signal samples x(k*Ts) This implements a Mininum Mean Squared Error interpolator with 8 taps. It is suitable for signals where the bandwidth of interest B = 1/(4*Ts) Where Ts is the time between samples |
| gsm_fr_decode_ps | GSM 06.10 Full Rate Vocoder Decoder |
| gsm_fr_encode_sp | GSM 06.10 Full Rate Vocoder Encoder shorts in; 33 byte packets out |
| python::stdgui::gui_flow_graph | |
| gnuradio::gr::hier_block::hier_block | Simple concrete class for building hierarchical blocks |
| gnuradio::gr::hier_block2::hier_block2 | Python wrapper around the C++ hierarchical block implementation |
| gnuradio::gr::hier_block::hier_block_base | Abstract base class for hierarchical signal processing blocks |
| i2c | Abstract class for controlling i2c bus |
| i2c_bbio | Abstract class that implements bit banging i/o for i2c bus |
| i2c_bbio_pp | Concrete class that bit bangs eval board i2c bus using parallel port |
| i2c_bitbang | Class for controlling i2c bus |
| python::form::identity_converter | |
| input::input | |
| python::waterfallsink2::input_watcher | |
| ra_fftsink::input_watcher | |
| ra_stripchartsink::input_watcher | |
| ra_waterfallsink::input_watcher | |
| python::fftsink2::input_watcher | |
| python::fftsink::input_watcher | |
| python::waterfallsink::input_watcher | |
| python::numbersink::input_watcher | |
| python::numbersink2::input_watcher | |
| python::scopesink::input_watcher | |
| python::scopesink2::input_watcher | |
| python::form::int_converter | |
| python::form::int_field | |
| interleaver | INTERLEAVER class |
| interleaver_fifo< symbol_type > | Template class for interleaver fifo |
| gnuradio::gruimpl::lmx2306::lmx2306 | Control the National LMX2306 PLL |
| gnuradio::blks2impl::logpwrfft::logpwrfft_c | ! Create an fft block chain, with complex input |
| gnuradio::blks2impl::logpwrfft::logpwrfft_f | ! Create an fft block chain, with real input |
| md5_ctx | |
| microtune_4702 | Class for controlling microtune 4702 tuner module |
| microtune_4702_eval_board | Control microtune 4702 eval board |
| microtune_4937 | Class for controlling microtune 4937 tuner module |
| microtune_4937_eval_board | Control microtune 4937 eval board |
| microtune_xxxx | Abstract class for controlling microtune {4937,4702} tuner modules |
| microtune_xxxx_eval_board | Abstract class for controlling microtune xxxx eval board |
| mld_condition_t | |
| mld_mutex_t | |
| mld_thread_t | |
| gnuradio::blks2impl::pkt::mod_pkts | Wrap an arbitrary digital modulator in our packet handling framework |
| gnuradio::blksimpl::pkt::mod_pkts | Wrap an arbitrary digital modulator in our packet handling framework |
| usrp_multi::multi_source_align | |
| multi_file::my_graph | |
| multi_scope::my_graph | |
| multi_usrp_rx_cfile::my_graph | |
| gen_whitener::my_graph | |
| multi_fft::my_graph | |
| benchmark_tx::my_top_block | |
| dial_tone_daemon::my_top_block | |
| audio_copy::my_top_block | |
| audio_to_file::my_top_block | |
| rx_voice::my_top_block | |
| mono_tone::my_top_block | |
| benchmark_loopback::my_top_block | |
| audio_play::my_top_block | |
| usrp_tv_rcv_nogui::my_top_block | |
| tx_voice::my_top_block | |
| benchmark_rx::my_top_block | |
| tunnel::my_top_block | |
| spectrum_inversion::my_top_block | |
| noise::my_top_block | |
| python::gpio_rx_sfile::my_top_block | |
| python::gpio_usrp_siggen::my_top_block | |
| test_resampler::my_top_block | |
| dial_tone_wav::my_top_block | |
| usrp_nbfm_rcv::my_top_block | |
| usrp_siggen::my_top_block | |
| fm_tx_2_daughterboards::my_top_block | |
| usrp_rx_cfile::my_top_block | |
| dial_tone::my_top_block | |
| usrp_spectrum_sense::my_top_block | |
| multi_tone::my_top_block | |
| hfx2::MyApp | |
| ui::MyFrame | |
| hfx2::MyFrame | |
| gnuradio::blksimpl::nbfm_rx::nbfm_rx | |
| gnuradio::blks2impl::nbfm_rx::nbfm_rx | |
| gnuradio::blksimpl::nbfm_tx::nbfm_tx | |
| gnuradio::blks2impl::nbfm_tx::nbfm_tx | |
| gnuradio::gr::exceptions::NotDAG | Not a directed acyclic graph |
| python::numbersink::number_sink_base | |
| python::numbersink2::number_sink_base | |
| python::numbersink2::number_sink_c | |
| python::numbersink::number_sink_c | |
| python::numbersink2::number_sink_f | |
| python::numbersink::number_sink_f | |
| python::numbersink::number_window | |
| python::numbersink2::number_window | |
| omni_condition | |
| omni_mutex | |
| omni_mutex_lock | |
| omni_semaphore | |
| omni_semaphore_lock | |
| omni_thread | |
| omni_thread::omni_thread::ensure_self | |
| omni_thread::omni_thread::init_t | |
| omni_thread::omni_thread::value_t | |
| omni_thread_fatal | |
| omni_thread_invalid | |
| omni_time | |
| option | |
| output::output | |
| pager_flex_deinterleave | Flex deinterleave description |
| pager_flex_frame | Flex_frame |
| pager_flex_parse | |
| pager_flex_sync | Flex sync description |
| pager_slicer_fb | Slicer description |
| usrp_spectrum_sense::parse_msg | |
| fm_tx4::pipeline | |
| plinfo | Pipeline info that flows with data |
| plot_data::plot_data | |
| python::plot::PlotCanvas | Subclass of a wx.Window to allow simple general plotting of data with zoom, labels, and automatic axis scaling |
| python::plot::PlotGraphics | Container to hold PolyXXX objects and graph labels
|
| python::plot::PlotPrintout | Controls how the plot is made in printing and previewing |
| python::powermate::PMButtonEvent | |
| python::powermate::PMRotateEvent | |
| python::powermate::PMShuttleEvent | |
| gnuradio::gruimpl::freqz::poly1d | A one-dimensional polynomial class |
| python::plot::PolyLine | Class to define line type and style
|
| python::plot::PolyMarker | Class to define marker type and style
|
| python::plot::PolyPoints | Base Class for lines and markers
|
| python::powermate::powermate | Interface to Griffin PowerMate and Contour Shuttles |
| ppio | Abstract class that provides low level access to parallel port bits |
| ppio_ppdev | Access to parallel port bits using the linux ppdev interface |
| usrp_nbfm_ptt::ptt_block | |
| gnuradio::blks2impl::qam16::qam16_demod | |
| gnuradio::blksimpl::qam16::qam16_demod | |
| gnuradio::blks2impl::qam16::qam16_mod | |
| gnuradio::blksimpl::qam16::qam16_mod | |
| gnuradio::blks2impl::qam256::qam256_demod | |
| gnuradio::blksimpl::qam256::qam256_demod | |
| gnuradio::blks2impl::qam256::qam256_mod | |
| gnuradio::blksimpl::qam256::qam256_mod | |
| gnuradio::blks2impl::qam64::qam64_demod | |
| gnuradio::blksimpl::qam64::qam64_demod | |
| gnuradio::blks2impl::qam64::qam64_mod | |
| gnuradio::blksimpl::qam64::qam64_mod | |
| gnuradio::blks2impl::qam8::qam8_demod | |
| gnuradio::blksimpl::qam8::qam8_demod | |
| gnuradio::blksimpl::qam8::qam8_mod | |
| gnuradio::blks2impl::qam8::qam8_mod | |
| sssr::quad_filter | Quad filter (used to compute timing error) |
| python::form::quantized_slider_field | |
| ra_fftsink::ra_fft_sink_base | |
| ra_fftsink::ra_fft_sink_c | |
| ra_fftsink::ra_fft_sink_f | |
| radar_mono::radar | |
| radar_mono::radar_rx | |
| radar_mono::radar_tx | |
| radio::radio | |
| radio::radio_frame | |
| python::form::radiobox_field | |
| ui::RadioFrame | |
| gnuradio::blksimpl::rational_resampler::rational_resampler_ccc | |
| gnuradio::blks2impl::rational_resampler::rational_resampler_ccc | |
| gnuradio::blks2impl::rational_resampler::rational_resampler_ccf | |
| gnuradio::blksimpl::rational_resampler::rational_resampler_ccf | |
| gnuradio::blks2impl::rational_resampler::rational_resampler_fff | |
| gnuradio::blksimpl::rational_resampler::rational_resampler_fff | |
| receive_path::receive_path | |
| receive_path_lb::receive_path | |
| usrp_nbfm_rcv::receive_path | |
| usrp_nbfm_ptt::receive_path | |
| ra_waterfallsink::rg_dialog | |
| rs | |
| s_buffer | |
| gnuradio::gr::scheduler::scheduler | |
| gnuradio::gr::scheduler::scheduler_thread | |
| python::scopesink::scope_sink_c | |
| python::scopesink2::scope_sink_c | |
| python::scopesink::scope_sink_f | |
| python::scopesink2::scope_sink_f | |
| python::scopesink::scope_window | |
| python::scopesink2::scope_window | |
| gnuradio::gruimpl::sdr_1000::sdr_1000 | |
| sdr_1000_base | Very low level interface to SDR 1000 xcvr hardware |
| sssr::seg_sync_integrator | Segment sync integrator |
| gnuradio::gruimpl::seq_with_cursor::seq_with_cursor | |
| boost::shared_ptr< T > | Shared_ptr documentation stub |
| usrp::sink_c | |
| usrp::sink_s | |
| python::form::slider_field | |
| sounder::sounder | |
| sounder::sounder_rx | |
| sounder::sounder_tx | |
| usrp::source_c | |
| usrp::source_s | |
| gnuradio::detail::sptr_magic | |
| ssbdemod::ssb_demod | |
| gnuradio::blksimpl::standard_squelch::standard_squelch | |
| gnuradio::blks2impl::standard_squelch::standard_squelch | |
| python::form::static_float_field | |
| python::form::static_int_field | |
| python::form::static_text_field | |
| python::numbersink::static_text_window | |
| python::numbersink2::static_text_window | |
| python::stdgui2::std_top_block | |
| python::stdgui2::stdapp | |
| python::stdgui::stdapp | |
| python::stdgui::stdframe | |
| python::stdgui2::stdframe | |
| python::stdgui2::stdpanel | |
| python::stdgui::stdpanel | |
| gnuradio::blks2impl::stream_to_vector_decimator::stream_to_vector_decimator | ! Convert the stream to a vector, decimate the vector stream to achieve the vector rate |
| ra_stripchartsink::stripchart_sink_base | |
| ra_stripchartsink::stripchart_sink_f | |
| ra_stripchartsink::stripchart_window | |
| SwigDirector_feval | |
| SwigDirector_feval_cc | |
| SwigDirector_feval_dd | |
| SwigDirector_feval_ll | |
| SwigDirector_gr_prefs | |
| atsc::syminfo | |
| gnuradio::blks2impl::filterbank::synthesis_filterbank | Uniformly modulated polyphase DFT filter bank: synthesis |
| gnuradio::blksimpl::filterbank::synthesis_filterbank | Uniformly modulated polyphase DFT filter bank: synthesis |
| python::fftsink2::test_app_block | |
| ra_waterfallsink::test_app_flow_graph | |
| python::numbersink::test_app_flow_graph | |
| python::fftsink::test_app_flow_graph | |
| ra_fftsink::test_app_flow_graph | |
| python::scopesink::test_app_flow_graph | |
| python::waterfallsink::test_app_flow_graph | |
| python::numbersink2::test_app_flow_graph | |
| test_dft_analysis::test_graph | |
| test_dft_synth::test_graph | |
| python::scopesink2::test_top_block | |
| python::waterfallsink2::test_top_block | |
| gnuradio::gr_unittest::TestCase | A subclass of unittest.TestCase that adds additional assertions |
| python::plot::TestFrame | |
| python::form::text_field | |
| gnuradio::gr::top_block::top_block | |
| transmit_path::transmit_path | |
| transmit_path_lb::transmit_path | |
| usrp_nbfm_ptt::transmit_path | |
| trellis_encoder_bb | Convolutional encoder |
| trellis_encoder_bi | Convolutional encoder |
| trellis_encoder_bs | Convolutional encoder |
| trellis_encoder_ii | Convolutional encoder |
| trellis_encoder_si | Convolutional encoder |
| trellis_encoder_ss | Convolutional encoder |
| trellis_metrics_c | Evaluate metrics for use by the Viterbi algorithm |
| trellis_metrics_f | Evaluate metrics for use by the Viterbi algorithm |
| trellis_metrics_i | Evaluate metrics for use by the Viterbi algorithm |
| trellis_metrics_s | Evaluate metrics for use by the Viterbi algorithm |
| trellis_permutation | Permutation |
| trellis_siso_combined_f | |
| trellis_siso_f | |
| trellis_viterbi_b | |
| trellis_viterbi_combined_cb | |
| trellis_viterbi_combined_ci | |
| trellis_viterbi_combined_cs | |
| trellis_viterbi_combined_fb | |
| trellis_viterbi_combined_fi | |
| trellis_viterbi_combined_fs | |
| trellis_viterbi_combined_ib | |
| trellis_viterbi_combined_ii | |
| trellis_viterbi_combined_is | |
| trellis_viterbi_combined_sb | |
| trellis_viterbi_combined_si | |
| trellis_viterbi_combined_ss | |
| trellis_viterbi_i | |
| trellis_viterbi_s | |
| usrp_spectrum_sense::tune | This class allows C++ code to callback into python |
| usrp::tune_result | Container for intermediate tuning information |
| usrp_tv_rcv::tv_rx_block | |
| tx_debug_gui::tx_debug_gui | |
| ui::ui_frame | |
| hfx2::UpdateTimer | |
| usb_dev_handle | |
| usrp1_sink_base | Abstract interface to Universal Software Radio Peripheral Tx path (Rev 1) |
| usrp1_sink_c | Interface to Universal Software Radio Peripheral Tx path (Rev 1) |
| usrp1_sink_s | Interface to Universal Software Radio Peripheral Tx path (Rev 1) |
| usrp1_source_base | Abstract interface to Universal Software Radio Peripheral Rx path (Rev 1) |
| usrp1_source_c | Interface to Universal Software Radio Peripheral Rx path (Rev 1) |
| usrp1_source_s | Interface to Universal Software Radio Peripheral Rx path (Rev 1) |
| usrp_basic | Base class for usrp operations |
| usrp_basic_rx | Class for accessing the receive side of the USRP |
| usrp_basic_tx | Class for accessing the transmit side of the USRP |
| usrp::usrp_common | |
| usrp_dboard_eeprom | |
| usrp_local_sighandler | Get and set signal handler |
| usrp_signal | Representation of signal |
| usrp_rx_nogui::usrp_src | Create a USRP source object supplying complex floats |
| usrp_standard_common | |
| usrp_standard_rx | Standard usrp RX class |
| usrp_standard_tx | Standard usrp TX class |
| std::vector< T > | Vector documentation stub |
| vector_sink::vector_sink | |
| vector_source::vector_source | |
| video_sdl_sink_s | Video sink using SDL |
| video_sdl_sink_uc | Video sink using SDL |
| viterbi_state | |
| ra_waterfallsink::waterfall_sink_base | |
| python::waterfallsink2::waterfall_sink_base | |
| python::waterfallsink::waterfall_sink_base | |
| python::waterfallsink::waterfall_sink_c | |
| ra_waterfallsink::waterfall_sink_c | |
| python::waterfallsink2::waterfall_sink_c | |
| python::waterfallsink2::waterfall_sink_f | |
| ra_waterfallsink::waterfall_sink_f | |
| python::waterfallsink::waterfall_sink_f | |
| ra_waterfallsink::waterfall_window | |
| python::waterfallsink::waterfall_window | |
| python::waterfallsink2::waterfall_window | |
| db_wbx::wbx_base | Abstract base class for all wbx boards |
| db_wbx::wbx_base_rx | |
| db_wbx::wbx_base_tx | |
| gnuradio::blksimpl::wfm_rcv::wfm_rcv | |
| gnuradio::blks2impl::wfm_rcv::wfm_rcv | |
| gnuradio::blks2impl::wfm_rcv_pll::wfm_rcv_pll | |
| gnuradio::blksimpl::wfm_rcv_pll::wfm_rcv_pll | |
| usrp_wfm_rcv_nogui::wfm_rx_block | |
| usrp_wfm_rcv_pll::wfm_rx_block | |
| usrp_wfm_rcv2_nogui::wfm_rx_block | |
| usrp_wfm_rcv::wfm_rx_block | |
| usrp_am_mw_rcv::wfm_rx_block | |
| usrp_wfm_rcv_sca::wfm_rx_sca_block | |
| gnuradio::blksimpl::wfm_tx::wfm_tx | |
| gnuradio::blks2impl::wfm_tx::wfm_tx | |
| python::scopesink::win_info | |
| python::scopesink2::win_info | |
| usrp_wxapt_rcv::wxapt_rx_block |
1.5.8