 Aadvark | Models the mammal Aadvark |
 gr::analog::kernel::agc2_cc | High performance Automatic Gain Control class |
  gr::analog::agc2_cc_impl | |
 gr::analog::kernel::agc2_ff | |
  gr::analog::agc2_ff_impl | |
 gr::analog::kernel::agc_cc | High performance Automatic Gain Control class for complex signals |
  gr::analog::agc_cc_impl | |
 gr::analog::kernel::agc_ff | High performance Automatic Gain Control class for float signals |
  gr::analog::agc_ff_impl | |
 atsc_data_segment | 832 3 bit symbols. The low 3 bits in the byte hold the symbol |
 atsc_mpeg_packet | |
 atsc_mpeg_packet_no_sync | |
 atsc_mpeg_packet_rs_encoded | |
 atsc_root_raised_cosine | |
  atsc_root_raised_cosine_bandpass | |
 atsc_soft_data_segment | |
 atsc_vsbtx_lp | |
 atsci_basic_trellis_encoder | ATSC trellis encoder building block |
 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 |
 bit128 | |
 circular_buffer< T > | |
 CODEC2 | |
 COMP | |
 convolutional_interleaver< symbol_type > | Template class for generic convolutional interleaver |
 convolutional_interleaver< unsigned char > | |
  atsci_data_deinterleaver | Atsc convolutional data deinterleaver |
  atsci_data_interleaver | Atsc convolutional data interleaver |
 gr::analog::cpm | |
 dc_blocker_cc | Computationally efficient controllable DC blocker |
 dc_blocker_ff | Computationally efficient controllable DC blocker |
 digital_constellation | An abstracted constellation objectThe constellation objects hold the necessary information to pass around constellation information for modulators and demodulators. These objects contain the mapping between the bits and the constellation points used to represent them as well as methods for slicing the symbol space. Various implementations are possible for efficiency and ease of use |
  digital_constellation_8psk | Digital constellation for 8PSK |
  digital_constellation_bpsk | Digital constellation for BPSK |
  digital_constellation_calcdist | Calculate Euclidian distance for any constellationConstellation which calculates the distance to each point in the constellation for decision making. Inefficient for large constellations |
  digital_constellation_dqpsk | Digital constellation for DQPSK |
  digital_constellation_qpsk | Digital constellation for QPSK |
  digital_constellation_sector | Sectorized digital constellationConstellation space is divided into sectors. Each sector is associated with the nearest constellation point |
   digital_constellation_psk | Digital_constellation_pskConstellation space is divided into pie slices sectors |
   digital_constellation_rect | |
 sssr::digital_correlator | Digital correlator for 1001 and 0110 patterns |
 digital_impl_glfsr | Galois Linear Feedback Shift Register using specified polynomial maskGenerates a maximal length pseudo-random sequence of length 2^degree-1 |
 digital_impl_mpsk_snr_est | A parent class for SNR estimators, specifically for M-PSK signals in AWGN channels |
  digital_impl_mpsk_snr_est_m2m4 | SNR Estimator using 2nd and 4th-order moments |
  digital_impl_mpsk_snr_est_simple | SNR Estimator using simple mean/variance estimates |
  digital_impl_mpsk_snr_est_skew | SNR Estimator using skewness correction |
  digital_impl_mpsk_snr_est_svr | Signal-to-Variation Ratio SNR Estimator |
  digital_impl_snr_est_m2m4 | SNR Estimator using 2nd and 4th-order moments |
 FCD_CAPS_STRUCT | FCD capabilities that depend on both hardware and firmware |
 gr::fft::fft_complex | FFT: complex in, complex out |
 gr::filter::kernel::fft_filter_ccc | Fast FFT filter with gr_complex input, gr_complex output and gr_complex taps |
 gr::filter::kernel::fft_filter_fff | Fast FFT filter with float input, float output and float taps |
 gr::fft::fft_real_fwd | FFT: real in, complex out |
 gr::fft::fft_real_rev | FFT: complex in, float out |
 gr::filter::kernel::fir_filter_ccc | |
  gr::filter::adaptive_fir_ccc_impl | |
 gr::filter::kernel::fir_filter_ccf | |
  gr::filter::adaptive_fir_ccf_impl | |
 gr::filter::kernel::fir_filter_fcc | |
 gr::filter::kernel::fir_filter_fff | |
 gr::filter::kernel::fir_filter_fsf | |
 gr::filter::kernel::fir_filter_scc | |
 gr::filter::kernel::fir_filter_with_buffer_ccc | FIR with internal buffer for gr_complex input, gr_complex output and gr_complex taps |
 gr::filter::kernel::fir_filter_with_buffer_ccf | FIR with internal buffer for gr_complex input, gr_complex output and gr_complex taps |
 gr::filter::kernel::fir_filter_with_buffer_fff | FIR with internal buffer for float input, float output and float taps |
 gr::filter::firdes | Finite Impulse Response (FIR) filter design functions |
 flex_mode | |
 fsm | Finite State Machine Specification class |
 g72x_state | |
 gr::fft::goertzel | Implements Goertzel single-bin DFT calculation |
 gr_block_detail | Implementation details to support the signal processing abstractionThis 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_block_executor | Manage the execution of a single block |
 gr_block_gw_message_type | |
 gr_block_registry | |
 gr_buffer | Single writer, multiple reader fifo |
 gr_buffer_reader | How we keep track of the readers of a gr_buffer |
 gr_circular_file | |
 gr_cpm | |
 gr_cpu | |
 gr_dispatcher | Invoke callbacks based on select |
 gr_edge | Class representing a connection between to graph endpoints |
 gr_endpoint | Class representing a specific input or output graph endpoint |
 gr_error_handler | Abstract error handler |
  gr_base_error_handler | |
   gr_file_error_handler | |
 gr_feval | Base class for evaluating a function: void -> voidThis 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 -> complexThis 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 -> doubleThis 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 -> longThis 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_file_sink_base | Common base class for file sinks |
  gr_file_sink | Write stream to file |
 gr_fir_ccc_simd | Common base class for SIMD versions of gr_fir_cccThis base class handles alignment issues common to SSE and 3DNOW subclasses |
  gr_fir_ccc_3dnow | 3DNow! version of gr_fir_ccc |
  gr_fir_ccc_3dnowext | |
  gr_fir_ccc_sse | SSE version of gr_fir_ccc |
 gr_fir_ccf_armv7_a | Armv7_a using NEON coprocessor version of gr_fir_ccf |
 gr_fir_ccf_simd | Common base class for SIMD versions of gr_fir_ccfThis base class handles alignment issues common to SSE and 3DNOW subclasses |
  gr_fir_ccf_3dnow | 3DNow! version of gr_fir_ccf |
  gr_fir_ccf_sse | SSE version of gr_fir_ccf |
 gr_fir_fcc_simd | Common base class for SIMD versions of gr_fir_fccThis base class handles alignment issues common to SSE and 3DNOW subclasses |
  gr_fir_fcc_3dnow | 3DNow! version of gr_fir_fcc |
  gr_fir_fcc_sse | SSE version of gr_fir_fcc |
 gr_fir_fff_altivec | Altivec version of gr_fir_fff |
 gr_fir_fff_armv7_a | Armv7_a using NEON coprocessor version of gr_fir_fff |
 gr_fir_fff_simd | Common base class for SIMD versions of gr_fir_fffThis base class handles alignment issues common to SSE and 3DNOW subclasses |
  gr_fir_fff_3dnow | 3DNow! version of gr_fir_fff |
  gr_fir_fff_sse | SSE version of gr_fir_fff |
 gr_fir_fsf_simd | Common base class for SIMD versions of gr_fir_fsfThis base class handles alignment issues common to SSE and 3DNOW subclasses |
  gr_fir_fsf_3dnow | 3DNow! version of gr_fir_fsf |
  gr_fir_fsf_sse | SSE version of gr_fir_fsf |
 gr_fir_scc_simd | Common base class for SIMD versions of gr_fir_sccThis base class handles alignment issues common to SSE and 3DNOW subclasses |
  gr_fir_scc_3dnow | 3DNow! version of gr_fir_scc |
  gr_fir_scc_3dnowext | 3DNow! Ext version of gr_fir_scc |
  gr_fir_scc_sse | SSE version of gr_fir_scc |
 gr_fir_sysconfig_armv7_a | |
 gr_fir_sysconfig_powerpc | |
 gr_fir_sysconfig_x86 | |
 gr_firdes | Finite Impulse Response (FIR) filter design functions |
 gr_flowgraph | Class representing a directed, acyclic graph of basic blocks |
  gr_flat_flowgraph | Class specializing gr_flat_flowgraph that has all nodes as gr_blocks, with no hierarchy |
 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_hier_block2_detail | |
 gr_io_signature | I/o signature for input and output ports |
 gr_local_sighandler | Get and set signal handler |
 gr_message | Message class |
 gr_msg_edge | Class representing a msg connection between to graph msg endpoints |
 gr_msg_endpoint | |
 gr_msg_handler | Abstract class of message handlers |
  gr_msg_queue | Thread-safe message queue |
 gr_nco< o_type, i_type > | Base class template for Numerically Controlled Oscillator (NCO) |
 gr_oscope_guts | Guts of oscilloscope trigger and buffer module |
 gr_pfb_interpolator_ccf | Polyphase filterbank interpolator with gr_complex input, gr_complex output and float taps |
 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_random | Pseudo random number generator |
 gr_rotator | |
 gr_scheduler | Abstract scheduler that takes a flattened flow graph and runs it |
  gr_scheduler_sts | Concrete scheduler that uses the single_threaded_scheduler |
  gr_scheduler_tpb | Concrete scheduler that uses a kernel thread-per-block |
 gr_select_handler | Abstract handler for select based notification |
 gr_signal | Representation of signal |
 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_threaded_scheduler | Simple scheduler for stream computations |
 gr_tag_t | |
 gr_timer | Implement timeouts |
 gr_top_block_impl | Abstract implementation details of gr_top_blockThe actual implementation of gr_top_block. Separate class allows decoupling of changes from dependent classes |
 gr_tpb_detail | Used by thread-per-block scheduler |
 gr_tpb_thread_body | The body of each thread-per-block thread |
 gr_tuntap_pdu | |
 gr_vco< o_type, i_type > | Base class template for Voltage Controlled Oscillator (VCO) |
 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_mmap_shm_open | Concrete class to implement circular buffers with mmap and shm_open |
  gr_vmcircbuf_mmap_tmpfile | Concrete class to implement circular buffers with mmap and shm_open |
  gr_vmcircbuf_sysv_shm | Concrete class to implement circular buffers with mmap and shm_open |
 gr_vmcircbuf_factory | Abstract factory for creating circular buffers |
  gr_vmcircbuf_createfilemapping_factory | Concrete factory for circular buffers built using 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_factory | Concrete factory for circular buffers built using mmap and shm_open |
  gr_vmcircbuf_sysv_shm_factory | Concrete factory for circular buffers built using mmap and shm_open |
 gr_vmcircbuf_sysconfig | |
 gri_agc2_cc | High performance Automatic Gain Control class |
  gr_agc2_cc | High performance Automatic Gain Control classFor Power the absolute value of the complex number is used |
 gri_agc2_ff | High performance Automatic Gain Control class with attack and decay rate |
  gr_agc2_ff | High performance Automatic Gain Control class |
 gri_agc_cc | High performance Automatic Gain Control class |
  gr_agc_cc | High performance Automatic Gain Control classFor Power the absolute value of the complex number is used |
 gri_agc_ff | High performance Automatic Gain Control class |
  gr_agc_ff | High performance Automatic Gain Control classPower is approximated by absolute value |
 gri_control_loop | |
  digital_constellation_receiver_cb | This block does fine-phase and frequency locking and decision making.The phase and frequency synchronization are based on a Costas loop that finds the error of the incoming signal point compared to its nearest constellation point. The frequency and phase of the NCO are updated according to this error |
  digital_costas_loop_cc | Carrier tracking PLL for QPSKinput: complex; output: complex
