* \defgroup clock Signal Clock Synchronization
*/
+/*!
+ * \defgroup dft Fourier Transformation
+ */
+
+/*!
+ * \defgroup synch Synchronization
+ */
+
/*! @} */
/*! \defgroup filter_design Digital Filter Design */
/*! \defgroup graphical Graphical Utilities */
-/*! \defgroup internal Implementation Details */
-/*! \defgroup hardware Hardware */
/*! \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 internal Implementation Details */
+
+/*! \defgroup base Misc Common Base Classes */
/*!
* \defgroup applications Applications
* These are some applications build using gnuradio...
*/
/*!
- * \defgroup radar Radar
- * Radar Applications...
+ * \defgroup atsc ATSC
+ * ATSC Applications...
*/
/*!
- * \defgroup atsc ATSC
- * ATSC Applications...
+ * \defgroup radar Radar
+ * Radar Applications...
*/
/*!
/*! @} */
/*! \defgroup usrp USRP */
+/*! \defgroup hardware Hardware */
/*!
* \brief common base class for SIMD versions of gr_fir_ccc
+ * \ingroup filter
*
* 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
*
* This base class handles alignment issues common to SSE and 3DNOW
* subclasses.
/*!
* \brief 3DNow! version of gr_fir_ccf
+ * \ingroup filter
*/
class gr_fir_ccf_3dnow : public gr_fir_ccf_simd
{
/*!
* \brief SSE version of gr_fir_ccf
+ * \ingroup filter
*/
class gr_fir_ccf_sse : public gr_fir_ccf_simd
{
/*!
* \brief common base class for SIMD versions of gr_fir_fcc
+ * \ingroup filter
*
* This base class handles alignment issues common to SSE and 3DNOW
* subclasses.
/*!
* \brief 3DNow! version of gr_fir_fcc
+ * \ingroup filter
*/
class gr_fir_fcc_3dnow : public gr_fir_fcc_simd
{
/*!
* \brief SSE version of gr_fir_fcc
+ * \ingroup filter
*/
class gr_fir_fcc_sse : public gr_fir_fcc_simd
{
/*!
* \brief common base class for SIMD versions of gr_fir_fff
+ * \ingroup filter
*
* This base class handles alignment issues common to SSE and 3DNOW
* subclasses.
/*!
* \brief common base class for SIMD versions of gr_fir_fsf
+ * \ingroup filter
*
* This base class handles alignment issues common to SSE and 3DNOW
* subclasses.
/*!
* \brief 3DNow! version of gr_fir_fsf
+ * \ingroup filter
*/
class gr_fir_fsf_3dnow : public gr_fir_fsf_simd
{
/*!
* \brief SSE version of gr_fir_fsf
+ * \ingroup filter
*/
class gr_fir_fsf_sse : public gr_fir_fsf_simd
{
/*!
* \brief common base class for SIMD versions of gr_fir_scc
+ * \ingroup filter
*
* This base class handles alignment issues common to SSE and 3DNOW
* subclasses.
/*!
* \brief Goertzel single-bin DFT calculation.
- * \ingroup filter
+ * \ingroup dft
*/
class gr_goertzel_fc : public gr_sync_decimator
{
/*!
* \brief class template for single pole moving average filter
+ * \ingroup filter
*/
template<class o_type, class i_type, class tap_type>
class gr_single_pole_avg {
#include <gr_types.h>
/*!
- * \brief implements Goertzel single-bin DFT calculation
+ * \brief Implements Goertzel single-bin DFT calculation
+ * \ingroup dft
*/
class gri_goertzel
/*!
* \brief Compute intermediate samples between signal samples x(k*Ts)
+ * \ingroup filter
*
* 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
*
* 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
*
* 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
*/
float gain = 1.0, float max_gain = 0.0);
/*!
* \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
*/
#include <gr_block.h>
-class gr_align_on_samplenumbers_ss;
-typedef boost::shared_ptr<gr_align_on_samplenumbers_ss> gr_align_on_samplenumbers_ss_sptr;
-
-gr_align_on_samplenumbers_ss_sptr gr_make_align_on_samplenumbers_ss (int nchan=2, int align_interval=128);
-
/*!
* \brief align several complex short (interleaved short) input channels with corresponding unsigned 32 bit sample_counters (provided as interleaved 16 bit values)
+ * \ingroup misc
* \param number of complex_short input channels (including the 32 bit counting channel)
* \param align_interval is after how much samples (minimally) the sample-alignement is refreshed. Default is 128.
* A bigger value means less processing power but also requests more buffer space, which has a maximum.
* This means that the first complex_short channel on every input is an interleaved 32 bit counter.
* The samples are aligned by dropping samples untill the samplenumbers match.
*/
+class gr_align_on_samplenumbers_ss;
+typedef boost::shared_ptr<gr_align_on_samplenumbers_ss> gr_align_on_samplenumbers_ss_sptr;
+
+gr_align_on_samplenumbers_ss_sptr gr_make_align_on_samplenumbers_ss (int nchan=2, int align_interval=128);
+
+
class gr_align_on_samplenumbers_ss : public gr_block
/*!
* \brief slice float binary symbol outputting 1 bit output
- * \ingroup block
+ * \ingroup converter
*
* x < 0 --> 0
* x >= 0 --> 1
/*!
* \brief Convert stream of bytes to stream of +/- 1 symbols
- * \ingroup block
+ * \ingroup converter
*
* input: stream of bytes; output: stream of float
*
/*!
* \brief Mueller and Müller (M&M) based clock recovery block with complex input, complex output.
- * \ingroup block
+ * \ingroup clock
*
* 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 block
+ * \ingroup clock
*
* This implements the Mueller and Müller (M&M) discrete-time error-tracking synchronizer.
*
/*!
* \brief output = complex conjugate of input
- * \ingroup block
+ * \ingroup math
*/
class gr_conjugate_cc : public gr_sync_block
{
gr_make_constellation_decoder_cb (const std::vector<gr_complex> &sym_position,
const std::vector<unsigned char> &sym_value_out);
-
+/*!
+ * \brief Constellation Decoder
+ * \ingroup coding
+ *
+ */
class gr_constellation_decoder_cb : public gr_sync_block
{
/*!
* \brief Examine input for specified access code, one bit at a time.
- * \ingroup block
+ * \ingroup synch
*
* 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)
#include <stdexcept>
#include <fstream>
-class gr_costas_loop_cc;
-typedef boost::shared_ptr<gr_costas_loop_cc> gr_costas_loop_cc_sptr;
/*! \brief A Costas loop carrier recovery module.
+ * \ingroup clock
*
* The Costas loop locks to the center frequency of a signal and
* downconverts it to baseband. The second (order=2) order loop is
* \param min_freq the minimum frequency deviation (normalized frequency) the loop can handle
* \param order the loop order, either 2 or 4
*/
+class gr_costas_loop_cc;
+typedef boost::shared_ptr<gr_costas_loop_cc> gr_costas_loop_cc_sptr;
+
+
gr_costas_loop_cc_sptr
gr_make_costas_loop_cc (float alpha, float beta,
float max_freq, float min_freq,
/*!
* \brief Carrier tracking PLL for QPSK
- * \ingroup block
+ * \ingroup clock
* input: complex; output: complex
* <br>The Costas loop can have two output streams:
* stream 1 is the baseband I and Q;
/*!
* \brief update running CRC-32
+ * \ingroup misc
*
* Update a running CRC with the bytes buf[0..len-1] The CRC should be
* initialized to all 1's, and the transmitted value is the 1's
/*!
* \brief gate or zero output if ctcss tone not present
- * \ingroup block
+ * \ingroup level
*/
class gr_ctcss_squelch_ff : public gr_squelch_base_ff
{
/*!
* \brief Decision directed M-PSK synchronous demod
+ * \ingroup clock
* 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 block
+ * \ingroup misc
*/
class gr_deinterleave : public gr_sync_decimator
{
/*!
* \brief delay the input by a certain number of samples
- * \ingroup block
+ * \ingroup misc
*/
class gr_delay : public gr_sync_block
{
/*!
* \brief y[0] = (x[0] - x[-1]) % M
- * \ingroup block
+ * \ingroup coding
*
* Differential decoder
*/
/*!
* \brief y[0] = (x[0] + y[-1]) % M
- * \ingroup block
+ * \ingroup coding
*
* Differential encoder
*/
#include <gr_sync_block.h>
+/*!
+ * \brief Please fix my documentation!
+ * \ingroup misc
+ */
class gr_diff_phasor_cc;
typedef boost::shared_ptr<gr_diff_phasor_cc> gr_diff_phasor_cc_sptr;
/*!
* \brief Detect the peak of a signal
- * \ingroup block
+ * \ingroup level
*
* If a peak is detected, this block outputs a 1,
* or it outputs 0's.
/*!
* \brief pad packet with alternating 1,0 pattern.
- * \ingroup block
+ * \ingroup coding
*
* input: stream of byte vectors; output: stream of byte vectors
*/
/*!
* \brief remove fake padding from packet
- * \ingroup block
+ * \ingroup coding
*
* 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
*/
class gr_feedforward_agc_cc : public gr_sync_block
{
/*!
* \brief base class for evaluating a function: double -> double
+ * \ingroup misc
*
* This class is designed to be subclassed in Python or C++
* and is callable from both places. It uses SWIG's
/*!
* \brief base class for evaluating a function: complex -> complex
+ * \ingroup misc
*
* This class is designed to be subclassed in Python or C++
* and is callable from both places. It uses SWIG's
/*!
* \brief base class for evaluating a function: long -> long
+ * \ingroup misc
*
* This class is designed to be subclassed in Python or C++
* and is callable from both places. It uses SWIG's
/*!
* \brief base class for evaluating a function: void -> void
+ * \ingroup misc
*
* This class is designed to be subclassed in Python or C++
* and is callable from both places. It uses SWIG's
/*!
* \brief Compute forward or reverse FFT. complex vector in / complex vector out.
- * \ingroup block
+ * \ingroup dft
*/
class gr_fft_vcc : public gr_sync_block
/*!
* \brief Compute forward FFT. float vector in / complex vector out.
- * \ingroup block
+ * \ingroup dft
*/
class gr_fft_vfc : public gr_sync_block
/*!
* \brief Finite Impulse Response (FIR) filter design functions.
+ * \ingroup filter_design
*/
class gr_firdes {
/*!
* \brief Frequency modulator block
- * \ingroup block
+ * \ingroup modulation
*
* float input; complex baseband output
*/
/*!
* \brief fixed point sine and cosine and friends.
+ * \ingroup math
*
* fixed pt radians
* --------- --------
/*!
* \brief Numerically Controlled Oscillator (NCO)
+ * \ingroup misc
*/
class gr_fxpt_nco {
gr_int32 d_phase;
/*!
* \brief Voltage Controlled Oscillator (VCO)
+ * \ingroup misc
*/
class gr_fxpt_vco {
gr_int32 d_phase;
/*!
* \brief copies the first N items to the output then signals done
- * \ingroup block
+ * \ingroup flow
*
* Useful for building test cases
*/
/*!
* \brief interleave N inputs to a single output
- * \ingroup block
+ * \ingroup misc
*/
class gr_interleave : public gr_sync_interpolator
{
/*!
* \brief decimate a stream, keeping one item out of every n.
- * \ingroup block
+ * \ingroup misc
*/
class gr_keep_one_in_n : public gr_block
{
/*!
* \brief output[i] = input[i]
- * \ingroup block
+ * \ingroup misc
*
* This is a short term kludge to work around a problem with the hierarchical block impl.
*/
/*!
* \brief Least-Mean-Square Decision Feedback Equalizer (complex in/out)
- * \ingroup block
+ * \ingroup misc
*/
class gr_lms_dfe_cc : public gr_sync_block
{
/*!
* \brief Least-Mean-Square Decision Feedback Equalizer (float in/out)
- * \ingroup block
+ * \ingroup misc
*/
class gr_lms_dfe_ff : public gr_sync_block
{
/*!
* \brief output[i] = map[input[i]]
- * \ingroup block
+ * \ingroup misc
*/
class gr_map_bb : public gr_sync_block
/*!
* \brief Fast arc tangent using table lookup and linear interpolation
+ * \ingroup math
*
* \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 block
+ * \ingroup synch
*
* 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 base class template for Numerically Controlled Oscillator (NCO)
+ * \ingroup misc
*/
/*!
* \brief output = n*log10(input) + k
- * \ingroup block
+ * \ingroup math
*/
class gr_nlog10_ff : public gr_sync_block
{
/*!
* \brief Does nothing. Used for testing only.
- * \ingroup block
+ * \ingroup misc
*/
class gr_nop : public gr_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
*/
class gr_ofdm_bpsk_demapper : public gr_block
* \brief take a message in and map to a vector of complex
* constellation points suitable for IFFT input to be used in an ofdm
* modulator. Simple BPSK version.
+ * \ingroup modulation
*/
class gr_ofdm_bpsk_mapper : public gr_sync_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 block
+ * \ingroup synch
*/
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
*/
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.
- * \inblock blocks
+ * \ingroup demodulation
*
* 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
* 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
*
* <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
*
*/
* \brief take a message in and map to a vector of complex
* constellation points suitable for IFFT input to be used in an ofdm
* modulator. Simple QAM version.
+ * \ingroup modulation
*/
class gr_ofdm_qam_mapper : public gr_sync_block
* \brief take a message in and map to a vector of complex
* constellation points suitable for IFFT input to be used in an ofdm
* modulator. Simple QPSK version.
+ * \ingroup modulation
*/
class gr_ofdm_qpsk_mapper : public gr_sync_block
unsigned int symbol_length);
/*!
- * \brief does the rest of the OFDM stuff (fixme)
+ * \brief does the rest of the OFDM stuff
+ * \ingroup misc
*/
class gr_ofdm_sampler : public gr_block
/*!
* \brief pa_2x2 phase combiner
- * \ingroup block
+ * \ingroup misc
*
* Anntenas are arranged like this:
*
/*!
* \brief Detect the peak of a signal
- * \ingroup block
+ * \ingroup level
*
* 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 block
+ * \ingroup modulation
* 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 block
+ * \ingroup clock
*
* 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 block
+ * \ingroup clock
*
* 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 block
+ * \ingroup clock
*
* input: stream of complex; output: stream of complex
*
/*!
* \brief PN code sequential search correlator
*
+ * \ingroup synch
* Receives complex baseband signal, outputs complex correlation against
* reference PN code, one sample per PN code period
*/
/*!
* \brief Base class for representing user preferences a la windows INI files.
+ * \ingroup misc
*
* The real implementation is in Python, and is accessable from C++
* via the magic of SWIG directors.
/*!
* \brief gate or zero output when input power below threshold
- * \ingroup block
+ * \ingroup level
*/
class gr_pwr_squelch_cc : public gr_squelch_base_cc
{
/*!
* \brief gate or zero output when input power below threshold
- * \ingroup block
+ * \ingroup level
*/
class gr_pwr_squelch_ff : public gr_squelch_base_ff
{
/*!
* \brief quadrature demodulator: complex in, float out
- * \ingroup block
+ * \ingroup demodulation
*
* This can be used to demod FM, FSK, GMSK, etc.
* The input is complex baseband.
/*!
* \brief pseudo random number generator
+ * \ingroup math
*/
class gr_random {
protected:
/*!
* \brief Detect the peak of a signal and repeat every period samples
- * \ingroup block
+ * \ingroup level
*
* 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 Parks-McClellan FIR filter design.
*
+ * \ingroup filter_design
*
* Calculates the optimal (in the Chebyshev/minimax sense) FIR filter
* inpulse reponse given a set of band edges, the desired reponse on
/*!
* \brief RMS average power
+ * \ingroup math
*/
class gr_rms_cf : public gr_sync_block
{
/*!
* \brief RMS average power
+ * \ingroup math
*/
class gr_rms_ff : public gr_sync_block
{
/*!
* \brief inverse of gr_simple_framer (more or less)
- * \ingroup block
+ * \ingroup synch
*/
class gr_simple_correlator : public gr_block
{
/*!
* \brief add sync field, seq number and command field to payload
- * \ingroup block
+ * \ingroup synch
*/
class gr_simple_framer : public gr_block
{
#ifndef INCLUDED_GR_SIMPLE_FRAMER_SYNC_H
#define INCLUDED_GR_SIMPLE_FRAMER_SYNC_H
-/*
- * Here are a couple of maximum length sequences (m-sequences) that were generated by the
+/*!
+ * \brief Here are a couple of maximum length sequences (m-sequences) that were generated by the
* the "mseq" matlab/octave code downloaded from:
* http://www.mathworks.com/matlabcentral/fileexchange/loadFile.do?objectId=990&objectType=file
*
+ * \ingroup synch
* 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
*/
class gr_simple_squelch_cc : public gr_sync_block
{
/*!
* \brief skips the first N items, from then on copies items to the output
- * \ingroup block
+ * \ingroup flow
*
* Useful for building test cases and sources which have metadata or junk at the start
*/
#include <gr_block.h>
#include <vector>
-class gr_stream_mux;
-typedef boost::shared_ptr<gr_stream_mux> gr_stream_mux_sptr;
-
/*!
* \brief Creates a stream muxing block to multiplex many streams into
* one with a specified format.
+ * \ingroup converter
*
* \param itemsize the item size of the stream
* \param length a vector (list/tuple) specifying the number of
* indefinitely for the items.
*
*/
+class gr_stream_mux;
+typedef boost::shared_ptr<gr_stream_mux> gr_stream_mux_sptr;
+
+
gr_stream_mux_sptr
gr_make_stream_mux (size_t itemsize, const std::vector<int> &lengths);
/*!
* \brief convert a stream of items into a N streams of items
- * \ingroup block
+ * \ingroup converter
*
* 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 block
+ * \ingroup converter
*/
class gr_stream_to_vector : public gr_sync_decimator
{
/*!
* \brief Convert N streams of 1 item into a 1 stream of N items
- * \ingroup block
+ * \ingroup converter
*
* 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 block
+ * \ingroup converter
*/
class gr_streams_to_vector : public gr_sync_block
{
/*!
* \brief Test class for testing runtime system (setting up buffers and such.)
- * \ingroup block
+ * \ingroup misc
*
* This block does not do any usefull actual data processing.
* It just exposes setting all standard block parameters using the contructor or public methods.
gr_threshold_ff_sptr gr_make_threshold_ff (float lo, float hi, float initial_state=0);
/*!
- * \brief
- * \ingroup block
+ * \brief Please fix my documentation
+ * \ingroup misc
*/
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 block
+ * \ingroup flow
*
* input: one stream of itemsize; output: one stream of itemsize
*/
class gr_unpack_k_bits_bb;
/*!
- * \brief Converts a byte with k relevent bits to k output bytes with 1 bit in the LSB
+ * \brief Converts a byte with k relevent bits to k output bytes with 1 bit in the LSB.
+ * \ingroup converter
*/
class gr_unpack_k_bits_bb : public gr_sync_interpolator
{
/*!
* \brief base class template for Voltage Controlled Oscillator (VCO)
+ * \ingroup misc
*/
//FIXME Eventually generalize this to fixed point
#include <gr_sync_block.h>
#include <gr_fxpt_vco.h>
-class gr_vco_f;
-typedef boost::shared_ptr<gr_vco_f> gr_vco_f_sptr;
-
/*!
* \brief VCO - Voltage controlled oscillator
+ * \ingroup misc
*
* \param sampling_rate sampling rate (Hz)
* \param sensitivity units are radians/sec/volt
* \param amplitude output amplitude
*/
+class gr_vco_f;
+typedef boost::shared_ptr<gr_vco_f> gr_vco_f_sptr;
+
+
gr_vco_f_sptr gr_make_vco_f(double sampling_rate, double sensitivity, double amplitude);
/*!
* \brief VCO - Voltage controlled oscillator
- * \ingroup block
*
* 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 block
+ * \ingroup converter
*/
class gr_vector_to_stream : public gr_sync_interpolator
{
/*!
* \brief Convert 1 stream of vectors of length N to N streams of items
- * \ingroup block
+ * \ingroup converter
*/
class gr_vector_to_streams : public gr_sync_block
{
/*!
* \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 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
*/
/*!
* \brief FFT: complex in, complex out
+ * \ingroup dft
*/
class gri_fft_complex {
/*!
* \brief FFT: real in, complex out
+ * \ingroup dft
*/
class gri_fft_real_fwd {
int d_fft_size;
/*!
* \brief FFT: complex in, float out
+ * \ingroup dft
*/
class gri_fft_real_rev {
int d_fft_size;
/*!
* \brief Galois Linear Feedback Shift Register using specified polynomial mask
+ * \ingroup math
*
* 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
*
* Generates a maximal length pseudo-random sequence of length 2^15 - 1 bits.
*/
/*!
* \brief generate pseudo-random sequence of length 32768 bits.
+ * \ingroup math
*
* 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 block
+ * \ingroup math
*
* Add across all input streams.
*/
/*!
* \brief output = input + constant
- * \ingroup block
+ * \ingroup math
*/
class @NAME@ : public gr_sync_block
{
/*!
* \brief output vector = input vector + constant vector
- * \ingroup block
+ * \ingroup math
*/
class @NAME@ : public gr_sync_block
{
/*!
* \brief output = sum (input_0, input_1, ...)
- * \ingroup block
+ * \ingroup math
*
* Add across all input vectors.
*/
/*!
* \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 block
+ * \ingroup converter
*
* input: stream of @I_TYPE@; output: stream of @O_TYPE@
*
/*!
* \brief output = input_0 / input_1 / input_x ...)
- * \ingroup block
+ * \ingroup math
*
* Divide across all input streams.
*/
/*!
* \brief output = prod (input_0, input_1, ...)
- * \ingroup block
+ * \ingroup math
*
* Multiply across all input streams.
*/
/*!
* \brief output = input * constant
- * \ingroup block
+ * \ingroup math
*/
class @NAME@ : public gr_sync_block
{
/*!
* \brief output vector = input vector * constant vector (element-wise)
- * \ingroup block
+ * \ingroup math
*/
class @NAME@ : public gr_sync_block
{
/*!
* \brief output = prod (input_0, input_1, ...)
- * \ingroup block
+ * \ingroup math
*
* Element-wise multiply across all input vectors.
*/
/*!
* \brief output = input or zero if muted.
- * \ingroup block
+ * \ingroup level
*/
class @NAME@ : public gr_sync_block
{
/*!
* \brief Convert a stream of packed bytes or shorts to stream of unpacked bytes or shorts.
- * \ingroup block
+ * \ingroup converter
*
* input: stream of @I_TYPE@; output: stream of @O_TYPE@
*
/*!
* \brief Detect the peak of a signal
- * \ingroup block
+ * \ingroup level
*
* If a peak is detected, this block outputs a 1,
* or it outputs 0's.
/*!
* \brief sample and hold circuit
- * \ingroup block
+ * \ingroup level
*
* Samples the data stream (input stream 0) and holds the value
* if the control signal is 1 (intput stream 1).
/*!
* \brief output = input_0 - input_1 - ...)
- * \ingroup block
+ * \ingroup math
*
* Subtract across all input streams.
*/
/*!
* \brief Convert a stream of unpacked bytes or shorts into a stream of packed bytes or shorts.
- * \ingroup block
+ * \ingroup converter
*
* input: stream of @I_TYPE@; output: stream of @O_TYPE@
*
/*!
* \brief abstract class that implements bit banging i/o for i2c bus.
+ * \ingroup base
*/
class i2c_bbio {
public:
/*!
* \brief concrete class that bit bangs eval board i2c bus using parallel port
*
+ * \ingroup base
* This class talks to the i2c bus on the microtune eval board using
* the parallel port. This works for both the 4937 and 4702 boards.
*/
/*!
* \brief class for controlling i2c bus
+ * \ingroup base
*/
class i2c_bitbang : public i2c {
friend i2c_sptr make_i2c_bitbang (i2c_bbio_sptr io);
/*!
* \brief class for controlling microtune 4702 tuner module
+ * \ingroup hardware
*/
class microtune_4702 : public microtune_xxxx {
/*!
* \brief control microtune 4702 eval board
+ * \ingroup hardware
*/
class microtune_4702_eval_board : public microtune_xxxx_eval_board {
/*!
* \brief class for controlling microtune 4937 tuner module
+ * \ingroup hardware
*/
class microtune_4937 : public microtune_xxxx {
public:
/*!
* \brief control microtune 4937 eval board
+ * \ingroup hardware
*/
class microtune_4937_eval_board : public microtune_xxxx_eval_board {
/*!
* \brief abstract class for controlling microtune {4937,4702} tuner modules
+ * \ingroup base
*/
class microtune_xxxx {
public:
/*!
* \brief abstract class for controlling microtune xxxx eval board
+ * \ingroup hardware
*/
class microtune_xxxx_eval_board {
public:
/*!
* \brief abstract class that provides low level access to parallel port bits
+ * \ingroup hardware
*/
class ppio {
/*!
* \brief access to parallel port bits using the linux ppdev interface
+ * \ingroup hardware
*/
class ppio_ppdev : public ppio {
/*!
* \brief Very low level interface to SDR 1000 xcvr hardware
* \sa sdr_1000.py for a higher level interface.
+ * \ingroup hardware
*/
class sdr_1000_base {
ppio_sptr d_ppio;
/*!
* \brief The abstract base class for all signal processing blocks.
- * \ingroup block
+ * \ingroup base
*
* 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 block
+ * \ingroup base
*
* A signal processing flow is constructed by creating a tree of
* hierarchical blocks, which at any level may also contain terminal nodes
/*!
* \brief invoke callbacks based on select.
+ * \ingroup internal
*
* \sa gr_select_handler
*/
/*!
* \brief abstract error handler
+ * \ingroup base
*/
class gr_error_handler {
public:
/*!
*\brief Class specializing gr_flat_flowgraph that has all nodes
* as gr_blocks, with no hierarchy
+ * \ingroup base
*
*/
class gr_flat_flowgraph : public gr_flowgraph
/*!
*\brief Class representing a specific input or output graph endpoint
+ * \ingroup internal
*
*/
class gr_endpoint
/*!
* \brief public constructor for gr_hier_block2
+
*/
gr_hier_block2_sptr gr_make_hier_block2(const std::string &name,
gr_io_signature_sptr input_signature,
/*!
* \brief gr_hier_block2 - Hierarchical container class for gr_block's
+ * \ingroup internal
*
*/
class gr_hier_block2 : public gr_basic_block
/*!
* \brief Create an i/o signature
*
+ * \ingroup internal
* \param min_streams specify minimum number of streams (>= 0)
* \param max_streams specify maximum number of streams (>= min_streams or -1 -> infinite)
* \param sizeof_stream_item specify the size of the items in each stream
/*!
* \brief Get and set signal handler.
*
+ * \ingroup internal
* Constructor installs new handler, destructor reinstalls
* original value.
*/
gr_make_message_from_string(const std::string s, long type = 0, double arg1 = 0, double arg2 = 0);
/*!
- * \brief Message.
+ * \brief Message class.
*
+ * \ingroup misc
* The ideas and method names for adjustable message length were
* lifted from the click modular router "Packet" class.
*/
/*!
* \brief abstract class of message handlers
+ * \ingroup base
*/
class gr_msg_handler {
public:
/*!
* \brief thread-safe message queue
+ * \ingroup misc
*/
class gr_msg_queue : public gr_msg_handler {
omni_mutex d_mutex;
/*!
* \brief If possible, enable high-priority "real time" scheduling.
+ * \ingroup misc
*/
gr_rt_status_t
gr_enable_realtime_scheduling();
/*!
*\brief A single thread of execution for the scheduler
*
+ * \ingroup internal
* This class implements a single thread that runs undetached, and
* invokes the single-threaded block scheduler. The runtime makes
* one of these for each distinct partition of a flowgraph and runs
/*!
* \brief Abstract handler for select based notification.
+ * \ingroup base
*
* \sa gr_dispatcher
*/
/*!
* \brief synchronous 1:1 input to output with history
- * \ingroup block
+ * \ingroup internal
*
* Override work to provide the signal processing implementation.
*/
/*!
* \brief synchronous N:1 input to output with history
- * \ingroup block
+ * \ingroup internal
*
* Override work to provide the signal processing implementation.
*/
/*!
* \brief synchronous 1:N input to output with history
- * \ingroup block
+ * \ingroup internal
*
* Override work to provide the signal processing implementation.
*/
/*!
* \brief create a timeout.
*
+ * \ingroup misc
* gr_timer_hook is called when timer fires.
*/
gr_timer_sptr gr_make_timer (gr_timer_hook, void *);
/*!
*\brief Top-level hierarchical block representing a flowgraph
+ * \ingroup internal
*
*/
class gr_top_block : public gr_hier_block2
/*!
*\brief Implementation details of gr_top_block
*
+ * \ingroup internal
* The actual implementation of gr_top_block. Separate class allows
* decoupling of changes from dependent classes.
*
/*!
* \brief abstract class to implement doubly mapped virtual memory circular buffers
+ * \ingroup base
*/
class gr_vmcircbuf {
protected:
#endif
/*!
* \brief concrete class to implement circular buffers with mmap and shm_open
+ * \ingroup base
*/
class gr_vmcircbuf_createfilemapping : public gr_vmcircbuf
{
/*!
* \brief concrete class to implement circular buffers with mmap and shm_open
+ * \ingroup base
*/
class gr_vmcircbuf_mmap_shm_open : public gr_vmcircbuf {
public:
/*!
* \brief concrete class to implement circular buffers with mmap and shm_open
+ * \ingroup base
*/
class gr_vmcircbuf_mmap_tmpfile : public gr_vmcircbuf {
public:
/*!
* \brief concrete class to implement circular buffers with mmap and shm_open
+ * \ingroup base
*/
class gr_vmcircbuf_sysv_shm : public gr_vmcircbuf {
public:
projects / debian / gnuradio / commitdiff