Loading...
Searching...
No Matches
gr::digital::ofdm_equalizer_simpledfe Class Reference
GNU Radio C++ Signal Processing Blocks » OFDM Blocks | GNU Radio C++ Signal Processing Blocks » Equalizers

Simple decision feedback equalizer for OFDM. More...

`#include <gnuradio/digital/ofdm_equalizer_simpledfe.h>`

## Public Types

typedef std::shared_ptr< ofdm_equalizer_simpledfe > | sptr
Public Types inherited from gr::digital::ofdm_equalizer_1d_pilots
typedef std::shared_ptr< ofdm_equalizer_1d_pilots > | sptr
Public Types inherited from gr::digital::ofdm_equalizer_base
typedef std::shared_ptr< ofdm_equalizer_base > | sptr

## Public Member Functions

ofdm_equalizer_simpledfe (int fft_len, const gr::digital::constellation_sptr &constellation, const std::vector< std::vector< int > > &occupied_carriers=std::vector< std::vector< int > >(), const std::vector< std::vector< int > > &pilot_carriers=std::vector< std::vector< int > >(), const std::vector< std::vector< gr_complex > > &pilot_symbols=std::vector< std::vector< gr_complex > >(), int symbols_skipped=0, float alpha=0.1, bool input_is_shifted=true, bool enable_soft_output=false)

| ~ofdm_equalizer_simpledfe () override
void | equalize (gr_complex *frame, int n_sym, const std::vector< gr_complex > &initial_taps=std::vector< gr_complex >(), const std::vector< tag_t > &tags=std::vector< tag_t >()) override
| Run the actual equalization.
Public Member Functions inherited from gr::digital::ofdm_equalizer_1d_pilots
| ofdm_equalizer_1d_pilots (int fft_len, const std::vector< std::vector< int > > &occupied_carriers, const std::vector< std::vector< int > > &pilot_carriers, const std::vector< std::vector< gr_complex > > &pilot_symbols, int symbols_skipped, bool input_is_shifted)
| ~ofdm_equalizer_1d_pilots () override
void | reset () override
| Reset the channel information state knowledge.
void | get_channel_state (std::vector< gr_complex > &taps) override
| Return the current channel state.
Public Member Functions inherited from gr::digital::ofdm_equalizer_base
| ofdm_equalizer_base (int fft_len)
virtual | ~ofdm_equalizer_base ()
int | fft_len ()
sptr | base ()

## Static Public Member Functions

static sptr

make (int fft_len, const gr::digital::constellation_sptr &constellation, const std::vector< std::vector< int > > &occupied_carriers=std::vector< std::vector< int > >(), const std::vector< std::vector< int > > &pilot_carriers=std::vector< std::vector< int > >(), const std::vector< std::vector< gr_complex > > &pilot_symbols=std::vector< std::vector< gr_complex > >(), int symbols_skipped=0, float alpha=0.1, bool input_is_shifted=true, bool enable_soft_output=false)

## Additional Inherited Members

Protected Attributes inherited from gr::digital::ofdm_equalizer_1d_pilots
std::vector< bool > | d_occupied_carriers
| If `d_occupied_carriers`[k][l] is true, symbol k, carrier l is carrying data.
std::vector< std::vector< bool > > | d_pilot_carriers
| If `d_pilot_carriers`[k][l] is true, symbol k, carrier l is carrying data.
std::vector< std::vector< gr_complex > > | d_pilot_symbols
| If `d_pilot_carriers`[k][l] is true, d_pilot_symbols[k][l] is its tx'd value.
int | d_symbols_skipped
| In case the frame doesn't begin with OFDM symbol 0, this is the index of the first symbol.
int | d_pilot_carr_set
| The current position in the set of pilot symbols.
std::vector< gr_complex > | d_channel_state
| Vector of length d_fft_len saving the current channel state (on the occupied carriers)
Protected Attributes inherited from gr::digital::ofdm_equalizer_base
int | d_fft_len

## Detailed Description

Simple decision feedback equalizer for OFDM.

Equalizes an OFDM signal symbol by symbol using knowledge of the complex modulations symbols. For every symbol, the following steps are performed:

- On every sub-carrier, decode the modulation symbol
- Use the difference between the decoded symbol and the received symbol to update the channel state on this carrier
- Whenever a pilot symbol is found, it uses the known pilot symbol to update the channel state.

This equalizer makes a lot of assumptions:

- The initial channel state is good enough to decode the first symbol without error (unless the first symbol only consists of pilot tones)
- The channel changes only very slowly, such that the channel state from one symbol is enough to decode the next
- SNR low enough that equalization will always suffice to correctly decode a symbol If these assumptions are not met, the most common error is that the channel state is estimated incorrectly during equalization; after that, all subsequent symbols will be completely wrong.

Note that, by default, the equalized symbols are exact points on the constellation. This means that soft information of the modulation symbols is lost after the equalization, which is suboptimal for channel codes that use soft decision. If this behaviour is not desired, set the `enable_soft_output` parameter to true.

## Member Typedef Documentation

## sptr

std::shared_ptr<ofdm_equalizer_simpledfe> gr::digital::ofdm_equalizer_simpledfe::sptr

## Constructor & Destructor Documentation

## ofdm_equalizer_simpledfe()

gr::digital::ofdm_equalizer_simpledfe::ofdm_equalizer_simpledfe | ( | int | fft_len,
|  | const gr::digital::constellation_sptr & | constellation,
|  | const std::vector< std::vector< int > > & | occupied_carriers = std::vector< std::vector< int > >(),
|  | const std::vector< std::vector< int > > & | pilot_carriers = std::vector< std::vector< int > >(),
|  | const std::vector< std::vector< gr_complex > > & | pilot_symbols = std::vector< std::vector< gr_complex > >(),
|  | int | symbols_skipped = 0,
|  | float | alpha = 0.1,
|  | bool | input_is_shifted = true,
|  | bool | enable_soft_output = false )

## ~ofdm_equalizer_simpledfe()

gr::digital::ofdm_equalizer_simpledfe::~ofdm_equalizer_simpledfe | ( |  | ) |

override

## Member Function Documentation

## equalize()

void gr::digital::ofdm_equalizer_simpledfe::equalize | ( | gr_complex * | frame,
|  | int | n_sym,
|  | const std::vector< gr_complex > & | initial_taps = std::vector< gr_complex >(),
|  | const std::vector< tag_t > & | tags = std::vector< tag_t >() )

override virtual

Run the actual equalization.

Implements gr::digital::ofdm_equalizer_base.

## make()

static sptr gr::digital::ofdm_equalizer_simpledfe::make | ( | int | fft_len,
|  | const gr::digital::constellation_sptr & | constellation,
|  | const std::vector< std::vector< int > > & | occupied_carriers = std::vector< std::vector< int > >(),
|  | const std::vector< std::vector< int > > & | pilot_carriers = std::vector< std::vector< int > >(),
|  | const std::vector< std::vector< gr_complex > > & | pilot_symbols = std::vector< std::vector< gr_complex > >(),
|  | int | symbols_skipped = 0,
|  | float | alpha = 0.1,
|  | bool | input_is_shifted = true,
|  | bool | enable_soft_output = false )

static

The documentation for this class was generated from the following file:

- ofdm_equalizer_simpledfe.h