The Costas loop can have two output streams: stream 1 is the baseband I and Q; stream 2 is the normalized frequency of the loop |
  digital_fll_band_edge_cc | Frequency Lock Loop using band-edge filters |
  digital_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::analog::pll_carriertracking_cc_impl | |
  gr::analog::pll_freqdet_cf_impl | |
  gr::analog::pll_refout_cc_impl | |
  gr_pll_carriertracking_cc | Implements a PLL which locks to the input frequency and outputs the input signal mixed with that carrier.input: stream of complex; output: stream of complex |
  gr_pll_freqdet_cf | Implements a PLL which locks to the input frequency and outputs an estimate of that frequency. Useful for FM Demod.input: stream of complex; output: stream of floats |
  gr_pll_refout_cc | Implements a PLL which locks to the input frequency and outputs a carrierinput: stream of complex; output: stream of complex |
 gri_fft_complex | FFT: complex in, complex out |
 gri_fft_filter_ccc_generic | Fast FFT filter with gr_complex input, gr_complex output and gr_complex taps |
 gri_fft_filter_ccc_sse | Fast FFT filter with gr_complex input, gr_complex output and gr_complex taps |
 gri_fft_filter_fff_generic | |
 gri_fft_filter_fff_sse | |
 gri_fft_planner | Export reference to planner mutex for those apps that want to use FFTW w/o using the gri_fftw* classes |
 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 maskGenerates 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 | Fibonacci Linear Feedback Shift Register using specified polynomial maskGenerates a maximal length pseudo-random sequence of length 2^degree-1 |
 gri_lfsr_15_1_0 | Linear Feedback Shift Register using primitive polynomial x^15 + x + 1Generates 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_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_state | |
 hid_device_info | |
 i2c | Abstract class for controlling i2c bus |
  i2c_bitbang | 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 |
 gr::filter::kernel::iir_filter< i_type, o_type, tap_type > | Base class template for Infinite Impulse Response filter (IIR) |
 imaxdiv_t | |
 interleaver | INTERLEAVER class |
 interleaver_fifo< symbol_type > | Template class for interleaver fifo |
 interleaver_fifo< unsigned char > | |
 kiss_fft_cpx | |
 kiss_fft_state | |
 gr::analog::lfsr | Fibonacci Linear Feedback Shift Register using specified polynomial maskGenerates a maximal length pseudo-random sequence of length 2^degree-1 |
 lsp_codebook | |
 microtune_xxxx | Abstract class for controlling microtune {4937,4702} tuner modules |
  microtune_4702 | Class for controlling microtune 4702 tuner module |
  microtune_4937 | Class for controlling microtune 4937 tuner module |
 microtune_xxxx_eval_board | Abstract class for controlling microtune xxxx eval board |
  microtune_4702_eval_board | Control microtune 4702 eval board |
  microtune_4937_eval_board | Control microtune 4937 eval board |
 gr::filter::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 |
 gr::filter::mmse_fir_interpolator_ff | 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 |
 MODEL | |
 moving_averager_c | |
 gr::filter::moving_averager_c | |
 moving_averager_f | |
 gr::filter::moving_averager_f | |
 gruel::msg_accepter | Virtual base class that accepts messages |
  gr_msg_accepter | Accepts messages and inserts them into a message queue, then notifies subclass gr_basic_block there is a message pending |
   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, a set of inputs and outputs, and a message queue. 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_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 |
     atsc_bit_timing_loop | ATSC BitTimingLoop3This class accepts a single real input and produces two outputs, the raw symbol (float) and the tag (atsc_syminfo) |
     atsc_field_sync_demux | ATSC Field Sync Demux |
     digital_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 |
     digital_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 |
     digital_constellation_decoder_cb | Constellation Decoder |
     digital_constellation_receiver_cb | This block does fine-phase and frequency locking and decision making.The phase and frequency synchronization are based on a Costas loop that finds the error of the incoming signal point compared to its nearest constellation point. The frequency and phase of the NCO are updated according to this error |
     digital_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 |
     digital_ofdm_frame_acquisition | Take a vector of complex constellation points in from an FFT and performs a correlation and equalization.This block takes the output of an FFT of a received OFDM symbol and finds the start of a frame based on two known symbols. It also looks at the surrounding bins in the FFT output for the correlation in case there is a large frequency shift in the data. This block assumes that the fine frequency shift has already been corrected and that the samples fall in the middle of one FFT bin |
     digital_ofdm_insert_preamble | Insert "pre-modulated" preamble symbols before each payload |
     digital_ofdm_sampler | Does the rest of the OFDM stuff |
     digital_pfb_clock_sync_ccf | Timing synchronizer using polyphase filterbanks |
     digital_pfb_clock_sync_fff | Timing synchronizer using polyphase filterbanks |
     digital_simple_framer | Add sync field, seq number and command field to payloadTakes in enough samples to create a full output frame. The frame is prepended with the GRSF_SYNC (defind in digital_simple_framer_sync.h) and an 8-bit sequence number |
     gr::analog::ctcss_squelch_ff | Gate or zero output if ctcss tone not present |
      gr::analog::ctcss_squelch_ff_impl | |
     gr::analog::pwr_squelch_cc | Gate or zero output when input power below threshold |
      gr::analog::pwr_squelch_cc_impl | |
     gr::analog::pwr_squelch_ff | Gate or zero output when input power below threshold |
      gr::analog::pwr_squelch_ff_impl | |
     gr::analog::squelch_base_cc | Basic squelch block; to be subclassed for other squelches |
      gr::analog::pwr_squelch_cc | Gate or zero output when input power below threshold |
      gr::analog::squelch_base_cc_impl | |
       gr::analog::pwr_squelch_cc_impl | |
     gr::analog::squelch_base_ff | Basic squelch block; to be subclassed for other squelches |
      gr::analog::ctcss_squelch_ff | Gate or zero output if ctcss tone not present |
      gr::analog::pwr_squelch_ff | Gate or zero output when input power below threshold |
      gr::analog::squelch_base_ff_impl | |
       gr::analog::ctcss_squelch_ff_impl | |
       gr::analog::pwr_squelch_ff_impl | |
     gr::blocks::keep_m_in_n | Decimate a stream, keeping one item out of every n |
      gr::blocks::keep_m_in_n_impl | |
     gr::blocks::keep_one_in_n | Decimate a stream, keeping one item out of every n |
      gr::blocks::keep_one_in_n_impl | |
     gr::blocks::patterned_interleaver | |
      gr::blocks::patterned_interleaver_impl | |
     gr::blocks::stream_mux | Stream muxing block to multiplex many streams into one with a specified format |
      gr::blocks::stream_mux_impl | |
     gr::filter::fractional_interpolator_cc | Interpolating MMSE filter with complex input, complex output |
      gr::filter::fractional_interpolator_cc_impl | |
     gr::filter::fractional_interpolator_ff | Interpolating MMSE filter with float input, float output |
      gr::filter::fractional_interpolator_ff_impl | |
     gr::filter::pfb_arb_resampler_ccf | Polyphase filterbank arbitrary resampler with gr_complex input, gr_complex output and float taps |
      gr::filter::pfb_arb_resampler_ccf_impl | |
     gr::filter::pfb_arb_resampler_fff | Polyphase filterbank arbitrary resampler with float input, float output and float taps |
      gr::filter::pfb_arb_resampler_fff_impl | |
     gr::filter::pfb_channelizer_ccf | Polyphase filterbank channelizer with gr_complex input, gr_complex output and float taps |
      gr::filter::pfb_channelizer_ccf_impl | |
     gr_align_on_samplenumbers_ss | |
     gr_block_gateway | |
     gr_copy | 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_delay | Delay the input by a certain number of samples |
     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_keep_m_in_n | Decimate a stream, keeping one item out of every n |
     gr_keep_one_in_n | Decimate a stream, keeping one item out of every n |
     gr_message_strobe | Send message at defined interval |
     gr_nop | Does nothing. Used for testing only |
     gr_ofdm_bpsk_demapper | Take a vector of complex constellation points in from an FFT and demodulate to a stream of bits. Simple BPSK version |
     gr_pfb_arb_resampler_ccf | Polyphase filterbank arbitrary resampler with gr_complex input, gr_complex output and float taps |
     gr_pfb_arb_resampler_fff | Polyphase filterbank arbitrary resampler with float input, float output and float taps |
     gr_pfb_channelizer_ccf | Polyphase filterbank channelizer with gr_complex input, gr_complex output and float taps |
     gr_pfb_clock_sync_ccf | Timing synchronizer using polyphase filterbanks |
     gr_pfb_clock_sync_fff | Timing synchronizer using polyphase filterbanks |
     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_skiphead | Skips the first N items, from then on copies items to the outputUseful for building test cases and sources which have metadata or junk at the start |
     gr_squelch_base_cc | |
      gr_pwr_squelch_cc | Gate or zero output when input power below threshold |
     gr_squelch_base_ff | |
      gr_ctcss_squelch_ff | Gate or zero output if ctcss tone not present |
      gr_pwr_squelch_ff | Gate or zero output when input power below threshold |
     gr_stream_mux | Stream muxing block to multiplex many streams into one with a specified format |
     gr_sync_block | Synchronous 1:1 input to output with historyOverride work to provide the signal processing implementation |
      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_derandomizer | "dewhiten" incoming mpeg transport stream packetsinput: atsc_mpeg_packet_no_sync; output: atsc_mpeg_packet; |
      atsc_ds_to_softds | Debug glue routine (atsc_data_segment –> atsc_soft_data_segment)input: atsc_data_segment; output: 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_mux | Insert ATSC Field Syncs as required (atsc_data_segment –> atsc_data_segment)input: atsc_data_segment; output: 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_randomizer | "Whiten" incoming mpeg transport stream packetsinput: atsc_mpeg_packet; output: atsc_mpeg_packet_no_sync |
      atsc_rs_decoder | Reed-Solomon decoder for ATSCinput: atsc_mpeg_packet_rs_encoded; output: atsc_mpeg_packet_no_sync |
      atsc_rs_encoder | Reed-Solomon encoder for ATSCinput: atsc_mpeg_packet_no_sync; output: atsc_mpeg_packet_rs_encoded |
      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 |
      audio_sink | Creates a sink from an audio device |
       audio_alsa_sink | Audio sink using ALSAThe sink has N input streams of floats, where N depends on the hardware characteristics of the selected device |
       audio_jack_sink | Audio sink using JACKThe sink has one input stream of floats |
       audio_oss_sink | Audio sink using OSSinput signature is one or two streams of floats. Input samples must be in the range [-1,1] |
       audio_osx_sink | Audio sink using OSXinput signature is one or two streams of floats. Input samples must be in the range [-1,1] |
       audio_portaudio_sink | Audio sink using PORTAUDIOInput samples must be in the range [-1,1] |
       audio_windows_sink | Audio sink using winmm mmsystem (win32 only)input signature is one or two streams of floats. Input samples must be in the range [-1,1] |
      audio_source | Creates a source from an audio device |
       audio_alsa_source | Audio source using ALSAThe source has between 1 and N input streams of floats, where N is depends on the hardware characteristics of the selected device |
       audio_jack_source | Audio source using JACKThe source has one input stream of floats |
       audio_oss_source | Audio source using OSSOutput signature is one or two streams of floats. Output samples will be in the range [-1,1] |
       audio_osx_source | Audio source using OSXInput signature is one or two streams of floats. Samples must be in the range [-1,1] |
       audio_portaudio_source | Audio source using PORTAUDIOInput samples must be in the range [-1,1] |
       audio_windows_source | Audio source using winmm mmsystem (win32 only)Output signature is one or two streams of floats. Output samples will be in the range [-1,1] |
      comedi_sink_s | Sink using COMEDI |
      comedi_source_s | Source using COMEDI |
      digital_additive_scrambler_bb | |
      digital_binary_slicer_fb | Slice float binary symbol outputting 1 bit outputx < 0 –> 0 x >= 0 –> 1 |
      digital_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) |
      digital_correlate_access_code_tag_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: unaltered stream of bits (plus tags) |
      digital_costas_loop_cc | Carrier tracking PLL for QPSKinput: complex; output: complex
