/*!
- * \defgroup block Signal Processing Blocks
- * These are the signal processing blocks...
+ * \defgroup block GNU Radio C++ Signal Processing Blocks
+ * \brief All C++ blocks that can be used in GR graphs are listed here or in
+ * the subcategories below.
+ *
+ * Sorry, at this time the Python hierarchical blocks are not included
+ * in this index.
* @{
*/
-/*!
- * \defgroup source Signal Sources
- * signal sources docs...
- */
-
-/*!
- * \defgroup sink Signal Sinks
- * docs for sinks...
- */
-
-/*!
- * \defgroup filter Filters
- */
+/*! \defgroup container_blk Top Block and Hierarchical Block Base Classes */
+/*! \defgroup source_blk Signal Sources */
+/*! \defgroup sink_blk Signal Sinks */
+/*! \defgroup filter_blk Filters */
+/*! \defgroup math_blk Mathematics */
+/*! \defgroup modulation_blk Signal Modulation */
+/*! \defgroup demodulation_blk Signal Demodulation */
+/*! \defgroup coding_blk Information Coding and Decoding*/
+/*! \defgroup synch_blk Synchronization */
+/*! \defgroup eq_blk Equalization */
+/*! \defgroup converter_blk Type Conversions */
+/*! \defgroup level_blk Signal Level Control (AGC) */
+/*! \defgroup dft_blk Fourier Transform */
+/*! \defgroup wavelet_blk Wavelet Transform */
+/*! \defgroup misc_blk Miscellaneous Blocks */
+/*! \defgroup slicedice_blk Slicing and Dicing Streams */
+/*! \defgroup vocoder_blk Voice Encoders and Decoders */
-/*!
- * \defgroup converter Type Conversions
+/*!
+ * \defgroup base_blk Base classes for GR Blocks
+ * \brief All C++ blocks are derived from these base classes
*/
-/*!
- * \defgroup level Signal Level Control
- */
-
-/*!
- * \defgroup clock Signal Clock Synchronization
- */
-
-/*!
- * \defgroup dft Fourier Transformation
- */
-
-/*!
- * \defgroup synch Synchronization
- */
-
-/*!
- * \defgroup packet Packetization
- */
-
-/*!
- * \defgroup logic Logical
- */
/*! @} */
-/*! \defgroup filter_design Digital Filter Design */
-/*! \defgroup graphical Graphical Utilities */
-/*! \defgroup encdec Voice Encoders and Decoders */
-/*! \defgroup coding Information Coding and Decoding */
-/*! \defgroup modulation Signal Modulation */
-/*! \defgroup demodulation Signal Demodulation */
-/*! \defgroup flow Samples Flow Control */
-
-/*! \defgroup math Mathmatics */
-/*! \defgroup tools Tools */
-/*! \defgroup misc Miscellaneous */
+/*! \defgroup filter_design Digital Filter Design */
+/*! \defgroup misc Miscellaneous */
/*! \defgroup internal Implementation Details */
-/*! \defgroup base Misc Common Base Classes */
/*!
* \defgroup applications Applications
* These are some applications build using gnuradio...
/*! @} */
-/*! \defgroup usrp USRP */
-/*! \defgroup usrp2 USRP2 */
-/*! \defgroup hardware Hardware */
+/*! \defgroup usrp USRP */
+/*! \defgroup usrp2 USRP2 */
+/*! \defgroup hardware Misc Hardware Control */
/*!
* \brief Adaptive FIR filter with gr_complex input, gr_complex output and float taps
- * \ingroup filter
+ * \ingroup filter_blk
*/
class gr_adaptive_fir_ccf : public gr_sync_decimator
{
/*!
* \brief Implements constant modulus adaptive filter on complex stream
- * \ingroup filter
+ * \ingroup eq_blk
*/
class gr_cma_equalizer_cc : public gr_adaptive_fir_ccf
{
/*!
* \brief Fast FFT filter with gr_complex input, gr_complex output and gr_complex taps
- * \ingroup filter
+ * \ingroup filter_blk
*/
class gr_fft_filter_ccc : public gr_sync_decimator
{
/*!
* \brief Fast FFT filter with float input, float output and float taps
- * \ingroup filter
+ * \ingroup filter_blk
*/
class gr_fft_filter_fff : public gr_sync_decimator
{
/*!
* \brief Filter-Delay Combination Block.
- * \ingroup filter
+ * \ingroup filter_blk
*
* The block takes one or two float stream and outputs a complex
* stream. If only one float stream is input, the real output is
/*!
* \brief common base class for SIMD versions of gr_fir_ccc
- * \ingroup filter
+ * \ingroup filter_primitive
*
* This base class handles alignment issues common to SSE and 3DNOW
* subclasses.
/*!
* \brief common base class for SIMD versions of gr_fir_ccf
- * \ingroup filter
+ * \ingroup filter_primitive
*
* This base class handles alignment issues common to SSE and 3DNOW
* subclasses.
/*!
* \brief 3DNow! version of gr_fir_ccf
- * \ingroup filter
+ * \ingroup filter_primitive
*/
class gr_fir_ccf_3dnow : public gr_fir_ccf_simd
{
/*!
* \brief SSE version of gr_fir_ccf
- * \ingroup filter
+ * \ingroup filter_primitive
*/
class gr_fir_ccf_sse : public gr_fir_ccf_simd
{
/*!
* \brief common base class for SIMD versions of gr_fir_fcc
- * \ingroup filter
+ * \ingroup filter_primitive
*
* This base class handles alignment issues common to SSE and 3DNOW
* subclasses.
/*!
* \brief 3DNow! version of gr_fir_fcc
- * \ingroup filter
+ * \ingroup filter_primitive
*/
class gr_fir_fcc_3dnow : public gr_fir_fcc_simd
{
/*!
* \brief SSE version of gr_fir_fcc
- * \ingroup filter
+ * \ingroup filter_blk
*/
class gr_fir_fcc_sse : public gr_fir_fcc_simd
{
/*!
* \brief common base class for SIMD versions of gr_fir_fff
- * \ingroup filter
+ * \ingroup filter_primitive
*
* This base class handles alignment issues common to SSE and 3DNOW
* subclasses.
/*!
* \brief FIR filter with @I_TYPE@ input, @O_TYPE@ output and @TAP_TYPE@ taps
- * \ingroup filter
+ * \ingroup filter_blk
*/
class @NAME@ : public gr_sync_decimator
{
/*!
* \brief common base class for SIMD versions of gr_fir_fsf
- * \ingroup filter
+ * \ingroup filter_primitive
*
* This base class handles alignment issues common to SSE and 3DNOW
* subclasses.
/*!
* \brief 3DNow! version of gr_fir_fsf
- * \ingroup filter
+ * \ingroup filter_blk
*/
class gr_fir_fsf_3dnow : public gr_fir_fsf_simd
{
/*!
* \brief SSE version of gr_fir_fsf
- * \ingroup filter
+ * \ingroup filter_blk
*/
class gr_fir_fsf_sse : public gr_fir_fsf_simd
{
/*!
* \brief common base class for SIMD versions of gr_fir_scc
- * \ingroup filter
+ * \ingroup filter_blk
*
* This base class handles alignment issues common to SSE and 3DNOW
* subclasses.
/*!
* \brief Interpolating mmse filter with gr_complex input, gr_complex output
- * \ingroup filter
+ * \ingroup filter_blk
*/
class gr_fractional_interpolator_cc : public gr_block
{
/*!
* \brief Interpolating mmse filter with float input, float output
- * \ingroup filter
+ * \ingroup filter_blk
*/
class gr_fractional_interpolator_ff : public gr_block
{
/*!
* \brief FIR filter combined with frequency translation with @I_TYPE@ input, @O_TYPE@ output and @TAP_TYPE@ taps
- * \ingroup filter
+ * \ingroup filter_blk
*
* This class efficiently combines a frequency translation
* (typically "down conversion") with a FIR filter (typically low-pass)
/*!
* \brief Goertzel single-bin DFT calculation.
- * \ingroup dft
+ * \ingroup dft_blk
*/
class gr_goertzel_fc : public gr_sync_decimator
{
/*!
* \brief Hilbert transformer.
- * \ingroup filter
+ * \ingroup filter_blk
*
* real output is input appropriately delayed.
* imaginary output is hilbert filtered (90 degree phase shift)
/*!
* \brief IIR filter with float input, float output and double taps
- * \ingroup filter
+ * \ingroup filter_blk
*
* This filter uses the Direct Form I implementation, where
* \p fftaps contains the feed-forward taps, and \p fbtaps the feedback ones.
/*!
* \brief Interpolating FIR filter with @I_TYPE@ input, @O_TYPE@ output and @TAP_TYPE@ taps
- * \ingroup filter
+ * \ingroup filter_blk
*/
class @NAME@ : public gr_sync_interpolator
{
/*!
* \brief Rational Resampling Polyphase FIR filter with @I_TYPE@ input, @O_TYPE@ output and @TAP_TYPE@ taps
- * \ingroup filter
+ * \ingroup filter_blk
*/
class @NAME@ : public gr_block
{
/*!
* \brief single pole IIR filter with complex input, complex output
- * \ingroup filter
+ * \ingroup filter_blk
*
* The input and output satisfy a difference equation of the form
/*!
* \brief single pole IIR filter with float input, float output
- * \ingroup filter
+ * \ingroup filter_blk
*
* The input and output satisfy a difference equation of the form
/*!
* \brief Implements Goertzel single-bin DFT calculation
- * \ingroup dft
+ * \ingroup misc
*/
-
class gri_goertzel
{
public:
/*!
* \brief Compute intermediate samples between signal samples x(k*Ts)
- * \ingroup filter
+ * \ingroup filter_primitive
*
* 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)
/*!
* \brief Compute intermediate samples between signal samples x(k*Ts)
- * \ingroup filter
+ * \ingroup filter_primitive
*
* 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)
float gain = 1.0, float max_gain = 0.0);
/*!
* \brief high performance Automatic Gain Control class
- * \ingroup level
+ * \ingroup level_blk
*
* For Power the absolute value of the complex number is used.
*/
/*!
* \brief high performance Automatic Gain Control class
*
- * \ingroup level
+ * \ingroup level_blk
* Power is approximated by absolute value
*/
float gain = 1.0, float max_gain = 0.0);
/*!
* \brief high performance Automatic Gain Control class
- * \ingroup level
+ * \ingroup level_blk
*
* For Power the absolute value of the complex number is used.
*/
/*!
* \brief high performance Automatic Gain Control class
- * \ingroup level
+ * \ingroup level_blk
*
* Power is approximated by absolute value
*/
/*!
* \brief control scanning and record frequency domain statistics
- * \ingroup sink
+ * \ingroup sink_blk
*/
class gr_bin_statistics_f : public gr_sync_block
{
/*!
* \brief slice float binary symbol outputting 1 bit output
- * \ingroup converter
+ * \ingroup converter_blk
*
* x < 0 --> 0
* x >= 0 --> 1
/*!
* \brief Convert stream of bytes to stream of +/- 1 symbols
- * \ingroup converter
+ * \ingroup converter_blk
*
* input: stream of bytes; output: stream of float
*
/*!
* \brief Convert stream of chars to a stream of float
- * \ingroup converter
+ * \ingroup converter_blk
*/
class gr_char_to_float : public gr_sync_block
/*!
* \brief sink that checks if its input stream consists of a counting sequence.
* \param do_32bit expect an interleaved 32 bit counter in stead of 16 bit counter (default false)
- * \ingroup sink
+ * \ingroup sink_blk
*
* This sink is typically used to test the USRP "Counting Mode" or "Counting mode 32 bit".
*/
/*!
* \brief sink that checks if its input stream consists of a lfsr_32k sequence.
- * \ingroup sink
+ * \ingroup sink_blk
*
* This sink is typically used along with gr_lfsr_32k_source_s to test
* the USRP using its digital loopback mode.
/*!
* \brief Mueller and Müller (M&M) based clock recovery block with complex input, complex output.
- * \ingroup clock
+ * \ingroup synch_blk
*
* This implements the Mueller and Müller (M&M) discrete-time error-tracking synchronizer.
* The complex version here is based on:
/*!
* \brief Mueller and Müller (M&M) based clock recovery block with float input, float output.
- * \ingroup clock
+ * \ingroup synch_blk
*
* This implements the Mueller and Müller (M&M) discrete-time error-tracking synchronizer.
*
/*!
* \brief Convert stream of complex to a stream of interleaved shorts
- * \ingroup converter
+ * \ingroup converter_blk
*/
class gr_complex_to_interleaved_short : public gr_sync_interpolator
/*!
* \brief convert a stream of gr_complex to 1 or 2 streams of float
- * \ingroup converter
+ * \ingroup converter_blk
* \param vlen vector len (default 1)
*/
class gr_complex_to_float : public gr_sync_block
/*!
* \brief complex in, real out (float)
- * \ingroup converter
+ * \ingroup converter_blk
* \param vlen vector len (default 1)
*/
class gr_complex_to_real : public gr_sync_block
/*!
* \brief complex in, imaginary out (float)
- * \ingroup converter
+ * \ingroup converter_blk
* \param vlen vector len (default 1)
*/
class gr_complex_to_imag : public gr_sync_block
/*!
* \brief complex in, magnitude out (float)
- * \ingroup converter
+ * \ingroup converter_blk
* \param vlen vector len (default 1)
*/
class gr_complex_to_mag : public gr_sync_block
/*!
* \brief complex in, magnitude squared out (float)
- * \ingroup converter
+ * \ingroup converter_blk
* \param vlen vector len (default 1)
*/
class gr_complex_to_mag_squared : public gr_sync_block
/*!
* \brief complex in, angle out (float)
- * \ingroup converter
+ * \ingroup converter_blk
* \param vlen vector len (default 1)
*/
class gr_complex_to_arg : public gr_sync_block
/*!
* \brief output = complex conjugate of input
- * \ingroup math
+ * \ingroup math_blk
*/
class gr_conjugate_cc : public gr_sync_block
{
/*!
* \brief Constellation Decoder
- * \ingroup coding
+ * \ingroup coding_blk
*
*/
class gr_constellation_decoder_cb : public gr_sync_block
/*!
* \brief Examine input for specified access code, one bit at a time.
- * \ingroup synch
+ * \ingroup synch_blk
*
* 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)
/*! \brief A Costas loop carrier recovery module.
- * \ingroup clock
+ * \ingroup synch_blk
*
* The Costas loop locks to the center frequency of a signal and
* downconverts it to baseband. The second (order=2) order loop is
*
* \param alpha the loop gain used for phase adjustment
* \param beta the loop gain for frequency adjustments
- * \param max_freq the maximum frequency deviation (normalized frequency) the loop can handle
- * \param min_freq the minimum frequency deviation (normalized frequency) the loop can handle
+ * \param max_freq the maximum frequency deviation (radians/sample) the loop can handle
+ * \param min_freq the minimum frequency deviation (radians/sample) the loop can handle
* \param order the loop order, either 2 or 4
*/
class gr_costas_loop_cc;
/*!
* \brief Carrier tracking PLL for QPSK
- * \ingroup clock
+ * \ingroup synch_blk
* input: complex; output: complex
* <br>The Costas loop can have two output streams:
* stream 1 is the baseband I and Q;
/*!
* \brief Perform continuous phase 2-level frequency shift keying modulation
* on an input stream of unpacked bits.
- * \ingroup modulation
+ * \ingroup modulation_blk
*
* \param k modulation index
* \param ampl output amplitude
/*!
* \brief gate or zero output if ctcss tone not present
- * \ingroup level
+ * \ingroup level_blk
*/
class gr_ctcss_squelch_ff : public gr_squelch_base_ff
{
/*!
* \brief Decision directed M-PSK synchronous demod
- * \ingroup clock
+ * \ingroup synch_blk
* This block performs joint carrier tracking and symbol timing recovery.
*
* input: complex baseband; output: properly timed complex samples ready for slicing.
/*!
* \brief deinterleave a single input into N outputs
- * \ingroup misc
+ * \ingroup slicedice_blk
*/
class gr_deinterleave : public gr_sync_decimator
{
/*!
* \brief delay the input by a certain number of samples
- * \ingroup misc
+ * \ingroup misc_blk
*/
class gr_delay : public gr_sync_block
{
/*!
* \brief y[0] = (x[0] - x[-1]) % M
- * \ingroup coding
+ * \ingroup coding_blk
*
* Differential decoder
*/
/*!
* \brief y[0] = (x[0] + y[-1]) % M
- * \ingroup coding
+ * \ingroup coding_blk
*
* Differential encoder
*/
/*!
* \brief Detect the peak of a signal
- * \ingroup level
+ * \ingroup level_blk
*
* If a peak is detected, this block outputs a 1,
* or it outputs 0's.
/*!
* \brief pad packet with alternating 1,0 pattern.
- * \ingroup coding
+ * \ingroup coding_blk
*
* input: stream of byte vectors; output: stream of byte vectors
*/
/*!
* \brief remove fake padding from packet
- * \ingroup coding
+ * \ingroup coding_blk
*
* input: stream of byte vectors; output: stream of byte vectors
*/
/*!
* \brief Non-causal AGC which computes required gain based on max absolute value over nsamples
- * \ingroup level
+ * \ingroup level_blk
*/
class gr_feedforward_agc_cc : public gr_sync_block
{
/*!
* \brief Compute forward or reverse FFT. complex vector in / complex vector out.
- * \ingroup dft
+ * \ingroup dft_blk
*
* Abstract base class
*/
/*!
* \brief Compute forward or reverse FFT. complex vector in / complex vector out.
- * \ingroup dft
+ * \ingroup dft_blk
*
* Concrete class that uses FFTW.
*/
/*!
* \brief Compute forward FFT. float vector in / complex vector out.
- * \ingroup dft
+ * \ingroup dft_blk
*/
class gr_fft_vfc : public gr_sync_block
/*!
* \brief Convert stream of float to a stream of char
- * \ingroup converter
+ * \ingroup converter_blk
*/
class gr_float_to_char : public gr_sync_block
/*!
* \brief Convert 1 or 2 streams of float to a stream of gr_complex
- * \ingroup converter
+ * \ingroup converter_blk
*/
class gr_float_to_complex : public gr_sync_block
/*!
* \brief Convert stream of float to a stream of short
- * \ingroup converter
+ * \ingroup converter_blk
*/
class gr_float_to_short : public gr_sync_block
/*!
* \brief Convert stream of float to a stream of unsigned char
- * \ingroup converter
+ * \ingroup converter_blk
*/
class gr_float_to_uchar : public gr_sync_block
/*!
* \brief Given a stream of bits and access_code flags, assemble packets.
- * \ingroup sink
+ * \ingroup sink_blk
*
* input: stream of bytes from gr_correlate_access_code_bb
* output: none. Pushes assembled packet into target queue
/*!
* \brief Frequency modulator block
- * \ingroup modulation
+ * \ingroup modulation_blk
*
* float input; complex baseband output
*/
/*!
* \brief fixed point sine and cosine and friends.
- * \ingroup math
+ * \ingroup misc
*
* fixed pt radians
* --------- --------
/*!
* \brief Galois LFSR pseudo-random source
- * \ingroup source
+ * \ingroup source_blk
*/
class gr_glfsr_source_b : public gr_sync_block
{
/*!
* \brief Galois LFSR pseudo-random source generating float outputs -1.0 - 1.0
- * \ingroup source
+ * \ingroup source_blk
*/
class gr_glfsr_source_f : public gr_sync_block
{
/*!
* \brief copies the first N items to the output then signals done
- * \ingroup flow
+ * \ingroup slicedice_blk
*
* Useful for building test cases
*/
/*!
* \brief interleave N inputs to a single output
- * \ingroup misc
+ * \ingroup slicedice_blk
*/
class gr_interleave : public gr_sync_interpolator
{
/*!
* \brief Convert stream of interleaved shorts to a stream of complex
- * \ingroup converter
+ * \ingroup converter_blk
*/
class gr_interleaved_short_to_complex : public gr_sync_decimator
/*!
* \brief
- * \ingroup
+ * \ingroup misc_blk
*/
class gr_iqcomp_cc : public gr_sync_block
{
/*!
* \brief decimate a stream, keeping one item out of every n.
- * \ingroup misc
+ * \ingroup slicedice_blk
*/
class gr_keep_one_in_n : public gr_block
{
/*!
* \brief output[i] = input[i]
- * \ingroup misc
+ * \ingroup misc_blk
*
* This is a short term kludge to work around a problem with the hierarchical block impl.
*/
/*!
* \brief LFSR pseudo-random source with period of 2^15 bits (2^11 shorts)
- * \ingroup source
+ * \ingroup source_blk
*
* This source is typically used along with gr_check_lfsr_32k_s to test
* the USRP using its digital loopback mode.
/*!
* \brief Least-Mean-Square Decision Feedback Equalizer (complex in/out)
- * \ingroup misc
+ * \ingroup eq_blk
*/
class gr_lms_dfe_cc : public gr_sync_block
{
/*!
* \brief Least-Mean-Square Decision Feedback Equalizer (float in/out)
- * \ingroup misc
+ * \ingroup eq_blk
*/
class gr_lms_dfe_ff : public gr_sync_block
{
/*!
* \brief output[i] = map[input[i]]
- * \ingroup misc
+ * \ingroup coding_blk
*/
class gr_map_bb : public gr_sync_block
/*!
* \brief Fast arc tangent using table lookup and linear interpolation
- * \ingroup math
+ * \ingroup misc
*
* \param y component of input vector
* \param x component of input vector
/*!
* \brief This block takes care of receiving M-PSK modulated signals through phase, frequency, and symbol
* synchronization.
- * \ingroup synch
+ * \ingroup synch_blk
*
* 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.
/*!
* \brief output = n*log10(input) + k
- * \ingroup math
+ * \ingroup math_blk
*/
class gr_nlog10_ff : public gr_sync_block
{
/*!
* \brief Does nothing. Used for testing only.
- * \ingroup misc
+ * \ingroup misc_blk
*/
class gr_nop : public gr_block
{
/*!
* \brief Bit bucket
- * \ingroup sink
+ * \ingroup sink_blk
*/
class gr_null_sink : public gr_sync_block
/*!
* \brief A source of zeros.
- * \ingroup source
+ * \ingroup source_blk
*/
class gr_null_source : public gr_sync_block
/*!
* \brief take a vector of complex constellation points in from an FFT
* and demodulate to a stream of bits. Simple BPSK version.
- * \ingroup demodulation
+ * \ingroup demodulation_blk
*/
class gr_ofdm_bpsk_demapper : public gr_block
/*!
* \brief adds a cyclic prefix vector to an input size long ofdm
* symbol(vector) and converts vector to a stream output_size long.
- * \ingroup synch
+ * \ingroup synch_blk
*/
class gr_ofdm_cyclic_prefixer : public gr_sync_interpolator
{
* \brief take a stream of vectors in from an FFT and demodulate to a stream of
* bits. Abstract class must be subclassed with specific mapping.
*
- * \ingroup demodulation
+ * \ingroup demodulation_blk
*/
class gr_ofdm_demapper_vcb : public gr_sync_decimator
/*!
* \brief take a vector of complex constellation points in from an FFT
* and performs a correlation and equalization.
- * \ingroup demodulation
+ * \ingroup demodulation_blk
*
* 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
/*!
* \brief 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.
- * \ingroup sink
+ * \ingroup sink_blk
* 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.
/*!
* \brief insert "pre-modulated" preamble symbols before each payload.
- * \ingroup synch
+ * \ingroup synch_blk
*
* <pre>
* input 1: stream of vectors of gr_complex [fft_length]
* \brief 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.
- * \ingroup modulation
+ * \ingroup modulation_blk
*
*/
/*!
* \brief pa_2x2 phase combiner
- * \ingroup misc
+ * \ingroup misc_blk
*
* Anntenas are arranged like this:
*
);
/*!
* \brief process received bits looking for packet sync, header, and process bits into packet
- * \ingroup sink
+ * \ingroup sink_blk
*/
class gr_packet_sink : public gr_sync_block
{
/*!
* \brief Detect the peak of a signal
- * \ingroup level
+ * \ingroup level_blk
*
* If a peak is detected, this block outputs a 1,
* or it outputs 0's. A separate debug output may be connected, to
/*!
* \brief Phase modulator block
- * \ingroup modulation
+ * \ingroup modulation_blk
* output=complex(cos(in*sensitivity),sin(in*sensitivity))
*/
class gr_phase_modulator_fc : public gr_sync_block
/*!
* \brief Implements a PLL which locks to the input frequency and outputs the
* input signal mixed with that carrier.
- * \ingroup clock
+ * \ingroup synch_blk
*
* input: stream of complex; output: stream of complex
*
/*!
* \brief Implements a PLL which locks to the input frequency and outputs
* an estimate of that frequency. Useful for FM Demod.
- * \ingroup clock
+ * \ingroup synch_blk
*
* input: stream of complex; output: stream of floats
*
float max_freq, float min_freq);
/*!
* \brief Implements a PLL which locks to the input frequency and outputs a carrier
- * \ingroup clock
+ * \ingroup synch_blk
*
* input: stream of complex; output: stream of complex
*
/*!
* \brief PN code sequential search correlator
*
- * \ingroup synch
+ * \ingroup synch_blk
* Receives complex baseband signal, outputs complex correlation against
* reference PN code, one sample per PN code period
*/
/*!
* \brief compute avg magnitude squared.
- * \ingroup sink
+ * \ingroup sink_blk
*
* input: gr_complex
*
/*!
* \brief compute avg magnitude squared.
- * \ingroup sink
+ * \ingroup sink_blk
*
* input: gr_complex
* output: gr_float
/*!
* \brief compute avg magnitude squared.
- * \ingroup sink
+ * \ingroup sink_blk
*
* input: float
*
* This technique assumes an AWGN channel.
*
* \param alpha Mean and variance smoothing filter constant
- * \ingroup sink
+ * \ingroup sink_blk
*
* Compute the running average of the signal mean and noise variance.
* The estimated signal mean, noise variance, and SNR are available
/*!
* \brief Sink that allows a sample to be grabbed from Python.
- * \ingroup sink
+ * \ingroup sink_blk
*/
class gr_probe_signal_f : public gr_sync_block
{
/*!
* \brief gate or zero output when input power below threshold
- * \ingroup level
+ * \ingroup level_blk
*/
class gr_pwr_squelch_cc : public gr_squelch_base_cc
{
/*!
* \brief gate or zero output when input power below threshold
- * \ingroup level
+ * \ingroup level_blk
*/
class gr_pwr_squelch_ff : public gr_squelch_base_ff
{
/*!
* \brief quadrature demodulator: complex in, float out
- * \ingroup demodulation
+ * \ingroup demodulation_blk
*
* This can be used to demod FM, FSK, GMSK, etc.
* The input is complex baseband.
/*!
* \brief pseudo random number generator
- * \ingroup math
+ * \ingroup math_blk
*/
class gr_random {
protected:
/*!
* \brief Detect the peak of a signal and repeat every period samples
- * \ingroup level
+ * \ingroup level_blk
*
* 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
/*!
* \brief Repeat a sample 'interp' times in output stream
- * \ingroup converter
+ * \ingroup misc_blk
*/
class gr_repeat : public gr_sync_interpolator
/*!
* \brief RMS average power
- * \ingroup math
+ * \ingroup math_blk
*/
class gr_rms_cf : public gr_sync_block
{
/*!
* \brief RMS average power
- * \ingroup math
+ * \ingroup math_blk
*/
class gr_rms_ff : public gr_sync_block
{
* \param seed Initial shift register contents
* \param len Shift register length
*
- * \ingroup misc
+ * \ingroup coding_blk
*/
class gr_scrambler_bb : public gr_sync_block
/*!
* \brief Convert stream of short to a stream of float
- * \ingroup converter
+ * \ingroup converter_blk
*/
class gr_short_to_float : public gr_sync_block
/*!
* \brief inverse of gr_simple_framer (more or less)
- * \ingroup synch
+ * \ingroup synch_blk
*/
class gr_simple_correlator : public gr_block
{
/*!
* \brief add sync field, seq number and command field to payload
- * \ingroup synch
+ * \ingroup synch_blk
*/
class gr_simple_framer : public gr_block
{
* the "mseq" matlab/octave code downloaded from:
* http://www.mathworks.com/matlabcentral/fileexchange/loadFile.do?objectId=990&objectType=file
*
- * \ingroup synch
+ * \ingroup synch_blk
* 31-bit m-sequence:
* 0110100100001010111011000111110
* 0x690AEC76 (padded on right with a zero)
/*!
* \brief simple squelch block based on average signal power and threshold in dB.
- * \ingroup level
+ * \ingroup level_blk
*/
class gr_simple_squelch_cc : public gr_sync_block
{
/*!
* \brief skips the first N items, from then on copies items to the output
- * \ingroup flow
+ * \ingroup slicedice_blk
*
* Useful for building test cases and sources which have metadata or junk at the start
*/
/*!
* \brief Creates a stream muxing block to multiplex many streams into
* one with a specified format.
- * \ingroup converter
+ * \ingroup converter_blk
*
* \param itemsize the item size of the stream
* \param length a vector (list/tuple) specifying the number of
/*!
* \brief convert a stream of items into a N streams of items
- * \ingroup converter
+ * \ingroup slicedice_blk
*
* Converts a stream of N items into N streams of 1 item.
* Repeat ad infinitum.
/*!
* \brief convert a stream of items into a stream of blocks containing nitems_per_block
- * \ingroup converter
+ * \ingroup slicedice_blk
*/
class gr_stream_to_vector : public gr_sync_decimator
{
/*!
* \brief Convert N streams of 1 item into a 1 stream of N items
- * \ingroup converter
+ * \ingroup slicedice_blk
*
* Convert N streams of 1 item into 1 stream of N items.
* Repeat ad infinitum.
/*!
* \brief convert N streams of items to 1 stream of vector length N
- * \ingroup converter
+ * \ingroup slicedice_blk
*/
class gr_streams_to_vector : public gr_sync_block
{
* \brief adjust y-range of an input vector by mapping to range
* (max-of-input, stipulated-min). Primarily for spectral signature
* matching by normalizing spectrum dynamic ranges.
- * \ingroup misc
+ * \ingroup misc_blk
*/
* factor and/or large output_multiple.
* The runtime system should detect this and create large enough buffers
* all through the signal chain.
- *
*/
-
-
-
-
class gr_test : public gr_block {
public:
/*!
* \brief Please fix my documentation
- * \ingroup misc
+ * \ingroup misc_blk
*/
class gr_threshold_ff : public gr_sync_block
{
/*!
* \brief throttle flow of samples such that the average rate does not exceed samples_per_sec.
- * \ingroup flow
+ * \ingroup misc_blk
*
* input: one stream of itemsize; output: one stream of itemsize
+ *
+ * N.B. this should only be used in GUI apps where there is no other
+ * rate limiting block. It is not intended nor effective at precisely
+ * controlling the rate of samples. That should be controlled by a
+ * source or sink tied to sample clock. E.g., a USRP or audio card.
*/
class gr_throttle : public gr_sync_block
{
/*!
* \brief Convert stream of unsigned chars to a stream of float
- * \ingroup converter
+ * \ingroup converter_blk
*/
class gr_uchar_to_float : public gr_sync_block
/*!
* \brief Converts a byte with k relevent bits to k output bytes with 1 bit in the LSB.
- * \ingroup converter
+ * \ingroup converter_blk
*/
class gr_unpack_k_bits_bb : public gr_sync_interpolator
{
/*!
* \brief VCO - Voltage controlled oscillator
+ * \ingroup modulator_blk
*
* input: float stream of control voltages; output: float oscillator output
*/
/*!
* \brief convert a stream of blocks of nitems_per_block items into a stream of items
- * \ingroup converter
+ * \ingroup slicedice_blk
*/
class gr_vector_to_stream : public gr_sync_interpolator
{
/*!
* \brief Convert 1 stream of vectors of length N to N streams of items
- * \ingroup converter
+ * \ingroup slicedice_blk
*/
class gr_vector_to_streams : public gr_sync_block
{
/*!
* \brief compute wavelet transform using gsl routines
- * \ingroup math
+ * \ingroup wavelet_blk
*/
class gr_wavelet_ff : public gr_sync_block
/*!
* \brief computes the Wavelet Power Spectrum from a set of wavelet coefficients
- * \ingroup misc
+ * \ingroup wavelet_blk
*/
class gr_wvps_ff : public gr_sync_block
{
/*!
* \brief high performance Automatic Gain Control class
- * \ingroup level
*
* For Power the absolute value of the complex number is used.
*/
-
class gri_agc2_cc {
public:
/*!
* \brief high performance Automatic Gain Control class with attack and decay rate
- * \ingroup level
*
* Power is approximated by absolute value
*/
/*!
* \brief high performance Automatic Gain Control class
- * \ingroup level
*
* For Power the absolute value of the complex number is used.
*/
/*!
* \brief high performance Automatic Gain Control class
- * \ingroup level
*
* Power is approximated by absolute value
*/
-
class gri_agc_ff {
public:
/*!
* \brief FFT: complex in, complex out
- * \ingroup dft
+ * \ingroup misc
*/
class gri_fft_complex {
int d_fft_size;
/*!
* \brief FFT: real in, complex out
- * \ingroup dft
+ * \ingroup dft_blk
*/
class gri_fft_real_fwd {
int d_fft_size;
/*!
* \brief FFT: complex in, float out
- * \ingroup dft
+ * \ingroup dft_blk
*/
class gri_fft_real_rev {
int d_fft_size;
/*!
* \brief Galois Linear Feedback Shift Register using specified polynomial mask
- * \ingroup math
+ * \ingroup misc
*
* Generates a maximal length pseudo-random sequence of length 2^degree-1
*/
/*!
* \brief Fibonacci Linear Feedback Shift Register using specified polynomial mask
- * \ingroup math
+ * \ingroup misc
*
* Generates a maximal length pseudo-random sequence of length 2^degree-1
*
/*!
* \brief Linear Feedback Shift Register using primitive polynomial x^15 + x + 1
- * \ingroup math
+ * \ingroup misc
*
* Generates a maximal length pseudo-random sequence of length 2^15 - 1 bits.
*/
/*!
* \brief generate pseudo-random sequence of length 32768 bits.
- * \ingroup math
+ * \ingroup misc
*
* This is based on gri_lfsr_15_1_0 with an extra 0 added at the end
* of the sequence.
/*!
* \brief output = sum (input_0, input_1, ...)
- * \ingroup math
+ * \ingroup math_blk
*
* Add across all input streams.
*/
/*!
* \brief output = input + constant
- * \ingroup math
+ * \ingroup math_blk
*/
class @NAME@ : public gr_sync_block
{
/*!
* \brief output vector = input vector + constant vector
- * \ingroup math
+ * \ingroup math_blk
*/
class @NAME@ : public gr_sync_block
{
/*!
* \brief output = input_0 & input_1 & , ... & input_N)
- * \ingroup math
+ * \ingroup math_blk
*
* bitwise boolean and across all input streams.
*/
/*!
* \brief output_N = input_N & value
- * \ingroup math
+ * \ingroup math_blk
*
* bitwise boolean and of const to the data stream.
*/
/*!
* \brief Map a stream of symbol indexes (unpacked bytes or shorts) to stream of float or complex onstellation points.in \p D dimensions (\p D = 1 by default)
- * \ingroup converter
+ * \ingroup converter_blk
*
* input: stream of @I_TYPE@; output: stream of @O_TYPE@
*
/*!
* \brief output = input_0 / input_1 / input_x ...)
- * \ingroup math
+ * \ingroup math_blk
*
* Divide across all input streams.
*/
/*!
* \brief output = sum(input[0]...input[n])
- * \ingroup math
+ * \ingroup math_blk
*
* Integrate successive samples in input stream and decimate
*/
/*!
* \brief output is the moving sum of the last N samples, scaled by the scale factor
- * \ingroup filter
+ * \ingroup filter_blk
*
* max_iter limits how long we go without flushing the accumulator
* This is necessary to avoid numerical instability for float and complex.
/*!
* \brief output = prod (input_0, input_1, ...)
- * \ingroup math
+ * \ingroup math_blk
*
* Multiply across all input streams.
*/
/*!
* \brief output = input * constant
- * \ingroup math
+ * \ingroup math_blk
*/
class @NAME@ : public gr_sync_block
{
/*!
* \brief output vector = input vector * constant vector (element-wise)
- * \ingroup math
+ * \ingroup math_blk
*/
class @NAME@ : public gr_sync_block
{
/*!
* \brief output = input or zero if muted.
- * \ingroup level
+ * \ingroup level_blk
*/
class @NAME@ : public gr_sync_block
{
/*!
* \brief random number source
- * \ingroup source
+ * \ingroup source_blk
*/
class @NAME@ : public gr_sync_block {
friend @NAME@_sptr
/*!
* \brief output = ~input_0
- * \ingroup math
+ * \ingroup math_blk
*
* bitwise boolean not across input stream.
*/
/*!
* \brief output = input_0 | input_1 | , ... | input_N)
- * \ingroup math
+ * \ingroup math_blk
*
* bitwise boolean or across all input streams.
*/
/*!
* \brief Convert a stream of packed bytes or shorts to stream of unpacked bytes or shorts.
- * \ingroup converter
+ * \ingroup converter_blk
*
* input: stream of @I_TYPE@; output: stream of @O_TYPE@
*
/*!
* \brief Detect the peak of a signal
- * \ingroup level
+ * \ingroup level_blk
*
* If a peak is detected, this block outputs a 1,
* or it outputs 0's.
/*!
* \brief sample and hold circuit
- * \ingroup level
+ * \ingroup level_blk
*
* Samples the data stream (input stream 0) and holds the value
* if the control signal is 1 (intput stream 1).
/*!
* \brief signal generator with @TYPE@ output.
- * \ingroup source
+ * \ingroup source_blk
*/
class @NAME@ : public gr_sync_block {
/*!
* \brief output = input_0 - input_1 - ...)
- * \ingroup math
+ * \ingroup math_blk
*
* Subtract across all input streams.
*/
/*!
* \brief Convert a stream of unpacked bytes or shorts into a stream of packed bytes or shorts.
- * \ingroup converter
+ * \ingroup converter_blk
*
* input: stream of @I_TYPE@; output: stream of @O_TYPE@
*
/*!
* \brief @TYPE@ sink that writes to a vector
- * \ingroup sink
+ * \ingroup sink_blk
*/
class @NAME@ : public gr_sync_block {
/*!
* \brief source of @TYPE@'s that gets its data from a vector
- * \ingroup source
+ * \ingroup source_blk
*/
class @NAME@ : public gr_sync_block {
/*!
* \brief output = input_0 ^ input_1 ^ , ... ^ input_N)
- * \ingroup math
+ * \ingroup math_blk
*
* bitwise boolean xor across all input streams.
*/
/*!
* \brief Write stream to file descriptor.
- * \ingroup sink
+ * \ingroup sink_blk
*/
class gr_file_descriptor_sink : public gr_sync_block
/*!
* \brief Read stream from file descriptor.
- * \ingroup source
+ * \ingroup source_blk
*/
class gr_file_descriptor_source : public gr_sync_block
/*!
* \brief Write stream to file.
- * \ingroup sink
+ * \ingroup sink_blk
*/
class gr_file_sink : public gr_sync_block, public gr_file_sink_base
/*!
* \brief Read stream from file
- * \ingroup source
+ * \ingroup source_blk
*/
class gr_file_source : public gr_sync_block
/*!
* \brief Histogram module.
- * \ingroup sink
+ * \ingroup sink_blk
*/
class gr_histo_sink_f : public gr_sync_block
{
/*!
* \brief Gather received items into messages and insert into msgq
- * \ingroup sink
+ * \ingroup sink_blk
*/
class gr_message_sink : public gr_sync_block
{
/*!
* \brief Turn received messages into a stream
- * \ingroup source
+ * \ingroup source_blk
*/
class gr_message_source : public gr_sync_block
{
/*!
* \brief Building block for python oscilloscope module.
- * \ingroup sink
+ * \ingroup sink_blk
*
* Accepts multiple float streams.
*/
/*!
* \brief Abstract class for python oscilloscope module.
- * \ingroup sink
+ * \ingroup sink_blk
*
* Don't instantiate this. Use gr_oscope_sink_f or gr_oscope_sink_c instead.
*/
/*!
* \brief Write stream to an UDP socket.
- * \ingroup sink
+ * \ingroup sink_blk
*
* \param itemsize The size (in bytes) of the item datatype
* \param src The source address as either the host name or the 'numbers-and-dots'
/*!
* \brief Read stream from an UDP socket.
- * \ingroup sink
+ * \ingroup source_blk
*
* \param itemsize The size (in bytes) of the item datatype
* \param src The source address as either the host name or the 'numbers-and-dots'
* Values are within [-1;1].
* Check gr_make_wavfile_source() for extra info.
*
- * \ingroup sink
+ * \ingroup sink_blk
*/
class gr_wavfile_sink : public gr_sync_block
{
* Unless otherwise called, values are within [-1;1].
* Check gr_make_wavfile_source() for extra info.
*
- * \ingroup source
+ * \ingroup source_blk
*/
class gr_wavfile_source : public gr_sync_block
/*!
* \brief The abstract base class for all signal processing blocks.
- * \ingroup base
+ * \ingroup internal
*
* Basic blocks are the bare abstraction of an entity that has a name
* and a set of inputs and outputs. These are never instantiated
/*!
* \brief The abstract base class for all 'terminal' processing blocks.
- * \ingroup base
+ * \ingroup base_blk
*
* A signal processing flow is constructed by creating a tree of
* hierarchical blocks, which at any level may also contain terminal nodes
/*!
*\brief Class specializing gr_flat_flowgraph that has all nodes
* as gr_blocks, with no hierarchy
- * \ingroup base
- *
+ * \ingroup internal
*/
class gr_flat_flowgraph : public gr_flowgraph
{
#include <iostream>
/*!
- *\brief Class representing a specific input or output graph endpoint
+ * \brief Class representing a specific input or output graph endpoint
* \ingroup internal
- *
*/
class gr_endpoint
{
gr_flowgraph_sptr gr_make_flowgraph();
/*!
- *\brief Class representing a directed, acyclic graph of basic blocks
- *
+ * \brief Class representing a directed, acyclic graph of basic blocks
+ * \ingroup internal
*/
class gr_flowgraph
{
/*!
* \brief gr_hier_block2 - Hierarchical container class for gr_block's
- * \ingroup internal
+ * \ingroup container_blk
+ * \ingroup base_blk
*
*/
class gr_hier_block2 : public gr_basic_block
#include <gr_flat_flowgraph.h>
#include <boost/utility.hpp>
+/*!
+ * \ingroup internal
+ */
class gr_hier_block2_detail : boost::noncopyable
{
public:
/*!
* \brief i/o signature for input and output ports.
+ * \brief misc
*/
class gr_io_signature {
int d_min_streams;
/*!
* \brief synchronous 1:1 input to output with history
- * \ingroup internal
+ * \ingroup base_blk
*
* Override work to provide the signal processing implementation.
*/
/*!
* \brief synchronous N:1 input to output with history
- * \ingroup internal
+ * \ingroup base_blk
*
* Override work to provide the signal processing implementation.
*/
/*!
* \brief synchronous 1:N input to output with history
- * \ingroup internal
+ * \ingroup base_blk
*
* Override work to provide the signal processing implementation.
*/
/*!
*\brief Top-level hierarchical block representing a flowgraph
- * \ingroup internal
+ * \ingroup container_blk
*
*/
class gr_top_block : public gr_hier_block2
/*!
* \brief abstract class to implement doubly mapped virtual memory circular buffers
- * \ingroup base
+ * \ingroup internal
*/
class gr_vmcircbuf {
protected:
#endif
/*!
* \brief concrete class to implement circular buffers with mmap and shm_open
- * \ingroup base
+ * \ingroup internal
*/
class gr_vmcircbuf_createfilemapping : public gr_vmcircbuf
{
/*!
* \brief concrete class to implement circular buffers with mmap and shm_open
- * \ingroup base
+ * \ingroup internal
*/
class gr_vmcircbuf_mmap_shm_open : public gr_vmcircbuf {
public:
/*!
* \brief concrete class to implement circular buffers with mmap and shm_open
- * \ingroup base
+ * \ingroup internal
*/
class gr_vmcircbuf_mmap_tmpfile : public gr_vmcircbuf {
public:
/*!
* \brief concrete class to implement circular buffers with mmap and shm_open
- * \ingroup base
+ * \ingroup internal
*/
class gr_vmcircbuf_sysv_shm : public gr_vmcircbuf {
public:
* \param neg_accum_max Minimum integer value allowed for the internal reference. Default: "-32767" (-2^15 + 1 or MINSHORT+1)
*
*/
-
cvsd_decode_bs_sptr cvsd_make_decode_bs (short min_step=10,
short max_step=1280,
double step_decay=0.9990234375,
* is modeled after the CVSD encoder/decoder specifications defined in the
* Bluetooth standard.
*
- * \ingroup block
+ * \ingroup vocoder
*
* CVSD is a method for encoding speech that seeks to reduce the
* bandwidth required for digital voice transmission. CVSD takes
* is modeled after the CVSD encoder/decoder specifications defined in the
* Bluetooth standard.
*
- * \ingroup block
+ * \ingroup vocoder
*
* CVSD is a method for encoding speech that seeks to reduce the
* bandwidth required for digital voice transmission. CVSD takes
/*!
* \brief Compute forward or reverse FFT. complex vector in / complex vector out.
- * \ingroup dft
+ * \ingroup dft_blk
*
* Concrete class that uses gcell to offload FFT to SPEs.
*/
/*!
* \brief GSM 06.10 Full Rate Vocoder Decoder
+ * \ingroup vocoder
*/
class gsm_fr_decode_ps : public gr_sync_interpolator {
struct gsm_state *d_gsm;
/*!
* \brief GSM 06.10 Full Rate Vocoder Encoder
- * \ingroup block
+ * \ingroup vocoder
*
* shorts in; 33 byte packets out
*/
/*!
- * \brief interface to Universal Software Radio Peripheral Tx path (Rev 1)
+ * \brief Interface to Universal Software Radio Peripheral Tx path
+ * \ingroup usrp
+ * \ingroup sink_blk
*
* input: gr_complex
*/
) throw (std::runtime_error);
/*!
- * \brief interface to Universal Software Radio Peripheral Tx path (Rev 1)
+ * \brief Interface to Universal Software Radio Peripheral Tx path
+ * \ingroup usrp
+ * \ingroup sink_blk
*
* input: short
*/
) throw (std::runtime_error);
/*!
- * \brief interface to Universal Software Radio Peripheral Rx path (Rev 1)
+ * \brief Interface to Universal Software Radio Peripheral Rx path
+ * \ingroup usrp
+ * \ingroup source_blk
+ *
+ * output: 1 stream of complex<float>
*/
class usrp_source_c : public usrp_source_base {
private:
) throw (std::runtime_error);
/*!
- * \brief interface to Universal Software Radio Peripheral Rx path (Rev 1)
+ * \brief Interface to Universal Software Radio Peripheral Rx path
+ * \ingroup usrp
+ * \ingroup source_blk
*
* output: 1 stream of short
*/
const std::string &mac="")
throw (std::runtime_error);
+/*!
+ * \ingroup sink_blk
+ * \ingroup usrp2
+ */
class usrp2_sink_16sc : public usrp2_sink_base
{
private:
const std::string &mac="")
throw (std::runtime_error);
+/*!
+ * \ingroup sink_blk
+ * \ingroup usrp2
+ */
class usrp2_sink_32fc : public usrp2_sink_base
{
private:
const std::string &mac="")
throw (std::runtime_error);
+/*!
+ * \ingroup source_blk
+ * \ingroup usrp2
+ */
class usrp2_source_16sc : public usrp2_source_base
{
private:
const std::string &mac="")
throw (std::runtime_error);
+/*!
+ * \ingroup source_blk
+ * \ingroup usrp2
+ */
class usrp2_source_32fc : public usrp2_source_base
{
private:
/******************************************************************************/
+/*!
+ * \brief Abstract base class for all USRP daughterboards
+ * \ingroup usrp
+ */
class db_base
{
protected:
/*!
* \brief abstract base class for usrp operations
+ * \ingroup usrp
*/
class usrp_basic : boost::noncopyable
{
\f/*!
* \brief class for accessing the receive side of the USRP
+ * \ingroup usrp
*/
class usrp_basic_rx : public usrp_basic
{
\f/*!
* \brief class for accessing the transmit side of the USRP
+ * \ingroup usrp
*/
class usrp_basic_tx : public usrp_basic
{
typedef boost::shared_ptr<usrp_standard_tx> usrp_standard_tx_sptr;
typedef boost::shared_ptr<usrp_standard_rx> usrp_standard_rx_sptr;
+/*!
+ * \ingroup usrp
+ */
class usrp_standard_common
{
int d_fpga_caps; // capability register val
};
/*!
- * \brief standard usrp RX class.
+ * \brief The C++ interface the receive side of the USRP
+ * \ingroup usrp
*
- * Assumes digital down converter in FPGA
+ * This is the recommended interface to USRP receive functionality
+ * for applications that use the USRP but not GNU Radio.
*/
class usrp_standard_rx : public usrp_basic_rx, public usrp_standard_common
{
// ----------------------------------------------------------------
/*!
- * \brief standard usrp TX class.
+ * \brief The C++ interface the transmit side of the USRP
+ * \ingroup usrp
+ *
+ * This is the recommended interface to USRP transmit functionality
+ * for applications that use the USRP but not GNU Radio.
*
* Uses digital upconverter (coarse & fine modulators) in AD9862...
*/
/*!
* \brief metadata associated with received frames
+ * \ingroup usrp2
*/
struct rx_metadata {
uint32_t word0; //< debugging, extensions
/*!
* \brief metadata associated with transmitted frames
+ * \ingroup usrp2
*/
struct tx_metadata {
fpga_timestamp timestamp; //< time to transmit first sample of frame
#include <boost/shared_ptr.hpp>
/*!
+ * \ingroup usrp2
+ *
* Base class for receive handlers that must copy into potentially limited
* range destination buffers.
*
/*!
* \brief Abstract function object called to handle received data blocks.
+ * \ingroup usrp2
*
* An object derived from this class is passed to usrp2::rx_samples
* to process the received frames of samples.
namespace usrp2 {
+ /*
+ * \ingroup usrp2
+ */
class tune_result
{
public:
static const int GPIO_TX_BANK = 0;
static const int GPIO_RX_BANK = 1;
+ /*!
+ * \brief standard C++ interface to USRP2
+ * \ingroup usrp2
+ */
class usrp2 : boost::noncopyable
{
public:
/* -*- c++ -*- */
/*
- * Copyright 2008 Free Software Foundation, Inc.
+ * Copyright 2008,2009 Free Software Foundation, Inc.
*
* This file is part of GNU Radio
*
projects / debian / gnuradio / commitdiff