Very simple static equalizer for OFDM. More...

#include <gnuradio/digital/ofdm_equalizer_static.h>

Public Types
typedef std::shared_ptr< ofdm_equalizer_static >	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_static (int fft_len, 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, bool input_is_shifted=true)

	~ofdm_equalizer_static () 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
	Divide the input signal with the current channel state.

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 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, bool input_is_shifted=true)

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

Very simple static equalizer for OFDM.

This is an extremely simple equalizer. It will only work for high-SNR, very, very slowly changing channels.

It simply divides the signal with the currently known channel state. Whenever a pilot symbol comes around, it updates the channel state on that particular carrier by dividing the received symbol with the known pilot symbol.

Member Typedef Documentation

◆ sptr

typedef std::shared_ptr<ofdm_equalizer_static> gr::digital::ofdm_equalizer_static::sptr

Constructor & Destructor Documentation

◆ ofdm_equalizer_static()

gr::digital::ofdm_equalizer_static::ofdm_equalizer_static	(	int	fft_len,
		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`,
		bool	input_is_shifted = `true`
	)

◆ ~ofdm_equalizer_static()

gr::digital::ofdm_equalizer_static::~ofdm_equalizer_static ( )

override

Member Function Documentation

◆ equalize()

void gr::digital::ofdm_equalizer_static::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 >()`
	)

overridevirtual

Divide the input signal with the current channel state.

Does the following (and nothing else):

Divide every OFDM symbol with the current channel state
If a pilot symbol is found, re-set the channel state by dividing the received symbol with the known pilot symbol

Implements gr::digital::ofdm_equalizer_base.

◆ make()

static sptr gr::digital::ofdm_equalizer_static::make	(	int	fft_len,
		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`,
		bool	input_is_shifted = `true`
	)

static

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

ofdm_equalizer_static.h

Public Types

Public Member Functions

Static Public Member Functions

Additional Inherited Members