The Costas loop can have two output streams: stream 1 is the baseband I and Q; stream 2 is the normalized frequency of the loop |
      digital_descrambler_bb | |
      digital_diff_decoder_bb | Y[0] = (x[0] - x[-1]) % MUses current and previous symbols and the alphabet modulus to perform differential decoding |
      digital_diff_encoder_bb | Y[0] = (x[0] + y[-1]) % MUses current and previous symbols and the alphabet modulus to perform differential encoding |
      digital_diff_phasor_cc | |
      digital_fll_band_edge_cc | Frequency Lock Loop using band-edge filters |
      digital_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 |
      digital_glfsr_source_b | Galois LFSR pseudo-random source |
      digital_glfsr_source_f | Galois LFSR pseudo-random source generating float outputs -1.0 - 1.0 |
      digital_map_bb | Output[i] = map[input[i]]This block maps an incoming signal to the value in the map. The block expects that the incoming signal has a maximum value of len(map)-1 |
      digital_mpsk_snr_est_cc | A block for computing SNR of a signal |
      digital_ofdm_frame_sink | Takes an OFDM symbol in, demaps it into bits of 0's and 1's, packs them into packets, and sends to to a message queue sink.NOTE: The mod input parameter simply chooses a pre-defined demapper/slicer. Eventually, we want to be able to pass in a reference to an object to do the demapping and slicing for a given modulation type |
      digital_ofdm_mapper_bcv | Take a stream of bytes in and map to a vector of complex constellation points suitable for IFFT input to be used in an ofdm modulator. Abstract class must be subclassed with specific mapping |
      digital_packet_sink | Process received bits looking for packet sync, header, and process bits into packetinput: stream of symbols to be sliced |
      digital_probe_density_b | |
      digital_probe_mpsk_snr_est_c | A probe for computing SNR of a signal |
      digital_scrambler_bb | |
      gr::analog::agc2_cc | High performance Automatic Gain Control classFor Power the absolute value of the complex number is used |
       gr::analog::agc2_cc_impl | |
      gr::analog::agc2_ff | High performance Automatic Gain Control class |
       gr::analog::agc2_ff_impl | |
      gr::analog::agc_cc | High performance Automatic Gain Control classFor Power the absolute value of the complex number is used |
       gr::analog::agc_cc_impl | |
      gr::analog::agc_ff | High performance Automatic Gain Control classPower is approximated by absolute value |
       gr::analog::agc_ff_impl | |
      gr::analog::dpll_bb | Detect the peak of a signalIf a peak is detected, this block outputs a 1, or it outputs 0's |
       gr::analog::dpll_bb_impl | |
      gr::analog::feedforward_agc_cc | Non-causal AGC which computes required gain based on max absolute value over nsamples |
       gr::analog::feedforward_agc_cc_impl | |
      gr::analog::fmdet_cf | Implements an IQ slope detector |
       gr::analog::fmdet_cf_impl | |
      gr::analog::frequency_modulator_fc | Frequency modulator blockfloat input; complex baseband output |
       gr::analog::frequency_modulator_fc_impl | |
      gr::analog::phase_modulator_fc | Phase modulator blockoutput = complex(cos(in*sensitivity), sin(in*sensitivity)) |
       gr::analog::phase_modulator_fc_impl | |
      gr::analog::pll_carriertracking_cc | Implements a PLL which locks to the input frequency and outputs the input signal mixed with that carrier.Input stream 0: complex Output stream 0: complex |
       gr::analog::pll_carriertracking_cc_impl | |
      gr::analog::pll_freqdet_cf | Implements a PLL which locks to the input frequency and outputs an estimate of that frequency. Useful for FM Demod.Input stream 0: complex Output stream 0: float |
       gr::analog::pll_freqdet_cf_impl | |
      gr::analog::pll_refout_cc | Implements a PLL which locks to the input frequency and outputs a carrierInput stream 0: complex Output stream 0: complex |
       gr::analog::pll_refout_cc_impl | |
      gr::analog::probe_avg_mag_sqrd_c | Compute avg magnitude squared.Input stream 0: complex |
       gr::analog::probe_avg_mag_sqrd_c_impl | |
      gr::analog::probe_avg_mag_sqrd_cf | Compute avg magnitude squared.Input stream 0: complex Output stream 0: float |
       gr::analog::probe_avg_mag_sqrd_cf_impl | |
      gr::analog::probe_avg_mag_sqrd_f | Compute avg magnitude squared.input stream 0: float |
       gr::analog::probe_avg_mag_sqrd_f_impl | |
      gr::analog::quadrature_demod_cf | Quadrature demodulator: complex in, float outThis can be used to demod FM, FSK, GMSK, etc. The input is complex baseband |
       gr::analog::quadrature_demod_cf_impl | |
      gr::analog::rail_ff | Clips input values to min, max |
       gr::analog::rail_ff_impl | |
      gr::analog::simple_squelch_cc | Simple squelch block based on average signal power and threshold in dB |
       gr::analog::simple_squelch_cc_impl | |
      gr::blocks::add_ff | |
       gr::blocks::add_ff_impl | |
      gr::blocks::char_to_float | Convert stream of chars to a stream of float |
       gr::blocks::char_to_float_impl | |
      gr::blocks::char_to_short | Convert stream of chars to a stream of short |
       gr::blocks::char_to_short_impl | |
      gr::blocks::complex_to_arg | Complex in, arg out (float) |
       gr::blocks::complex_to_arg_impl | |
      gr::blocks::complex_to_float | Convert a stream of gr_complex to 1 or 2 streams of float |
       gr::blocks::complex_to_float_impl | |
      gr::blocks::complex_to_imag | Complex in, imag out (float) |
       gr::blocks::complex_to_imag_impl | |
      gr::blocks::complex_to_mag | Complex in, magnitude out (float) |
       gr::blocks::complex_to_mag_impl | |
      gr::blocks::complex_to_mag_squared | Complex in, magnitude squared out (float) |
       gr::blocks::complex_to_mag_squared_impl | |
      gr::blocks::complex_to_real | Complex in, real out (float) |
       gr::blocks::complex_to_real_impl | |
      gr::blocks::conjugate_cc | Output = complex conjugate of input |
       gr::blocks::conjugate_cc_impl | |
      gr::blocks::file_meta_sink | Write stream to file with meta-data headers.These files represent data as binary information in between meta-data headers. The headers contain information about the type of data and properties of the data in the next segment of samples. The information includes: |
       gr::blocks::file_meta_sink_impl | |
      gr::blocks::file_meta_source | Reads stream from file with meta-data headers. Headers are parsed into tags.The information in the metadata headers includes: |
       gr::blocks::file_meta_source_impl | |
      gr::blocks::file_source | Read stream from file |
       gr::blocks::file_source_impl | |
      gr::blocks::float_to_char | Convert stream of floats to a stream of char |
       gr::blocks::float_to_char_impl | |
      gr::blocks::float_to_complex | One or two floats in, complex out |
       gr::blocks::float_to_complex_impl | |
      gr::blocks::float_to_int | Convert stream of floats to a stream of char |
       gr::blocks::float_to_int_impl | |
      gr::blocks::float_to_short | Convert stream of floats to a stream of shorts |
       gr::blocks::float_to_short_impl | |
      gr::blocks::float_to_uchar | Convert stream of floats to a stream of unsigned chars |
       gr::blocks::float_to_uchar_impl | |
      gr::blocks::int_to_float | Convert stream of ints to a stream of floats |
       gr::blocks::int_to_float_impl | |
      gr::blocks::multiply_cc | |
       gr::blocks::multiply_cc_impl | |
      gr::blocks::multiply_conjugate_cc | |
       gr::blocks::multiply_conjugate_cc_impl | |
      gr::blocks::multiply_const_cc | Output = input * complex constant |
       gr::blocks::multiply_const_cc_impl | |
      gr::blocks::multiply_const_ff | Output = input * real constant |
       gr::blocks::multiply_const_ff_impl | |
      gr::blocks::multiply_ff | |
       gr::blocks::multiply_ff_impl | |
      gr::blocks::nlog10_ff | Output = n*log10(input) + k |
       gr::blocks::nlog10_ff_impl | |
      gr::blocks::short_to_char | Convert stream of shorts to a stream of chars |
       gr::blocks::short_to_char_impl | |
      gr::blocks::short_to_float | Convert stream of shorts to a stream of floats |
       gr::blocks::short_to_float_impl | |
      gr::blocks::streams_to_vector | Convert N streams of items to 1 stream of vector length N |
       gr::blocks::streams_to_vector_impl | |
      gr::blocks::uchar_to_float | Convert stream of unsigned chars to a stream of floats |
       gr::blocks::uchar_to_float_impl | |
      gr::blocks::vector_to_streams | Convert 1 stream of vectors of length N to N streams of items |
       gr::blocks::vector_to_streams_impl | |
      gr::fft::fft_vcc | |
       gr::fft::fft_vcc_fftw | |
      gr::fft::fft_vfc | |
       gr::fft::fft_vfc_fftw | |
      gr::filter::dc_blocker_cc | |
       gr::filter::dc_blocker_cc_impl | |
      gr::filter::dc_blocker_ff | |
       gr::filter::dc_blocker_ff_impl | |
      gr::filter::filter_delay_fc | |
       gr::filter::filter_delay_fc_impl | |
      gr::filter::hilbert_fc | |
       gr::filter::hilbert_fc_impl | |
      gr::filter::iir_filter_ffd | IIR filter with float input, float output and double tapsThis filter uses the Direct Form I implementation, where fftaps contains the feed-forward taps, and fbtaps the feedback ones |
       gr::filter::iir_filter_ffd_impl | |
      gr::filter::pfb_decimator_ccf | Polyphase filterbank bandpass decimator with gr_complex input, gr_complex output and float taps |
       gr::filter::pfb_decimator_ccf_impl | |
      gr::filter::single_pole_iir_filter_cc | Single pole IIR filter with complex input, complex outputThe input and output satisfy a difference equation of the form
