Equalize signal using equalizer object

`y = equalize(eqobj,x)`

y = equalize(eqobj,x,trainsig)

[y,yd] = equalize(...)

[y,yd,e] = equalize(...)

`y = equalize(eqobj,x)`

processes
the baseband signal vector `x`

with equalizer object `eqobj`

and
returns the equalized signal vector `y`

. At the end
of the process, `eqobj`

contains updated state information
such as equalizer weight values and input buffer values. To construct `eqobj`

,
use the `lineareq`

or `dfe`

function,
as described in Adaptive Algorithms. The `equalize`

function
assumes that the signal `x`

is sampled at `nsamp`

samples
per symbol, where `nsamp`

is the value of the `nSampPerSym`

property
of `eqobj`

. For adaptive algorithms other than CMA,
the equalizer adapts in decision-directed mode using a detector specified
by the `SigConst`

property of `eqobj`

.
The delay of the equalizer is `(eqobj.RefTap-1)/eqobj.nSampPerSym`

,
as described in Delays from Equalization.

Note that `(eqobj.RefTap-1)`

must be an integer
multiple of `nSampPerSym`

. For a fractionally-spaced
equalizer, the taps are spaced at fractions of a symbol period. The
reference tap pertains to training symbols, and thus, must coincide
with a whole number of symbols (i.e., an integer number of samples
per symbol). `eqobj.RefTap=1`

corresponds to the
first symbol, `eqobj.RefTap=nSampPerSym+1`

to the
second, and so on. Therefore `(eqobj.RefTap-1)`

must
be an integer multiple of `nSampPerSym`

.

If `eqobj.ResetBeforeFiltering`

is `0`

, `equalize`

uses
the existing state information in `eqobj`

when starting
the equalization operation. As a result, ```
equalize(eqobj,[x1
x2])
```

is equivalent to `[equalize(eqobj,x1) equalize(eqobj,x2)]`

.
To reset `eqobj`

manually, apply the `reset`

function
to `eqobj`

.

If `eqobj.ResetBeforeFiltering`

is `1`

, `equalize`

resets `eqobj`

before
starting the equalization operation, overwriting any previous state
information in `eqobj`

.

`y = equalize(eqobj,x,trainsig)`

initially
uses a training sequence to adapt the equalizer. After processing
the training sequence, the equalizer adapts in decision-directed mode.
The vector length of `trainsig`

must be less than
or equal to `length(x)-(eqobj.RefTap-1)/eqobj.nSampPerSym`

.

`[y,yd] = equalize(...)`

returns
the vector `yd`

of detected data symbols.

`[y,yd,e] = equalize(...)`

returns
the result of the error calculation described in Error Calculation.
For adaptive algorithms other than CMA, `e`

is the
vector of errors between `y`

and the reference signal,
where the reference signal consists of the training sequence or detected
symbols.

For examples that use this function, see Equalize Using a Training Sequence in MATLAB, Example: Equalizing Multiple Times, Varying the Mode, and Example: Adaptive Equalization Within a Loop.

Was this topic helpful?