\f{
y[n] - (1-alpha) y[n-1] = alpha x[n]
\f}
|
       gr::filter::single_pole_iir_filter_cc_impl | |
      gr::filter::single_pole_iir_filter_ff | Single pole IIR filter with float input, float outputThe input and output satisfy a difference equation of the form
\f{
y[n] - (1-alpha) y[n-1] = alpha x[n]
\f}
|
       gr::filter::single_pole_iir_filter_ff_impl | |
      gr_add_ff | Add streams of complex values |
      gr_additive_scrambler_bb | |
      gr_agc2_cc | High performance Automatic Gain Control classFor 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 classFor Power the absolute value of the complex number is used |
      gr_agc_ff | High performance Automatic Gain Control classPower is approximated by absolute value |
      gr_annotator_1to1 | 1-to-1 stream annotator testing block. FOR TESTING PURPOSES ONLY |
      gr_annotator_alltoall | All-to-all stream annotator testing block. FOR TESTING PURPOSES ONLY |
      gr_annotator_raw | Raw stream annotator testing block |
      gr_bin_statistics_f | Control scanning and record frequency domain statistics |
      gr_burst_tagger | Output[i] = input[i] |
      gr_char_to_float | Convert stream of chars to a stream of float |
      gr_char_to_short | 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_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_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_correlate_access_code_tag_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: unaltered stream of bits (plus tags) |
      gr_dc_blocker_cc | Computationally efficient controllable DC blocker |
      gr_dc_blocker_ff | Computationally efficient controllable DC blocker |
      gr_descrambler_bb | |
      gr_diff_decoder_bb | Y[0] = (x[0] - x[-1]) % MDifferential decoder |
      gr_diff_encoder_bb | Y[0] = (x[0] + y[-1]) % MDifferential encoder |
      gr_diff_phasor_cc | |
      gr_dpll_bb | Detect the peak of a signalIf a peak is detected, this block outputs a 1, or it outputs 0's |
      gr_endian_swap | Convert stream of items into thier byte swapped version |
      gr_fake_channel_decoder_pp | Remove fake padding from packetinput: 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_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_sink | Write stream to file |
      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_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_int | Convert stream of float to a stream of short |
      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_fmdet_cf | Implements an IQ slope detector |
      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_frequency_modulator_fc | Frequency modulator blockfloat input; complex baseband output |
      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_head | Copies the first N items to the output then signals doneUseful for building test cases |
      gr_hilbert_fc | Hilbert transformer.real output is input appropriately delayed. imaginary output is hilbert filtered (90 degree phase shift) version of input |
      gr_histo_sink_f | Histogram module |
      gr_iir_filter_ffd | IIR filter with float input, float output and double tapsThis filter uses the Direct Form I implementation, where fftaps contains the feed-forward taps, and fbtaps the feedback ones |
      gr_int_to_float | Convert stream of int to a stream of float |
      gr_iqcomp_cc | |
      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_map_bb | Output[i] = map[input[i]] |
      gr_message_burst_source | Turn received messages into a stream and tag them for UHD to send |
      gr_message_sink | Gather received items into messages and insert into msgq |
      gr_message_source | Turn received messages into a stream |
      gr_multiply_cc | Multiply streams of complex values |
      gr_multiply_conjugate_cc | Multiplies a stream by the conjugate of the second stream |
      gr_multiply_const_cc | Multiply stream of complex values with a constant k |
      gr_multiply_const_ff | Multiply stream of float values with a constant k |
      gr_multiply_ff | Multiply streams of complex values |
      gr_nlog10_ff | Output = n*log10(input) + k |
      gr_null_sink | Bit bucket |
      gr_null_source | A source of zeros |
      gr_ofdm_frame_sink2 | Takes an OFDM symbol in, demaps it into bits of 0's and 1's, packs them into packets, and sends to to a message queue sink.NOTE: The mod input parameter simply chooses a pre-defined demapper/slicer. Eventually, we want to be able to pass in a reference to an object to do the demapping and slicing for a given modulation type |
      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_oscope_sink_f | Building block for python oscilloscope module.Accepts multiple float streams |
      gr_pa_2x2_phase_combiner | Pa_2x2 phase combinerAnntenas are arranged like this: |
      gr_packet_sink | Process received bits looking for packet sync, header, and process bits into packet |
      gr_pdu_to_tagged_stream | Turn received messages into a stream |
      gr_peak_detector2_fb | Detect the peak of a signalIf 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_pfb_decimator_ccf | Polyphase filterbank bandpass decimator with gr_complex input, gr_complex output and float taps |
      gr_phase_modulator_fc | Phase modulator blockoutput=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.input: stream of complex; output: stream of complex |
      gr_pll_freqdet_cf | Implements a PLL which locks to the input frequency and outputs an estimate of that frequency. Useful for FM Demod.input: stream of complex; output: stream of floats |
      gr_pll_refout_cc | Implements a PLL which locks to the input frequency and outputs a carrierinput: stream of complex; output: stream of complex |
      gr_probe_avg_mag_sqrd_c | Compute avg magnitude squared.input: gr_complex |
      gr_probe_avg_mag_sqrd_cf | Compute avg magnitude squared.input: gr_complex output: gr_float |
      gr_probe_avg_mag_sqrd_f | Compute avg magnitude squared.input: float |
      gr_probe_density_b | |
      gr_quadrature_demod_cf | Quadrature demodulator: complex in, float outThis can be used to demod FM, FSK, GMSK, etc. The input is complex baseband |
      gr_rail_ff | |
      gr_regenerate_bb | Detect the peak of a signal and repeat every period samplesIf 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_rms_cf | RMS average power |
      gr_rms_ff | RMS average power |
      gr_scrambler_bb | |
      gr_short_to_char | Convert stream of short to a stream of float |
      gr_short_to_float | Convert stream of short to a stream of float |
      gr_simple_squelch_cc | Simple squelch block based on average signal power and threshold in dB |
      gr_single_pole_iir_filter_cc | Single pole IIR filter with complex input, complex outputThe input and output satisfy a difference equation of the form
\f{
y[n] - (1-alpha) y[n-1] = alpha x[n]
\f}
|
      gr_single_pole_iir_filter_ff | Single pole IIR filter with float input, float outputThe input and output satisfy a difference equation of the form
\f{
y[n] - (1-alpha) y[n-1] = alpha x[n]
\f}
|
      gr_stream_pdu_base | Gather received items into messages and insert into msgq |
       gr_socket_pdu | Gather received items into messages and insert into msgq |
      gr_streams_to_vector | Convert N streams of items to 1 stream of vector length N |
      gr_stretch_ff | |
      gr_sync_decimator | Synchronous N:1 input to output with historyOverride work to provide the signal processing implementation |
       atsc_pad | Pad mpeg ts packets from 188 byte char to to 256 byte atsc_mpeg_packetinput: unsigned char; output: atsc_mpeg_packet |
       digital_pn_correlator_cc | PN code sequential search correlator |
       gr::blocks::deinterleave | Deinterleave a single input into N outputs |
        gr::blocks::deinterleave_impl | |
       gr::blocks::interleaved_short_to_complex | Convert stream of interleaved shorts to a stream of complex |
        gr::blocks::interleaved_short_to_complex_impl | |
       gr::blocks::stream_to_streams | Convert a stream of items into a N streams of itemsConverts a stream of N items into N streams of 1 item. Repeat ad infinitum |
        gr::blocks::stream_to_streams_impl | |
       gr::blocks::stream_to_vector | Convert a stream of items into a stream of blocks containing nitems_per_block |
        gr::blocks::stream_to_vector_impl | |
       gr::fft::goertzel_fc | |
        gr::fft::goertzel_fc_impl | |
       gr::filter::adaptive_fir_ccc | Adaptive FIR filter with gr_complex input, gr_complex output and gr_complex tapsThis is a base class to implement an adaptive FIR filter. Generally, another block will inherit from this one to build a new type of adaptive filter such as an equalizer |
        gr::filter::adaptive_fir_ccc_impl | |
       gr::filter::adaptive_fir_ccf | Adaptive FIR filter with gr_complex input, gr_complex output and float tapsThis is a base class to implement an adaptive FIR filter. Generally, another block will inherit from this one to build a new type of adaptive filter such as an equalizer |
        gr::filter::adaptive_fir_ccf_impl | |
       gr::filter::fft_filter_ccc | |
        gr::filter::fft_filter_ccc_impl | |
       gr::filter::fft_filter_fff | |
        gr::filter::fft_filter_fff_impl | |
       gr_adaptive_fir_ccc | Adaptive FIR filter with gr_complex input, gr_complex output and float taps |
        digital_cma_equalizer_cc | Implements constant modulus adaptive filter on complex streamThe error value and tap update equations (for p=2) can be found in: |
        digital_kurtotic_equalizer_cc | Implements a kurtosis-based adaptive equalizer on complex stream"Y. Guo, J. Zhao, Y. Sun, "Sign kurtosis maximization based blind equalization algorithm," IEEE Conf. on Control, Automation,
Robotics and Vision, Vol. 3, Dec. 2004, pp. 2052 - 2057." |
        digital_lms_dd_equalizer_cc | Least-Mean-Square Decision Directed Equalizer (complex in/out)This block implements an LMS-based decision-directed equalizer. It uses a set of weights, w, to correlate against the inputs, u, and a decisions is then made from this output. The error in the decision is used to update teh weight vector |
       gr_adaptive_fir_ccf | Adaptive FIR filter with gr_complex input, gr_complex output and float taps |
       gr_decode_ccsds_27_fb | A rate 1/2, k=7 convolutional decoder for the CCSDS standardThis block performs soft-decision convolutional decoding using the Viterbi algorithm |
       gr_deinterleave | Deinterleave a single input into N outputs |
       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_goertzel_fc | Goertzel single-bin DFT calculation |
       gr_interleaved_short_to_complex | Convert stream of interleaved shorts to a stream of complex |
       gr_pack_k_bits_bb | Converts a stream of bytes with 1 bit in the LSB to a byte with k relevent bits |
       gr_pn_correlator_cc | PN code sequential search correlator |
       gr_stream_to_streams | Convert a stream of items into a N streams of itemsConverts 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 |
       pager_flex_deinterleave | Flex deinterleave description |
       vocoder_codec2_encode_sp | CODEC2 Vocoder Encoder |
       vocoder_cvsd_encode_sb | This block performs CVSD audio encoding. Its design and implementation is modeled after the CVSD encoder/decoder specifications defined in the Bluetooth standard |
       vocoder_gsm_fr_encode_sp | GSM 06.10 Full Rate Vocoder Encodershorts in; 33 byte packets out |
      gr_sync_interpolator | Synchronous 1:N input to output with historyOverride work to provide the signal processing implementation |
       atsc_depad | Depad mpeg ts packets from 256 byte atsc_mpeg_packet to 188 byte charinput: atsc_mpeg_packet; output: unsigned char |
       digital_bytes_to_syms | Convert stream of bytes to stream of +/- 1 symbolsinput: stream of bytes; output: stream of float |
       digital_ofdm_cyclic_prefixer | Adds a cyclic prefix vector to an input size long ofdm symbol(vector) and converts vector to a stream output_size long |
       gr::analog::cpfsk_bc | Perform continuous phase 2-level frequency shift keying modulation on an input stream of unpacked bits |
        gr::analog::cpfsk_bc_impl | |
       gr::blocks::complex_to_interleaved_short | Convert stream of complex to a stream of interleaved shorts |
        gr::blocks::complex_to_interleaved_short_impl | |
       gr::blocks::interleave | Interleave N inputs into a single output |
        gr::blocks::interleave_impl | |
       gr::blocks::repeat | Repeat each input 'interp' times |
        gr::blocks::repeat_impl | |
       gr::blocks::streams_to_stream | Convert N streams of 1 item into a 1 stream of N itemsConvert N streams of 1 item into 1 stream of N items. Repeat ad infinitum |
        gr::blocks::streams_to_stream_impl | |
       gr::blocks::vector_to_stream | Convert a stream of blocks of nitems_per_block items into a stream of items |
        gr::blocks::vector_to_stream_impl | |
       gr::filter::pfb_interpolator_ccf | |
        gr::filter::pfb_interpolator_ccf_impl | |
       gr::filter::pfb_synthesizer_ccf | Polyphase synthesis filterbank with gr_complex input, gr_complex output and float taps |
        gr::filter::pfb_synthesizer_ccf_impl | |
       gr_bytes_to_syms | Convert stream of bytes to stream of +/- 1 symbolsinput: stream of bytes; output: stream of float |
       gr_complex_to_interleaved_short | Convert stream of complex to a stream of interleaved shorts |
       gr_cpfsk_bc | Perform continuous phase 2-level frequency shift keying modulation on an input stream of unpacked bits |
       gr_encode_ccsds_27_bb | A rate 1/2, k=7 convolutional encoder for the CCSDS standardThis block performs convolutional encoding using the CCSDS standard polynomial ("Voyager") |
       gr_interleave | Interleave N inputs to a single output |
       gr_pfb_interpolator_ccf | Polyphase filterbank interpolator with gr_complex input, gr_complex output and float taps |
       gr_pfb_synthesizer_ccf | Polyphase synthesis filterbank with gr_complex input, gr_complex output and float taps |
       gr_repeat | Repeat a sample 'interp' times in output stream |
       gr_streams_to_stream | Convert N streams of 1 item into a 1 stream of N itemsConvert N streams of 1 item into 1 stream of N items. Repeat ad infinitum |
       gr_unpack_k_bits_bb | Converts a byte with k relevent bits to k output bytes with 1 bit in the LSB |
       gr_vector_to_stream | Convert a stream of blocks of nitems_per_block items into a stream of items |
       vocoder_codec2_decode_ps | CODEC2 Vocoder Decoder |
       vocoder_cvsd_decode_bs | This block performs CVSD audio decoding. Its design and implementation is modeled after the CVSD encoder/decoder specifications defined in the Bluetooth standard |
       vocoder_gsm_fr_decode_ps | GSM 06.10 Full Rate Vocoder Decoder |
      gr_tagged_file_sink | Write stream to file descriptor |
      gr_tagged_stream_to_pdu | Turn received messages into a stream |
      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_transcendental | A block that performs various transcendental math operations |
      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_vco_f | VCO - Voltage controlled oscillatorinput: float stream of control voltages; output: float oscillator output |
      gr_vector_map | Maps elements from a set of input vectors to a set of output vectors |
      gr_vector_to_streams | Convert 1 stream of vectors of length N to N streams of items |
      gr_wavfile_sink | Write stream to a Microsoft PCM (.wav) file |
      gr_wavfile_source | Read stream from a Microsoft PCM (.wav) file, output floats |
      noaa_hrpt_decoder | |
      noaa_hrpt_pll_cf | |
      pager_slicer_fb | Slicer description |
      qtgui_time_sink_c | A graphical sink to display multiple signals in time.This is a QT-based graphical sink the takes set of a complex streams and plots them in the time domain. For each signal, both the signal's I and Q parts are plotted, and they are all plotted with a different color, and the set_title and set_color functions can be used to change the lable and color for a given input number |
      qtgui_time_sink_f | A graphical sink to display multiple signals in time.This is a QT-based graphical sink the takes set of a float streams and plots them in the time domain. Each signal is plotted with a different color, and the set_title and set_color functions can be used to change the lable and color for a given input number |
      shd_smini_sink | |
      shd_smini_source | |
      tag_sink_demo | |
      tag_source_demo | |
      trellis_permutation | Permutation |
      uhd_usrp_sink | |
      uhd_usrp_source | |
      video_sdl_sink_s | Video sink using SDL |
      video_sdl_sink_uc | Video sink using SDL |
      vocoder_alaw_decode_bs | This block performs alaw audio decoding |
      vocoder_alaw_encode_sb | This block performs g.711 alaw audio encoding |
      vocoder_g721_decode_bs | This block performs g721 audio decoding |
      vocoder_g721_encode_sb | This block performs g721 audio encoding |
      vocoder_g723_24_decode_bs | This block performs g723_24 audio decoding |
      vocoder_g723_24_encode_sb | This block performs g723_24 audio encoding |
      vocoder_g723_40_decode_bs | This block performs g723_40 audio decoding |
      vocoder_g723_40_encode_sb | This block performs g723_40 audio encoding |
      vocoder_ulaw_decode_bs | This block performs ulaw audio decoding |
      vocoder_ulaw_encode_sb | This block performs g.711 ulaw audio encoding |
      wavelet_squash_ff | |
       wavelet_squash_ff_impl | |
      wavelet_wavelet_ff | Compute wavelet transform using gsl routines |
       wavelet_wavelet_ff_impl | |
      wavelet_wvps_ff | Computes the Wavelet Power Spectrum from a set of wavelet coefficients |
       wavelet_wvps_ff_impl | |
     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 |
     noaa_hrpt_deframer | |
     pager_flex_sync | Flex sync description |
     qtgui_sink_c | A graphical sink to display freq, spec, time, and const plots.This is a QT-based graphical sink the takes a complex stream and plots it. The default action is to plot the signal as a PSD (FFT), spectrogram (waterfall), time domain I&Q, and constellation (I vs. Q) plots. The plots may be turned off by setting the appropriate boolean value in the constructor to False |
     qtgui_sink_f | A graphical sink to display freq, spec, and time.This is a QT-based graphical sink the takes a float stream and plots it. The default action is to plot the signal as a PSD (FFT), spectrogram (waterfall), and time domain plots. The plots may be turned off by setting the appropriate boolean value in the constructor to False |
     trellis_constellation_metrics_cf | Evaluate metrics for use by the Viterbi algorithm |
     trellis_siso_combined_f | |
     trellis_siso_f | |
    gr_hier_block2 | Hierarchical container class for gr_block's and gr_hier_block2's |
     digital_cpmmod_bc | Generic CPM modulator |
      digital_gmskmod_bc | GMSK modulator |
     fcd_source_c | Funcube Dongle source block |
      fcd_source_c_impl | |
     gr::filter::channel_model | Channel simulatorThis block implements a basic channel model simulator that can be used to help evaluate, design, and test various signals, waveforms, and algorithms. This model allows the user to set the voltage of an AWGN noise source, a (normalized) frequency offset, a sample timing offset, and a noise seed to randomize the AWGN noise source |
      gr::filter::channel_model_impl | |
     gr_channel_model | Channel simulator |
     gr_top_block | Top-level hierarchical block representing a flowgraph |
  gruel::msg_accepter_msgq | Concrete class that accepts messages and inserts them into a message queue |
 gruel::msg_queue | Thread-safe message queue |
 option | |
 pager_flex_frame | Flex_frame |
 gr::fft::planner | Export reference to planner mutex for those apps that want to use FFTW w/o using the fft_impl_fftw* classes |
 plinfo | Pipeline info that flows with data |
 pmt::pmt_base | |
  pmt::pmt_any | |
  pmt::pmt_bool | |
  pmt::pmt_complex | |
  pmt::pmt_integer | |
  pmt::pmt_null | |
  pmt::pmt_pair | |
  pmt::pmt_real | |
  pmt::pmt_symbol | |
  pmt::pmt_tuple | |
  pmt::pmt_uint64 | |
  pmt::pmt_uniform_vector | |
  pmt::pmt_vector | |
 pmt::pmt_comperator | Provide a comparator function object to allow pmt use in stl types |
 pmt::pmt_exception | |
  pmt::pmt_notimplemented | |
  pmt::pmt_out_of_range | |
  pmt::pmt_wrong_type | |
 pmt::pmt_pool | Very simple thread-safe fixed-size allocation pool |
 gr::filter::kernel::polyphase_filterbank | Polyphase filterbank parent class |
  gr::filter::pfb_channelizer_ccf_impl | |
  gr::filter::pfb_decimator_ccf_impl | |
  gr::filter::pfb_interpolator_ccf_impl | |
 ppio | Abstract class that provides low level access to parallel port bits |
  ppio_ppdev | Access to parallel port bits using the linux ppdev interface |
 sssr::quad_filter | Quad filter (used to compute timing error) |
 QwtDblClickPlotPicker | |
 QwtPickerDblClickPointMachine | |
 gr::analog::rotator | |
 rs | |
 gruel::rt_sched_param | |
 sdr_1000_base | Very low level interface to SDR 1000 xcvr hardware |
 sssr::seg_sync_integrator | Segment sync integrator |
 boost::shared_ptr< T > | Shared_ptr documentation stub |
 gr::filter::single_pole_iir< o_type, i_type, tap_type > | Class template for single pole IIR filter |
 gr::filter::single_pole_iir< gr_complex, i_type, double > | |
 gnuradio::detail::sptr_magic | |
 uhd::stream_args_t | |
 atsc::syminfo | |
 gruel::sys_pri | |
 tcp_connection | |
 gruel::thread_body_wrapper< F > | |
 gruel::thread_group | |
 uhd_amsg_source | |
 v_float_u | |
 viterbi_state | |
 volk_arch_pref | |
 VOLK_CPU | |
 volk_func_desc | |
 volk_machine | |
 xmm_register | |
 xmm_regs | |